web-dev-qa-db-de.com

Konfigurieren Sie im Frühjahr das @ ResponseBody-JSON-Format

Stellen Sie sich vor, ich habe diese kommentierte Methode in einem Spring 3 @Controller

@RequestMapping("")
public @ResponseBody MyObject index(@RequestBody OtherObject obj) {
    MyObject result = ...;
    return result;
}

Aber ich muss das Ausgabe-Json-Format so konfigurieren, als würde ich Folgendes tun:

ObjectMapper om = new ObjectMapper();
om.configure(JsonGenerator.Feature.QUOTE_FIELD_NAMES, true);
om.getSerializationConfig()
        .setSerializationInclusion(JsonSerialize.Inclusion.NON_DEFAULT);
om.getSerializationConfig()
        .set(SerializationConfig.Feature.INDENT_OUTPUT, false);

Gibt es eine Möglichkeit, dieses Verhalten zu konfigurieren?

Ich habe ein paar verwandte Fragen gefunden, bin mir aber nicht sicher, wie ich sie an meinen speziellen Fall anpassen soll:

  1. Frühjahrsvorwahl mit Antwortkörper
  2. Wer legt den Antwortinhaltstyp in Spring MVC fest (@ResponseBody)

Vielen Dank !

39
Guido

AngerClown zeigte mich in die richtige Richtung.

Das habe ich schließlich getan, nur für den Fall, dass jemand es für nützlich hält.

<bean
    class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
    <property name="messageConverters">
        <list>
            <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">
                <property name="objectMapper" ref="jacksonObjectMapper" />
            </bean>
        </list>
    </property>
</bean>

<!-- jackson configuration : https://stackoverflow.com/questions/3661769 -->
<bean id="jacksonObjectMapper" class="org.codehaus.jackson.map.ObjectMapper" />
<bean id="jacksonSerializationConfig" class="org.codehaus.jackson.map.SerializationConfig"
    factory-bean="jacksonObjectMapper" factory-method="getSerializationConfig" />
<bean
    class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
    <property name="targetObject" ref="jacksonSerializationConfig" />
    <property name="targetMethod" value="setSerializationInclusion" />
    <property name="arguments">
        <list>
            <value type="org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion">NON_DEFAULT</value>
        </list>
    </property>
</bean>

Ich muss noch herausfinden, wie man die anderen Eigenschaften konfiguriert, wie zum Beispiel:

om.configure(JsonGenerator.Feature.QUOTE_FIELD_NAMES, true);
15
Guido

Für die Leute, die Java-basierte Spring-Konfiguration verwenden :

@Configuration
@ComponentScan(basePackages = "com.domain.sample")
@EnableWebMvc
public class SpringConfig extends WebMvcConfigurerAdapter {
....

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        final MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
        final ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        converter.setObjectMapper(objectMapper);
        converters.add(converter);
        super.configureMessageConverters(converters);
    }

....

}

Ich benutze MappingJackson2HttpMessageConverter - was von fastenxml ist.

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.3.1</version>
</dependency>

Wenn Sie den Codehaus-Jackson-Mapper verwenden möchten, verwenden Sie stattdessen diesen MappingJacksonHttpMessageConverter.

 <dependency>
    <groupId>org.codehaus.jackson</groupId>
    <artifactId>jackson-mapper-asl</artifactId>
    <version>${codehaus.jackson.version}</version>
 </dependency>
31
Õzbek

Ich brauche, um ein sehr ähnliches Problem zu lösen, das Jackson Mapper so konfiguriert, dass "Nullwerte nicht um Christi willen serialisiert werden !!!".

Ich wollte kein ausgefallenes mvc: annotation-driven Tag verlassen, also fand ich heraus, wie man Jackson's ObjectMapper konfiguriert, ohne mvc: annotation-driven zu entfernen und ContentNegotiatingViewResolver nicht wirklich fancy hinzuzufügen.

Das Schöne ist, dass Sie keinen Java-Code selbst schreiben müssen!

Und hier ist die XML-Konfiguration (nicht mit anderen Namensräumen der Jackson-Klassen verwechseln, ich habe einfach die neue Jakson 2.x-Bibliothek verwendet ... das gleiche sollte auch mit Jackson 1.x-Bibliotheken funktionieren):

<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="com.fasterxml.jackson.databind.ObjectMapper">
                    <property name="serializationInclusion">
                        <value type="com.fasterxml.jackson.annotation.JsonInclude.Include">NON_NULL</value>
                    </property>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>
28
tkuty

Für Spring Version 4.1.3+

Ich habe Jamas Lösung ausprobiert, aber dann wurden alle Antworten mit dem Inhaltstyp 'application/json' zurückgegeben, einschließlich der generierten HTML-Seite.

Überschreiben von configureMessageConverters(...)verhindert, dass spring die Standardkonverter einrichtet. Spring 4.1.3 ermöglicht die Änderung bereits konfigurierter Konverter durch Überschreiben vonextendMessageConverters(...):

@Configuration
public class ConverterConfig extends WebMvcConfigurerAdapter {
    @Override
    public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        for (HttpMessageConverter<?> converter : converters) {
            if (converter instanceof AbstractJackson2HttpMessageConverter) {
                AbstractJackson2HttpMessageConverter c = (AbstractJackson2HttpMessageConverter) converter;
                ObjectMapper objectMapper = c.getObjectMapper();
                objectMapper.setSerializationInclusion(Include.NON_NULL);
            }
        }

        super.extendMessageConverters(converters);
    }
}

siehe org.springframework..WebMvcConfigurationSupport#getMessageConverters()

siehe org.springframework..WebMvcConfigurationSupport#addDefaultHttpMessageConverters(...)

10
Melv

Im Frühjahr 3.2 wird eine neue Lösung eingeführt durch: http://static.springsource.org/spring/docs/3.2.0.BUILD-SNAPSHOT/api/org/springframework/http/converter/json/Jackson2ObjectMapperFactoryBean.html , das unten ist mein Beispiel:

 <mvc:annotation-driven>
   ​<mvc:message-converters>
     ​​<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
       ​​​<property name="objectMapper">
         ​​​​<bean
 class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
           ​​​​​<property name="featuresToEnable">
             ​​​​​​<array>
               ​​​​​​​<util:constant static-field="com.fasterxml.jackson.core.JsonParser.Feature.ALLOW_SINGLE_QUOTES" />
             ​​​​​​</array>
           ​​​​​</property>
         ​​​​</bean>
       ​​​</property>
     ​​</bean>
   ​</mvc:message-converters>
 </mvc:annotation-driven>
10
Tody.Lu

Ich habe meine eigene FactoryBean geschrieben, die einen ObjectMapper (vereinfachte Version) instanziiert: 

 public class ObjectMapperFactoryBean implements FactoryBean<ObjectMapper>{

        @Override
        public ObjectMapper getObject() throws Exception {
                ObjectMapper mapper = new ObjectMapper();
                mapper.getSerializationConfig().setSerializationInclusion(JsonSerialize.Inclusion.NON_NULL);
                return mapper;
        }

        @Override
        public Class<?> getObjectType() {
                return ObjectMapper.class;
        }

        @Override
        public boolean isSingleton() {
                return true;
        }

}

Und die Verwendung in der Federkonfiguration:

<bean
    class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
    <property name="messageConverters">
        <list>
            <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">
                <property name="objectMapper" ref="jacksonObjectMapper" />
            </bean>
        </list>
    </property>
</bean>

4
oehmiche

Beantwortet die Frage nicht, aber dies ist das beste Ergebnis von Google.

Wenn jemand hierher kommt und dies für Spring 4 tun möchte (wie mir das passiert ist), können Sie die Anmerkung verwenden

@JsonInclude(Include.NON_NULL)

auf der wiederkehrenden Klasse.

4

Sehen Sie sich Rick Hightowers Ansatz an. Sein Ansatz vermeidet die Konfiguration von ObjectMapper als Singleton und ermöglicht es Ihnen, die JSON-Antwort für dasselbe Objekt auf unterschiedliche Weise für jede Anforderungsmethode zu filtern.

http://www.jroller.com/RickHigh/entry/filtering_json_feeds_from_spring

3
Greg Sheremeta

Sie können den ObjectMapper als Bean in Ihrer Spring-XML-Datei konfigurieren. Was einen Verweis auf den ObjectMapper enthält, ist die MappingJacksonJsonView-Klasse. Sie müssen dann die Ansicht an einen ViewResolver anhängen.

So etwas sollte funktionieren:

<bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
      <property name="mediaTypes">
      <map>
        <entry key="json" value="application/json" />
        <entry key="html" value="text/html" />
      </map>
    </property>
    <property name="viewResolvers">
      <list>
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
          <property name="prefix" value="/WEB-INF/jsp/" />
          <property name="suffix" value=".jsp" />
        </bean>
      </list>
    </property>
    <property name="defaultViews">
      <list>
        <bean class="org.springframework.web.servlet.view.json.MappingJacksonJsonView">
          <property name="prefixJson" value="false" />
          <property name="objectMapper" value="customObjectMapper" />
        </bean>
      </list>
    </property>
  </bean>

Wo customObjectMapper an anderer Stelle in der XML-Datei definiert ist. Beachten Sie, dass Sie die Spring-Eigenschaftswerte direkt mit den Enums-Jackson-Definitionen festlegen können. siehe diese Frage .

ContentNegotiatingViewResolver ist wahrscheinlich nicht erforderlich, es ist lediglich der Code, den ich in einem vorhandenen Projekt verwende.

2
AngerClown

Ja, aber was passiert, wenn Sie beispielsweise mit Mixins beginnen, können Sie ObjectMapper nicht als Singleton verwenden, da Sie die Konfiguration global anwenden. Sie müssen also die Mixin-Klassen in derselben ObjectMapper-Instanz hinzufügen oder festlegen?

1
serge

Sie können Folgendes tun (Jackson-Version <2):

Benutzerdefinierte Mapper-Klasse:

import org.codehaus.jackson.JsonGenerator;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.SerializationConfig;
import org.codehaus.jackson.map.annotate.JsonSerialize;

public class CustomObjectMapper extends ObjectMapper {
    public CustomObjectMapper() {
        super.configure(JsonGenerator.Feature.QUOTE_FIELD_NAMES, true);
        super.getSerializationConfig()
                .setSerializationInclusion(JsonSerialize.Inclusion.NON_DEFAULT);
        super.getSerializationConfig()
                .set(SerializationConfig.Feature.INDENT_OUTPUT, false);
    }
}

Spring config:

<mvc:annotation-driven>
    <mvc:message-converters register-defaults="false">
        <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">
            <property name="objectMapper">
                <bean class="package.CustomObjectMapper"/>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>
1
I V