Jackson,强大的java json解析器,方便json字符串、对象bean、map、数组list互相转换

概述

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

优点

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

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

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

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


    com.fasterxml.jackson.core
    jackson-databind
    2.11.2

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 valueType) 方法
    将字符串反序列化为 Java 对象
  • readValue(byte[] src, Class valueType) 方法
    将字节数组反序列化为 Java 对象
  • readValue(File src, Class 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
String jsonStr="[{\"name\":\"singleZhang1\",\"age\":\"17\"},{\"name\":\"singleZhang2\",\"age\":\"18\"}]";
CollectionType listType = mapper.getTypeFactory().constructCollectionType(ArrayList.class, User.class);
List userList = mapper.readValue(jsonStr, listType);

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


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

配置
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 {
    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平时常用的一些方法,一般也可以解决日常开发中的大部分场景了。

你可能感兴趣的:(Jackson,强大的java json解析器,方便json字符串、对象bean、map、数组list互相转换)