Ich hätte gerne eine bidirektionale JSON-zu-Java-Serialisierung
Ich verwende erfolgreich den Pfad von Java zu JSON zu JQuery ... ( @ResponseBody
) z
@RequestMapping(value={"/fooBar/{id}"}, method=RequestMethod.GET)
public @ResponseBody FooBar getFooBar(
@PathVariable String id,
HttpServletResponse response , ModelMap model) {
response.setContentType("application/json");
...
}
und In JQuery verwende ich
$.getJSON('fooBar/1', function(data) {
//do something
});
Dies funktioniert gut (zB Anmerkungen funktionieren bereits, danke an alle Antwortenden)
Wie mache ich jedoch den umgekehrten Pfad: Muss JSON mithilfe von RequestBody wieder in ein Java-Objekt serialisiert werden?
Egal was ich versuche, ich kann so etwas nicht zum Laufen bringen:
@RequestMapping(value={"/fooBar/save"}, method=RequestMethod.POST)
public String saveFooBar(@RequestBody FooBar fooBar,
HttpServletResponse response , ModelMap model) {
//This method is never called. (it does when I remove the RequestBody...)
}
Ich habe Jackson richtig konfiguriert (es wird auf dem Weg nach draußen serialisiert) und ich habe MVC als Annotationen eingestellt, die natürlich gesteuert werden
Wie bringe ich es zum Laufen? ist es überhaupt möglich? oder ist Spring / JSON / JQuery oneway (out)?
Aktualisieren:
Ich habe diese Jackson-Einstellung geändert
<bean id="jsonHttpMessageConverter"
class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />
<!-- Bind the return value of the Rest service to the ResponseBody. -->
<bean
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
<property name="messageConverters">
<util:list id="beanList">
<ref bean="jsonHttpMessageConverter" />
<!-- <ref bean="xmlMessageConverter" /> -->
</util:list>
</property>
</bean>
Zu dem (fast ähnlichen) vorgeschlagenen
<bean id="jacksonMessageConverter"
class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"></bean>
<bean
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
<property name="messageConverters">
<list>
<ref bean="jacksonMessageConverter" />
</list>
</property>
</bean>
Und es scheint zu funktionieren! Ich weiß nicht genau, was den Trick gemacht hat, aber es funktioniert ...
Antworten:
Ich bin mir ziemlich sicher, dass Sie sich nur registrieren müssen
MappingJacksonHttpMessageConverter
(Der einfachste Weg, dies zu tun, ist
<mvc:annotation-driven />
in XML oder@EnableWebMvc
in Java )Sehen:
Hier ist ein Arbeitsbeispiel:
Maven POM
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion><groupId>test</groupId><artifactId>json</artifactId><packaging>war</packaging> <version>0.0.1-SNAPSHOT</version><name>json test</name> <dependencies> <dependency><!-- spring mvc --> <groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>3.0.5.RELEASE</version> </dependency> <dependency><!-- jackson --> <groupId>org.codehaus.jackson</groupId><artifactId>jackson-mapper-asl</artifactId><version>1.4.2</version> </dependency> </dependencies> <build><plugins> <!-- javac --><plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId> <version>2.3.2</version><configuration><source>1.6</source><target>1.6</target></configuration></plugin> <!-- jetty --><plugin><groupId>org.mortbay.jetty</groupId><artifactId>jetty-maven-plugin</artifactId> <version>7.4.0.v20110414</version></plugin> </plugins></build> </project>
im Ordner src / main / webapp / WEB-INF
web.xml
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4"> <servlet><servlet-name>json</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>json</servlet-name> <url-pattern>/*</url-pattern> </servlet-mapping> </web-app>
json-servlet.xml
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <import resource="classpath:mvc-context.xml" /> </beans>
im Ordner src / main / resources:
mvc-context.xml
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> <mvc:annotation-driven /> <context:component-scan base-package="test.json" /> </beans>
Im Ordner src / main / java / test / json
TestController.java
@Controller @RequestMapping("/test") public class TestController { @RequestMapping(method = RequestMethod.POST, value = "math") @ResponseBody public Result math(@RequestBody final Request request) { final Result result = new Result(); result.setAddition(request.getLeft() + request.getRight()); result.setSubtraction(request.getLeft() - request.getRight()); result.setMultiplication(request.getLeft() * request.getRight()); return result; } }
Request.java
public class Request implements Serializable { private static final long serialVersionUID = 1513207428686438208L; private int left; private int right; public int getLeft() {return left;} public void setLeft(int left) {this.left = left;} public int getRight() {return right;} public void setRight(int right) {this.right = right;} }
Result.java
public class Result implements Serializable { private static final long serialVersionUID = -5054749880960511861L; private int addition; private int subtraction; private int multiplication; public int getAddition() { return addition; } public void setAddition(int addition) { this.addition = addition; } public int getSubtraction() { return subtraction; } public void setSubtraction(int subtraction) { this.subtraction = subtraction; } public int getMultiplication() { return multiplication; } public void setMultiplication(int multiplication) { this.multiplication = multiplication; } }
Sie können dieses Setup testen, indem Sie es
mvn jetty:run
in der Befehlszeile ausführen und anschließend eine POST-Anforderung senden:URL: http://localhost:8080/test/math mime type: application/json post body: { "left": 13 , "right" : 7 }
Ich habe dazu das Poster Firefox Plugin verwendet.
So sieht die Antwort aus:
{"addition":20,"subtraction":6,"multiplication":91}
quelle
<mvc:annotation-driven>
ich denke.curl -v -H "Content-Type: application/json" -X POST -d "{\"left\":13,\"right\":7}" http://localhost:8080/test/math
Darüber hinaus müssen Sie auch sicher sein, dass Sie haben
in Ihrer SPring-Konfiguration xml.
Ich würde Ihnen auch empfehlen, diesen Blog-Beitrag zu lesen. Es hat mir sehr geholfen. Frühlingsblog - Ajax-Vereinfachungen im Frühjahr 3.0
Aktualisieren:
habe gerade meinen Arbeitscode überprüft, wo ich
@RequestBody
richtig gearbeitet habe. Ich habe auch diese Bean in meiner Konfiguration:<bean id="jacksonMessageConverter" class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"></bean> <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"> <property name="messageConverters"> <list> <ref bean="jacksonMessageConverter"/> </list> </property> </bean>
Vielleicht wäre es schön zu sehen, was
Log4j
gesagt wird. Es gibt normalerweise mehr Informationen und meiner Erfahrung@RequestBody
nach schlägt das fehl, wenn der Inhaltstyp Ihrer Anfrage nicht lautetApplication/JSON
. Sie können Fiddler 2 ausführen, um es zu testen, oder sogar das Mozilla Live HTTP-Header-Plugin kann helfen.quelle
Neben den Antworten hier ...
Wenn Sie jquery auf der Client-Seite verwenden, hat dies für mich funktioniert:
Java:
@RequestMapping(value = "/ajax/search/sync") public String sync(@RequestBody Foo json) {
Jquery (Sie müssen json2.js von Douglas Crockford einschließen, um die Funktion JSON.stringify zu haben):
$.ajax({ type: "post", url: "sync", //your valid url contentType: "application/json", //this is required for spring 3 - ajax to work (at least for me) data: JSON.stringify(jsonobject), //json object or array of json objects success: function(result) { //do nothing }, error: function(){ alert('failure'); } });
quelle
Wenn Sie die Nachrichtenkonverter nicht selbst konfigurieren möchten, können Sie entweder @EnableWebMvc oder <mvc: annotation-powered /> verwenden , Jackson zum Klassenpfad hinzufügen und Spring gibt Ihnen sowohl JSON als auch XML (und einige andere Konverter) von Standard. Darüber hinaus erhalten Sie einige andere häufig verwendete Funktionen zum Konvertieren, Formatieren und Überprüfen.
quelle
Falls Sie bereit sind, Curl für Anrufe mit JSON 2 und Spring 3.2.0 zu verwenden, lesen Sie die FAQ hier . As AnnotationMethodHandlerAdapter ist veraltet und wird durch RequestMappingHandlerAdapter ersetzt.
quelle