Jackson JSON benutzerdefinierte Serialisierung für bestimmte Felder

Gibt es eine Möglichkeit, mit der Jackson JSON Processor zu tun benutzerdefiniertes Feld-Ebene Serialisierung? Zum Beispiel würde ich gerne die Klasse

public class Person {
    public String name;
    public int age;
    public int favoriteNumber;
}

serialisiert, um die Folgen JSON:

{ "name": "Joe", "age": 25, "favoriteNumber": "123" }

Beachten Sie, dass Alter=25 codiert ist, als ein Anzahl während favoriteNumber=123 verschlüsselt als string. Out of the box Jackson marshalls int auf eine Zahl. In diesem Fall möchte ich favoriteNumber werden codiert als string.

InformationsquelleAutor der Frage Steve Kuo | 2012-08-20

Können Sie implementieren eine benutzerdefinierte serializer wie folgt:

public class Person {
    public String name;
    public int age;
    @JsonSerialize(using = IntToStringSerializer.class, as=String.class)
    public int favoriteNumber:
}


public class IntToStringSerializer extends JsonSerializer<Integer> {

    @Override
    public void serialize(Integer tmpInt, 
                          JsonGenerator jsonGenerator, 
                          SerializerProvider serializerProvider) 
                          throws IOException, JsonProcessingException {
        jsonGenerator.writeObject(tmpInt.toString());
    }
}

Java behandeln soll, das autoboxing von int zu Integer für Sie.

InformationsquelleAutor der Antwort Kevin Bowersox

Jackson-databind (zumindest 2.1.3) bietet Besondere ToStringSerializer (com.fasterxml.jackson.databind.ser.std.ToStringSerializer)

Beispiel:

public class Person {
    public String name;
    public int age;
    @JsonSerialize(using = ToStringSerializer.class)
    public int favoriteNumber:
}

InformationsquelleAutor der Antwort werupokz

Hinzufügen @JsonProperty getter annotiert, das gibt einen String für die favoriteNumber Feld:

public class Person {
    public String name;
    public int age;
    private int favoriteNumber;

    public Person(String name, int age, int favoriteNumber) {
        this.name = name;
        this.age = age;
        this.favoriteNumber = favoriteNumber;
    }

    @JsonProperty
    public String getFavoriteNumber() {
        return String.valueOf(favoriteNumber);
    }

    public static void main(String... args) throws Exception {
        Person p = new Person("Joe", 25, 123);
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(p)); 
        //{"name":"Joe","age":25,"favoriteNumber":"123"}
    }
}

InformationsquelleAutor der Antwort João Silva

5

jackson-annotations bietet @JsonFormat die mit einer Menge von Anpassungen ohne die Notwendigkeit zu schreiben, die benutzerdefinierte serializer.

Zum Beispiel, um eine STRING Form für ein Feld mit numerischen Typs ausgegeben wird, den numerischen Wert als string
```
public class Person {
    public String name;
    public int age;
    @JsonFormat(shape = JsonFormat.Shape.STRING)
    public int favoriteNumber;
}
```
Folge, dass die gewünschte Ausgabe
```
{"name":"Joe","age":25,"favoriteNumber":"123"}
```
InformationsquelleAutor der Antwort Oleg Estekhin

mit Hilfe von @JsonView wir entscheiden können, Felder der model-Klassen zu serialisieren, die erfüllen die minimalen Kriterien ( wir haben die Kriterien definieren) wie können wir eine core-Klasse mit 10 Eigenschaften, aber nur 5 Eigenschaften werden serialisiert, die notwendigen für den Kunden nur

Definieren unsere Ansichten, indem Sie einfach erstellen Sie folgende Klasse:

public class Views
{
    static class Android{};
    static class IOS{};
    static class Web{};
}

Kommentierte model-Klasse mit Aussicht:

public class Demo 
{
    public Demo() 
    {
    }

@JsonView(Views.IOS.class)
private String iosField;

@JsonView(Views.Android.class)
private String androidField;

@JsonView(Views.Web.class)
private String webField;

 //getters/setters
...
..
}

Wir haben jetzt zu schreiben, benutzerdefinierte json-Konverter, indem HttpMessageConverter Klasse von Frühling:

    public class CustomJacksonConverter implements HttpMessageConverter<Object> 
    {
    public CustomJacksonConverter() 
        {
            super();
        //this.delegate.getObjectMapper().setConfig(this.delegate.getObjectMapper().getSerializationConfig().withView(Views.ClientView.class));
        this.delegate.getObjectMapper().configure(MapperFeature.DEFAULT_VIEW_INCLUSION, true);
        this.delegate.getObjectMapper().setSerializationInclusion(Include.NON_NULL);

    }

    //a real message converter that will respond to methods and do the actual work
    private MappingJackson2HttpMessageConverter delegate = new MappingJackson2HttpMessageConverter();

    @Override
    public boolean canRead(Class<?> clazz, MediaType mediaType) {
        return delegate.canRead(clazz, mediaType);
    }

    @Override
    public boolean canWrite(Class<?> clazz, MediaType mediaType) {
        return delegate.canWrite(clazz, mediaType);
    }

    @Override
    public List<MediaType> getSupportedMediaTypes() {
        return delegate.getSupportedMediaTypes();
    }

    @Override
    public Object read(Class<? extends Object> clazz,
            HttpInputMessage inputMessage) throws IOException,
            HttpMessageNotReadableException {
        return delegate.read(clazz, inputMessage);
    }

    @Override
    public void write(Object obj, MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException 
    {
        synchronized(this) 
        {
            String userAgent = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest().getHeader("userAgent");
            if ( userAgent != null ) 
            {
                switch (userAgent) 
                {
                case "IOS" :
                    this.delegate.getObjectMapper().setConfig(this.delegate.getObjectMapper().getSerializationConfig().withView(Views.IOS.class));
                    break;
                case "Android" :
                    this.delegate.getObjectMapper().setConfig(this.delegate.getObjectMapper().getSerializationConfig().withView(Views.Android.class));
                    break;
                case "Web" :
                    this.delegate.getObjectMapper().setConfig(this.delegate.getObjectMapper().getSerializationConfig().withView( Views.Web.class));
                    break;
                default:
                    this.delegate.getObjectMapper().setConfig(this.delegate.getObjectMapper().getSerializationConfig().withView( null ));
                    break;
                }
            }
            else
            {
                //reset to default view
                this.delegate.getObjectMapper().setConfig(this.delegate.getObjectMapper().getSerializationConfig().withView( null ));
            }
            delegate.write(obj, contentType, outputMessage);
        }
    }

}

Ist dort jetzt sagen müssen, Frühjahr verwenden Sie diese benutzerdefinierten json konvertieren, indem Sie diese in dispatcher-servlet.xml

<mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean id="jsonConverter" class="com.mactores.org.CustomJacksonConverter" >
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

Das ist, wie Sie in der Lage zu entscheiden, welche Felder zu bekommen serialisieren.

InformationsquelleAutor der Antwort user3820510

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.