JSON工具类选型指南

前言

平时我们在做项目的时候会用到各种有关Json的转换，现在对于他们的使用有一个总结和整理。

---

叙述

JSON

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。
它基于ECMAScript的一个子集。 JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C、C++、C#、Java、JavaScript、Perl、Python等）。这些特性使JSON成为理想的数据交换语言。 易于人阅读和编写，同时也易于机器解析和生成(一般用于提升网络传输速率)。

JSON结构

json简单说就是javascript中的对象和数组，所以这两种结构就是对象和数组两种结构，通过这两种结构可以表示各种复杂的结构。

1、对象：对象在js中表示为“{}”括起来的内容，数据结构为 {key：value,key：value,…}的键值对的结构，在面向对象的语言中，key为对象的属性，value为对应的属性值，所以很容易理解，取值方法为 对象.key 获取属性值，这个属性值的类型可以是 数字、字符串、数组、对象几种。
2、数组：数组在js中是中括号“[]”括起来的内容，数据结构为 [“java”,“javascript”,“vb”,…]，取值方式和所有语言中一样，使用索引获取，字段值的类型可以是 数字、字符串、数组、对象几种。
JSON的数据格式的介绍

{“id”:1,”name”:aaa}
[{“id”:1,”name”:aaa},{“id”:2,”name”:bbb}]
{
“city”:{“cid”:1,”cname”:”xxx”}
}

那么JSON都有哪些呢？请看链接

---

接下来我们就Java中的几种常用的JSON工具进行分析。

JSON工具类型比较

1.json-lib

json-lib最开始的也是应用最广泛的json解析工具，json-lib 不好的地方确实是依赖于很多第三方包，包括commons-beanutils.jar，commons-collections-3.2.jar，commons-lang-2.6.jar，commons-logging-1.1.1.jar，ezmorph-1.0.6.jar。

对于复杂类型的转换，json-lib对于json转换成bean还有缺陷，比如一个类里面会出现另一个类的list或者map集合，json-lib从json到bean的转换就会出现问题。
json-lib在功能和性能上面都不能满足现在互联网化的需求。

2.开源的Jackson

相比json-lib框架，Jackson所依赖的jar包较少，简单易用并且性能也要相对高些。
而且Jackson社区相对比较活跃，更新速度也比较快。

Jackson对于复杂类型的json转换bean会出现问题，一些集合Map，List的转换出现问题。
Jackson对于复杂类型的bean转换Json，转换的json格式不是标准的Json格式

3.Google的Gson

Gson是目前功能最全的Json解析神器，Gson当初是为因应Google公司内部需求而由Google自行研发而来，但自从在2008年五月公开发布第一版后已被许多公司或用户应用。

Gson的应用主要为toJson与fromJson两个转换函数，无依赖，不需要例外额外的jar，能够直接跑在JDK上。
而在使用这种对象转换之前需先创建好对象的类型以及其成员才能成功的将JSON字符串成功转换成相对应的对象。

类里面只要有get和set方法，Gson完全可以将复杂类型的json到bean或bean到json的转换，是JSON解析的神器。
Gson在功能上面无可挑剔，但是性能上面比FastJson有所差距。

4.阿里巴巴的FastJson

Fastjson是一个Java语言编写的高性能的JSON处理器,由阿里巴巴公司开发。
无依赖，不需要例外额外的jar，能够直接跑在JDK上。

FastJson在复杂类型的Bean转换Json上会出现一些问题，可能会出现引用的类型，导致Json转换出错，需要制定引用。
FastJson采用独创的算法，将parse的速度提升到极致，超过所有json库。

综上4种Json技术的比较，在项目选型的时候可以使用Google的Gson和阿里巴巴的FastJson两种并行使用，
如果只是功能要求，没有性能要求，可以使用google的Gson，
如果有性能上面的要求可以使用Gson将bean转换json确保数据的正确，使用FastJson将Json转换Bean

---

工具类具体用法

1.json-lib

maven依赖

  <!-- jsonlib -->
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
            <classifier>jdk15</classifier>
        </dependency>

操作实例：

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;
import net.sf.json.util.CycleDetectionStrategy;
import net.sf.json.xml.XMLSerializer;

import java.util.List;
import java.util.Map;

/**
 * 处理json数据格式的工具类
 *
 * @Classname JsonUtil
 * @Auther sunshinezhang
 * @Date 2019/10/4 20:19
 */
public class JsonUtil {

	/**
	 * 将数组转换成String类型的JSON数据格式
	 *
	 * @param objects
	 * @return
	 */
	public static String array2json(Object[] objects) {
		JSONArray jsonArray = JSONArray.fromObject(objects);
		return jsonArray.toString();
	}

	/**
	 * 将list集合转换成String类型的JSON数据格式
	 *
	 * @param list
	 * @return
	 */
	public static String list2json(List list) {
		JSONArray jsonArray = JSONArray.fromObject(list);
		return jsonArray.toString();
	}


	/**
	 * 将map集合转换成String类型的JSON数据格式
	 *
	 * @param map
	 * @return
	 */
	public static String map2json(Map map) {
		JSONObject jsonObject = JSONObject.fromObject(map);
		return jsonObject.toString();
	}


	/**
	 * 将Object对象转换成String类型的JSON数据格式
	 *
	 * @param object
	 * @return
	 */
	public static String object2json(Object object){
		JSONObject jsonObject = JSONObject.fromObject(object);
		return jsonObject.toString();
	}



	/**
	 * 将XML数据格式转换成String类型的JSON数据格式
	 *
	 * @param xml
	 * @return
	 */
	public static String xml2json(String xml){
		JSONArray jsonArray = (JSONArray) new XMLSerializer().read(xml);
		return jsonArray.toString();
	}


	/**
	 * 除去不想生成的字段（特别适合去掉级联的对象）
	 *
	 * @param excludes
	 * @return
	 */
	public static JsonConfig configJson(String[] excludes){
		JsonConfig jsonConfig = new JsonConfig();
		jsonConfig.setExcludes(excludes);
		jsonConfig.setIgnoreDefaultExcludes(true);
		jsonConfig.setCycleDetectionStrategy(CycleDetectionStrategy.LENIENT);
		return jsonConfig;
	}


}

2.开源的Jackson

maven依赖：

  <!-- jackson -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.3</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.9.3</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.9.3</version>
        </dependency>

操作实例：

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ser.FilterProvider;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
import lombok.Data;
import org.junit.Test;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @Classname JacksonUtil
 * @Auther sunshinezhang
 * @Date 2019/10/5 08:47
 */
public class JacksonUtil {

	// 将Product转换成json
	@Test
	public void test1() {
		Product p = new Product();
		p.setId(1);
		p.setName("电视机");
		p.setPrice(2000);
		p.setReleaseDate(new Date());

		ObjectMapper mapper = new ObjectMapper();
		mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd"));
		String json = null;
		try {
			json = mapper.writeValueAsString(p);
		} catch (JsonProcessingException e) {
			e.printStackTrace();
		}
		System.out.println(json);
	}

    // 将List转换成json
	@Test
	public void test2(){
		Product p1 = new Product();
		p1.setId(1);
		p1.setName("电视机");
		p1.setPrice(2000);

		Product p2 = new Product();
		p2.setId(2);
		p2.setName("电冰箱");
		p2.setPrice(3000);

		List<Product> ps = new ArrayList<>();
		ps.add(p1);
		ps.add(p2);

		ObjectMapper mapper = new ObjectMapper();

		// 处理过滤属性
		//FilterProvider fp = new SimpleFilterProvider().addFilter("productFilter", SimpleBeanPropertyFilter.filterOutAllExcept("id", "name"));
		FilterProvider fp = new SimpleFilterProvider().addFilter("productFilter",
				SimpleBeanPropertyFilter.serializeAllExcept("id", "name"));
		mapper.setFilters(fp);
		String json = null;
		try {
			json = mapper.writeValueAsString(ps);
		} catch (JsonProcessingException e) {
			e.printStackTrace();
		}
		System.out.println(json);

	}


	@Data
	public class Product {
		private int id;
		private String name;
		private double price;
		private Date releaseDate;
	}
}

3.Google的Gson

maven依赖

 <!-- gson -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.3</version>
        </dependency>

操作实例：

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

import java.util.List;
import java.util.Map;

/**
 *
 * 基于com.google.code.gson封装的json转换工具类
 * @Classname GsonUtil
 * @Auther sunshinezhang
 * @Date 2019/10/4 20:30
 */
public class GsonUtil {
	private static Gson gson = null;
	static {
		if (gson==null){
			gson=new Gson();
		}
	}

	private GsonUtil(){}


	/**
	 * 对象转成json
	 *
	 * @param object
	 * @return json
	 */
	public static String gsonString(Object object){
		String gsonString=null;
		if (gson != null) {
			gsonString = gson.toJson(object);
		}
		return gsonString;
	}

	/**
	 * Json转成对象
	 *
	 * @param gsonString
	 * @param cls
	 * @return 对象
	 */
	public static <T> T gsonToBean(String gsonString,Class<T> cls){
		T t=null;
		if (gson != null) {
			t = gson.fromJson(gsonString, cls);
		}
		return t;
	}

	/**
	 * json转成list
	 *
	 * @param gsonString
	 * @param cls
	 * @return list
	 */
	public static <T> List<T> gsonToList(String gsonString,Class<T> cls){
		List<T> list = null;
		if (gson != null) {
			list = gson.fromJson(gsonString, new TypeToken<List<T>>(){}.getType());
		}
		return list;
	}

	/**
	 * json转成list中有map的
	 *
	 * @param gsonString
	 * @return List>
	 */
	public static <T> List<Map<String,T>> gsonToListMaps(String gsonString){
		List<Map<String, T>> list = null;
		if (gson != null) {
			list = gson.fromJson(gsonString, new TypeToken<List<Map<String, T>>>(){}.getType());
		}
		return list;
	}


	/**
	 * json转成map的
	 *
	 * @param gsonString
	 * @return Map
	 */

	public static <T> Map<String,T> gsonToMaps(String gsonString){
		Map<String,T> map=null;
		if (gson != null) {
			map = gson.fromJson(gsonString, new TypeToken<Map<String, T>>() {
			}.getType());
		}
		return map;
	}
}

4.阿里巴巴的FastJson

maven依赖

 <!-- fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.4</version>
        </dependency>

操作实例：

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;

import java.util.List;
import java.util.Map;

/**
 * 基于fastjson封装的json转换工具类
 *
 * @Classname FastJsonUtils
 * @Auther sunshinezhang
 * @Date 2019/10/5 08:21
 */
public class FastJsonUtil {

	/**
	 * 功能描述：把JSON数据转换成指定的java对象
	 *
	 * @param jsonData JSON数据
	 * @param clazz    指定的java对象
	 * @return 指定的java对象
	 */
	public static <T> T getJsonToBean(String jsonData, Class<T> clazz) {
		return JSON.parseObject(jsonData, clazz);
	}


	/**
	 * 功能描述：把java对象转换成JSON数据
	 *
	 * @param object java对象
	 * @return JSON数据
	 */
	public static String getBeanToJson(Object object) {
		return JSON.toJSONString(object);
	}

	/**
	 * 功能描述：把JSON数据转换成指定的java对象列表
	 * @param jsonData JSON数据
	 * @param clazz 指定的java对象
	 * @return List
	 */
	public static <T> List<T> getJsonToList(String jsonData,Class<T> clazz){
		return JSON.parseArray(jsonData, clazz);
	}

	/**
	 * 功能描述：把JSON数据转换成较为复杂的List>
	 * @param jsonData JSON数据
	 * @return List

	public static List<Map<String,Object>> getJsonToListMap(String jsonData) {
		return JSON.parseObject(jsonData, new TypeReference<List<Map<String, Object>>>() {
		});
	}

}

---

小结

对于知识的学习我们应该做到手中无剑，心中无剑的层次。

更多有关Json数据类型转换的内容，请参考此篇文章。

感谢您的阅读~~