思享工具箱

【json的处理】二、Jackson的处理

摘要：
添加相关的依赖包后，您可以使用Jackson＜dependency＞＜groupId＞com。fasterxml。杰克逊。核心jackson数据绑定2.11.0I。jackson的一些常用方法介绍一些概念和方法：ObjectMapper是JSON操作的核心，jackson的所有JSON操作都在ObjectMapper中实现。WriteValue将arg1转换为json序列，并将其保存到arg0文件中。WriteValueAsString将arg0转换为json序列，并将结果作为字符串输出。

目前处理json的方法有很多，这里主要总结四种方法

1. Gson方式处理json 【json的处理】一、Gson处理

2. FastJson方式处理json 【json的处理】三、FastJson的处理

3. Jackson方式处理json 【json的处理】二、Jackson的处理

4. json-flattener方式处理json 【json的处理】四、json-flattener的处理

本文主要介绍Jackson的方式

前言

下面主要通过几个方面来介绍jackson：

1. jackson的一些常用方法

2. jackson的一些常用注解

3. JsonNode && ArrayNode && ObjectNode

4. jackson处理文件的导入导出

首先需要引入依赖

jackson-databind 依赖 jackson-core 和 jackson-annotations，当添加 jackson-databind 之后， jackson-core 和 jackson-annotations 也随之添加到 Java 项目工程中。在添加相关依赖包之后，就可以使用 Jackson。

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

一、jackson的一些常用方法

一些概念和方法的介绍：

ObjectMapper是JSON操作的核心，Jackson的所有JSON操作都是在ObjectMapper中实现。

ObjectMapper有多个JSON序列化的方法，可以把JSON字符串保存File、OutputStream等不同的介质中。

writeValue(File arg0, Object arg1)把arg1转成json序列，并保存到arg0文件中。

writeValue(OutputStream arg0, Object arg1)把arg1转成json序列，并保存到arg0输出流中。

writeValueAsBytes(Object arg0)把arg0转成json序列，并把结果输出成字节数组。

writeValueAsString(Object arg0)把arg0转成json序列，并把结果输出成字符串。

//实体类
@Data
@AllArgsConstructor
public class TestUser {
    private String name;
    private Integer age;
    private Integer sex;
    private Date date;
}

//测试类

//定义一个对象用于测试
TestUser testUser = new TestUser("1",11,1,new Date());
TestUser testUser2 = new TestUser("2",22,2,new Date());
ObjectMapper mapper = new ObjectMapper();
//【对象转String】
String str = mapper.writeValueAsString(testUser);
//结果：{"name":"1","age":11,"sex":1,"date":1600595735478}
System.out.println(str);
//【String转对象】这里要注意，版本号2.10.1以上readValue方法就会报错，2.9.5就可以
//报错信息：java.lang.ClassNotFoundException: com.fasterxml.jackson.core.exc.InputCoercionException
TestUser testUserTemp = mapper.readValue(str, TestUser.class);
//结果：TestUser(name=1, age=11, sex=1, date=Sun Sep 20 18:07:43 CST 2020)
System.out.println(testUserTemp);
//list转json-string
List<TestUser> testUserList = new ArrayList<>();
testUserList.add(testUser);
testUserList.add(testUser2);
String json = mapper.writeValueAsString(testUserList);
//结果：[{"name":"1","age":11,"sex":1,"date":1600910383747},{"name":"2","age":22,"sex":2,"date":1600910383747}]
System.out.println(json);

二、jackson的一些常用注解

@JsonIgnore

此注解用于属性上，作用是进行JSON操作时忽略该属性。

@JsonIgnoreProperties

此注解用于类上，作用是忽略多个属性，如：@JsonIgnoreProperties({"userName", "userAge"})

@JsonFormat

此注解用于属性上，作用是把Date类型直接转化为想要的格式，如@JsonFormat(pattern = "yyyy-MM-dd HH-mm-ss")。

@JsonProperty

此注解用于属性上，作用是把该属性的名称序列化为另外一个名称，如把trueName属性序列化为name，@JsonProperty("name")。

@JsonInclude

此注解可用于属性和类上，作用是排除值为null的属性，如：

@JsonInclude(JsonInclude.Include.NON_NULL)-->属性为null不参与序列化。

@JsonInclude(JsonInclude.Include.NON_EMPTY)-->属性为空或者null都不参与序列化。

@JsonUnwrapped

此注解用于属性上，作用：

1. 是去掉外包装
2. 把成员对象中的属性提升到其容器类，并添加给定的前缀，如：@JsonUnwrapped(prefix = "user_")

@JsonAppend

此注解用于类上，为json添加虚拟属性，如：@JsonAppend(attrs = {@JsonAppend.Attr(value = "version")})

@JsonNaming

此注解用于类上，作用是将驼峰式改成下划线，如：

@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)

此外还有：

  • KEBAB_CASE: 属性名单词用短线分隔连接, 比如hello-world

  • LOWER_CASE: 属性名用小写字母而且没有分隔符, 比如helloworld

  • SNAKE_CASE: 属性名用小写字母而且用下划线做分隔符, 比如hello_world

  • UPPER_CAMEL_CASE: 属性名所有单词用大写开头而且没有分隔符, 比如HelloWorld

MapperFeature.USE_ANNOTATIONS

禁用所有jackson注解的功能

@JsonPropertyOrder

此注解用于类上，作用是给序列化之后的json排序，如：

@JsonPropertyOrder(value = {"userSex","userAge","userName"})

1. JsonIgnore && JsonIgnoreProperties

@Data
@AllArgsConstructor
public class TestUser {
    @JsonIgnore
    private String name;
    private Integer age;
    private Integer sex;
    private Date date;
}

//定义一个对象用于测试
TestUser testUser = new TestUser("1",11,1,new Date());
ObjectMapper mapper = new ObjectMapper();
//【对象转String】
String str = mapper.writeValueAsString(testUser);
//加上注解前：{"name":"1","age":11,"sex":1,"date":1600913752059}
//加上注解后：{"age":11,"sex":1,"date":1600913711465}
System.out.println(str);

--------------------------------------------------------------------------------------------

@Data
@AllArgsConstructor
@JsonIgnoreProperties({"userName", "userAge"})
public class TestUser {
    private String userName;
    private Integer userAge;
    private Integer userSex;
}

//定义一个对象用于测试
TestUser testUser = new TestUser("111",11,1);
ObjectMapper mapper = new ObjectMapper();
//【对象转String】
String str = mapper.writeValueAsString(testUser);
//加上注解前：{"userName":"111","userAge":11,"userSex":1}
//加上注解后：{"userSex":1}
System.out.println(str);

2. JsonFormat

@Data
@AllArgsConstructor
public class TestUser {
    private String name;
    private Integer age;
    private Integer sex;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date date;
}

//定义一个对象用于测试
TestUser testUser = new TestUser("1",11,1,new Date());
ObjectMapper mapper = new ObjectMapper();
//【对象转String】
String str = mapper.writeValueAsString(testUser);
//加上注解前：{"name":"1","age":11,"sex":1,"date":1600913893613}
//加上注解后：{"name":"1","age":11,"sex":1,"date":"2020-09-24 02:17:56"}
System.out.println(str);

3. JsonProperty

@Data
@AllArgsConstructor
public class TestUser {
    @JsonProperty("t_name")
    private String name;
    private Integer age;
    private Integer sex;
    private Date date;
}

//定义一个对象用于测试
TestUser testUser = new TestUser("1",11,1,new Date());
ObjectMapper mapper = new ObjectMapper();
//【对象转String】
String str = mapper.writeValueAsString(testUser);
//加上注解前：{"name":"1","age":11,"sex":1,"date":1600913893613}
//加上注解后：{"t_name":"1","age":11,"sex":1,"date":1600913990057}
System.out.println(str);

4. JsonInclued

@Data
@AllArgsConstructor
public class TestUser {
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String name;
    private Integer age;
    private Integer sex;
    private Date date;
}

@Data
@AllArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
public class TestUser {
    private String name;
    private Integer age;
    private Integer sex;
    private Date date;
}

//定义一个对象用于测试
TestUser testUser = new TestUser(null,11,1,new Date());
ObjectMapper mapper = new ObjectMapper();
//【对象转String】
String str = mapper.writeValueAsString(testUser);
//加上注解前：{"name":null,"age":11,"sex":1,"date":1600914468252}
//加上注解后：{"age":11,"sex":1,"date":1600914452682}
System.out.println(str);

5. JsonUnwrapped

@Data
@AllArgsConstructor
public class TestUser {
    private String name;
    private Integer age;
    private Integer sex;
    @JsonUnwrapped
    private Teacher teacher;
}

@Data
@AllArgsConstructor
public class Teacher {
    private String tel;
    private String email;
}

//定义一个对象用于测试
TestUser testUser = new TestUser("111",11,1,new Teacher("13718999090","12345@qq.com"));
ObjectMapper mapper = new ObjectMapper();
//【对象转String】
String str = mapper.writeValueAsString(testUser);
//加上注解前：{"name":"111","age":11,"sex":1,"teacher":{"tel":"13718999090","email":"12345@qq.com"}}
//加上注解后：{"name":"111","age":11,"sex":1,"tel":"13718999090","email":"12345@qq.com"}
System.out.println(str);

----------------------------------------------------------------------------------------------
    
@Data
@AllArgsConstructor
public class TestUser {
    private String userName;
    private Integer userAge;
    private Integer userSex;
    @JsonUnwrapped(prefix = "user_")
    private Teacher teacher;
}

//定义一个对象用于测试
TestUser testUser = new TestUser("111",11,1,new Teacher("11111","11111@qq.com"));
ObjectMapper mapper = new ObjectMapper();
//【对象转String】
String str = mapper.writeValueAsString(testUser);
//加上注解前：{"userName":"111","userAge":11,"userSex":1,"teacher":{"tel":"11111","email":"11111@qq.com"}}
//加上注解后：{"userName":"111","userAge":11,"userSex":1,"user_tel":"11111","user_email":"11111@qq.com"}
System.out.println(str);

6. JsonAppend

@Data
@AllArgsConstructor
@JsonAppend(attrs = {@JsonAppend.Attr(value = "version")})
public class TestUser {
    private String name;
    private Integer age;
    private Integer sex;
}

//定义一个对象用于测试
TestUser testUser = new TestUser("111",11,1);
ObjectMapper mapper = new ObjectMapper();
//为虚拟属性添加值
ObjectWriter writer = mapper.writerFor(TestUser.class).withAttribute("version", "1.0");
//【对象转String】
String str = writer.writeValueAsString(testUser);
//加上注解前：{"name":"111","age":11,"sex":1}
//加上注解后：{"name":"111","age":11,"sex":1,"version":"1.0"}
System.out.println(str);

7. JsonNaming

@Data
@AllArgsConstructor
@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)
public class TestUser {
    private String userName;
    private Integer userAge;
    private Integer userSex;
}

//定义一个对象用于测试
TestUser testUser = new TestUser("111",11,1);
ObjectMapper mapper = new ObjectMapper();
//【对象转String】
String str = mapper.writeValueAsString(testUser);
//加上注解前：{"userName":"111","userAge":11,"userSex":1}
//加上注解后：{"user_name":"111","user_age":11,"user_sex":1}
System.out.println(str);

8. MapperFeature.USE_ANNOTATIONS

@Data
@AllArgsConstructor
@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)
public class TestUser {
    private String userName;
    private Integer userAge;
    private Integer userSex;
}

//定义一个对象用于测试
TestUser testUser = new TestUser("111",11,1);
ObjectMapper mapper = new ObjectMapper();
//禁用jackson注解
mapper.disable(MapperFeature.USE_ANNOTATIONS);
//【对象转String】
String str = mapper.writeValueAsString(testUser);
//加上注解前：{"userName":"111","userAge":11,"userSex":1}
//加上注解后：{"userName":"111","userAge":11,"userSex":1}
System.out.println(str);

9. JsonPropertyOrder

@Data
@AllArgsConstructor
@JsonPropertyOrder(value = {"userSex","userAge","userName"})
public class TestUser {
    private String userName;
    private Integer userAge;
    private Integer userSex;
}

//定义一个对象用于测试
TestUser testUser = new TestUser("111",11,1);
ObjectMapper mapper = new ObjectMapper();
//【对象转String】
String str = mapper.writeValueAsString(testUser);
//加上注解前：{"userName":"111","userAge":11,"userSex":1}
//加上注解后：{"userSex":1,"userAge":11,"userName":"111"}
System.out.println(str);

三、JsonNode && ArrayNode && ObjectNode

ObjectNode

是对象结点，可以存入对象属性。如 { "name":"Lilei", "age":"18", "school":"HNU" }

ArrayNode

是数组结点，用于存放JsonNode数据。如[ "Lilei", "XiaoHong", {"nm1": "Jay", "nm2": "Kong"} ]

JsonNode

是ObjectNode和ArrayNode的父接口。想要生成JsonNode对象都要先生成ObjectMapper类对象，它是产生Json结点的工厂。

 

1. JsonNode

String jsonStr = "{"userName":"111","userAge":11,"userSex":1}";
ObjectMapper mapper = new ObjectMapper();
//【JsonNode】
JsonNode jsonNode = mapper.readTree(jsonStr);
//结果：{"userName":"111","userAge":11,"userSex":1}
System.out.println(jsonNode);
//【判断值类型】
String nodeType = jsonNode.get("userName").getNodeType().toString()+"***"+jsonNode.get("userAge").getNodeType().toString();
//结果：STRING***NUMBER
System.out.println(nodeType);
//【遍历key】
Iterator<String> fieldNames = jsonNode.fieldNames();
while (fieldNames.hasNext()) {
    //结果：userName  userAge  userSex
    System.out.println(fieldNames.next());
}
//【遍历value】
Iterator<JsonNode> elements = jsonNode.elements();
while (elements.hasNext()) {
    //结果："111"  11  1
    System.out.println(elements.next());
}
//【单独获取某个key的值】
JsonNode path = jsonNode.get("userName");
//结果："111"
System.out.println(path);
//结果：true
System.out.println(jsonNode instanceof ObjectNode);

获取属性、子节点有以下两个方法：

  1. path：

    路径访问安全，当访问的结点不存在时返回“MissingNode”，我将其理解为没有任何属性值的结点，也可以通过asText()转换为String类型，值为空字串；当访问的属性无效时同样返回空字串""。

    优势是不知道多层子节点的值是否一定存在时可以连续使用path，若不存在一律返回""；但不能判断结点是否存在。

  2. get：

    路径访问不安全，其访问结点路径或属性无效时返回null，故使用连续使用get访问时，若路径不存在会出现空指针异常。

    优势是可以用是否为null判断结点是否存在。

  3. 访问技巧：

    不知道节点路径上是否所有节点都存在，可以使用

    JsonNode temp = xxxNode.path("prop1").path("prop2").....get("propN");

    if (null != temp) { do something... } 这样的方式安全得到不一定存在的节点

String jsonStr = "{"userName":"111","userAge":11,"userSex":1}";
ObjectMapper mapper = new ObjectMapper();
//【JsonNode】
JsonNode jsonNode = mapper.readTree(jsonStr);
//【path】
JsonNode path = jsonNode.path("userName");
//结果："111"
System.out.println(path);
JsonNode kkk = jsonNode.path("kkk");
//结果：空
System.out.println(kkk);
//【连续path】
JsonNode paths = jsonNode.path("a").path("b").path("c");
//结果：空
System.out.println(paths);
//【get】
JsonNode get1 = jsonNode.get("userName");
//结果："111"
System.out.println(get1);
//结果：null
JsonNode get2 = jsonNode.get("kkk");
System.out.println(get2);
//【连续get】
JsonNode get3 = jsonNode.get("userName").get("kkk");
//结果：null
System.out.println(get3);
//【连续get-->如果get的结果为null之后继续get就会报错】
JsonNode get4 = jsonNode.get("userName").get("kkk").get("kkk");
//结果：java.lang.NullPointerException
System.out.println(get4);
//【asText && asInt】
String userName_userAgeText_userAgeInt = jsonNode.path("userName").asText()+"_"+jsonNode.path("userAge").asText()+"_"+jsonNode.path("userSex").asInt();
//结果：111_11_1
System.out.println(userName_userAgeText_userAgeInt);

2. ObjectNode

ObjectMapper mapper = new ObjectMapper();
//生成对象结点
ObjectNode objNode = mapper.createObjectNode();
//【put方法--在jdk1.8中，简单值用put设置】
objNode.put("name","111");
objNode.put("age",11);
//结果：{"name":"111","age":11}
System.out.println(objNode);
//【set方法--在jdk1.8中，子节点用set设置】
ObjectNode objectNode = mapper.createObjectNode();
objectNode.put("innername", "222");
objectNode.put("innerage", 22);
objNode.set("inner", objectNode);
//结果：{"name":"111","age":11,"inner":{"innername":"222","innerage":22}}
System.out.println(objNode);

3. ArrayNode

ObjectMapper mapper = new ObjectMapper();
//【生成数组结点】-->注意：数组结点添加元素不做简单值和结点类的区分
ArrayNode arrNode = mapper.createArrayNode();
arrNode.add("111");
//结果：["111"]
System.out.println(arrNode);
//生成对象结点
ObjectNode objNode = mapper.createObjectNode();
objNode.put("name","111");
objNode.put("age",11);
ArrayNode addObj = arrNode.add(objNode);
//结果：["111",{"name":"111","age":11}]
System.out.println(addObj);

四、Jackson处理文件的导入导出

1. txt文件的导出

ObjectMapper mapper = new ObjectMapper();
//生成对象结点
ObjectNode objNode = mapper.createObjectNode();
objNode.put("name","111");
objNode.put("age",11);
//【写入txt文件】
OutputStream outputStream= new FileOutputStream(new File("d:/11.txt"));
mapper.writeValue(outputStream, objNode);

效果：

【json的处理】二、Jackson的处理第1张

2. txt文件的导入

ObjectMapper mapper = new ObjectMapper();
//【导入txt文件数据】
JsonNode jsonNode = mapper.readTree(new File("d:/11.txt"));
//结果：{"name":"111","age":11}
System.out.println(jsonNode);

3. 导入导出案例

要求：

根据实体类对象的类型生成相应的json并导出

导入json数据

映射到对象

@Data
@AllArgsConstructor
public class TestUser {
    private String userName;
    private Integer userAge;
    private Integer userSex;
    private Integer[] test;
}

ObjectMapper mapper = new ObjectMapper();
//生成数组节点
ArrayNode arrayNode = mapper.createArrayNode();
arrayNode.add(1);
arrayNode.add(2);
arrayNode.add(3);
//生成对象结点
ObjectNode objNode = mapper.createObjectNode();
objNode.put("userName","111");
objNode.put("userAge",11);
objNode.put("userSex",1);
objNode.put("test",arrayNode);
//【导出】
OutputStream outputStream= new FileOutputStream(new File("d:/test.txt"));
mapper.writeValue(outputStream, objNode);
//【导入】
JsonNode jsonNode = mapper.readTree(new File("d:/test.txt"));
TestUser testUser = mapper.treeToValue(jsonNode, TestUser.class);
//结果：TestUser(userName=111, userAge=11, userSex=1, test=[1, 2, 3])
System.out.println(testUser);

效果：

【json的处理】二、Jackson的处理第2张

参考：

1. https://www.cnblogs.com/jpfss/p/9055747.html

2. https://blog.csdn.net/wang_snake/article/details/93719178

3. https://blog.csdn.net/blwinner/article/details/98532847?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task

持续更新！！！

标签：#string#date#mapper | 浏览：648 | 发布日期：

免责声明：文章转载自《【json的处理】二、Jackson的处理》仅用于学习参考。如对内容有疑问，请及时联系本站处理。

上篇windows下复制文件报错“文件名对目标文件夹可能过长 。您可以缩短文件名并重试，或者......”在ThinkPHP框架（5.0.24）下引入Ueditor并实现向七牛云对象存储上传图片同时将图片信息保存到MySQL数据库，同时实现lazyload懒加载下篇

宿迁高防，2C2G15M，22元/月；香港BGP，2C5G5M，25元/月 雨云优惠码：MjYwNzM=

相关文章

用Javascript进行HTML转义（分享）

  众所周知页面上的字符内容通常都需要进行HTML转义才能正确显示，尤其对于Input，Textarea提交的内容，更是要进行转义以防止javascript注入攻击。   通常的HTML转义主要是针对内容中的"<"，">"，"&"，以及空格、单双引号等。但其实还有很多字符也需要进行转义。具体的可以参考这篇文章。   ** 1、HTML转...

android spinner学习

   用法 1 ：以资源方式，静态展示 Spinner 选项 1.     在资源文件 (strings.xml) 中，增加：          < string name = "spin_prompt" > 请选择城市 </ string >          < string-array name = "cities" &...

java 接收 char字符型

import java.io.BufferedReader;import java.io.InputStreamReader;import java.util.Scanner;public class GetChar {public static void main(String[] args)throws Exception {//通过扫描类输入Scan...

sscanf函数用法详解

名称: sscanf() - 从一个字符串中读进与指定格式相符的数据. 函数原型: Int sscanf( string str, string fmt, mixed var1, mixed var2 … ); int scanf( const char *format [,argument]… ); 说明： sscanf与scanf类似，都是用于输入的，...

【笔记】SpringBoot+Shiro 实现简单权限管理(使用mysql数据库)

网上翻了好久 都没有SpringBoot+Shiro的入门教程 原本想看《跟我学Shiro》 然后发现这是从头开始 但是我就需要和SpringBoot整一块 不需要那么多的东西 感觉这个当参考书不错 于是东拼西凑终于整成了 把别人的教程上我用不到的都删了 该改的改 终于拿到了我理想中的效果 先是数据库部分 因为是简单的实现 就没有弄得太复杂 三部分 用户...

java 注解 Annontation

什么是注解？ 　　对于很多初次接触的开发者来说应该都有这个疑问？Annontation是Java5开始引入的新特征，中文名称叫注解。它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，并且供指定...

最新文章

随机推荐

思享工具箱导航