当前位置：首页 > 资讯 > 技术文档

深入剖析构建JSON字符串的三种方式(推荐)

时间：2021-10-17 12:47 编辑：来源：阅读：
扫一扫，手机访问

摘要：深入剖析构建JSON字符串的三种方式(推荐)

前言：JSON 是轻量级的数据交换格式，很常用，尤其是在使用 Ajax 时，在后台将数据封装为 JSON 字符串更是常见。之前在做项目的时候用过几种方式在后端将数组或 List 集合转换为 JSON 字符串，现在回想起来竟然又有些遗忘。现在来一个汇总，把这几种构建 JSON 字符串的方式彻底回忆起来。笔记中提供了大量的代码示例，需要说明的是，大部分代码示例都是本人所敲代码并进行测试，不足之处，请大家指正~ [b]一、alibaba 的 Fastjson[/b] 1.Fastjson 是一个以 Java 语言编写的 JSON 处理器,由阿里巴巴公司开发，功能强大。要使用第三方的工具当然要导入 jar 包了，只需导入 fastjson-1.2.8.jar 即可，jar 包的获取，大家可以直接去网上下载，也可以联系本人。先来一个 fastjson 的简单实例吧，如下代码构造了一个 Customer 的实例，并将此实例转化成为 JSON 字符串，调用了 com.alibaba.fastjson.JSON 的 toJSONString() 方法，将 Customer 实例传入

@Test
public void test1() {
 
 Customer customer = new Customer();
 customer.setId(1);
 customer.setCustName("Tom");
 customer.setAddress("BeiJing");
 
 String jsonStr = JSON.toJSONString(customer);
 System.out.println(jsonStr);
}

打印结果：{"address":"BeiJing","custName":"Tom","id":1} 再来一个小测试，将一个 List 的 Customer 的集合转换为 JSON 字符串，22 行还是直接调用 JSON 的 toJSONString() 方法，将 List 集合传入即可

/**
* 将 List 集合转换为 JSON 字符串
*/
@Test
public void test2() {
 List<Customer> lists = new ArrayList<>();
 
 Customer customer = new Customer();
 customer.setId(1);
 customer.setCustName("Tom");
 customer.setAddress("BeiJing");
 
 lists.add(customer);
 
 Customer customer2 = new Customer();
 customer2.setId(1);
 customer2.setCustName("Bob");
 customer2.setAddress("ShangHai");
 
 lists.add(customer2);
 
 String jsonStr = JSON.toJSONString(lists);
 System.out.println(jsonStr);
}

打印结果：[{"address":"BeiJing","custName":"Tom","id":1},{"address":"ShangHai","custName":"Bob","id":1}] 2. 深入研究一下，我们看下面这种情况：3 行创建了一个 List 的 Customer 集合，10 和 11 行进行了一个重复的 add 操作，那么打印结果是什么样的呢？

@Test
public void test3() {
 List<Customer> lists = new ArrayList<>();

 Customer customer = new Customer();
 customer.setId(1);
 customer.setCustName("Tom");
 customer.setAddress("BeiJing");

 lists.add(customer);
 lists.add(customer);
 
 String jsonStr = JSON.toJSONString(lists);
 System.out.println(jsonStr);

}

打印结果：[{"address":"BeiJing","custName":"Tom","id":1},{"$ref":"$[0]"}]，大家看，第二个 Customer 实例没有打印出，这就证明了[b] fastjson 默认禁止循环的引用[/b]，如果想改变这种情况，需要在 JSON 的 toJSONString() 方法中传递第二个参数 SerializerFeature.DisableCircularReferenceDetect 即可解决,如下：

@Test
public void test3() {
　　List<Customer> lists = new ArrayList<>();

　　Customer customer = new Customer();
　　customer.setId(1);
　　customer.setCustName("Tom");
　　customer.setAddress("BeiJing");

　　lists.add(customer);
　　lists.add(customer);
 
　　String jsonStr = JSON.toJSONString(lists, SerializerFeature.DisableCircularReferenceDetect);
　　System.out.println(jsonStr);

}

此时的打印结果为：[{"address":"BeiJing","custName":"Tom","id":1},{"address":"BeiJing","custName":"Tom","id":1}]，[b]建议以后再使用 JSON 的 toJSONString() 方法时将第二个参数添加上[/b] 3.再深入一点，来看一个常见的问题，Department 和 Manager 类维护双向一对一的关联关系，Department 类中有 Manager 类的引用，Manager 类中有 Department 类的引用，来看如下代码：在 11 和 12 行设置了关联关系，14 行和 15 行进行 JSON 字符串的转换，结果会怎样呢？

　　@Test
 public void test4() {
 Manager mgr = new Manager();
 mgr.setMgrId(1);
 mgr.setMgrName("Tom");
 
 Department dept = new Department();
 dept.setDeptId(2);
 dept.setDeptName("DEV");
 
 mgr.setDept(dept);
 dept.setManager(mgr);
 
 String jsonStr = JSON.toJSONString(dept, SerializerFeature.DisableCircularReferenceDetect);
// String jsonStr = JSON.toJSONString(mgr, SerializerFeature.DisableCircularReferenceDetect);
 System.out.println(jsonStr);
 }

答案是，[b]抛出了异常[/b]，常见的 java.lang.StackOverflowError，抛异常的原因是双方都维护关联关系进入了死循环，那么如何解决这个问题呢？可以在一方添加[b]@JSONField(serialize=false) [/b]注解，7 行所示，即可解决

public class Department {
 
 private Integer deptId;
 
 private String deptName;
 
 @JSONField(serialize=false)
 private Manager manager;

 public Integer getDeptId() {
 return deptId;
 }

 public void setDeptId(Integer deptId) {
 this.deptId = deptId;
 }

 public String getDeptName() {
 return deptName;
 }

 public void setDeptName(String deptName) {
 this.deptName = deptName;
 }

 public Manager getManager() {
 return manager;
 }

 public void setManager(Manager manager) {
 this.manager = manager;
 }
 
}

打印结果为：{"dept":{"deptId":2,"deptName":"DEV"},"mgrId":1,"mgrName":"Tom"}，结果也很令人满意。 4.最后提供一个 fastjson 的工具类，开发时可以直接使用，供大家参考

package qi.ssh.utils;

import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletResponse;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;

public class FastJsonUtil {
 
 /**
 * 将对象转成json串
 * @param object
 * @return
 */
 public static String toJSONString(Object object){
 //DisableCircularReferenceDetect来禁止循环引用检测
 return JSON.toJSONString(object,SerializerFeature.DisableCircularReferenceDetect);
 }
 
 //输出json
 public static void write_json(HttpServletResponse response,String jsonString)
 {
 response.setContentType("application/json;utf-8");
 response.setCharacterEncoding("UTF-8");
 try {
  response.getWriter().print(jsonString);
 } catch (IOException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
 } 
 }
 /**
 * ajax提交后回调的json字符串
 * @return
 */
 public static String ajaxResult(boolean success,String message)
 {
 Map map=new HashMap();
 map.put("success", success);//是否成功
 map.put("message", message);//文本消息
 String json= JSON.toJSONString(map); 
 return json;
 }
 

 /**
 * JSON串自动加前缀
 * @param json 原json字符串
 * @param prefix 前缀
 * @return 加前缀后的字符串
 */

 public static String JsonFormatterAddPrefix(String json,String prefix,Map<String,Object> newmap)
 {
 if(newmap == null){
  newmap = new HashMap();
 }
 Map<String,Object> map = (Map) JSON.parse(json);

 for(String key:map.keySet())
 {
  Object object=map.get(key);
  if(isEntity(object)){
  String jsonString = JSON.toJSONString(object);
  JsonFormatterAddPrefix(jsonString,prefix+key+".",newmap);
  
  }else{
  newmap.put(prefix+key, object);
  }
  
 }
 return JSON.toJSONString(newmap); 
 }
 /**
 * 判断某对象是不是实体
 * @param object
 * @return
 */
 private static boolean isEntity(Object object)
 {
 if(object instanceof String )
 {
  return false;
 }
 if(object instanceof Integer )
 {
  return false;
 }
 if(object instanceof Long )
 {
  return false;
 }
 if(object instanceof java.math.BigDecimal )
 {
  return false;
 }
 if(object instanceof Date )
 {
  return false;
 }
 if(object instanceof java.util.Collection )
 {
  return false;
 }
 return true;
 
 }
}

[b]二、Jackson [/b] 1.同样也需要导入 jar 包，Jackson 导入的 jar 包有三个 [img]http://files.jb51.net/file_images/article/201710/2017102111134521.png[/img] 具体使用也通过一个小例子说明：

package com.software.jackson;

import java.util.Arrays;
import java.util.List;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Customer {

 private int id;

 private String name;

 public Customer(int id, String name) {
  super();
  this.id = id;
  this.name = name;
 }

 public int getId() {
  return id;
 }

 public void setId(int id) {
  this.id = id;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }
 
 public String getCity(){
  return "BeiJing";
 }
 
 @JsonIgnore
 public String getSchool(){
  return "School";
 }
 
 public static void main(String[] args) throws JsonProcessingException {
  //创建ObjectMapper对象
  ObjectMapper mapper = new ObjectMapper();
  
  Customer customer = new Customer(1, "Tom");
  List<Customer> lists = Arrays.asList(customer, new Customer(2, "Bob"));
  
  //调用 ObjectMapper 的 writeValueAsString(xxx) 方法，把一个对象或几个传入，转为一个 JSON 字符串
  String jsonStr = mapper.writeValueAsString(lists);
  System.out.println(jsonStr);
  
 }

}

定义了一个 Customer 类，38 行和 43 行定义了两个额外的 get 方法并直接赋值，main 方法中创建 [b]ObjectMapper[/b] 的对象，调用其[b] writeValueAsString()[/b] 方法，传入单个对象或对象的集合，便会返回对应的 JSON 字符串，打印结果为：[{"id":1,"name":"Tom","city":"BeiJing"},{"id":2,"name":"Bob","city":"BeiJing"}]，大家可能会发现，我们 43 行定义的 getSchool() 方法中的 School 没有被打印出，这是因为我们在此方法上添加了[b]@JsonIgnore[/b] 注解，添加了此注解，在构造 JSON 字符串时便忽略此属性，细想一下，此注解添加到 get 方法上，这也说明 Jackson 构造 JSON 字符串时基于 getter 方法的。 2.与之前一样，我们想看一看 Jackson 有没有禁止循环的引用，类似的代码：

　　@Test
 public void test2() throws JsonProcessingException {
  List<Customer> lists = new ArrayList<>();

  Customer customer = new Customer();
  customer.setId(1);
  customer.setCustName("Tom");
  customer.setAddress("BeiJing");

  lists.add(customer);
  lists.add(customer);
  
  ObjectMapper mapper = new ObjectMapper();
  String jsonStr = mapper.writeValueAsString(lists);
  System.out.println(jsonStr);
 }

来看一下输出结果：[{"id":1,"custName":"Tom","address":"BeiJing"},{"id":1,"custName":"Tom","address":"BeiJing"}]，结果显而易见。 3.我们再来看一看如果像 Fastjson 中测试的 Department 和 Manager 双向一对一映射的例子，Jackson 会表现的怎么样：

　　@Test
 public void test1() throws JsonProcessingException {
  Manager mgr = new Manager();
  mgr.setMgrId(1);
  mgr.setMgrName("Tom");
  
  Department dept = new Department();
  dept.setDeptId(2);
  dept.setDeptName("DEV");
  
  mgr.setDept(dept);
  dept.setManager(mgr);
  
  ObjectMapper mapper = new ObjectMapper();
  String jsonStr = mapper.writeValueAsString(dept);
  System.out.println(jsonStr);
 }

直接运行还是会出相同的异常 Caused by: java.lang.StackOverflowError，我们的思路与测试 Fastjson 一样，为 Department 中的 Manager 引用添加 @JsonIgnore 注解，异常解决了，但打印结果是很满意，结果为：{"deptId":2,"deptName":"DEV"} ，远不如 Fastjson 的输出结果。由此可以看出 Fastjson 功能之强大。 [b]三、Google Gson[/b] 1.看看如何使用：jar 包呢只需要一个 gson-2.2.4.jar ，普通对象与集合转为 JSON 没有什么可说的，简单演示一下将 List 集合转为 JSON 字符串吧，直接 new 出 Gson 的对象，调用其 toJson() 方法传入需要转换的对象即可。

　　@Test
 public void test2() {
  List<Customer> lists = new ArrayList<>();

  Customer customer = new Customer();
  customer.setId(1);
  customer.setCustName("Tom");
  customer.setAddress("BeiJing");

  lists.add(customer);

  Customer customer2 = new Customer();
  customer2.setId(1);
  customer2.setCustName("Bob");
  customer2.setAddress("ShangHai");

  lists.add(customer2);

  Gson gson = new Gson();
  String jsonStr = gson.toJson(lists);
  System.out.println(jsonStr);
 }

打印结果：[{"address":"BeiJing","custName":"Tom","id":1},{"address":"ShangHai","custName":"Bob","id":1}] 2. 那有没有禁止循环引用呢？

　　@Test
 public void test3() {
  List<Customer> lists = new ArrayList<>();

  Customer customer = new Customer();
  customer.setId(1);
  customer.setCustName("Tom");
  customer.setAddress("BeiJing");

  lists.add(customer);
  lists.add(customer);
  
  Gson gson = new Gson();
  String jsonStr = gson.toJson(lists);
  System.out.println(jsonStr);

 }

输出结果：[{"id":1,"custName":"Tom","address":"BeiJing"},{"id":1,"custName":"Tom","address":"BeiJing"}]，显而易见是没有的。 3.若有双向一对一的关联关系映射的话，Google Gson 也是会有死循环问题造成 java.lang.StackOverflowError 异常，但是 Gson 并没有为我们提供一个注解，要解决此问题LZ提供一个解决方案的思路，Google Gson 使用的是 ExclusionStrategy 策略进行某个字段或某个域的序列化，可以通过此接口自定义一个注解来解决此问题。但是建议大家如果涉及到双向关联关系的对象转换为 JSON 的需求是，使用 Fastjson。 [b]四、三种方式的简单比较[/b] LZ 从以下几个方面来比较构造 JSON 字符串的三种方式： 1. jar 包方面：显然是 Fastjson 和 Google Gson 胜出，Jackson 需要加入 3 个 jar 包。 2. 简单对象或集合转为 JSON:若是普通的简单对象或集合进行转换，可能 Jackson 和 Google Gson 要胜出一些了，起码构造比较方便。 3. 涉及到双向关联关系的转换：毫无疑问阿里巴巴的 Fastjson 将胜出。建议大家在实际的开发中根据自己的需求合理选择某一方式。以上这篇深入剖析构建JSON字符串的三种方式(推荐)就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持编程素材网。

全部评论(0)

上一篇：WIN7系统JavaEE(java)环境配置教程（一）
下一篇：mybatis 中 foreach collection的用法小结(三种)

资讯排行榜
更多>>