Jackson使用简介与示例

Jackson是当前用最流行的json解析器之一，用来序列化和反序列化。

Jackson基础

Jackson的核心模块由三部分组成：

• jackson-core：核心包，提供基于"流模式"解析的相关API，包括JsonPaser和JsonGenerator；
• jackson-annotations：注解包，提供标准注解功能；
• jackson-databind：数据绑定包，提供基于"对象绑定"解析的相关API（ObjectMapper）和"树模型"解析的相关API（JsonNode）。

为使用Jackson，需要在pom.xml中增加maven依赖：

<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-core</artifactId>
	<version>2.11.2</version>
</dependency>

ObjectMapper

ObjectMapper类是Jackson库的主要类：它将JSON映射到Java对象（反序列化），或将Java对象映射到JSON（序列化）。它使用JsonParser和JsonGenerator的实例实现JSON实际的读/写。

ObjectMapper有三种方式将JSON字段与Java字段进行匹配：

• 将JSON对象的字段映射到Java对象中的字段；或与Java对象中的getter和setter方法相匹配（删除getter和setter方法名称的“get”和“set”部分，并将剩余名称的第一个字符转换为小写）。
• 通过java反射进行匹配；
• 通过注解或者其它方式进行自定义的序列化和反序列化程序；

通过对其设置可以改变序列化方式与行为：

// 设置输入:禁止把POJO中值为null的字段映射到json字符串中
objectMapper.configure(SerializationFeature.WRITE_NULL_MAP_VALUES, false);
//反序列化时，属性不存在的兼容处理（遇到未知属性时是否引起结果失败）
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

//空值不序列化
objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

// 类为空时，不要抛异常
objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);

// 禁止序列化日期时以timestamps输出，默认true
objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
// 序列化时，日期的统一格式（针对Date类）
objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

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

注解

通过Jackson的注解，可根据实际需要，灵活的调整它的默认序列化与反序列化方式。

注解	说明
@JsonProperty	用于属性，指定属性对应序列化名称 @JsonProperty(“Name”) private String name;
@JsonFormat	用于属性或者方法，把属性的格式序列化时转换成指定的格式 @JsonFormat(pattern = “yyyy-MM-dd HH:mm:ss”) private LocalDateTime cur;
@JsonIgnore	用于属性，指定属性不被Jackson序列化和反序列化
@JsonRootName	用于类，指定有rootName时，rootName名称 @JsonRootName(“MyPerson”) class Person {}
@JsonPropertyOrde	用于类，指定属性在Json中的顺序 @JsonPropertyOrder({ “birthday”, “name” }) class Person {}

Java8日期时间类支持

Java8增加了一套全新的日期时间类(LocalDate, LocalTime, LocalDateTime)，为支持这些类的序列化，需要先注册这些模块。

objectMapper.registerModule(new JavaTimeModule())
        // .registerModule(new ParameterNamesModule())
        .registerModule(new Jdk8Module());

Jackson使用

通过Jackson，即可方便的对类进行直接序列化；也可通过Map或JsonNode进行手动序列化。

Convert类封装

为了方便使用，我们封装Jackson为：

public class JasonConvert {
     
    private static final Logger _logger = LoggerFactory.getLogger(JasonConvert.class);
    private final static ObjectMapper objectMapper = new ObjectMapper();

    static {
     
        objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        // 强制JSON 空字符串("")转换为null
        objectMapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

        objectMapper.registerModule(new JavaTimeModule())
                // .registerModule(new ParameterNamesModule())
                .registerModule(new Jdk8Module());
    }

    public static <T> T fromJson(String strJson, Class<T> clsT) {
     
        try {
     
            return objectMapper.readValue(strJson, clsT);
        } catch (IOException e) {
     
            _logger.error("Deserialize fail: {}", e);
        }
        return null;
    }

    public static String toJson(Object obj) {
     
        try {
     
            return objectMapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
     
            _logger.error("Serialize fail: {}", e);
        }
        return null;
    }

    public static void toFile(String strFile, Object obj){
     
        try {
     
            objectMapper.writeValue(new File(strFile), obj);
        } catch (IOException e) {
     
            _logger.error("Serialize fail: {}", e);
        }
    }

    public static <T> T fromFile(String strFile, Class<T> clsT) {
     
        try {
     
            return objectMapper.readValue(new File(strFile), clsT);
        } catch (IOException e) {
     
            _logger.error("Deserialize fail: {}", e);
        }
        return null;
    }

    public static JsonNode asTree(String strJson) {
     
        try {
     
            return objectMapper.readTree(strJson);
        } catch (IOException e) {
     
            _logger.error("Deserialize fail: {}", e);
        }
        return null;
    }
}

JsonNode构造Json

使用JsonNode，可以方便的构造Json（但是不支持Java8日期时间类）；通过ArrayNode可以添加数组：

static void createJsonByNode() {
     
    JsonNodeFactory nodeFactory = JsonNodeFactory.instance;
    ObjectNode rootNode = nodeFactory.objectNode();
    rootNode.put("cap", "test");
    rootNode.put("count", 123);
    rootNode.put("result", true);
    // rootNode.put("time", LocalTime.now());

    ArrayNode aryNode = nodeFactory.arrayNode();
    aryNode.add("first");
    aryNode.add("second");
    rootNode.set("names", aryNode);

    ArrayNode numbers = nodeFactory.arrayNode(2);
    numbers.add(1);
    numbers.add(2);
    rootNode.set("values", numbers);

    String strJson = toJson(rootNode);
    // {"cap":"test","count":123,"result":true,"names":["first","second"],"values":[1,2]}
    System.out.println(strJson);
}

Map构造Json

通过Map可灵活地构造Json：

static void createJsonByMap() {
     
    Map<String, Object> mapJson = new HashMap<>();
    mapJson.put("cap", "test");
    mapJson.put("count", 123);
    mapJson.put("result", true);
    mapJson.put("time", new Date());
    mapJson.put("names", new String[] {
      "first", "second" });
    mapJson.put("values", new int[] {
      1, 2 });

    String strJson = toJson(mapJson);
    // {"result":true,"cap":"test","names":["first","second"],"values":[1,2],"count":123,"time":"2020-09-12 22:31:04"}
    System.out.println(strJson);
}

类构造Json

最常用的方式就是通过类进行Json的构造，同时也可通过属性进行灵活地控制。定义类：

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@JsonPropertyOrder({
      "birthday", "name" }) 
@JsonRootName("Person")
class Person {
     
    @JsonProperty("Name")
    private String name;
    @JsonIgnore
    private int age;
    private LocalDate birthday;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime cur;
}

通过Builder属性，可构造出有调用链的类，方便构造与属性设定。有了类后，我们即可方便的进行序列化与反序列化：

Person per = Person.builder().name("mike").birthday(LocalDate.of(2010, 3, 5)).build(); // new Person();
per.setCur(LocalDateTime.now());
per.setAge(12);
String strJson = toJson(per);
// {"birthday":"2010-03-05","Name":"mike","cur":"2020-09-12 22:31:04"}
System.out.println(strJson);

Person p2 = fromJson(strJson, Person.class);
System.out.println(p2);

tree反序列化

通过tree可以反序列化Json后，方便、灵活地获取里面的元素：

String strResult = "{\"session\":123456789,\"name\":\"mike\",\"info\": {\"user\":\"1008\", \"disc\":\"test only\", \"show\":true}}";
JsonNode rootResult = asTree(strResult);
long lSess = rootResult.get("session").longValue();
String user = rootResult.get("info").get("user").textValue();
// 123456789,1008
System.out.println(lSess +"," +  user);