Al usar Spring MVC para REST, ¿cómo habilita Jackson para imprimir JSON renderizado?

Si está utilizando Spring Boot 1.2 o posterior, la solución simple es agregar

spring.jackson.serialization.INDENT_OUTPUT=true

Al archivo application.properties. Esto asume que está usando Jackson para serialización.

Si está utilizando una versión anterior de Spring Boot, puede agregar

http.mappers.json-pretty-print=true

Esta solución todavía funciona con Spring Boot 1.2, pero está en desuso y eventualmente se eliminará por completo. Recibirá una advertencia de obsolescencia en el registro en el momento del inicio.

(probado usando spring-boot-starter-web)

Cuando estás usando Jackson 2.0.0, puedes hacerlo de la manera que Les quería. Actualmente uso RC3 y la configuración parece estar funcionando como se esperaba.

ObjectMapper jacksonMapper = new ObjectMapper();
jacksonMapper.configure(SerializationFeature.INDENT_OUTPUT, true);

Traduce

{"foo":"foo","bar":{"field1":"field1","field2":"field2"}}

Hacia

{
  "foo" : "foo",
  "bar" : {
    "field1" : "field1",
    "field2" : "field2"
  }
}

¿Cómo hago que Jackson imprima bastante el contenido JSON que genera?

He aquí un ejemplo sencillo:

Entrada JSON original:

{"one":"AAA","two":["BBB","CCC"],"three":{"four":"DDD","five":["EEE","FFF"]}}

Foo.java:

import java.io.FileReader;

import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.ObjectWriter;

public class Foo
{
  public static void main(String[] args) throws Exception
  {
    ObjectMapper mapper = new ObjectMapper();
    MyClass myObject = mapper.readValue(new FileReader("input.json"), MyClass.class);
    // this is Jackson 1.x API only: 
    ObjectWriter writer = mapper.defaultPrettyPrintingWriter();
    // ***IMPORTANT!!!*** for Jackson 2.x use the line below instead of the one above: 
    // ObjectWriter writer = mapper.writer().withDefaultPrettyPrinter();
    System.out.println(writer.writeValueAsString(myObject));
  }
}

class MyClass
{
  String one;
  String[] two;
  MyOtherClass three;

  public String getOne() {return one;}
  void setOne(String one) {this.one = one;}
  public String[] getTwo() {return two;}
  void setTwo(String[] two) {this.two = two;}
  public MyOtherClass getThree() {return three;}
  void setThree(MyOtherClass three) {this.three = three;}
}

class MyOtherClass
{
  String four;
  String[] five;

  public String getFour() {return four;}
  void setFour(String four) {this.four = four;}
  public String[] getFive() {return five;}
  void setFive(String[] five) {this.five = five;}
}

Salida:

{
  "one" : "AAA",
  "two" : [ "BBB", "CCC" ],
  "three" : {
    "four" : "DDD",
    "five" : [ "EEE", "FFF" ]
  }
}

Si este enfoque no se ajusta exactamente a sus necesidades, si busca la API docs v1.8.1 para "pretty", mostrará los componentes relevantes disponibles. Si utiliza la versión 2 de la API.x a continuación, mire en su lugar la API 2.1.0 más reciente docs .

Podría sugerir este enfoque, es válido con Spring 4.0.x y posiblemente versiones anteriores.

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import java.util.List;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
@EnableWebMvc    
public class WebMvcConfig extends WebMvcConfigurerAdapter {


    @Bean
    public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter() {
        MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter = new MappingJackson2HttpMessageConverter();
        mappingJackson2HttpMessageConverter.setObjectMapper(objectMapper());
        return mappingJackson2HttpMessageConverter;
    }

    @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper objMapper = new ObjectMapper();
        objMapper.enable(SerializationFeature.INDENT_OUTPUT);
        return objMapper;
    }

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        super.configureMessageConverters(converters);        
        converters.add(mappingJackson2HttpMessageConverter());
    }

}

Gracias a Willie Wheeler por la solución: El blog de primavera de Willie Wheeler

Pretty print se activará agregando y configurando el convertidor MappingJackson2HttpMessageConverter. Deshabilite prettyprint dentro del entorno de producción.

Configuración del convertidor de mensajes

<mvc:annotation-driven>
    <mvc:message-converters>
        <bean id="jacksonHttpMessageConverter"
            class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="prettyPrint" value="${json.prettyPrint}" />
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

Basado en baeldung esto podría ser una buena idea usando java 8:

@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {

    Optional<HttpMessageConverter<?>> converterFound;
       converterFound = converters.stream().filter(c -> c instanceof AbstractJackson2HttpMessageConverter).findFirst();

    if (converterFound.isPresent()) {
        final AbstractJackson2HttpMessageConverter converter;
        converter = (AbstractJackson2HttpMessageConverter) converterFound.get();
        converter.getObjectMapper().enable(SerializationFeature.INDENT_OUTPUT);
        converter.getObjectMapper().enable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
    }
}

Tuve problemas para que el MappingJacksonHttpMessageConverter personalizado funcionara como se sugirió anteriormente, pero finalmente pude hacerlo funcionar después de tener problemas con la configuración. Desde el punto de vista del código hice exactamente lo que se mencionó anteriormente, pero tuve que agregar la siguiente configuración a mi springapp-servlet.xml para que funcione.

Espero que esto ayude a otros que buscan implementar lo mismo.

<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
    <property name="messageConverters">
        <list>
            <ref bean="jsonConverter" />
        </list>
    </property>
</bean>

<bean id="jsonConverter" class="com.xxx.xxx.xxx.common.PrettyPrintMappingJacksonHttpMessageConverter">
    <property name="supportedMediaTypes" value="application/json" />
    <property name="prettyPrint" value="true" />
</bean>

Jackson 2 tiene una API más agradable, de acuerdo, pero no resolverá este problema en un entorno Spring MVC dado que Spring MVC usa ObjectMapper#writeValue(JsonGenerator, Object) para escribir objetos como JSON. Esta variante writeValue no aplica características de serialización ObjectMapper como INDENT_OUTPUT en Jackson 1.x ó 2.0.

Creo que esto es algo confuso. Dado que usamos el ObjectMapper para construir JsonGenerators, esperaría que los generadores devueltos se inicialicen en función de configuración de ObjectMapper configurada. Informé esto como un problema contra Jackson 2.0 aquí: https://github.com/FasterXML/jackson-databind/issues/12 .

La sugerencia de Les de llamar a JsonGenerator#useDefaultPrettyPrinter basado en el valor de una bandera prettyPrint es lo mejor que podemos hacer en este momento. He seguido adelante y creado un HttpMessageConverter Jackson2 que hace esto basado en el estado habilitado de la SerializationFeature INDENT_OUTPUT: https://gist.github.com/2423129 .

Lo haría un problema de renderizado, no la preocupación del servicio REST.

¿Quién está haciendo el renderizado? Deje que ese componente formatee el JSON. Tal vez pueden ser dos URLs - una para producción y otra para desarrollo.