一. 前言


jackson 1.x和2.x版本的注解是放置在不同的包下的
1.x是在jackson core jar包org.codehaus.jackson.annotate下
2.x是在jackson-databind包com.fasterxml.jackson.annotation下
本页面列出常规用途的Jacakson2.0的注解，并按照使用场景分类。

二. 常用注解

1. @JsonAutoDetect 自动检测

作用在类上，jackson拥有自动检测机制，允许使用任意的构造方法或工厂方法来构造实例，jackson默认的字段属性发现规则如下：

  • 所有的 public 类型的属性
  • 所有的 public 类型的 get 方法
  • 所有的 set 方法（无论方法的可见性）

使用@JsonAutoDetect（作用在类上）来开启/禁止自动检测 ，配置注解属性**fieldVisibility**来调整字段的可见级别

  • ANY：任何级别的字段都可以自动识别
  • NONE：所有字段都不可以自动识别
  • NON_PRIVATE：非private修饰的字段可以自动识别
  • PROTECTED_AND_PUBLIC：被protected和public修饰的字段可以被自动识别
  • PUBLIC_ONLY：只有被public修饰的字段才可以被自动识别
  • DEFAULT：同PUBLIC_ONLY

配置getterVisibility=JsonAutoDetect.Visibility.NONE
举例：

  1. @AllArgsConstructor
  2. @NoArgsConstructor
  3. //@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY)
  4. public class TestPOJO{
  5.     private String name;
  6. }

这个类我们只有一个private的name属性，并且没有提供对应的get,set方法，如果按照默认的属性发现规则我们将无法序列化和反序列化name字段(如果没有get,set方法，只有被public修饰的属性才会被发现)，你可以通过修改@JsonAutoDetect的fieldVisibility来调整自动发现级别，为了使name被自动发现，我们需要将级别调整为ANY

除了fieldVisibility，还可以配置getterVisibility，setterVisibility，creatorVisibility等的可见级别。

2. @JsonIgnore 忽略序列化(HOT🔥)

作用在字段或方法上，用来完全忽略被注解的字段和方法对应的属性，即便这个字段或方法可以被自动检测到或者还有其他的注解，set和get方法任意添加一个即可，本例中的name和count都会被忽略解析

  1. @JsonIgnore
  2. public String name;
  3. public int count;
  4. @JsonIgnore
  5. public void setCount(int count) {
  6.     this.count = count;
  7. }

3. @JsonIgnoreProperties 批量忽略序列化(HOT🔥)

作用在类上，用来说明有些属性在序列化/反序列化时需要忽略掉，可以将它看做是@JsonIgnore的批量操作，但它的功能比@JsonIgnore要强，比如一个类是代理类，我们无法将将@JsonIgnore标记在属性或方法上，此时便可用@JsonIgnoreProperties标注在类声明上，它还有一个重要的功能是作用在反序列化时解析字段时过滤一些未知的属性，否则通常情况下解析到我们定义的类不认识的属性便会抛出异常。
可以注明是想要忽略的属性列表如@JsonIgnoreProperties({“name”,”age”,”title”})，
也可以注明过滤掉未知的属性如@JsonIgnoreProperties(ignoreUnknown=true)

4. @JsonProperty 序列化字段(HOT🔥)

作用在字段或方法上，用来对属性的序列化/反序列化，可以用来避免遗漏属性，同时提供对属性名称重命名

  1. @JsonProperty
  2. /* 注意这里必须得有该注解，因为没有提供对应的getId和setId函数，
  3.  * 而是其他的getter和setter，防止遗漏该属性 */
  4. private int id;
  5. @JsonProperty("第一个名字")
  6. private String firstName;

5. @JsonUnwrapped 序列化细节

作用在字段或方法上，指定某个字段(类型是POJO)序列化成扁平化，而不是嵌套对象，在反序列化时再包装成对象。在2.0+版本中@JsonUnwrapped添加了**prefix和suffix**属性，用来对字段添加前后缀，这在有关属性分组上比较有用
举例：

  1. public class TestPojo {
  2.     public int id;
  3.     @JsonUnwrapped(prefix = "pre_", suffix = "_suf")
  4.     public TestName testName;
  5. }
  6. private class TestName {
  7.     private String firstName;
  8.     private String secondName;
  9. }

结果为: 

  1. {"id":111,"pre_firstName_suf":"张","pre_secondName_suf":"三"}

6. @JsonIdentityInfo 循环依赖

作用于类或属性上，2.0+版本新注解，，当entity被标注后，jackson在每一次序列化的时候都会为该实例生成专门的ID（也可以是实例自带的属性），通过这种方式辨别实例。这种方式适用于存在一个实体关联链的场景，比如 Parent->Child->Perent。实际使用时应尽量避免这种循环依赖的情况，如果出现，可以使用@JsonIgnore忽略不解析的数据。

  1. @JsonIdentityInfo(generator = ObjectIdGenerators.IntSequenceGenerator.class,property = "@id")
  2. public static class Parent{
  3.     private String name;
  4.     private Child[] children;
  6. }
  7. @JsonIdentityInfo(generator=ObjectIdGenerators.IntSequenceGenerator.class, property="@id")
  8. public static class Child{
  9.     private String name;
  10.     private Parent parent;
  11. }

7. @JsonNaming 批量命名

作用于类或方法上，jackson 2.1+版本的注解，注意这个注解是在jackson-databind包中而不是在jackson-annotations包里，它可以让你定制属性命名策略，作用和前面提到的@JsonProperty的重命名属性名称相同。
如果POJO里有很多属性，给每个属性都要加上@JsonProperty是多么繁重的工作，这里就需要用到@JsonNaming了，它不仅能制定统一的命名规则，还能任意按自己想要的方式定制。

  1. @JsonNaming(PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy.class)
  2. public class TestPOJO{
  3.     public String id;
  4.     public String name;
  5. }

命名策略
@JsonNaming使用了jackson已经实现的命名策PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy，它可以将大写转换为小写并添加下划线。你可以自定义，必须继承类PropertyNamingStrategy，建议继承PropertyNamingStrategyBase，我们自己实现一个类似LowerCaseWithUnderscoresStrategy的策略，只是将下划线改为破折号

  1. public static class MyPropertyNamingStrategy extends PropertyNamingStrategy.PropertyNamingStrategyBase {
  2.     @Override
  3.     public String translate(String input) {
  4.         if (input == null) return input; // garbage in, garbage out
  5.         int length = input.length();
  6.         StringBuilder result = new StringBuilder(length * 2);
  7.         int resultLength = 0;
  8.         boolean wasPrevTranslated = false;
  9.         for (int i = 0; i < length; i++)
  10.         {
  11.             char c = input.charAt(i);
  12.             if (i > 0 || c != '-') // skip first starting underscore
  13.             {
  14.                 if (Character.isUpperCase(c))
  15.                 {
  16.                     if (!wasPrevTranslated && resultLength > 0 && result.charAt(resultLength - 1) != '-')
  17.                     {
  18.                         result.append('-');
  19.                         resultLength++;
  20.                     }
  21.                     c = Character.toLowerCase(c);
  22.                     wasPrevTranslated = true;
  23.                 }
  24.                 else
  25.                 {
  26.                     wasPrevTranslated = false;
  27.                 }
  28.                 result.append(c);
  29.                 resultLength++;
  30.             }
  31.         }
  32.         return resultLength > 0 ? result.toString() : input;
  33.     }
  34. }

如果你想让自己定制的策略对所有解析都实现，除了对每个具体的实体类对应的位置加上@JsonNaming外你还可以如下做全局配置

  1. ObjectMapper objectMapper = new ObjectMapper();
  2. objectMapper.setPropertyNamingStrategy(new MyPropertyNamingStrategy());

三. 多态类型处理注解

jackson允许配置多态类型处理，当进行反序列化时，JSON数据匹配的对象可能有多个子类型，为了正确的读取对象的类型，我们需要添加一些类型信息。可以通过下面几个注解来实现：

1. @JsonTypeInfo 多态解析

作用于类/接口，被用来开启多态类型处理，对基类/接口和子类/实现类都有效
这个注解有一些属性：

  • use**: 定义使用哪一种类型识别码**，它有下面几个可选值

    • JsonTypeInfo.Id.CLASS：使用完全限定类名做识别，如com.logicbig.example.TestPOJO

    • JsonTypeInfo.Id.**MINIMAL_CLASS**：若基类和子类在同一包类，使用类名(忽略包名)作为识别码

    • JsonTypeInfo.Id.**NAME：一个合乎逻辑的指定名称，结合@JsonSubTypes（name = “map”）**使用

    • JsonTypeInfo.Id.**C**USTOM：自定义识别码，由@JsonTypeIdResolver对应，稍后解释

    • JsonTypeInfo.Id.**NO**NE：不使用识别码

  • i**nclude(可选): 指定识别码是如何被包含进去的**，它有下面几个可选值：

    • JsonTypeInfo.As.**PROPERTY**：作为数据的兄弟属性

    • JsonTypeInfo.As.**EXISTING_PROPERTY**：作为POJO中已经存在的属性

    • JsonTypeInfo.As.**EXTERNAL_PROPERTY**：作为扩展属性

    • JsonTypeInfo.As.**WRAPPER_OBJECT**：作为一个包装的对象

    • JsonTypeInfo.As.**WRAPPER_ARRAY**：作为一个包装的数组

  • property(可选)**:制定识别码的属性名称，仅当一下情况时有效**
    • use
      • JsonTypeInfo.Id.CLASS（若不指定property则默认为@class）
      • use为JsonTypeInfo.Id.MINIMAL_CLASS(若不指定property则默认为@c)
      • use为JsonTypeInfo.Id.NAME(若不指定property默认为@type)，通常在这种情况下使用
    • include
      • JsonTypeInfo.As.PROPERTY
      • JsonTypeInfo.As.EXISTING_PROPERTY
      • JsonTypeInfo.As.EXTERNAL_PROPERTY
  • defaultImpl(可选)**：类型识别码不存在或者无效时指定反序列化时使用的默认类型**
    • 通常在use为JsonTypeInfo.Id.NAME时，配合property**使用**
  • visible(可选)**：是否可见，默认false**，通常不配置
    • 属性定义了类型标识符的值是否会通过JSON流成为反序列化器的一部分，默认为fale,也就是说,jackson会从JSON内容中处理和删除类型标识符再传递给JsonDeserializer。

举例：

  1. @JsonTypeInfo(
  2.     use = JsonTypeInfo.Id.NAME,
  3.     property = "type",
  4.     defaultImpl = Son1.class
  5. )
  6. @JsonSubTypes({
  7.     @JsonSubTypes.Type(value = Son1.class, name = "son1"),
  8.     @JsonSubTypes.Type(value = Son2.class, name = "son2"),
  9.     @JsonSubTypes.Type(value = Son3.class, name = "son3") 
  10. })
  11. public Father {}
  1. @JsonTypeInfo(use = Id.MINIMAL_CLASS)
  2. @JsonSubTypes({
  3.     @JsonSubTypes.Type(Son1.class),
  4.     @JsonSubTypes.Type(Son2.class)
  5. })
  6. public Father {}

2. @JsonSubTypes 指定子类型

作用于类/接口，用来列出给定类的子类，只有当子类类型无法被检测到时才会使用它
一般是配合@JsonTypeInfo在基类上使用

  1. @JsonSubTypes({
  2.     @JsonSubTypes.Type(Son1.class),
  3.     @JsonSubTypes.Type(Son2.class)
  4. })

@JsonSubTypes的值是一个@JsonSubTypes.Type[]数组，里面枚举了多态类型(value对应类)和类型的标识符值(name对应@JsonTypeInfo中的property标识名称的值，此为可选值，若不制定需由@JsonTypeName在子类上制定)

3. @JsonTypeName 指定子类型的name

作用于子类，在未设置@JsonSubTypes 时用来为多态子类指定类型标识符的值，如果未在父类上设置@JsonSubTypes可以在子类上指定name
比如：

  1. @JsonTypeName(value = "son1")
  2. public Son1 {}

4. @JsonTypeResolver和@JsonTypeIdResoler（自定义多态）

作用于类，可以自定义多态的类型标识符，这个平时很少用到，主要是现有的一般就已经满足绝大多数的需求了，如果你需要比较特别的类型标识符，建议使用这2个注解，自己定制基于TypeResolverBuilder和TypeIdResolver的类即可

5. 例子

定义父类Super，子类Sub1和Sub2，创建TestPOJO内部的成员变量为Super数组，转换成json字符串。

  1. import com.fasterxml.jackson.databind.ObjectMapper;
  2. import lombok.AllArgsConstructor;
  3. import lombok.Data;
  4. import lombok.NoArgsConstructor;
  6. public class JacksonUtilsTest {
  8.     public static void main(String[] args) throws Exception {
  9.         Sub1 sub1 = new Sub1();
  10.         sub1.setId(1);
  11.         sub1.setName("sub1Name");
  12.         Sub2 sub2 = new Sub2();
  13.         sub2.setId(2);
  14.         sub2.setAge(33);
  15.         ObjectMapper objectMapper = new ObjectMapper();
  16.         TestPOJO testPOJO = new TestPOJO();
  17.         testPOJO.setSupers(new Super[]{sub1, sub2});
  18.         String jsonStr = objectMapper.writeValueAsString(testPOJO);
  19.         //TestPOJO testPOJO_2 = objectMapper.readValue(jsonStr, TestPOJO.class);
  20.         System.out.println(jsonStr);
  21.     }
  24.     @Data
  25.     public static abstract class Super{
  26.         private int id;
  27.     }
  29.     @Data
  30.     public static class Sub1 extends Super{
  31.         private String name;
  32.     }
  34.     @Data
  35.     public static class Sub2 extends Super{
  36.         private int age;
  37.     }
  38.     @Data
  39.     @AllArgsConstructor
  40.     @NoArgsConstructor
  41.     public static class TestPOJO{
  42.         private JacksonUtilsTest.Super[] supers;
  43.     }
  44. }

这是序列化时最简单的一种多态处理方式，因为没有使用任何多态处理注解，即默认使用的识别码类型为**JsonTypeInfo.Id.**NONE，而jackson没有自动搜索功能，所以只能序列化而不能反序列化(去掉注释会报错)，上面序列化测试的结果格式化后为以下结果，我们可以看到JSON串中是没有对应的多态类型识别码的。

  1. {
  2.     "supers": [
  3.         {
  4.             "id": 1,
  5.             "name": "sub1Name"
  6.         },
  7.         {
  8.             "id": 2,
  9.             "age": 33
  10.         }
  11.     ]
  12. }

下面我们在基类Super上加上多态处理相关注解，首先我们在基类Super上添加@JsonTy**peInfo(use = JsonTypeInfo.Id.CLASS)**即

  1.     @Data
  2.     @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS,property = "typeName")
  3.     public static abstract class Super{
  4.         private int id;
  5.     }

再次执行上面的序列化测试代码结果将会是:

  1. {
  2.     "supers": [
  3.         {
  4.             "typeName": "com.logicbig.example.JacksonUtilsTest$Sub1",
  5.             "id": 1,
  6.             "name": "sub1Name"
  7.         },
  8.         {
  9.             "typeName": "com.logicbig.example.JacksonUtilsTest$Sub2",
  10.             "id": 2,
  11.             "age": 33
  12.         }
  13.     ]
  14. }

这次多态类型识别码的名称已经变成了我们指定的typeName而不是默认的@class了
上面的例子都是默认选择的include为**JsonTypeInfo.As.**PROPERTY，下面我们更改include方式，看看有什么变化，将include设置为**JsonTypeInfo.As.**WRAPPER_OBJECT即

  1. @Data
  2.     @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS,include = JsonTypeInfo.As.WRAPPER_OBJECT,property = "typeName")
  3.     public static abstract class Super{
  4.         private int id;
  5.     }

结果为:

  1. {
  2.     "supers": [
  3.         {
  4.             "com.logicbig.example.JacksonUtilsTest$Sub1": {
  5.                 "id": 1,
  6.                 "name": "sub1Name"
  7.             }
  8.         },
  9.         {
  10.             "com.logicbig.example.JacksonUtilsTest$Sub2": {
  11.                 "id": 2,
  12.                 "age": 33
  13.             }
  14.         }
  15.     ]
  16. }

我们看到类型识别码不再成为兄弟属性包含进去了而是为父属性将其他属性包含进去，此时我们指定的property=“typeName”已经无用了

再次修改use属性指定为JsonTypeInfo.Id.**MINIMAL_CLASS**，即

  1. @JsonTypeInfo(use = JsonTypeInfo.Id.MINIMAL_CLASS,
  2.               include = JsonTypeInfo.As.PROPERTY,property = "typeName")

结果为：

  1. {
  2.     "supers": [
  3.         {
  4.             "typeName": ".JacksonUtilsTest$Sub1",
  5.             "id": 1,
  6.             "name": "sub1Name"
  7.         },
  8.         {
  9.             "typeName": ".JacksonUtilsTest$Sub2",
  10.             "id": 2,
  11.             "age": 33
  12.         }
  13.     ]
  14. }

我们发现已经没有同包的package名称，识别码的值更加简短了

测试反序列化

此时我们取消之前反序列化的注释

  1. TestPOJO testPOJO_2 = objectMapper.readValue(jsonStr, TestPOJO.class);

通过debug查看testPOJO_2的结构，我们可以看到已经反序列化成功了
image.png

可能我们在反序列化时觉得如此传递识别码很不友好，最好可以自定义识别码的值，可以选择use = JsonTypeInfo.Id.NAME和@JsonSubTypes配合即

  1. @JsonTypeInfo(use = JsonTypeInfo.Id.MINIMAL_CLASS)
  2. @JsonSubTypes({@JsonSubTypes.Type(value=Sub1.class,name="sub1"),
  3.                @JsonSubTypes.Type(value=Sub2.class,name="sub2")})
  4. public static abstract class Super{
  5.     private int id;
  6.     //getters、setters省略
  7. }

结果为:

  1. {
  2.     "supers": [
  3.         {
  4.             "@c": ".JacksonUtilsTest$Sub1",
  5.             "id": 1,
  6.             "name": "sub1Name"
  7.         },
  8.         {
  9.             "@c": ".JacksonUtilsTest$Sub2",
  10.             "id": 2,
  11.             "age": 33
  12.         }
  13.     ]
  14. }

也可以在子类上添加@JsonTypeName(value = “sub1”)和@JsonTypeName(value = “sub2”)以便取代父类上的@JsonSubTypes注解

如果想不使用@JsonSubTypes来侵入代码，我们可以在ObjectMapper上注册子类实现，即

  1. ObjectMapper objectMapper = new ObjectMapper();
  2. objectMapper.registerSubtypes(new NamedType(Sub1.class,"sub1"));
  3. objectMapper.registerSubtypes(new NamedType(Sub2.class,"sub2"));

四. 用于序列化和反序列化的注解

（未解析）

1. @JsonSerialize和@JsonDeserialize

作用于方法和字段上，通过 using(JsonSerializer)和using(JsonDeserializer)来指定序列化和反序列化的实现，通常我们在需要自定义序列化和反序列化时会用到，比如下面的例子中的日期转换

  1. @Test
  2. public void jsonSerializeAndDeSerialize() throws Exception {
  3.     TestPOJO testPOJO = new TestPOJO();
  4.     testPOJO.setName("myName");
  5.     testPOJO.setBirthday(new Date());
  6.     ObjectMapper objectMapper = new ObjectMapper();
  7.     String jsonStr = objectMapper.writeValueAsString(testPOJO);
  8.     System.out.println(jsonStr);
  10.     String jsonStr2 = "{\"name\":\"myName\",\"birthday\":\"2014-11-11 19:01:58\"}";
  11.     TestPOJO testPOJO2 = objectMapper.readValue(jsonStr2,TestPOJO.class);
  12.     System.out.println(testPOJO2.toString());
  13. }
  15. public static class TestPOJO{
  16.     private String name;
  17.     @JsonSerialize(using = MyDateSerializer.class)
  18.     @JsonDeserialize(using = MyDateDeserializer.class)
  19.     private Date birthday;
  21.     //getters、setters省略
  23.     @Override
  24.     public String toString() {
  25.         return "TestPOJO{" +
  26.             "name='" + name + '\'' +
  27.             ", birthday=" + birthday +
  28.             '}';
  29.     }
  30. }
  32. private static class MyDateSerializer extends JsonSerializer<Date>{
  33.     @Override
  34.     public void serialize(Date value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
  35.         DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  36.         String dateStr = dateFormat.format(value);
  37.         jgen.writeString(dateStr);
  38.     }
  39. }
  41. private static class MyDateDeserializer extends JsonDeserializer<Date>{
  42.     @Override
  43.     public Date deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
  44.         String value = jp.getValueAsString();
  45.         DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  46.         try {
  47.             return dateFormat.parse(value);
  48.         } catch (ParseException e) {
  49.             e.printStackTrace();
  50.         }
  51.         return null;
  52.     }
  53. }

上面的例子中自定义了日期的序列化和反序列化方式，可以将Date和指定日期格式字符串之间相互转换。

也可以通过使用as(JsonSerializer)和as(JsonDeserializer)来实现多态类型转换，上面我们有提到多态类型处理时可以使用@JsonTypeInfo实现，还有一种比较简便的方式就是使用@JsonSerialize和@JsonDeserialize指定as的子类类型，注意这里必须指定为子类类型才可以实现替换运行时的类型

  1. @Test 
  2. public void jsonSerializeAndDeSerialize() throws Exception {
  3.     TestPOJO testPOJO = new TestPOJO();
  4.     testPOJO.setName("myName");
  5.     Sub1 sub1 = new Sub1();
  6.     sub1.setId(1);
  7.     sub1.setName("sub1Name");
  8.     Sub2 sub2 = new Sub2();
  9.     sub2.setId(2);
  10.     sub2.setAge(22);
  11.     testPOJO.setSub1(sub1);
  12.     testPOJO.setSub2(sub2);
  13.     ObjectMapper objectMapper = new ObjectMapper();
  14.     String jsonStr = objectMapper.writeValueAsString(testPOJO);
  15.     System.out.println(jsonStr);
  16.     String jsonStr2 = "{\"name\":\"myName\",\"sub1\":{\"id\":1,\"name\":\"sub1Name\"},\"sub2\":{\"id\":2,\"age\":22}}";
  17.     TestPOJO testPOJO2 = objectMapper.readValue(jsonStr2,TestPOJO.class);
  18.     System.out.println(testPOJO2.toString());
  19. }
  21. public static class TestPOJO{
  22.     private String name;
  23.     @JsonSerialize(as = Sub1.class)
  24.     @JsonDeserialize(as = Sub1.class)
  25.     private MyIn sub1;
  26.     @JsonSerialize(as = Sub2.class)
  27.     @JsonDeserialize(as = Sub2.class)
  28.     private MyIn sub2;
  30.     //getters、setters省略
  32.     @Override
  33.     public String toString() {
  34.         return "TestPOJO{" +
  35.             "name='" + name + '\'' +
  36.             ", sub1=" + sub1 +
  37.             ", sub2=" + sub2 +
  38.             '}';
  39.     }
  40. }
  42. public static class MyIn{
  43.     private int id;
  45.     //getters、setters省略
  46. }
  48. public static class Sub1 extends MyIn{
  49.     private String name;
  51.     //getters、setters省略
  53.     @Override
  54.     public String toString() {
  55.         return "Sub1{" +
  56.             "id=" + getId()  +
  57.             "name='" + name + '\'' +
  58.             '}';
  59.     }
  60. }
  61. public static class Sub2 extends MyIn{
  62.     private int age;
  63.     //getters、setters省略
  65.     @Override
  66.     public String toString() {
  67.         return "Sub1{" +
  68.             "id=" + getId() +
  69.             "age='" + age +
  70.             '}';
  71.     }
  72. }

上面例子中通过as来指定了需要替换实际运行时类型的子类，实际上上面例子中序列化时是可以不使用@JsonSerialize(as = Sub1.class)的，因为jackson可以自动将POJO转换为对应的JSON，而反序列化时由于无法自动检索匹配类型必须要指定@JsonDeserialize(as = Sub1.class)方可实现
最后@JsonSerialize可以配置include属性来指定序列化时被注解的属性被包含的方式，默认总是被包含进来，但是可以过滤掉空的属性或有默认值的属性，举个简单的过滤空属性的例子如下

  1. @Test
  2. public void jsonSerializeAndDeSerialize() throws Exception {
  3.     TestPOJO testPOJO = new TestPOJO();
  4.     testPOJO.setName("");
  5.     ObjectMapper objectMapper = new ObjectMapper();
  6.     String jsonStr = objectMapper.writeValueAsString(testPOJO);
  7.     Assert.assertEquals("{}",jsonStr);
  8. }
  10. public static class TestPOJO{
  11.     @JsonSerialize(include = JsonSerialize.Inclusion.NON_EMPTY)
  12.     private String name;
  14.     //getters、setters省略
  15. }

2. @JsonPropertyOrder

作用在类上，被用来指明当序列化时需要对属性做排序，它有2个属性
一个是alphabetic：布尔类型，表示是否采用字母拼音顺序排序，默认是为false，即不排序

  1. @Test
  2. public void jsonPropertyOrder() throws Exception {
  3.     TestPOJO testPOJO = new TestPOJO();
  4.     testPOJO.setA("1");
  5.     testPOJO.setB("2");
  6.     testPOJO.setC("3");
  7.     testPOJO.setD("4");
  8.     ObjectMapper objectMapper = new ObjectMapper();
  9.     String jsonStr = objectMapper.writeValueAsString(testPOJO);
  10.     Assert.assertEquals("{\"a\":\"1\",\"c\":\"3\",\"d\":\"4\",\"b\":\"2\"}",jsonStr);
  11. }
  13. public static class TestPOJO{
  14.     private String a;
  15.     private String c;
  16.     private String d;
  17.     private String b;
  19.     //getters、setters省略
  20. }

我们先看一个默认的排序方式，序列化单元测试结果依次为{“a”:”1”,”c”:”3”,”d”:”4”,”b”:”2”}，即是没有经过排序操作的，在TestPOJO上加上@jsonPropertyOrder(alphabetic = true)再执行测试结果将会为{“a”:”1”,”b”:”2”,”c”:”3”,”d”:”4”}
还有一个属性是value：数组类型，表示将优先其他属性排序的属性名称

  1. @Test 
  2. public void jsonPropertyOrder() throws Exception {
  3.     TestPOJO testPOJO = new TestPOJO();
  4.     testPOJO.setA("1");
  5.     testPOJO.setB("2");
  6.     testPOJO.setC("3");
  7.     testPOJO.setD("4");
  8.     ObjectMapper objectMapper = new ObjectMapper();
  9.     String jsonStr = objectMapper.writeValueAsString(testPOJO);
  10.     System.out.println(jsonStr);
  11.     Assert.assertEquals("{"c":"3","b":"2","a":"1","d":"4"}",jsonStr);
  12. }
  14. @JsonPropertyOrder(alphabetic = true,value = {"c","b"})
  15. public static class TestPOJO{
  16.     private String a;
  17.     private String c;
  18.     private String d;
  19.     private String b;
  21.     //getters、setters省略
  22. }

上面例子可以看到value指定了c和b属性优先排序，所以序列化后为{“c”:”3”,”b”:”2”,”a”:”1”,”d”:”4”}
还记得本文上面最开始配置MapperFeature时也有属性排序么，对，就是

objectMapper.configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY,true);
只不过@JsonPropertyOrder颗粒度要更细一点，可以决定哪些属性优先排序

3. @JsonView

视图模板，作用于方法和属性上，用来指定哪些属性可以被包含在JSON视图中，在前面我们知道已经有@JsonIgnore和@JsonIgnoreProperties可以排除过滤掉不需要序列化的属性，可是如果一个POJO中有上百个属性，比如订单类、商品详情类这种属性超多，而我们可能只需要概要简单信息即序列化时只想输出其中几个或10几个属性，此时使用@JsonIgnore和@JsonIgnoreProperties就显得非常繁琐，而使用@JsonView便会非常方便，只许在你想要输出的属性(或对应的getter)上添加@JsonView即可，举例：

  1. @Test 
  2. public void jsonView() throws Exception {
  3.     TestPOJO testPOJO = new TestPOJO();
  4.     testPOJO.setA("1");
  5.     testPOJO.setB("2");
  6.     testPOJO.setC("3");
  7.     testPOJO.setD("4");
  8.     ObjectMapper objectMapper = new ObjectMapper();
  9.     objectMapper.configure(MapperFeature.DEFAULT_VIEW_INCLUSION, false);
  10.     String jsonStr = objectMapper.writerWithView(FilterView.OutputA.class).writeValueAsString(testPOJO);
  11.     Assert.assertEquals("{"a":"1","c":"3"}",jsonStr);
  12.     String jsonStr2 = objectMapper.writerWithView(FilterView.OutputB.class).writeValueAsString(testPOJO);
  13.     Assert.assertEquals("{"d":"4","b":"2"}",jsonStr2);
  14. }
  16. public static class TestPOJO{
  17.     @JsonView(FilterView.OutputA.class)
  18.     private String a;
  19.     @JsonView(FilterView.OutputA.class)
  20.     private String c;
  21.     @JsonView(FilterView.OutputB.class)
  22.     private String d;
  23.     @JsonView(FilterView.OutputB.class)
  24.     private String b;
  25.     //getters、setters忽略
  26. }
  29. private static class FilterView {
  30.     static class OutputA {}
  31.     static class OutputB {}
  32. }

上面的测试用例中，我们在序列化之前先设置了objectMapper.configure(MapperFeature.DEFAULT_VIEW_INCLUSION, false)，看javadoc说这是一个双向开关，开启将输出没有JsonView注解的属性，false关闭将输出有JsonView注解的属性，可惜我在测试中开启开关后有JsonView注解的属性任然输出了，大家可以研究下。序列化时使用了objectMapper.writerWithView(FilterView.OutputA.class).writeValueAsString(testPOJO)，即使用哪个视图来输出。在上面的例子中又2种视图，我们在序列化的时候可以选择想要的视图来输出，这在一些地方比较好用，比如安卓、苹果、桌面等不同的客户端可能会输出不同的属性。在1.6版本中这个@JsonView注解同时也会强制性自动发现，也就是说不管属性的可见性以及是否设置了自动发现这些属性都将会自动被发现，在上例中TestPOJO中的getters、setters可以不需要也能输出我们想要的结果。

4. @JsonFilter

Json属性过滤器，作用于类，作用同上面的@JsonView，都是过滤掉不想要的属性，输出自己想要的属性。和@FilterView不同的是@JsonFilter可以动态的过滤属性，比如我不想输出以system开头的所有属性等待，应该说@JsonFilter更高级一点，举个简单的例子

  1. @Test
  2. public void jsonFilter() throws Exception {
  3.     TestPOJO testPOJO = new TestPOJO();
  4.     testPOJO.setA("1");
  5.     testPOJO.setB("2");
  6.     testPOJO.setC("3");
  7.     testPOJO.setD("4");
  8.     ObjectMapper objectMapper = new ObjectMapper();
  9.     FilterProvider filters = new SimpleFilterProvider().addFilter("myFilter",SimpleBeanPropertyFilter.filterOutAllExcept("a"));
  10.     objectMapper.setFilters(filters);
  11.     String jsonStr = objectMapper.writeValueAsString(testPOJO);
  12.     Assert.assertEquals("{\"a\":\"1\"}",jsonStr);
  13. }
  15. @JsonFilter("myFilter")
  16. public static class TestPOJO{
  17.     private String a;
  18.     private String c;
  19.     private String d;
  20.     private String b;
  22.     //getters、setters省略
  23. }

上面例子中在我们想要序列化的POJO上加上了@JsonFilter，表示该类将使用名为myFilter的过滤器。在测试中定义了一个名为myFilter的SimpleFilterProvider，这个过滤器将会过滤掉所有除a属性以外的属性。这只是最简单的输出指定元素的例子，你可以自己实现FilterProvider来满足你的过滤需求。
有时候我们可能需要根据现有的POJO来过滤属性，而这种情况下通常不会让你修改已有的代码在POJO上加注解，这种情况下我们就可以结合@JsonFilter和MixInAnnotations来实现过滤属性，如下例所示，不再多做解释

  1. @Test
  2. public void jsonFilter() throws Exception {
  3.     TestPOJO testPOJO = new TestPOJO();
  4.     testPOJO.setA("1");
  5.     testPOJO.setB("2");
  6.     testPOJO.setC("3");
  7.     testPOJO.setD("4");
  8.     ObjectMapper objectMapper = new ObjectMapper();
  9.     FilterProvider filters = new SimpleFilterProvider().addFilter("myFilter",SimpleBeanPropertyFilter.filterOutAllExcept("a"));
  10.     objectMapper.setFilters(filters);
  11.     objectMapper.addMixInAnnotations(TestPOJO.class,MyFilterMixIn.class);
  12.     String jsonStr = objectMapper.writeValueAsString(testPOJO);
  13.     Assert.assertEquals("{\"a\":\"1\"}",jsonStr);
  14. }
  16. public static class TestPOJO{
  17.     private String a;
  18.     private String c;
  19.     private String d;
  20.     private String b;
  21.     //getters、setters省略
  22. }
  24. @JsonFilter("myFilter")
  25. private static interface MyFilterMixIn{
  26. }

5. @JsonIgnoreType

作用于类，表示被注解该类型的属性将不会被序列化和反序列化，也跟上面几个一样属于过滤属性功能的注解，举例：

  1. @Test 
  2. public void jsonFilter() throws Exception {
  3.     TestPOJO testPOJO = new TestPOJO();
  4.     testPOJO.setName("myName");
  5.     Sub1 sub1 = new Sub1();
  6.     sub1.setId(1);
  7.     sub1.setName("sub1");
  8.     Sub2 sub2 = new Sub2();
  9.     sub2.setId(2);
  10.     sub2.setAge(22);
  11.     testPOJO.setMyIn(sub1);
  12.     testPOJO.setSub1(sub1);
  13.     testPOJO.setSub2(sub2);
  14.     ObjectMapper objectMapper = new ObjectMapper();
  15.     String jsonStr = objectMapper.writeValueAsString(testPOJO);
  16.     System.out.println(jsonStr);
  17. }
  19. public static class TestPOJO{
  20.     private Sub1 sub1;
  21.     private Sub2 sub2;
  22.     private MyIn myIn;
  23.     private String name;
  24.     //getters、setters省略
  25. }
  27. public static class MyIn{
  28.     private int id;
  29.     //getters、setters省略
  30. }
  32. @JsonIgnoreType
  33. public static class Sub1 extends MyIn{
  34.     private String name;
  35.     //getters、setters省略
  36. }
  38. @JsonIgnoreType
  39. public static class Sub2 extends MyIn{
  40.     private int age;
  41.     //getters、setters省略
  42. }

上面例子中我们在类Sub1和Sub2上都加上了@JsonIgnoreType，那么需要序列化和反序列时POJO中所有Sub1和Sub2类型的属性都将会被忽略，上面测试结果为{“myIn”:{“id”:1,”name”:”sub1”},”name”:”myName”}，只输出了name和myIn属性。需要注意的是@JsonIgnoreType是可以继承的，即如果在基类上添加了该注解，那么子类也相当于加了该注解。在上例中，如果只在基类MyIn上添加@JsonIgnoreType那么序列化TestPOJO时将会过滤掉MyIn、Sub1、Sub2。输出结果为{“name”:”myName”}

6. @JsonAnySetter

作用于方法，在反序列化时用来处理遇到未知的属性的时候调用，在本文前面我们知道可以通过注解@JsonIgnoreProperties(ignoreUnknown=true)来过滤未知的属性，但是如果需要这些未知的属性该如何是好?那么@JsonAnySetter就可以派上用场了，它通常会和map属性配合使用用来保存未知的属性，举例：

  1. @Test 
  2. public void jsonAnySetter() throws Exception {
  3.     ObjectMapper objectMapper = new ObjectMapper();
  4.     String jsonStr = "{"name":"myName","code":"12345","age":12}";
  5.     TestPOJO testPOJO = objectMapper.readValue(jsonStr,TestPOJO.class);
  6.     Assert.assertEquals("myName",testPOJO.getName());
  7.     Assert.assertEquals("12345",testPOJO.getOther().get("code"));
  8.     Assert.assertEquals(12,testPOJO.getOther().get("age"));
  9.     }
  11. public static class TestPOJO{
  12.     private String name;
  14.     private Map other = new HashMap();
  16.     @JsonAnySetter
  17.     public void set(String name,Object value) {
  18.         other.put(name,value);
  19.     }
  21.     //getters、setters省略
  22. }

测试用例中我们在set方法上标注了@JsonAnySetter，每当遇到未知的属性时都会调用该方法

7. @JsonCreator

作用于方法，通常用来标注构造方法或静态工厂方法上，使用该方法来构建实例，默认的是使用无参的构造方法，通常是和@JsonProperty或@JacksonInject配合使用，举例

  1. @Test
  2. public void jsonCreator() throws Exception {
  3.     ObjectMapper objectMapper = new ObjectMapper();
  4.     String jsonStr = "{\"full_name\":\"myName\",\"age\":12}";
  5.     TestPOJO testPOJO = objectMapper.readValue(jsonStr,TestPOJO.class);
  6.     Assert.assertEquals("myName",testPOJO.getName());
  7.     Assert.assertEquals(12, testPOJO.getAge());
  8. }
  10. public static class TestPOJO{
  11.     private String name;
  12.     private int age;
  14.     @JsonCreator
  15.     public TestPOJO(@JsonProperty("full_name") String name,@JsonProperty("age") int age){
  16.         this.name = name;
  17.         this.age = age;
  18.     }
  19.     public String getName() {
  20.         return name;
  21.     }
  22.     public int getAge() {
  23.         return age;
  24.     }
  25. }

上面示例中是在构造方法上标注了@JsonCreator，同样你也可以标注在静态工厂方法上，比如：

  1. @Test 
  2. public void jsonCreator() throws Exception {
  3.     ObjectMapper objectMapper = new ObjectMapper();
  4.     String jsonStr = "{"name":"myName","birthday":1416299461556}";
  5.     TestPOJO testPOJO = objectMapper.readValue(jsonStr,TestPOJO.class);
  6.     Assert.assertEquals("myName",testPOJO.getName());
  7.     System.out.println(testPOJO.getBirthday());
  8. }
  10. public static class TestPOJO{
  11.     private String name;
  12.     private Date birthday;
  14.     private TestPOJO(String name,Date birthday){
  15.         this.name = name;
  16.         this.birthday = birthday;
  17.     }
  19.     @JsonCreator
  20.     public static TestPOJO getInstance(@JsonProperty("name") String name,@JsonProperty("birthday") long timestamp){
  21.         Date date = new Date(timestamp);
  22.         return new TestPOJO(name,date);
  23.     }
  25.     public String getName() {
  26.         return name;
  27.     }
  29.     public Date getBirthday() {
  30.         return birthday;
  31.     }
  32. }

这个实例中，TestPOJO的构造方法是私有的，外面无法new出来该对象，只能通过工厂方法getInstance来构造实例，此时@JsonCreator就标注在工厂方法上。
除了这2种方式外，还有一种构造方式成为授权式构造器，也是我们平常比较常用到的，这个构造器只有一个参数，且不能使用@JsonProperty。举例：

  1. @Test
  2. public void jsonCreator() throws Exception {
  3.     ObjectMapper objectMapper = new ObjectMapper();
  4.     String jsonStr = "{\"full_name\":\"myName\",\"age\":12}";
  5.     TestPOJO testPOJO = objectMapper.readValue(jsonStr,TestPOJO.class);
  6.     Assert.assertEquals("myName",testPOJO.getName());
  7.     Assert.assertEquals(12,testPOJO.getAge());
  8. }
  10. public static class TestPOJO{
  11.     private String name;
  12.     private int age;
  13.     @JsonCreator
  14.     public TestPOJO(Map map){
  15.         this.name = (String)map.get("full_name");
  16.         this.age = (Integer)map.get("age");
  17.     }
  19.     public String getName() {
  20.         return name;
  21.     }
  23.     public int getAge() {
  24.         return age;
  25.     }
  26. }

8. @JacksonInject

作用于属性、方法、构造参数上，被用来反序列化时标记已经被注入的属性，举例：

  1. @Test 
  2. public void jacksonInject() throws Exception {
  3.     ObjectMapper objectMapper = new ObjectMapper();
  4.     String jsonStr = "{"age":12}";
  5.     InjectableValues inject = new InjectableValues.Std().addValue("name","myName");
  6.     TestPOJO testPOJO = objectMapper.reader(TestPOJO.class).with(inject).readValue(jsonStr);
  7.     Assert.assertEquals("myName", testPOJO.getName());
  8.     Assert.assertEquals(12,testPOJO.getAge());
  9. }
  11. public static class TestPOJO{
  12.     @JacksonInject("name")
  13.     private String name;
  14.     private int age;
  16.     //getters、setters省略
  17. }

上面例子中我们在反序列化前通过InjectableValues来进行注入我们想要的属性

9. @JsonPOJOBuilder

作用于类，用来标注如何定制构建对象，使用的是builder模式来构建，比如Value v = new ValueBuilder().withX(3).withY(4).build();这种就是builder模式来构建对象，通常会喝@JsonDeserialize.builder来配合使用，我们举个例子：

  1. @Test
  2. public void jacksonInject() throws Exception {
  3.     ObjectMapper objectMapper = new ObjectMapper();
  4.     String jsonStr = "{\"name\":\"myName\",\"age\":12}";
  5.     TestPOJO testPOJO = objectMapper.readValue(jsonStr,TestPOJO.class);
  6.     Assert.assertEquals("myName", testPOJO.getName());
  7.     Assert.assertEquals(12,testPOJO.getAge());
  8. }
  10. @JsonDeserialize(builder=TestPOJOBuilder.class)
  11. public static class TestPOJO{
  12.     private String name;
  13.     private int age;
  15.     public TestPOJO(String name, int age) {
  16.         this.name = name;
  17.         this.age = age;
  18.     }
  20.     public String getName() {
  21.         return name;
  22.     }
  24.     public int getAge() {
  25.         return age;
  26.     }
  27. }
  29. @JsonPOJOBuilder(buildMethodName = "create",withPrefix = "with")
  30. public static class TestPOJOBuilder{
  31.     private String name;
  32.     private int age;
  34.     public TestPOJOBuilder withName(String name) {
  35.         this.name = name;
  36.         return this;
  37.     }
  39.     public TestPOJOBuilder withAge(int age) {
  40.         this.age = age;
  41.         return this;
  42.     }
  44.     public TestPOJO create() {
  45.         return new TestPOJO(name,age);
  46.     }
  47. }

在TestPOJOBuilder上有@JsonPOJOBuilder注解，表示所有的参数传递方法都是以with开头，最终构建好的对象是通过create方法来获得，而在TestPOJO上使用了@JsonDeserializer，告诉我们在反序列化的时候我们使用的是TestPOJOBuilder来构建此对象的

五. 过期注解

还有一些过期不推荐使用的注解，我们一笔带过，主要知道他们是跟哪些其他注解功能一样即可

  • @JsonGetter

作用于方法，1.0版本开始的注解，已经过期，不推荐使用，改用@JsonProperty

  • @JsonUseSerializer

作用于类和方法，1.5版本开始被移除了，改用@JsonSerialize

  • @JsonSetter

作用于方法，1.0版本开始的注解，已过期，不推荐使用，改用@JsonProperty

  • @JsonClass

作用于方法和类，1.9版本开始被移除了，改为@JsonDeserialize.as

  • @JsonContentClass

作用于方法，1.9版本开始被移除了，改为@JsonDeserialize.contentAs

  • @JsonKeyClass

作用于方法和类，1.9版本开始被移除了，改为@JsonDeserialize.keyAs

  • @JsonUseDeserializer

作用于方法和类，1.5版本开始被移除了，改为@JsonDeserialize
**