概述

json解析器有很多,Gson、Jackson、fastJson等，Jackson是一款优秀的json解析器,springboot项目默认的解析器。

优点

• 解析大文件的速度比较快；
• 运行时占用的内存比较少，性能更佳；
• API 很灵活，容易进行扩展和定制

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

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

在springboot以外的项目中，需引入依赖,如下:

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

jackson-databind 依赖于 jackson-core 和 jackson-annotations，所以添加完 jackson-databind 之后，Maven 会自动将 jackson-core 和 jackson-annotations 引入到项目当中。

使用 ObjectMapper

Jackson 最常用的 API 就是基于”对象绑定” 的 ObjectMapper
ObjectMapper通过 writeValue 的系列方法将 Java 对象序列化为 JSON，并且可以存储成不同的格式

• writeValueAsString(Object value) 方法
  将对象存储成字符串
• writeValueAsBytes(Object value) 方法
  将对象存储成字节数组
• writeValue(File resultFile, Object value) 方法
  将对象存储成文件
  ObjectMapper 通过 readValue 的系列方法从不同的数据源将 JSON 反序列化为 Java 对象。
• readValue(String content, Class<T> valueType) 方法
  将字符串反序列化为 Java 对象
• readValue(byte[] src, Class<T> valueType) 方法
  将字节数组反序列化为 Java 对象
• readValue(File src, Class<T> valueType) 方法
  将文件反序列化为 Java 对象

ObjectMapper mapper = new ObjectMapper();

//对象转json字符串
User user=new User("singleZhang", 18);
String userJson=mapper.writeValueAsString(user);

//Map转json字符串
Map map=new HashMap();  
String json=mapper.writeValueAsString(map);

//数组list转json字符串
User[] userArr = {user1, user2};  
String jsonFromArr =  mapper.writeValueAsString(userArr);

// json字符串转对象
String jsonStr= "{\"name\":\"singleZhang\"}";
User user = mapper.readValue(jsonStr, User.class);

//json字符串转Map
String jsonStr= "{\"name\":\"singleZhang\"}";
Map userMap = mapper.readValue(jsonStr, Map.class);

//json字符串转对象数组List<object>
String jsonStr="[{\"name\":\"singleZhang1\",\"age\":\"17\"},{\"name\":\"singleZhang2\",\"age\":\"18\"}]";
CollectionType listType = mapper.getTypeFactory().constructCollectionType(ArrayList.class, User.class);
List<User> userList = mapper.readValue(jsonStr, listType);

// json字符串转Map数组List<Map<String,Object>>
String jsonStr="[{\"name\":\"singleZhang1\",\"age\":\"17\"},{\"name\":\"singleZhang2\",\"age\":\"18\"}]";
CollectionType listType = mapper.getTypeFactory().constructCollectionType(ArrayList.class, Map.class);
List<Map<String,Object>> userMapList = mapper.readValue(jsonStr, listType);
//也可以借助 TypeReference 可以将json字符串转对象数组List<T>
String jsonStr="[{\"name\":\"singleZhang1\",\"age\":\"17\"},{\"name\":\"singleZhang2\",\"age\":\"18\"}]";
 List<User> userList = mapper.readValue(jsonStr, new TypeReference<List<User>>(){});


//List中的 bean转换为map
List<Map<String,String>> mapList=new ArrayList<Map<String,String>>();
List<User> beanList = userDao.selectAll();
ObjectMapper mapper = new ObjectMapper();
mapList = mapper.convertValue(beanList,new TypeReference<List<Map<String, String>>>(){});

配置
ObjectMapper 通过 configure() 方法忽略掉这些“无法识别”的字段

mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

处理日期格式

• 在 getter 上使用 @JsonFormat 注解

@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
public Date getCreateTime() {
    return createTime;
}

• 调用 ObjectMapper 的 setDateFormat() 方法

mapper.setDateFormat(StdDateFormat.getDateTimeInstance());

字段过滤
在将 Java 对象序列化为 JSON 时，可能有些字段需要过滤(比如密码、银行卡号等)，不显示在 JSON 中，Jackson 有一种比较简单的实现方式

• @JsonIgnore 用于过滤单个字段

@JsonIgnore
public String getPassword() {
    return password;
}

• @JsonIgnoreProperties 用于过滤多个字段

@JsonIgnoreProperties(value = { "password","cardId" })
class User{
    private String name;
    private String password;
    private String cardId;
}

自定义序列化和反序列化
自定义的序列化类需要继承 StdSerializer，同时重写 serialize() 方法，利用 JsonGenerator 生成 JSON
自定定义一个反序列化类UserDeserializer

public class UserDeserializer extends StdDeserializer<User> {
    protected UserDeserializer(Class<?> var1) {
        super(var1);
    }

    public UserDeserializer() {
        this(null);
    }

    @Override
    public User deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        JsonNode node = p.getCodec().readTree(p);
        User user = new User();
        int age = (Integer) ((IntNode) node.get("age")).numberValue();
        String name = node.get("name").asText();
        user.setAge(age);
        user.setName(name);
        return user;
    }
}

定义好自定义反序列化类后，要想在程序中调用它们，同样需要将其注册到 ObjectMapper 的 Module 中

        ObjectMapper mapper = new ObjectMapper();
        SimpleModule module = new SimpleModule("UserDeserializer", new Version(1, 0, 0, null, null, null));
        module.addDeserializer(User.class, new UserDeserializer());
        mapper.registerModule(module);
        String json = "{ \"name\" : \"singleZhang\", \"age\" : 18 }";
        User user = mapper.readValue(json, User.class);
        System.out.println(user.toString());

总结

以上就是Jackson平时常用的一些方法,一般也可以解决日常开发中的大部分场景了。