除了FastJson，你也应该了解一下Jackson（二）

概览

上一篇文章介绍了Jackson中的映射器ObjectMapper，以及如何使用它来实现Json与Java对象之间的序列化和反序列化，最后介绍了Jackson中一些序列化/反序列化的高级特性。而本文将会介绍Jackson中的一些常用的（序列化/反序列化）注解，并且通过示例来演示如何使用这些注解，从而来提高我们在处理Json上的工作效率。

序列化注解

@JsonAnyGetter

@JsonAnyGetter注解允许灵活地使用映射（键值对，如Map）字段作为标准属性。

我们声明如下Java类：

@Data
@Accessors(chain = true)
public static class ExtendableBean {public String name;private Map<String, String> properties;@JsonAnyGetterpublic Map<String, String> getProperties() {return properties;}
}

编写测试代码，测试@JsonAnyGetter：

@Test
public void testJsonAnyGetter() throws JsonProcessingException {ExtendableBean extendableBean = new ExtendableBean();Map<String, String> map = new HashMap<>();map.put("age", "13");extendableBean.setName("dxsn").setProperties(map);log.info(new ObjectMapper().writeValueAsString(extendableBean));//打印：{"name":"dxsn","age":"13"}assertThat(new ObjectMapper().writeValueAsString(extendableBean)).contains("name");assertThat(new ObjectMapper().writeValueAsString(extendableBean)).contains("age");
}

如上，可以看properties属性中的键值对（Map）被扩展到了ExtendableBean的Json对象中。

@JsonGetter

@JsonGetter注解是@JsonProperty注解的替代品，用来将一个方法标记为getter方法。

我们创建以下Java类

@Data
@AllArgsConstructor
@NoArgsConstructor
public static class MyBean {public int id;private String name;@JsonGetter("name")public String getTheName() {return name;}
}

如上，我们在类中声明了一个getTheName()方法，并且使用@JsonGetter(“name”)修饰，此时，该方法将会被Jackson认作是name属性的get方法。

编写测试代码：

@Test
public void testJsonGetter() throws JsonProcessingException {MyBean myBean = new MyBean(1, "dxsn");String jsonStr = new ObjectMapper().writeValueAsString(myBean);log.info(jsonStr);assertThat(jsonStr).contains("id");assertThat(jsonStr).contains("name");
}

可以看到，jackson将私有属性name，也进行了序列化。

@JsonPropertyOrder

我们可以使用@JsonPropertyOrder注解来指定Java对象的属性序列化顺序。

@JsonPropertyOrder({"name", "id"})
//order by key's name
//@JsonPropertyOrder(alphabetic = true)
@Data
@Accessors(chain = true)
public static class MyOrderBean {public int id;public String name;
}

编写测试代码：

@Test
public void testJsonPropertyOrder1() throws JsonProcessingException {MyOrderBean myOrderBean = new MyOrderBean().setId(1).setName("dxsn");String jsonStr = new ObjectMapper().writeValueAsString(myOrderBean);log.info(jsonStr);assertThat(jsonStr).isEqualTo("{\"name\":\"dxsn\",\"id\":1}");
}

如上，可以看到序列化得到的Json对象中属性的排列顺序正是我们在注解中指定的顺序。

@JsonRawValue

@JsonRawValue注解可以指示Jackson按原样序列化属性。

在下面的例子中，我们使用@JsonRawValue嵌入一些定制的JSON作为一个实体的值:

@Data
@AllArgsConstructor
@NoArgsConstructor
public static class RawBean {public String name;@JsonRawValuepublic String json;
}

编写测试代码：

@Test
public void testJsonRawValue() throws JsonProcessingException {RawBean rawBean = new RawBean("dxsn", "{\"love\":\"true\"}");log.info(new ObjectMapper().writeValueAsString(rawBean));//输出：{"name":"dxsn","json":{"love":"true"}}String result = new ObjectMapper().writeValueAsString(rawBean);assertThat(result).contains("dxsn");assertThat(result).contains("{\"love\":\"true\"}");
}

@JsonValue

@JsonValue表示Jackson将使用一个方法来序列化整个实例。

下面我们创建一个枚举类：

@AllArgsConstructor
public static enum TypeEnumWithValue {TYPE1(1, "Type A"), TYPE2(2, "Type 2");private Integer id;private String name;@JsonValuepublic String getName() {return name;}
}

如上，我们在getName()上使用@JsonValue进行修饰。

编写测试代码：

@Test
public void testJsonValue() throws JsonProcessingException {String  jsonStr = new ObjectMapper().writeValueAsString(TypeEnumWithValue.TYPE2);log.info(jsonStr);assertThat(jsonStr).isEqualTo("Type 2");
}

可以看到，枚举类的对象序列化后的值即getName()方法的返回值。

@JsonRootName

如果启用了包装（wrapping），则使用@JsonRootName注解可以指定要使用的根包装器的名称。

下面我们创建一个使用@JsonRootName修饰的Java类：

@JsonRootName(value = "user")
@Data
@AllArgsConstructor
public static class UserWithRoot {public int id;public String name;
}

编写测试：

@Test
public void testJsonRootName() throws JsonProcessingException {UserWithRoot userWithRoot = new UserWithRoot(1, "dxsn");ObjectMapper mapper = new ObjectMapper();//⬇️重点！！！mapper.enable(SerializationFeature.WRAP_ROOT_VALUE);String result = mapper.writeValueAsString(userWithRoot);log.info(result);//输出：{"user":{"id":1,"name":"dxsn"}}assertThat(result).contains("dxsn");assertThat(result).contains("user");
}

上面代码中，我们通过开启ObjectMapper的SerializationFeature.WRAP_ROOT_VALUE。可以看到UserWithRoot对象被序列化后的Json对象被包装在user中，而非单纯的{"id":1,"name":"dxsn"}。

@JsonSerialize

@JsonSerialize注解表示序列化实体时要使用的自定义序列化器。

我们定义一个自定义的序列化器：

public static class CustomDateSerializer extends StdSerializer<Date> {private static SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");public CustomDateSerializer() {this(null);}public CustomDateSerializer(Class<Date> t) {super(t);}@Overridepublic void serialize(Date value, JsonGenerator gen, SerializerProvider arg2) throws IOException, JsonProcessingException {gen.writeString(formatter.format(value));}
}

使用自定义的序列化器，创建Java类：

@Data
@AllArgsConstructor
public static class Event {public String name;@JsonSerialize(using = CustomDateSerializer.class)public Date eventDate;
}

编写测试代码：

@Test
public void testJsonSerialize() throws ParseException, JsonProcessingException {SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");String toParse = "20-12-2014 02:30:00";Date date = formatter.parse(toParse);Event event = new Event("party", date);String result = new ObjectMapper().writeValueAsString(event);assertThat(result).contains(toParse);
}

可以看到，使用@JsonSerialize注解修饰指定属性后，将会使用指定的序列化器来序列化该属性。

反序列化注解

@JsonCreator

我们可以使用@JsonCreator注解来优化/替换反序列化中使用的构造器/工厂。

当我们需要反序列化一些与我们需要获取的目标实体不完全匹配的JSON时，它非常有用。

现在，有如下一个Json对象：

{"id":1,"theName":"My bean"}

我们声名了一个Java类：

@Data
public static class BeanWithCreator {private int id;private String name;
}

此时，在我们的目标实体中没有theName字段，只有name字段。现在，我们不想改变实体本身，此时可以通过使用@JsonCreator和@JsonProperty注解来修饰构造函数:

@Data
public static class BeanWithCreator {private int id;private String name;@JsonCreatorpublic BeanWithCreator(@JsonProperty("id") int id, @JsonProperty("theName") String name) {this.id = id;this.name = name;}
}

编写测试：

@Test
public void beanWithCreatorTest() throws JsonProcessingException {String str = "{\"id\":1,\"theName\":\"My bean\"}";BeanWithCreator bean = new ObjectMapper().readerFor(BeanWithCreator.class).readValue(str);assertThat(bean.getId()).isEqualTo(1);assertThat(bean.getName()).isEqualTo("My bean");
}

可以看到，即使Json对象中的字段名和实体类中不一样，但由于我们手动指定了映射字段的名字，从而反序列化成功。

@JacksonInject

@JacksonInject表示java对象中的属性将通过注入来赋值，而不是从JSON数据中获得其值。

创建如下实体类，其中有字段被@JacksonInject修饰：

public static class BeanWithInject {@JacksonInjectpublic int id;public String name;
}

编写测试：

@Test
public void jacksonInjectTest() throws JsonProcessingException {String json = "{\"name\":\"dxsn\"}";InjectableValues inject = new InjectableValues.Std().addValue(int.class, 1);BeanWithInject bean = new ObjectMapper().reader(inject).forType(BeanWithInject.class).readValue(json);assertThat(bean.id).isEqualTo(1);assertThat(bean.name).isEqualTo("dxsn");
}

如上，我们在测试中将json字符串（仅存在name字段）进行反序列化，其中id通过注入的方式对属性进行赋值。

@JsonAnySetter

@JsonAnySetter允许我们灵活地使用映射（键值对、Map）作为标准属性。在反序列化时，JSON的属性将被添加到映射中。

创建一个带有@JsonAnySetter的实体类：

public static class ExtendableBean {public String name;public Map<String, String> properties;@JsonAnySetterpublic void add(String key, String value) {if (properties == null) {properties = new HashMap<>();}properties.put(key, value);}
}

编写测试：

@Test
public void testJsonAnySetter() throws JsonProcessingException {String json = "{\"name\":\"dxsn\", \"attr2\":\"val2\", \"attr1\":\"val1\"}";ExtendableBean extendableBean = new ObjectMapper().readerFor(ExtendableBean.class).readValue(json);assertThat(extendableBean.name).isEqualTo("dxsn");assertThat(extendableBean.properties.size()).isEqualTo(2);
}

可以看到，json对象中的attr1，attr2属性在反序列化之后进入了properties。

@JsonSetter

@JsonSetter是@JsonProperty的替代方法，它将方法标记为属性的setter方法。
当我们需要读取一些JSON数据，但目标实体类与该数据不完全匹配时，这非常有用，因此我们需要优化使其适合该数据。

创建如下实体类：

@Data
public static class MyBean {public int id;private String name;@JsonSetter("name")public void setTheName(String name) {this.name = "hello " + name;}
}

编写测试：

@Test
public void testJsonSetter() throws JsonProcessingException {String json = "{\"id\":1,\"name\":\"dxsn\"}";MyBean bean = new ObjectMapper().readerFor(MyBean.class).readValue(json);assertThat(bean.getName()).isEqualTo("hello dxsn");
}

可以看到，json对象中的name属性为“dxsn”，我们通过在MyBean类中定义了使用@JsonSetter(“name”)注解修饰的方法，这表明该类的对象在反序列话的时候，name属性将来自此方法。最后MyBean对象中name的值变为了hello dxsn。

@JsonDeserialize

@JsonDeserialize注解指定了在反序列化的时候使用的反序列化器。

如下，定义了一个自定义的反序列化器：

public static class CustomDateDeserializer extends StdDeserializer<Date> {private static SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");public CustomDateDeserializer() {this(null);}public CustomDateDeserializer(Class<?> vc) {super(vc);}@Overridepublic Date deserialize(JsonParser jsonparser, DeserializationContext context) throws IOException {String date = jsonparser.getText();try {return formatter.parse(date);} catch (ParseException e) {throw new RuntimeException(e);}}
}

创建一个使用@JsonDeserialize(using = CustomDateDeserializer.class)修饰的实体类：

public static class Event {public String name;@JsonDeserialize(using = CustomDateDeserializer.class)public Date eventDate;
}

编写测试：

@Test
public void whenDeserializingUsingJsonDeserialize_thenCorrect()throws IOException {String json = "{\"name\":\"party\",\"eventDate\":\"20-12-2014 02:30:00\"}";SimpleDateFormat df = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");Event event = new ObjectMapper().readerFor(Event.class).readValue(json);assertThat(event.name).isEqualTo("party");assertThat(event.eventDate).isEqualTo(df.format(event.eventDate));}

可以看到，在Event对象中，eventDate属性通过自定义的反序列化器，将“20-12-2014 02:30:00”反序列化成了Date对象。

@JsonAlias

@JsonAlias在反序列化期间为属性定义一个或多个替代名称。让我们通过一个简单的例子来看看这个注解是如何工作的:

@Data
public static class AliasBean {@JsonAlias({"fName", "f_name"})private String firstName;private String lastName;
}

如上，我们编写了一个使用@JsonAlias修饰的AliasBean实体类。

编写测试：

@Test
public void whenDeserializingUsingJsonAlias_thenCorrect() throws IOException {String json = "{\"fName\": \"John\", \"lastName\": \"Green\"}";AliasBean aliasBean = new ObjectMapper().readerFor(AliasBean.class).readValue(json);assertThat(aliasBean.getFirstName()).isEqualTo("John");
}

可以看到，即使json对象中的字段名是fName，但是由于在AliasBean中使用@JsonAlias修饰了firstName属性，并且指定了两个别名。所以反序列化之后fName被映射到AliasBean对象的firstName属性上。

除上述注解之外，Jackson还提供了很多额外的注解，这里不一一列举，接下来会例举几个常用的注解：

@JsonProperty：可以在类的指定属性上添加@JsonProperty注解来表示其对应在JSON中的属性名。
@JsonFormat：此注解在序列化对象中的日期/时间类型属性时可以指定一种字符串格式输出，如：@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = “dd-MM-yyyy hh:mm:ss”)。
@JsonUnwrapped：@JsonUnwrapped定义了在序列化/反序列化时应该被扁平化的值。
@JsonIgnore:序列化/反序列化时忽略被修饰的属性。
…

总结

本文主要介绍了Jackson常用的序列化/反序列化注解，最后介绍了几个常用的通用注解。Jackson中提供的注解除了本文列举的还有很多很多，使用注解可以让我们的序列化/反序列化工作更加轻松。如果你想将某库换成Jackson，希望这篇文章可以帮到你。

本文涉及的代码地址：https://gitee.com/jeker8chen/jackson-annotation-demo