Jackson介绍

Jackson是Java最受欢迎的JSON类库之一，包含两个不同的解析器：

1. Jackson ObjectMapper，将JSON转化为Java对象，或者转换为Jackson特定的树结构
2. Jackson JsonParser，JSON流解析器，每次只解析一个JSON标记（不做讲解）

Jackson还包含两个不同的生成器：

1. Jackson ObjectMapper，可以从Java对象生成JSON，或者是从Jackson的树结构生成JSON
2. Jackson Generator，每次生成一个JSON标记（不做讲解）

在springMVC中的具体应用

在spring项目中如何实现自定义类型的转换，例如如何将数字类型的属性转换为特定的枚举类型。一般来说，项目都会使用不同的数字来代表属性的不同含义，如果在代码中直接用数字类型表示可读性比较差，因此都会定义一个枚举来表示。但是如果每次都需要手工将数字转换为枚举那就太麻烦了，而且估计没人喜欢这样做。那解决方法是什么呢？

那就是让Jackson来替我们完成这个工作。来看下如何做，有如下代码：

@RestController
@RequestMapping("/json/exam")
public class ExamController {@PostMapping("/getExamList")public Result<List<GetExamListResVo>> getExamList(@Validated @RequestBody GetExamListReqVo reqVo,@AuthenticationPrincipal UserDetails userDetails)throws IOException {//......}
}

GetExamListReqVo类：

public class GetExamListReqVo {private ExamTypeEnum examType;// get set......
}

ExamStatusEnum枚举类：

public enum ExamTypeEnum implements EnumBase {UNKNOWN(0, ""),EXAM_INDEPENDENT(1, "独立考试"),EXAM_COURSE_SUITE(2, "关联课程");private final int code;private final String msg;ExamTypeEnum(int code, String msg) {this.code = code;this.msg = msg;}// get......
}/**
* 枚举类的公共接口，所有枚举均实现了此接口
*/
public interface EnumBase {int getCode();String getMsg();static <E extends Enum<?> & EnumBase> E codeOf(Class<E> enumClass, Integer code) {E[] enumConstants = enumClass.getEnumConstants();for (E e : enumConstants) {if (e.getCode() == code) {return e;}}throw new IllegalArgumentException("the code didn't match any enum,code:" + code + ",enum class:" + enumClass.getName());}
}

目标：将入参:{“examType”:1} 正确转换为 GetExamListReqVo 对象

为了完成这个目标，只需要编写三个类：

/*** 实现了EnumBase接口的枚举类对象序列化和反序列化*/
public class EnumBaseModule extends SimpleModule {public EnumBaseModule() {super(PackageVersion.VERSION);// 找到EnumBase接口所在的包下所有实现该接口的枚举类Set<Class> set = ClassUtils.getAllClassesFromPackage(EnumBase.class.getPackage().getName()).stream().filter(clz -> clz.isEnum() && EnumBase.class.isAssignableFrom(clz)).collect(Collectors.toSet());// 动态注册所有实现了EnumBase接口枚举类的序列化器和反序列化器到Jacksonset.forEach(enumClass -> {addDeserializer(enumClass, new EnumBaseDeserializer(enumClass));addSerializer(enumClass, new EnumBaseSerializer());});}
}/*** 用来序列化实现了EnumBase接口的枚举类*/
public class EnumBaseSerializer extends JsonSerializer<EnumBase> {@Overridepublic void serialize(EnumBase value, JsonGenerator gen, SerializerProvider serializers)throws IOException {if (value != null) {gen.writeNumber(value.getCode());} else {gen.writeNull();}}
}/*** 将前端传过来的数字转换为实现了EnumBase接口的枚举类对象*/
public class EnumBaseDeserializer<E extends Enum<?> & EnumBase> extends JsonDeserializer<EnumBase> implements ContextualDeserializer {private Class<E> targetClass;public EnumBaseDeserializer() {}public EnumBaseDeserializer(Class<E> targetClass) {this.targetClass = targetClass;}@Overridepublic E deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {return EnumBase.codeOf(targetClass, p.getIntValue());}@Overridepublic JsonDeserializer<?> createContextual(DeserializationContext ctxt,BeanProperty property) throws JsonMappingException {targetClass = (Class<E>) ctxt.getContextualType().getRawClass();return new EnumBaseDeserializer<>(targetClass);}
}

然后配置一下springMVC：

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {@Overridepublic void configureMessageConverters(List<HttpMessageConverter<?>> converters) {for (HttpMessageConverter<?> converter : converters) {if (converter instanceof StringHttpMessageConverter) {((StringHttpMessageConverter) converter).setDefaultCharset(StandardCharsets.UTF_8);} else if (converter instanceof MappingJackson2HttpMessageConverter) {MappingJackson2HttpMessageConverter messageConverter = (MappingJackson2HttpMessageConverter) converter;messageConverter.setObjectMapper(objectMapper());}}}@Beanpublic ObjectMapper objectMapper() {ObjectMapper objectMapper = new ObjectMapper();objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);objectMapper.configure(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE, false);objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);// 注册所有实现了EnumBase接口的枚举类处理器objectMapper.registerModule(new EnumBaseModule());return objectMapper;}}

ObjectMapper解析JSON的原理

默认情况下，Jackson通过Java bean的get，set方法，通过去掉get，set再把首字母小写得到的名字去和JSON的属性进行匹配。例如对于getBrand()和setBrand()经过处理得到brand,就会匹配到JSON的brand属性，从而把JSON brand属性的值赋给bean的brand字段。通过一系列这样的处理，就将JSON转换成了Java bean。如果需要以不同的方式来匹配，那么就得使用定制的serializer和deserializer，或者使用Jackson提供的众多的注解。

ObjectMapper创建Java对象的多种方式

Car类定义：

public class Car {private String brand = null;private Integer doors = 0;// get set......
}

测试代码:

        String carJson = "{ \"brand\" : \"Mercedes\", \"doors\" : 5 }";// 从字符串创建Car car = objectMapper.readValue(carJson, Car.class);System.out.println(objectMapper.writeValueAsString(car));// 从Reader创建Reader reader = new StringReader(carJson);car = objectMapper.readValue(reader, Car.class);System.out.println(objectMapper.writeValueAsString(car));File file = ResourceUtils.getFile("classpath:car.json");// 从文件创建car = objectMapper.readValue(file, Car.class);System.out.println(objectMapper.writeValueAsString(car));URL url = ResourceUtils.getFile("classpath:car.json").toURI().toURL();// 从URL创建car = objectMapper.readValue(url, Car.class);System.out.println(objectMapper.writeValueAsString(car));InputStream input = new FileInputStream(file);// 从InputStream创建car = objectMapper.readValue(input, Car.class);System.out.println(objectMapper.writeValueAsString(car));String jsonArray = "[{\"brand\":\"ford\"}, {\"brand\":\"Fiat\"}]";// 解析为数组Car[] cars = objectMapper.readValue(jsonArray, Car[].class);System.out.println(objectMapper.writeValueAsString(cars));// 解析为listList<Car> carList = objectMapper.readValue(jsonArray, new TypeReference<List<Car>>() {});System.out.println(objectMapper.writeValueAsString(carList));String jsonObjectStr = "{\"brand\":\"ford\", \"doors\":5}";// 解析为MapMap<String, Object> map = objectMapper.readValue(jsonObjectStr,new TypeReference<Map<String, Object>>() {});System.out.println(objectMapper.writeValueAsString(map));

配置ObjectMapper的工作方式

有时JSON会拥有比Java对象更多的属性，这种情况下Jackson默认会抛出异常，大概意思是说JSON某个属性未知因为在Java bean中未找到该属性。

然而，有时我们的确会遇到JSON属性比Java对象多的情况。例如我们从REST service获取的JSON会包含更多不需要的属性，这种情况下，Jackson允许通过配置来忽略未知的属性，像这样：

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

原始类型的null处理

public class Car {private String brand = null;private int doors = 0;// 原始类型int// get set......
}

对于{ “brand”:“Toyota”, “doors”:null }

Car类的doors是原始类型int，不能被赋值为null，因此Jackson对于原始类型的null值默认会忽略，然而我们也可以配置Jackson在这种情况下做失败处理：

objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, true);

设为true后对于试图解析原始类型的null就会抛出异常。还有其他更多的配置等等，例如：

// 遇到无效的子类型也不会解析失败
objectMapper.configure(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE, false);
// 对于空的bean也不会失败
objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false); 

更多配置请查阅API说明

Jackson对于Date类的处理

默认情况下Date类型属性会被序列化long的毫秒数，然而Jackson也支持将Date序列化成特定格式的日期字符串

public class Transaction {/*** 单独指定序列化后的格式和反序列化时以此格式来解析日期字符串*/@JsonFormat(pattern = "yyyyMMdd HH:mm:ssSSS", locale = "zh_CN", timezone = "GMT+8")private Date date = null;private Date create = null;// get set......
}

测试代码:

        Transaction transaction = new Transaction();transaction.setCreate(new Date());transaction.setDate(new Date());String resJson = objectMapper.writeValueAsString(transaction);// 默认把时间序列化为long// {"date":"20190618 11:33:42845","create":1560828822845}System.out.println(resJson);

可以改为序列化成日期字符串：

        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.SIMPLIFIED_CHINESE);dateFormat.setTimeZone(TimeZone.getTimeZone("GMT+8"));// 设置这个会影响所有Bean的Date序列化和反序列化objectMapper.setDateFormat(dateFormat);resJson = objectMapper.writeValueAsString(transaction);// {"date":"20190618 11:33:42845","create":"2019-06-18 11:33:42"}System.out.println(resJson);String transactionJsonStr = "{\"type\":\"transfer\",\"date\":\"20190118 14:27:52052\",\"create\":\"2019-01-18 14:27:52\"," +"\"transactionTypeEnum\":\"TICKET\",\"transactionType\":2,\"carTypeEnum\":3}";transaction = objectMapper.readValue(transactionJsonStr, Transaction.class);System.out.println(transaction);

Jackson的树模型JsonNode

Jackson内置有树模型用来代表JSON对象，这个树模型具体有什么用呢？当你不知道要解析的JSON的结构你就会发现它会很有用，或者由于某种原因你没法创建一个类来表示这个JSON对象。另外一个好处是你可以在使用这个JSON对象之前操纵这个JSON对象，核心类是JsonNode。

        String carJson ="{ \"brand\" : \"Mercedes\", \"doors\" : 5," +" \"owners\" : [\"John\", \"Jack\", \"Jill\"]," +" \"nestedObject\" : { \"field\" : \"value\" } }";JsonNode jsonNode = objectMapper.readValue(carJson, JsonNode.class);// 或者jsonNode = objectMapper.readTree(carJson);// 取JSON属性值JsonNode brandNode = jsonNode.get("brand");String brand = brandNode.asText();System.out.println("brand = " + brand);JsonNode doorsNode = jsonNode.get("doors");int doors = doorsNode.asInt();System.out.println("doors = " + doors);// 取JSON数组JsonNode jsonArray = jsonNode.get("owners");JsonNode jsonArrayNode = jsonArray.get(0);String john = jsonArrayNode.asText();System.out.println("john = " + john);// 取JSON内嵌对象JsonNode childNode = jsonNode.get("nestedObject");JsonNode childField = childNode.get("field");String field = childField.asText();System.out.println("field = " + field);

JsonNode类是不可变的，意味着我们不能直接创建该类的对象，然而可以使用JsonNode的子类ObjectNode来构建对象：

        // 创建ObjectNodeObjectNode objectNode = objectMapper.createObjectNode();objectNode.put("brand", "Mercedes");objectNode.put("doors", 5);ObjectNode nestNode = objectMapper.createObjectNode();nestNode.put("field", "value");objectNode.set("nestedObject", nestNode);System.out.println(objectMapper.writeValueAsString(objectNode));

Jackson注解

主要可分为三类：

读写注解（同时影响序列化和反序列化过程）

• @JsonIgnore
• @JsonIgnoreProperties
• @JsonIgnoreType
• @JsonAutoDetect
• @JsonProperty
• @JsonTypeInfo
• @JsonSubTypes

读注解（只影响反序列化过程）

• @JsonSetter
• @JsonAnySetter
• @JsonCreator
• @JsonDeserialize

写注解（只影响序列化过程）

• @JsonInclude
• @JsonGetter
• @JsonAnyGetter
• @JsonPropertyOrder
• @JsonRawValue
• @JsonValue
• @JsonSerialize

@JsonIgnore用于需要忽略的属性（不参与序列化和反序列化）

public class PersonIgnore {@JsonIgnoreprivate long personId = 0;private String name = null;// get set......
}PersonIgnore obj = new PersonIgnore(1,"John");
// {"name":"John"}
System.out.println(objectMapper.writeValueAsString(obj));

@JsonIgnoreProperties用于需要忽略的一系列属性

@JsonIgnoreProperties({"firstName", "lastName"})
public class PersonIgnoreProperties {private long personId = 0;private String firstName = null;private String lastName = null;// get set......
}PersonIgnoreProperties personIgnoreProperties = new PersonIgnoreProperties(1,"John","Rod");
// {"personId":1}
System.out.println(objectMapper.writeValueAsString(personIgnoreProperties));; 

@JsonIgnoreType表明所有用到此类的地方都会被忽略

public class PersonIgnoreType {private long personId = 0;private String name = null;private Address address = null;//get set......
}@JsonIgnoreType
public class Address {private String streetName = null;private String houseNumber = null;private String zipCode = null;private String city = null;private String country = null;// get set......
}PersonIgnoreType obj = new PersonIgnoreType(1, "John", new Address("China"));
// {"personId":1,"name":"John"}
System.out.println(objectMapper.writeValueAsString(obj));

@JsonAutoDetect用于检测需要将哪类访问权限的属性参与序列化和反序列化

@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY )
public class PersonAutoDetect {private long personId = 123;private String name = null;// get set......
}

JsonAutoDetect.Visibility用于指明可见性级别，包括ANY, DEFAULT, NON_PRIVATE, NONE, PROTECTED_AND_PRIVATE and PUBLIC_ONLY

@JsonProperty表明序列化和反序列化时以注解指明的为准

public class Person {@JsonProperty("id") private long personId = 0;private String name = null;// get set......
}

JSON：{ “id” : 1234, “name” : “John”}

@JsonTypeInfo和@JsonSubTypes用来处理多态类型的序列化及反序列化，这样说有点抽象，来看下具体例子

抽象父类:

@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS)
@JsonSubTypes({@JsonSubTypes.Type(value = MemberInformation.class),@JsonSubTypes.Type(value = EcardUserInformation.class)})
@JsonIgnoreProperties(ignoreUnknown = true)
public abstract class LoginUserInformation implements Serializable {private static final long serialVersionUID = -933578885036345619L;private String userType = "1";private String ip = "127.0.0.1";// get set......
}

两个具体子类:

public class MemberInformation extends LoginUserInformation implements Serializable {private static final long serialVersionUID = 3334937746962893477L;private String fpcardno = "513712340023";private String passwd = "12346";// get set......
}public class EcardUserInformation extends LoginUserInformation implements Serializable {private static final long serialVersionUID = -8191715041208933113L;private String aid;private String cellPhone;private String email;// get set......
}

测试代码:

        LoginUserInformation loginUserInformation = new EcardUserInformation();((EcardUserInformation) loginUserInformation).setAid("124124124");// {"@class":"org.javamaster.b2c.test.model.jackson.EcardUserInformation","userType":"1","ip":"127.0.0.1",//  "aid":"124124124","cellPhone":null,"email":null}System.out.println(objectMapper.writeValueAsString(loginUserInformation));LoginUserInformation memberInformation = new MemberInformation();((MemberInformation) memberInformation).setPasswd("qq123123");// {"@class":"org.javamaster.b2c.test.model.jackson.MemberInformation","userType":"1","ip":"127.0.0.1",//  "fpcardno":"513712340023","passwd":"qq123123"}System.out.println(objectMapper.writeValueAsString(memberInformation));String jsonStr = "{\"@class\":\"org.javamaster.b2c.core.model.jackson.MemberInformation\",\"userType\":\"1\"," +"\"ip\":\"127.0.0.1\",\"fpcardno\":\"513712340023\",\"passwd\":\"qq123123\"}";memberInformation = objectMapper.readValue(jsonStr, LoginUserInformation.class);System.out.println(objectMapper.writeValueAsString(memberInformation));

@JsonSetter用于表明set方法应该匹配的JSON的属性，当Java bean的属性名和JSON的属性名不一致时就可以使用此注解

public class Person {private long personId = 0;private String name = null;@JsonSetter("id")  // 应该和JSON的id属性匹配public void setPersonId(long personId) { this.personId = personId; }// get set......
}

JSON：{ “id” : 1234, “name” : “John”}

@JsonAnySetter用于指明将所有JSON未知的属性都收集在一起

public class Bag {private Map<String, Object> properties = new HashMap<>();@JsonAnySetterpublic void set(String fieldName, Object value){this.properties.put(fieldName, value);}public Object get(String fieldName){return this.properties.get(fieldName);}
}

所有JSON未知的属性都会收集到Bag类的properties属性里

@JsonCreator用于表明Java bean有一个构造方法能够匹配JSON的属性和bean的属性，对于一些没有set方法的bean（不可变对象）来说这个注解是很有用的。

public class PersonImmutable {private final long id;private final String name;@JsonCreatorpublic PersonImmutable(@JsonProperty("id")long id, @JsonProperty("name")String name) {this.id = id;this.name = name;}// get set......
}

JSON：{ “id” : 1234, “name” : “John”}

@JsonDeserialize用于定制bean属性的反序列化过程

public class PersonDeserialize {private long id = 0;private String name = null;// 这里我们想把1映射为true，0映射为false@JsonDeserialize(using = OptimizedBooleanDeserializer.class)private boolean enabled = false;// get set......
}public class OptimizedBooleanDeserializer extends JsonDeserializer<Boolean> {@Overridepublic Boolean deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {String text = jsonParser.getText();if ("0".equals(text)) {return false;} else {return true;}}
}

JSON：{“id” : 1234, “name” : “John”，“enabled”: 0}

@JsonInclude用于表明值满足特定条件的属性才会被序列化

 // 说明值不为null且不为空字符串的属性才会被序列化
@JsonInclude(JsonInclude.Include.NON_EMPTY)
public class PersonInclude {private long personId = 0;private String name = null;private String name1 = "";private String name2 = "John";// get set......
}

JSON：{“personId” : 0, “name2” : “John”}

@JsonGetter用于指明序列化后的属性名而不是用bean的字段名

public class PersonGetter {private long personId = 0;@JsonGetter("id")public long personId() { return this.personId; }@JsonSetter("id")public void personId(long personId) { this.personId = personId; }
}

序列化后： {“id”: 0}

@JsonAnyGetter能够让你使用一个Map作为容器包含任何你想要序列化的属性

public class PersonAnyGetter {private Map<String, Object> properties = new HashMap<>();@JsonAnyGetterpublic Map<String, Object> properties() {return properties;}public Map<String, Object> getProperties() {return properties;}
}

@JsonPropertyOrder用于指明bean属性序列化的顺序

@JsonPropertyOrder({"name", "personId"})
public class PersonPropertyOrder {private long personId = 0;private String name = "John";// get set......
}

序列化后： {“name”:“John”,“personId”,0}

@JsonRawValue用于表明属性值不做任何处理原样输出，String类型的值序列化后会被双引号括住，使用此注解后将不会加上双引号

public class PersonRawValue {private long personId = 0;@JsonRawValueprivate String address = "$#";// get set......
}

不加此注解时输出是这样的：{“personId”:0,“address”:"KaTeX parse error: Expected 'EOF', got '#' at position 1: #̲"}，加了后输出是这样的：{"…#}，这很明显是非法的JSON结构，所以我们为什么要这么做呢？这么做的理由是address属性的值是JSON字符串来的，像这样：

public class PersonRawValue {private long personId = 0;@JsonRawValueprivate String address = "{ \"street\" : \"Wall Street\", \"no\":1}";// get set......
}

序列化后是这样的：{“personId”:0,“address”:{ “street” : “Wall Street”, “no”:1}}

不加注解时序列化后是这样的：{“personId”:0,“address”:“{ “street” : “Wall Street”, “no”:1}”}

@JsonValue表明Jackson不做序列化，由此注解标注的方法完成序列化工作

public class PersonValue {private long personId = 0;private String name = null;@JsonValuepublic String toJson(){return this.personId + "," + this.name;}
}

序列化后是这样的：“0,null”

@JsonSerialize用于定制bean属性的序列化过程

public class PersonSerializer {private long personId = 0;private String name = "John";// 这里希望把false序列化成0，true序列化成1@JsonSerialize(using = OptimizedBooleanSerializer.class)private boolean enabled = false;// get set......
}public class OptimizedBooleanSerializer extends JsonSerializer<Boolean> {@Overridepublic void serialize(Boolean aBoolean, JsonGenerator jsonGenerator,SerializerProvider serializerProvider)throws IOException {if (aBoolean) {jsonGenerator.writeNumber(1);} else {jsonGenerator.writeNumber(0);}}
}

完全定制类的序列化和反序列化过程

        // 完全定制类的序列化和反序列化过程SimpleModule carModule = new CarModule();// 注册针对这个类型的处理模块objectMapper.registerModule(carModule);Car car = new Car();car.setBrand("BMW");car.setDoors(4);String json = objectMapper.writeValueAsString(car);System.out.println(json);car = objectMapper.readValue(json, Car.class);System.out.println(objectMapper.writeValueAsString(car));

其中CarModule CarSerializer CarDeserializer的定义：

// 类型处理模块
public class CarModule extends SimpleModule {public CarModule() {super(PackageVersion.VERSION);addDeserializer(Car.class, new CarDeserializer(Car.class));addSerializer(Car.class, new CarSerializer(Car.class));}
}// 序列化器
public class CarSerializer extends StdSerializer<Car> {private static final long serialVersionUID = 2807109332342106505L;public CarSerializer(Class<Car> c) {super(c);}@Overridepublic void serialize(Car car, JsonGenerator jsonGenerator,SerializerProvider serializerProvider)throws IOException {jsonGenerator.writeStartObject();if (car.getBrand() != null) {jsonGenerator.writeStringField("brand", car.getBrand());} else {jsonGenerator.writeNullField("brand");}if (car.getDoors() != null) {jsonGenerator.writeNumberField("doors", car.getDoors());} else {jsonGenerator.writeNullField("doors");}jsonGenerator.writeEndObject();}
}// 反序列化器
public class CarDeserializer extends StdDeserializer<Car> {private static final long serialVersionUID = 4977601024588834191L;public CarDeserializer(Class<?> c) {super(c);}@Overridepublic Car deserialize(JsonParser parser, DeserializationContext deserializer) throws IOException {Car car = new Car();while (!parser.isClosed()) {JsonToken jsonToken = parser.nextToken();if (JsonToken.FIELD_NAME == jsonToken) {String fieldName = parser.getCurrentName();parser.nextToken();if ("doors".equals(fieldName)) {car.setDoors(parser.getValueAsInt());} else if ("brand".equals(fieldName)) {car.setBrand(parser.getValueAsString());}}}return car;}
}