第一章 JacksonUtil 序列化与反序列化属性总结

1.json-lib与Jackson

　　关于json-lib与Jackson对比总结如下：

　　1).性能方面，Jackson的处理能力高出Json-lib10倍左右。

　　2).json-lib已经停止更新，最新的版本也是基于JDK1.5，而Jackson的社区则较为活跃。

　　3).json-lib依赖commons系列的包及 ezmorph包共 5个，而Jackson除自身的以外只依赖于commons-logging

 

2.1 Jackson序列化与反序列化方法

 1  public static String encode(Object obj) {
 2         try {
 3             return objectMapper.writeValueAsString(obj);
 4         } catch (Exception e) {
 5             logger.error("jackson encode error:", e); 
 6         }
 7         return null;
 8     }
 9 
10     /**
11      * 将json string反序列化成对象
12      *
13      * @param json
14      * @param valueType
15      * @return
16      */
17     public static  T decode(String json, Class valueType) {
18         try {
19             return objectMapper.readValue(json, valueType);
20         } catch (Exception e) {
21             logger.error("jackson decode(String, Class) error: ", e);
22         }
23         return null;
24     }
25 
26     /**
27      * 将json array反序列化为对象
28      *
29      * @param json
30      * @param typeReference
31      * @return
32      */
33     public static  T decode(String json, TypeReference typeReference) {
34         try {
35             return (T) objectMapper.readValue(json, typeReference);
36         } catch (Exception e) {
37             logger.error("decode(String, JsonTypeReference)", e);
38         }
39         return null;
40     }

View Code

 2.2 Jackson自动检测机制

 　　jackson默认的字段属性发现规则如下：

　　　　所有被public修饰的字段->所有被public修饰的getter->所有被public修饰的setter

　　若类中的一个private属性，且没有设置public的getter和setter方法，则对该类对象进行序列化时，默认不对这个private属性进行序列化。

　　若此时任然需要对该private属性进行序列化，可以通过设置自动检测功能来实现：

　　2.2.1 通过配置属性实现

1 objectMapper
2             .setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY) // 自动检测所有类的全部属性
3             .setVisibility(PropertyAccessor.GETTER, JsonAutoDetect.Visibility.ANY) //自动检测所有类的public getter方法
4 　　　　　　　.setVisibility(PropertyAccessor.IS_GETTER, JsonAutoDetect.Visibility.ANY); //自动检测所有类的public setter方法

View Code

　　2.2.2 使用@JsonAutoDetect（作用在类上）来开启/禁止自动检测　　

　　　　fieldVisibility:字段的可见级别

　　　　ANY:任何级别的字段都可以自动识别

　　　　NONE:所有字段都不可以自动识别

　　　　NON_PRIVATE:非private修饰的字段可以自动识别

　　　　PROTECTED_AND_PUBLIC:被protected和public修饰的字段可以被自动识别

　　　　PUBLIC_ONLY:只有被public修饰的字段才可以被自动识别

　　　　DEFAULT:同PUBLIC_ONLY

　　@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY) 

3.序列化与反序列化属性总结

　　与json-lib相比，Jackson在序列化与反序列时，可以对序列化与反序列化进行配置，是的输出结果满足自己的要求。序列化与反序列化属性很多，下面对一些常用属性进行介绍。

　　3.1 序列化属性　　

        //这个特性，决定了解析器是否将自动关闭那些不属于parser自己的输入源。
        // 如果禁止，则调用应用不得不分别去关闭那些被用来创建parser的基础输入流InputStream和reader；
        //默认是true
        objectMapper.configure(JsonParser.Feature.AUTO_CLOSE_SOURCE, true);
        //是否允许解析使用Java/C++ 样式的注释（包括'/'+'*' 和'//' 变量）
        objectMapper.configure(JsonParser.Feature.ALLOW_COMMENTS, true);

        //设置为true时，属性名称不带双引号
        objectMapper.configure(JsonGenerator.Feature.QUOTE_FIELD_NAMES, false);
        //反序列化是是否允许属性名称不带双引号
        objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);

        //是否允许单引号来包住属性名称和字符串值
        objectMapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);

        //是否允许JSON字符串包含非引号控制字符（值小于32的ASCII字符，包含制表符和换行符）
        objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);

        //是否允许JSON整数以多个0开始
        objectMapper.configure(JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS, true);

        //null的属性不序列化
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

        //按字母顺序排序属性,默认false
        objectMapper.configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY,true);

        //是否以类名作为根元素，可以通过@JsonRootName来自定义根元素名称,默认false
        objectMapper.configure(SerializationFeature.WRAP_ROOT_VALUE,true);

        //是否缩放排列输出,默认false
        objectMapper.configure(SerializationFeature.INDENT_OUTPUT,false);

        //序列化Date日期时以timestamps输出，默认true
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,true);

        //序列化枚举是否以toString()来输出，默认false，即默认以name()来输出
        objectMapper.configure(SerializationFeature.WRITE_ENUMS_USING_TO_STRING, true);

        //序列化枚举是否以ordinal()来输出，默认false
        objectMapper.configure(SerializationFeature.WRITE_ENUMS_USING_INDEX,false);

        //序列化单元素数组时不以数组来输出，默认false
        objectMapper.configure(SerializationFeature.WRITE_ENUMS_USING_TO_STRING,true);

        //序列化Map时对key进行排序操作，默认false
        objectMapper.configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS,true);

        //序列化char[]时以json数组输出，默认false
        objectMapper.configure(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS,true);

        //序列化BigDecimal时是输出原始数字还是科学计数，默认false，即以toPlainString()科学计数方式来输出
        objectMapper.configure(SerializationFeature.WRITE_BIGDECIMAL_AS_PLAIN,true);

 

　　下面写一个Person类，对上面介绍的序列化属性进行测试，并进行直观输出：　　

 1 import com.fasterxml.jackson.annotation.JsonRootName;
 2 import org.apache.commons.lang3.StringUtils;
 3 import java.util.Date;
 4 
 5 
 6 @JsonRootName("Test")
 7 public class Person {
 8 //  @JsonInclude(JsonInclude.Include.NON_NULL)
 9   private String name;
10 
11   private int age;
12 
13   private SexEnum sex;
14 
15   private Date birthDay;
16 
17   public enum SexEnum{
18     MAN("M", "m"),
19     WOMAN("F", "f");
20 
21     private String merchantCode;
22     private String nativeCode;
23 
24     SexEnum(String merchantCode, String nativeCode) {
25       this.merchantCode = merchantCode;
26       this.nativeCode = nativeCode;
27     }
28 
29     public String getMerchantCode() {
30       return merchantCode;
31     }
32 
33     public void setMerchantCode(String merchantCode) {
34       this.merchantCode = merchantCode;
35     }
36 
37     public String getNativeCode() {
38       return nativeCode;
39     }
40 
41     public void setNativeCode(String nativeCode) {
42       this.nativeCode = nativeCode;
43     }
44 
45     @Override
46     public String toString() {
47       return getMerchantCode();
48     }
49 
50   public Person() {
51   }
52 
53   public Person(String name, int age) {
54     this.name = name;
55     this.age = age;
56   }
57 
58   public String getName() {
59     return name;
60   }
61 
62   public void setName(String name) {
63     this.name = name;
64   }
65 
66   public int getAge() {
67     return age;
68   }
69 
70   public void setAge(int age) {
71     this.age = age;
72   }
73 
74   public SexEnum getSex() {
75     return sex;
76   }
77 
78   public void setSex(SexEnum sex) {
79     this.sex = sex;
80   }
81 
82   public Date getBirthDay() {
83     return birthDay;
84   }
85 
86   public void setBirthDay(Date birthDay) {
87     this.birthDay = birthDay;
88   }
89 }

View Code

　　下面是测试类：

1 import com.alibaba.fastjson.JSONObject;
 2 import com.example.myFirstProject.domain.Person;
 3 import com.example.myFirstProject.util.JacksonUtil;
 4 import org.joda.time.DateTime;
 5 import java.math.BigDecimal;
 6 import java.util.ArrayList;
 7 import java.util.Date;
 8 import java.util.List;
 9 import static com.example.myFirstProject.domain.Person.SexEnum;
10 import static com.example.myFirstProject.domain.Person.SexEnum.MAN;
11 
12 
13 /**
14  * Created by bjxiaojian on 2016/10/26.
15  */
16 public class JacksonTest {
17 
18   public static void main(String[] args) {
19 
20     Person person = new Person();
21 
22     Person person1 = new Person("xiaojian", 1);
23     person1.setSex(MAN);
24     person1.setBirthDay(new Date());
25     List personList = new ArrayList();
26     personList.add(person);
27     personList.add(person1);
28     System.out.println(JacksonUtil.encode(person));
29     System.out.println(JacksonUtil.encode(person1));
30     System.out.println(JacksonUtil.encode(personList));
31 
32   }
33 }
34 
35 
36 ---------------------------------输出结果--------------------------------------------
37 {"Test":{"age":0}}   null的属性不进行序列化
38 {"Test":{"age":1,"birthDay":1477661674628,"name":"xiaojian","sex":"M"}}   date类型的输出为时间戳，枚举类的输出默认为MAN或WOMAN，设置后为SexEnum的toString()的返回值
39 {"ArrayList":[{"age":0},{"age":1,"birthDay":1477661674628,"name":"xiaojian","sex":"M"}]}

View Code

　　3.2 反序列化属性

1         //当遇到未知属性（没有映射到属性，没有任何setter或者任何可以处理它的handler，是否应该抛出JsonMappingException异常
 2         objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

 3         //该特性决定对于json浮点数，是否使用BigDecimal来序列化。如果不允许，则使用Double序列化。 默认为false
 4         objectMapper.configure(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS, false);

 5         //该特性决定对于json整形（非浮点），是否使用BigInteger来序列化。如果不允许，则根据数值大小来确定 是使用Integer或者Long
 6         objectMapper.configure(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS, false);

 7         //该特性决定JSON ARRAY是映射为Object[]还是List