https://blog.csdn.net/WillJGL/article/details/77866224

SpringBoot中如果需要实现json的序列化和反序列化，我们会使用json解析工具。一般用到的有fastjson、GSON、Jackson
根据网上的测试，Jackson性能好一些，而且Jackson是SpringBoot默认引用的
本文记录SpringBoot如何使用Jackson

准备

1、在项目中创建包Jackson
2、分别创建4各类文件
2.1、Company实体类（里面包含Department的list）
2.2、Department实体类
2.3、jsonController controller类，接收测试请求
2.4、JsonHelper Jackson操作类
如题所示

每个类内容如下
Company


  2. import java.util.ArrayList;
  3. import java.util.List;
  5. public class Company {
  7.     private  String name;
  8.     private  String address;
  9.     private  int employeesCount;
  10.     private List<Department> departmentArrayList;
  12.     public String getName() {
  13.         return name;
  14.     }
  16.     public void setName(String name) {
  17.         this.name = name;
  18.     }
  20.     public String getAddress() {
  21.         return address;
  22.     }
  24.     public void setAddress(String address) {
  25.         this.address = address;
  26.     }
  28.     public int getEmployeesCount() {
  29.         return employeesCount;
  30.     }
  32.     public void setEmployeesCount(int employeesCount) {
  33.         this.employeesCount = employeesCount;
  34.     }
  36.     public List<Department> getDepartmentArrayList() {
  37.         return departmentArrayList;
  38.     }
  40.     public void setDepartmentArrayList(List<Department> departmentArrayList) {
  41.         this.departmentArrayList = departmentArrayList;
  42.     }
  43. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

Department


  2. public class Department {
  4.     private  String name;
  5.     private  int employeesCount;
  7.     public String getName() {
  8.         return name;
  9.     }
  11.     public void setName(String name) {
  12.         this.name = name;
  13.     }
  15.     public int getEmployeesCount() {
  16.         return employeesCount;
  17.     }
  19.     public void setEmployeesCount(int employeesCount) {
  20.         this.employeesCount = employeesCount;
  21.     }
  22. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

jsonController


  2. import com.fasterxml.jackson.core.JsonProcessingException;
  3. import com.fasterxml.jackson.core.type.TypeReference;
  4. import com.fasterxml.jackson.databind.JavaType;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.web.bind.annotation.GetMapping;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  9. import org.springframework.web.bind.annotation.RestController;
  11. import java.util.*;
  13. @RestController
  14. @RequestMapping("/json")
  15. public class jsonController {
  17.     private  final Logger logger = LoggerFactory.getLogger(this.getClass());//对象方式初始化Log对象
  19.     @GetMapping("")
  20.     public String index() throws Exception {
  21.         JsonHelper jm = new JsonHelper();
  23.         //1、对象<->Json
  24.             //准备数据
  25.         Company c = getCompany();
  26.             //对象转Json
  27.         String json =  jm.toJson(c);
  28.         logger.info("1.1、对象转Json="+json);
  29.             //Json转对象
  30.         Company obj = jm.fromJson(json,Company.class);
  31.         logger.info("1.2、Json转对象="+ obj.getDepartmentArrayList().get(0).getName());
  33.         //2、Map<->Json
  34.             //Json转Map
  35.         Map map = jm.fromJson(json,Map.class);
  36.         List<Map> tempList =  (List<Map>)map.get("departmentArrayList");
  37.         logger.info("2.1、Json转Map="+tempList.get(0).get("name"));
  39.             //Map转Json
  40.         json =  jm.toJson(map);
  41.         logger.info("2.2、Map转Json="+json);
  43.         //3、List<Object> <->Json
  44.             //准备数据
  45.         List<Company> companyList = new ArrayList<Company>();
  46.         companyList.add(getCompany());
  47.         companyList.add(getCompany());
  48.         companyList.add(getCompany());
  50.             //List<Object>转Json
  51.         json =  jm.toJson(companyList);
  52.         logger.info("3.1、List<Object>转Json="+json);
  54.             //Json转List<Object>
  55.         List<Company> companyListDecode = jm.fromJson(json,new TypeReference<List<Company>>() {});
  56.         logger.info("3.2、Json转List<Object>="+companyListDecode.get(0).getDepartmentArrayList().get(0).getName());
  58.         //4、Map<String, Object><-> Json
  59.             //准备数据
  60.         Map<String, Company> map1 = new HashMap<String, Company>() ;
  61.         map1.put("1",getCompany());
  62.         map1.put("2",getCompany());
  63.         map1.put("3",getCompany());
  65.             //Map<String, Object>转Json
  66.         json =  jm.toJson(map1);
  67.         logger.info("4.1、Map<String, Object>转Json="+json);
  69.             //Json转Map<String, Object>
  70.         Map<String, Company> map1Decode = jm.fromJson(json,new TypeReference<Map<String, Company>>() {});
  71.         logger.info("4.2、Json转Map<String, Object>="+map1Decode.get("1").getDepartmentArrayList().get(0).getName());
  73.         //5、List<Map<String, Object>><->Json
  74.             //准备数据
  75.         List<Map<String, Company>> listMap =new ArrayList<Map<String, Company>>();
  76.         Map<String, Company> map2 = new HashMap<String, Company>() ;
  77.         map2.put("a",getCompany());
  78.         map2.put("b",getCompany());
  79.         map2.put("c",getCompany());
  80.         listMap.add(map1);
  81.         listMap.add(map2);
  83.             //List<Map<String, Object>> 转Json
  84.         json =  jm.toJson(listMap);
  85.         logger.info("5.1、List<Map<String, Object>> 转Json="+json);
  87.             //Json 转 List<Map<String, Object>>
  88.         List<Map<String, Company>> listMapDecode = jm.fromJson(json,new TypeReference<List<Map<String, Company>>>() {});
  89.         logger.info("5.2、List<Map<String, Object>> 转Json="+listMapDecode.get(0).get("1").getDepartmentArrayList().get(0).getName());
  91.         return "";
  92.     }
  94.     private  Company getCompany()
  95.     {
  96.         long time = new Date().getTime();
  97.         String sTime =  String.valueOf(time);
  98.         Company c = new Company();
  99.         c.setEmployeesCount(10);
  100.         c.setName("公司名"+sTime);
  102.         List list = new ArrayList();
  103.         Department d1= new Department();
  104.         d1.setEmployeesCount(5);
  105.         d1.setName("部门1"+sTime);
  107.         Department d2= new Department();
  108.         d2.setEmployeesCount(5);
  109.         d2.setName("部门2"+sTime);
  111.         list.add(d1);
  112.         list.add(d2);
  114.         c.setDepartmentArrayList(list);
  116.         return  c;
  117.     }
  118. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120

JsonHelper


  2. import com.fasterxml.jackson.annotation.JsonInclude;
  3. import com.fasterxml.jackson.core.JsonParser;
  4. import com.fasterxml.jackson.core.JsonProcessingException;
  5. import com.fasterxml.jackson.core.type.TypeReference;
  6. import com.fasterxml.jackson.databind.DeserializationFeature;
  7. import com.fasterxml.jackson.databind.JavaType;
  8. import com.fasterxml.jackson.databind.ObjectMapper;
  9. import com.fasterxml.jackson.databind.SerializationFeature;
  10. import com.fasterxml.jackson.databind.util.JSONPObject;
  11. import org.slf4j.Logger;
  12. import org.slf4j.LoggerFactory;
  14. import java.io.IOException;
  16. public class JsonHelper {
  18.     private  Logger logger = LoggerFactory.getLogger(this.getClass());
  19.     ObjectMapper mapper;
  21.     public  JsonHelper()
  22.     {
  23.         mapper = new ObjectMapper();
  24.         mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
  25.         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  26.     }
  28.     public  JsonHelper(JsonInclude.Include include)
  29.     {
  30.         mapper = new ObjectMapper();
  31.         mapper.setSerializationInclusion(include);
  32.         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  33.     }
  35.     public  String toJson(Object object) throws JsonProcessingException {
  36.         return mapper.writeValueAsString(object);
  37.     }
  39.     public  <T> T fromJson(String json, Class<T> cls) throws IOException {
  40.         return mapper.readValue(json, cls);
  41.     }
  43.     public  <T> T fromJson(String json,TypeReference valueTypeRef) throws IOException {
  44.         return mapper.readValue(json, valueTypeRef);
  45.     }
  46. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

转换方式

共举例如下几种转换方式（整体在jsonController文件中，这里分别拆出来说明）

对象<->Json

  1. //1、对象<->Json
  2.         //准备数据
  3.         Company c = getCompany();
  4.         //对象转Json
  5.         String json =  jm.toJson(c);
  6.         logger.info("1.1、对象转Json="+json);
  7.         //Json转对象
  8.         Company obj = jm.fromJson(json,Company.class);
  9.         logger.info("1.2、Json转对象="+ obj.getDepartmentArrayList().get(0).getName());
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

Map<->Json

  1. //2、Map<->Json
  2.             //Json转Map
  3.         Map map = jm.fromJson(json,Map.class);
  4.         List<Map> tempList =  (List<Map>)map.get("departmentArrayList");
  5.         logger.info("2.1、Json转Map="+tempList.get(0).get("name"));
  7.             //Map转Json
  8.         json =  jm.toJson(map);
  9.         logger.info("2.2、Map转Json="+json);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

List<Object> <->Json

  1. //3、List<Object> <->Json
  2.             //准备数据
  3.         List<Company> companyList = new ArrayList<Company>();
  4.         companyList.add(getCompany());
  5.         companyList.add(getCompany());
  6.         companyList.add(getCompany());
  8.             //List<Object>转Json
  9.         json =  jm.toJson(companyList);
  10.         logger.info("3.1、List<Object>转Json="+json);
  12.             //Json转List<Object>
  13.         List<Company> companyListDecode = jm.fromJson(json,new TypeReference<List<Company>>() {});
  14.         logger.info("3.2、Json转List<Object>="+companyListDecode.get(0).getDepartmentArrayList().get(0).getName());
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

Map<String, Object><-> Json

  1. //4、Map<String, Object><-> Json
  2.             //准备数据
  3.         Map<String, Company> map1 = new HashMap<String, Company>() ;
  4.         map1.put("1",getCompany());
  5.         map1.put("2",getCompany());
  6.         map1.put("3",getCompany());
  8.             //Map<String, Object>转Json
  9.         json =  jm.toJson(map1);
  10.         logger.info("4.1、Map<String, Object>转Json="+json);
  12.             //Json转Map<String, Object>
  13.         Map<String, Company> map1Decode = jm.fromJson(json,new TypeReference<Map<String, Company>>() {});
  14.         logger.info("4.2、Json转Map<String, Object>="+map1Decode.get("1").getDepartmentArrayList().get(0).getName());
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

List<Map<String, Object>><->Json

  1. //5、List<Map<String, Object>><->Json
  2.             //准备数据
  3.         List<Map<String, Company>> listMap =new ArrayList<Map<String, Company>>();
  4.         Map<String, Company> map2 = new HashMap<String, Company>() ;
  5.         map2.put("a",getCompany());
  6.         map2.put("b",getCompany());
  7.         map2.put("c",getCompany());
  8.         listMap.add(map1);
  9.         listMap.add(map2);
  11.             //List<Map<String, Object>> 转Json
  12.         json =  jm.toJson(listMap);
  13.         logger.info("5.1、List<Map<String, Object>> 转Json="+json);
  15.             //Json 转 List<Map<String, Object>>
  16.         List<Map<String, Company>> listMapDecode = jm.fromJson(json,new TypeReference<List<Map<String, Company>>>() {});
  17.         logger.info("5.2、List<Map<String, Object>> 转Json="+listMapDecode.get(0).get("1").getDepartmentArrayList().get(0).getName());
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

测试

访问controller的方法，查看日志可以看出来每种转换都可以成功转为json，也可以成功转为对象

其它特性

在有些时候，我们会希望进行一些特殊处理，例如json不

忽略字段

@JsonIgnore 进行JSON操作时忽略该属性。
对于实体类中，如果有某个字段不希望参与json序列化与反序列化，可以把属性标记为@JsonIgnore
例如Company这个类
如果我们给Name、Address、employeesCount三个属性赋值了，序列化出来的内容是

  1. {
  2.     "name": "公司名1504688970821",
  3.     "address": "地址",
  4.     "employeesCount": 10
  5. }
  • 1
  • 2
  • 3
  • 4
  • 5

如果employeesCount是一个内容计数的值，不希望参与序列化，我们可以标记它

  1.     @JsonIgnore
  2.     private  int employeesCount;
  • 1
  • 2

这样再次序列化的结果就变为了

  1. {
  2.     "name": "公司名1504689048950",
  3.     "address": "地址"
  4. }
  • 1
  • 2
  • 3
  • 4

处理时间类型

@JsonFormat(pattern = “yyyy年MM月dd日”) 时间格式化
我们在Company实体类增加一个Date类型的属性，并且赋值序列化


  2.     private Date createDate;
  4.     public Date getCreateDate() {
  5.         return createDate;
  6.     }
  8.     public void setCreateDate(Date createDate) {
  9.         this.createDate = createDate;
  10.     }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

赋值然后再序列化，得到的内容是

  1. {
  2.     "name": "公司名1504689283756",
  3.     "address": "地址",
  4.     "createDate": 1504689283756
  5. }
  • 1
  • 2
  • 3
  • 4
  • 5

可以看到时间是一个数字
我们标记这个属性，再次序列化

  1. {
  2.     "name": "公司名1504689362487",
  3.     "address": "地址",
  4.     "createDate": "2017年09月06日"
  5. }
  • 1
  • 2
  • 3
  • 4
  • 5

时间按照指定的格式显示了

更改字段序列化名

@JsonProperty(“newName”) 改字段名
默认情况下，字段名是什么，序列化出来的key值也就是什么，如果我们希望序列化出来的名字和字段名不一样，则需要使用这个标记
我们把Company的name标记为newName

  1.     @JsonProperty("newName")
  2.     private  String name;
  • 1
  • 2

然后进行序列化

  1. {
  2.     "address": "地址",
  3.     "createDate": "2017年09月06日",
  4.     "newName": "公司名1504689496978"
  5. }
  • 1
  • 2
  • 3
  • 4
  • 5

可以看出来，结果出来的key就使用了自定义的名字

java json转换的更多相关文章

  1. java json转换工具类

    在java项目中,通常会用到json类型的转换,常常需要对 json字符串和对象进行相互转换. 在制作自定义的json转换类之前,先引入以下依赖 <!--json相关工具--><de ...

  2. java json转换（一）

    主要使用了2个类 JsonConvert.class 和 ConvertHelper.class 由于常规转json.只要model牵涉到复杂的关联实体对象.那么就会出现 深度循环的错误. 因此这里通 ...

  3. java json转换（二）

    package com.kps.common.utils; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONArra ...

  4. java json 转换

    1.直接输出: 2.字符串 通过eval转换输出,里面涉及到一个转义问题,还要注意eval的用法里面需要加"("+ + ")" 3.

  5. Java对象转换成xml对象和Java对象转换成JSON对象

    1.把Java对象转换成JSON对象 apache提供的json-lib小工具,它可以方便的使用Java语言来创建JSON字符串.也可以把JavaBean转换成JSON字符串. json-lib的核心 ...

  6. FastJson、Jackson、Gson进行Java对象转换Json细节处理

    前言 Java对象在转json的时候,如果对象里面有属性值为null的话,那么在json序列化的时候要不要序列出来呢?对比以下json转换方式 一.fastJson 1.fastJson在转换java ...

  7. FastJson、Jackson、Gson进行Java对象转换Json的细节处理

    前言 Java对象在转json的时候,如果对象里面有属性值为null的话,那么在json序列化的时候要不要序列出来呢?对比以下json转换方式 一.fastJson 1.fastJson在转换java ...

  8. java json与map互相转换（二）

      java json与map互相转换(二) CreationTime--2018年7月16日15点09分 Author:Marydon 1.准备工作 所需jar包: commons-beanutil ...

  9. java json与map互相转换（一）

      java json与map互相转换(一) CreationTime--2018年7月16日 Author:Marydon 1.准备工作 所需jar包:json-20180130.jar impor ...

随机推荐

  1. Django基于正则表达式的URL（2）

    Django基于正则表达式的URL(2) 1. 关于正则的说明 url(r'^detail-(\d+)-(\d+).html',views.detail), 当客户端输入 127.0.0.1:8000 ...

  2. struts2 常量

    struts.i18n.encoding 指定web应用的默认编码集

  3. Storm工作流程

    为什么storm的数据来自于消息队列? Storm的解决问题的scope主要在于流计算,说流计算之前我们先简单的说下一般数据处理系统的过程.一般数据处理简单说要有几个环节:数据采集,数据计算,结果输出 ...

  4. HBase随机读写

    HDFS不太适合做大量的随机读应用,但HBASE却特别适合随机的读写 个人理解: 1.数据库一般都会有一层缓存,任何对数据的更改实际上是先更改内存中的数据.然后有异步的守护进程负责将脏页按照一定策略刷 ...

  5. SSO单点登录的发展由来以及实现原理

    单点登录以及权限,在很早之前都有写过,不过都比较简单,今天就具体说一下,以及下一步要做的 1.web单系统应用 早期我们开发web应用都是所有的包放在一起打成一个war包放入tomcat容器来运行的, ...

  6. 【再话FPGA】在xilinx中PCIe IP Core使用方法

    采用Xilinx Virtex-5 XC5VSX50T-FF1136 FPGA或者Xilinx Virtex-5 XC5VSX95T-FF1136的板子.采用ISE13.2环境.步骤:一.建立一个IS ...

  7. HTML5学习笔记（十五）：方法

    在一个对象中绑定函数,称为这个对象的方法. 在JavaScript中,对象的定义是这样的: var xiaoming = { name: '小明', birth: 1990 }; 但是,如果我们给xi ...

  8. 【Acm】算法之美—Anagrams by Stack

    题目概述:Anagrams by Stack How can anagrams result from sequences of stack operations? There are two seq ...

  9. kafka消费者如何才能从头开始消费某个topic的全量数据

    消费者要从头开始消费某个topic的全量数据,需要满足2个条件(spring-kafka): (1)使用一个全新的"group.id"(就是之前没有被任何消费者使用过); (2)指 ...

  10. Docker 入门（Mac环境）- part 3 服务（services）

    part-3 服务(services) 简介 一个应用的规模的扩大是很常见的事情,会经常用到负载均衡这些,如要实现这些功能,我们就会用到docker中更高一层的东西-service(服务). 比如说一 ...