jackson对枚举类型的序列化

89 阅读 0 评论 59 点赞

我是靠谱客的博主优秀小蝴蝶，最近开发中收集的这篇文章主要介绍jackson对枚举类型的序列化，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

2. Controlling the Enum Representation

Let’s define the following Enum:

 
        public 
         enum 
         Distance { 
       
        KILOMETER( 
        "km" 
        ,  
        1000 
        ),  
       
        MILE( 
        "miles" 
        ,  
        1609.34 
        ), 
       
        METER( 
        "meters" 
        ,  
        1 
        ),  
       
        INCH( 
        "inches" 
        ,  
        0.0254 
        ), 
       
        CENTIMETER( 
        "cm" 
        ,  
        0.01 
        ),  
       
        MILLIMETER( 
        "mm" 
        ,  
        0.001 
        ); 
       
        private 
         String unit; 
       
        private 
         final 
         double 
         meters; 
       
        private 
         Distance(String unit,  
        double 
         meters) { 
       
        this 
        .unit = unit; 
       
        this 
        .meters = meters; 
       
        } 
       
        // standard getters and setters 
       
        }

3. Default Enum Representation

By default, Jackson will represent Java Enums as simple String – for example:

 
        new 
         ObjectMapper().writeValueAsString(Distance.MILE);

Will result in:

 
        "MILE"

What we would like to get when marshaling this ENUM to a JSON Object is to give something like:

 
        { 
        "unit" 
        : 
        "miles" 
        , 
        "meters" 
        :1609.34}

4. Enum as Json Object

Starting with Jackson 2.1.2 – the is now a configuration option that can handle this kind of representation – viathe @JsonFormat annotation, at the Enum level:

 
        @JsonFormat 
        (shape = JsonFormat.Shape.OBJECT) 
       
        public 
         enum 
         Distance { ... }

This will lead to the correct result when serializing this enum for Distance.MILE:

 
        { 
        "unit" 
        : 
        "miles" 
        , 
        "meters" 
        :1609.34}

5. Enums and @JsonValue

Yet another simple way of controlling the marshaling output for an enum is using the @JsonValue annotation on a getter:

 
        public 
         enum 
         Distance {  
       
        ... 
       
        @JsonValue 
       
        public 
         String getMeters() { 
       
        return 
         meters; 
       
        } 
       
        }

What we’re saying here is that getMeters() is the actual representation of this enum. So the result of serializing:

 
        1609.34

6. Custom Serializer for Enum

Before Jackson 2.1.2, or if even more customization is required for the enum – we can use a custom Jackson serializer – first we’ll need to define it:

 
        public 
         class 
         DistanceSerializer  
        extends 
         StdSerializer { 
       
        public 
         DistanceSerializer() { 
       
        super 
        (Distance. 
        class 
        ); 
       
        } 
       
        public 
         DistanceSerializer(Class t) { 
       
        super 
        (t); 
       
        } 
       
        public 
         void 
         serialize(Distance distance, JsonGenerator generator, 
       
        SerializerProvider provider)  
       
        throws 
         IOException, JsonProcessingException { 
       
        generator.writeStartObject(); 
       
        generator.writeFieldName( 
        "name" 
        ); 
       
        generator.writeString(distance.name()); 
       
        generator.writeFieldName( 
        "unit" 
        ); 
       
        generator.writeString(distance.getUnit()); 
       
        generator.writeFieldName( 
        "meters" 
        ); 
       
        generator.writeNumber(distance.getMeters()); 
       
        generator.writeEndObject(); 
       
        } 
       
        }

We will now tie together the serializer and the class it applies to:

 
        @JsonSerialize 
        (using = DistanceSerializer. 
        class 
        ) 
       
        public 
         enum 
         TypeEnum { ... }

The result:

 
   
        { 
        "name" 
        : 
        "MILE" 
        , 
        "unit" 
        : 
        "miles" 
        , 
        "meters" 
        :1609.34} 
       
 
 