4种JSON解析对比及实例

最新推荐文章于 2024-09-01 09:14:54 发布

tan06

最新推荐文章于 2024-09-01 09:14:54 发布

阅读量574

点赞数

分类专栏： JSON_XML_JXL 文章标签： json-lib Gson fastjson Jackson

本文链接：https://blog.csdn.net/tanksyg/article/details/84694410

版权

JSON_XML_JXL 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、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、Gson（Google）

Gson是目前功能最全的Json解析神器，Gson当初是为因应Google公司内部需求而由Google自行研发而来，但自从在2008年五月公开发布第一版后已被许多公司或用户应用。
Gson的应用主要为toJson与fromJson两个转换函数，无依赖，不需要例外额外的jar，能够直接跑在JDK上。而在使用这种对象转换之前需先创建好对象的类型以及其成员
才能成功的将JSON字符串成功转换成相对应的对象。类里面只要有get和set方法，Gson完全可以将复杂类型的json到bean或bean到json的转换，是JSON解析的神器。
Gson在功能上面无可挑剔，但是性能上面比FastJson有所差距。
3、FastJson（阿里巴巴）

Fastjson是一个Java语言编写的高性能的JSON处理器,由阿里巴巴公司开发。
无依赖，不需要例外额外的jar，能够直接跑在JDK上。
FastJson在复杂类型的Bean转换Json上会出现一些问题，可能会出现引用的类型，导致Json转换出错，需要制定引用。
FastJson采用独创的算法，将parse的速度提升到极致，超过所有json库
这里要说的就是它的功能性问题。可能是定位不一样，最初fastjson就是要快，因此在对象的序列化与反序列化上下了很大功夫。但是在功能上有所缺乏。
不知在哪个版本开始加上了key按字典排序的功能。但是貌似这个功能没有办法关闭。有些时候我是不希望字段顺序被打乱的，这个问题就无法解决。
我使用的fastjson版本为1.1.14。另外fastjson还有一些bug没有解决，而且是比较明显的bug。例如在@JsonField 注解中format参数，这个是用来指定Date类型数据如何序列化的。如果你使用英文或符号，OK，没有问题（例如yyyy-MM-dd），

但是格式中一旦出现中文就会出错（例如yyyy年MM月dd日）。而且经过实验，所有的注解都要放在属性的Getter（就是getXXX()方法）上，直接放在属性上是无法工作的。

在eclipse中，一般我们都是直接写属性，属性写完后用自动生成的方式生成Getter和Setter方法。如果今后该类的属性发生变化了，个人更倾向于直接删除所有Getter和Setter，然后重新生成。那么假如把注解全放到Getter上面，我删的时候就要非常小心。
再有一个比较致命的就是文档。几乎找不到全面的文档来介绍或支持fastjson。存在很多不确定的因素。
4、Jackson

首先说文档，Jackson Json项目主页上对每一个版本都有详尽的文档（http://jackson.codehaus.org/）。另外Jackson Json的序列化与反序列化速度也并不见得有多慢。更重要的是它的注解支持要好于fastjson。

就拿刚才说到的key按字典排序的功能吧，可以在实体类上直接加上@JsonPropertyOrder(alphabetic=false)注解就可以关闭排序功能。而对于其他功能的注解支持也很好。

二、实例

1、json-lib

package com.its.test.util.json.entity;

import java.util.Date;
import java.util.List;

public class User {

	private Integer id;
	private String name;
	private int age;
	private String sex;
	private Date birthday = new Date();
	private List<Role> roles;

	public Integer getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public List<Role> getRoles() {
		return roles;
	}

	public void setRoles(List<Role> roles) {
		this.roles = roles;
	}

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
}

package com.its.test.util.json.entity;

public class Role {

	private Integer id;
	private String name;

	public Integer getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

package com.its.test.util.json;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.its.model.dao.domain.Department;
import com.its.test.util.json.entity.Role;
import com.its.test.util.json.entity.User;
import net.sf.json.JSONArray;
import net.sf.json.JSONFunction;
import net.sf.json.JSONObject;
import net.sf.json.JSONSerializer;
import net.sf.json.JsonConfig;
import net.sf.json.processors.JsonValueProcessor;
import net.sf.json.util.PropertyFilter;
import net.sf.json.xml.XMLSerializer;

/**
 * 用json-lib转换java对象到JSON字符串 读取json字符串到java对象，序列化jsonObject到xml
 * json-lib-version: json-lib-2.3-jdk15.jar 依赖包: commons-beanutils.jar
 * commons-collections-3.2.jar ezmorph-1.0.3.jar commons-lang.jar
 * commons-logging.jar
 */
public class JsonlibTest {
	private JSONArray jsonArray = null;
	private JSONObject jsonObject = null;

	private User bean = null;

	@Before
	public void init() {
		jsonArray = new JSONArray();
		jsonObject = new JSONObject();
		bean = new User();
		bean.setId(1);
		bean.setName("Test");
		bean.setAge(20);
		bean.setSex("1");
		bean.setBirthday(new Date());
		Role role = new Role();
		role.setId(1);
		role.setName("角色1");
		Role role2 = new Role();
		role2.setId(2);
		role2.setName("角色2");
		List<Role> roles = new ArrayList<Role>();
		roles.add(role);
		roles.add(role2);
		bean.setRoles(roles);
	}

	@After
	public void destory() {
		jsonArray = null;
		jsonObject = null;
		bean = null;
		System.gc();
	}

	public final void print(String string) {
		System.out.println(string);
	}

	// Java对象转JSON
	@Test
	public void testObject2JSON() {
		// Java Bean对象转JSON
		print(JSONObject.fromObject(bean).toString());// Java Bean >>> JSON Object
		print(JSONArray.fromObject(bean).toString());// Java Bean >>> JSON Array,array会在最外层套上[]
		print(JSONSerializer.toJSON(bean).toString());// Java Bean >>> JSON  Object

		// 转换Java List集合到JSON
		// 如果你是转换List集合，一定得用JSONArray或是JSONSrializer提供的序列化方法。如果你用JSONObject.fromObject方法转换List会出现异常，
		// 通常使用JSONSrializer这个JSON序列化的方法，它会自动识别你传递的对象的类型，然后转换成相应的JSON字符串。
		print("***********************Java List >>> JSON*******************************");
		List<User> list = new ArrayList<User>();
		list.add(bean);
		bean.setName("jack");
		list.add(bean);
		print(JSONArray.fromObject(list).toString());
		print(JSONSerializer.toJSON(list).toString());

		// Map对象转JSON
		// Map集合有JavaBean、String、Boolean、Integer、以及Array和js的function函数的字符串。
		print("*************************Java Map >>> JSON*******************************");
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("A", bean);
		bean.setName("jack");
		map.put("B", bean);
		map.put("name", "json");
		map.put("bool", Boolean.TRUE);
		map.put("int", new Integer(1));
		map.put("arr", new String[] { "a", "b" });
		map.put("func", "function(i){ return this.arr[i]; }");
		print(JSONObject.fromObject(map).toString());// Java Map >>> JSON Object
		print(JSONArray.fromObject(map).toString());// Java Map >>> JSON Array
		print(JSONSerializer.toJSON(map).toString());// Java Map >>> JSON Object

		// 将更多类型转换成JSON
		// 这里还有一个JSONFunction的对象，可以转换JavaScript的function。可以获取方法参数和方法体。同时，还可以用JSONObject、JSONArray构建Java对象，完成Java对象到JSON字符串的转换。
		String[] sa = { "a", "b", "c" };
		print("==============Java StringArray >>> JSON Array ==================");
		print(JSONArray.fromObject(sa).toString());
		print(JSONSerializer.toJSON(sa).toString());
		Object[] o = { 1, "a", true, 'A', sa };
		print("==============Java Object Array >>> JSON Array ==================");
		print(JSONArray.fromObject(o).toString());
		print(JSONSerializer.toJSON(o).toString());
		print("==============Java String >>> JSON ==================");
		print(JSONArray.fromObject("['json','is','easy']").toString());
		print(JSONObject.fromObject("{'json':'is easy'}").toString());
		print(JSONSerializer.toJSON("['json','is','easy']").toString());
		print("==============Java JSONObject >>> JSON ==================");
		jsonObject = new JSONObject().element("string", "JSON").element("integer", "1").element("double", "2.0")
				.element("boolean", "true");
		print(JSONSerializer.toJSON(jsonObject).toString());

		print("==============Java JSONArray >>> JSON ==================");
		jsonArray = new JSONArray().element("JSON").element("1").element("2.0").element("true");
		print(JSONSerializer.toJSON(jsonArray).toString());

		print("==============Java JSONArray JsonConfig#setArrayMode >>> JSON ==================");
		List<String> input = new ArrayList<>();
		input.add("JSON");
		input.add("1");
		input.add("2.0");
		input.add("true");
		JSONArray jsonArray = (JSONArray) JSONSerializer.toJSON(input);
		JsonConfig jsonConfig = new JsonConfig();
		jsonConfig.setArrayMode(JsonConfig.MODE_OBJECT_ARRAY);
		Object[] output = (Object[]) JSONSerializer.toJava(jsonArray, jsonConfig);
		System.out.println(output[0]);

		print("==============Java JSONFunction >>> JSON ==================");
		String str = "{'func': function( param ){ doSomethingWithParam(param); }}";
		JSONObject jsonObject = (JSONObject) JSONSerializer.toJSON(str);
		JSONFunction func = (JSONFunction) jsonObject.get("func");
		print(func.getParams()[0]);
		print(func.getText());

	}

	// 注意的是使用了JsonConfig这个对象，这个对象可以在序列化的时候对JavaObject的数据进行处理、过滤等
	// 上面的jsonConfig的registerJsonValueProcessor方法可以完成对象值的处理和修改，比如处理生日为null时，给一个特定的值。
	// 同样setJsonPropertyFilter和setJavaPropertyFilter都是完成对转换后的值的处理。
	@Test
	public void test2JSONJsonConfig() {
		print("========================JsonConfig========================");
		JsonConfig jsonConfig = new JsonConfig();
		jsonConfig.registerJsonValueProcessor(Department.class, new JsonValueProcessor() {
			public Object processArrayValue(Object value, JsonConfig jsonConfig) {
				if (value == null) {
					return new Date();
				}
				return value;
			}

			public Object processObjectValue(String key, Object value, JsonConfig jsonConfig) {
				print("key:" + key);
				return value + "##修改过的日期";
			}

		});
		jsonObject = JSONObject.fromObject(bean, jsonConfig);

		print(jsonObject.toString());
		User student = (User) JSONObject.toBean(jsonObject, User.class);
		print(jsonObject.getString("birthday"));
		print(student.toString());

		print("#####################JsonPropertyFilter############################");
		jsonConfig.setJsonPropertyFilter(new PropertyFilter() {
			public boolean apply(Object source, String name, Object value) {
				print(source + "%%%" + name + "--" + value);
				// 忽略birthday属性
				if (value != null && Department.class.isAssignableFrom(value.getClass())) {
					return true;
				}
				return false;
			}
		});
		print(JSONObject.fromObject(bean, jsonConfig).toString());
		print("#################JavaPropertyFilter##################");
		jsonConfig.setRootClass(User.class);
		jsonConfig.setJavaPropertyFilter(new PropertyFilter() {
			public boolean apply(Object source, String name, Object value) {
				print(name + "@" + value + "#" + source);
				if ("id".equals(name) || "email".equals(name)) {
					value = name + "@@";
					return true;
				}
				return false;
			}
		});
		// jsonObject = JSONObject.fromObject(bean, jsonConfig);
		// student = (Student) JSONObject.toBean(jsonObject, Student.class);
		// print(student.toString());
		student = (User) JSONObject.toBean(jsonObject, jsonConfig);
		print("Student:" + student.toString());
	}

	// Json字符串转成Java对象
	@SuppressWarnings({ "unchecked", "deprecation" })
	@Test
	public void testJSON2Object() {
		try {
			// Json转Bean
			String objectJson = "{'age':20,'birthday':{'date':28,'day':3,'hours':18,'minutes':40,'month':10,'seconds':1,'time':1543401601583,'timezoneOffset':-480,'year':118},"
					+ "'id':1,'name':'Test','roles':[{'id':1,'name':'角色1'},{'id':2,'name':'角色2'}],'sex':'1'}";
			print("==============JSON Arry String >>> Java Array ==================");
			jsonObject = JSONObject.fromObject(objectJson);
			User user = (User) JSONObject.toBean(jsonObject, User.class);
			System.out.println(user);
			String arrayJson = "[" + objectJson + "]";
			jsonArray = JSONArray.fromObject(arrayJson);
			print(JSONArray.fromObject(arrayJson).join(""));
			User[] userArray = (User[]) JSONArray.toArray(jsonArray, User.class);
			System.out.println(userArray[0]);
			print("*************************Json转List*******************************");
			// Json转List
			List<User> list = new ArrayList<User>();
			list.add(bean);
			bean.setName("jack");
			list.add(bean);
			arrayJson = JSONArray.fromObject(list).toString();
			jsonArray = JSONArray.fromObject(arrayJson);
			List<User> listBean = JSONArray.toList(jsonArray, User.class);
			System.out.println(listBean.size());
			System.out.println(listBean.get(0).getName());
			print("************************Json转Map********************************");
			// Json转Map
			Map<String, User> maps = new HashMap<>();
			maps.put("user1", user);
			maps.put("user2", user);
			String mapJson = JSONObject.fromObject(maps).toString();
			print(mapJson);
			jsonObject = JSONObject.fromObject(mapJson);

			Map<String, Class<?>> clazzMap = new HashMap<String, Class<?>>();// JSON字符串不能直接转化为map对象，要想取得map中的键对应的值需要别的方式，
			clazzMap.put("user1", User.class);
			clazzMap.put("user2", User.class);
			Map<String, User> jsonToMap = (Map<String, User>) JSONObject.toBean(jsonObject, Map.class, clazzMap);
			System.out.println(jsonToMap.get("user2").getName());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	// Java对象转XML
	// 主要运用的是XMLSerializer的write方法，这个方法可以完成java对象到xml的转换，不过你很容易就可以看到这个xml序列化对象，
	// 需要先将java对象转成json对象，然后再将json转换吃xml文档。
	@Test
	public void testObject2XML() {
		XMLSerializer xmlSerializer = new XMLSerializer();
		xmlSerializer.setTypeHintsEnabled(false);
		xmlSerializer.setRootName("root");
		print("==============Java Bean >>> XML ==================");
		// xmlSerializer.setElementName("bean");
		print(xmlSerializer.write(JSONObject.fromObject(bean)));
		String[] sa = { "a", "b", "c" };
		print("==============Java String Array >>> XML ==================");
		print(xmlSerializer.write(JSONArray.fromObject(sa)));
		print(xmlSerializer.write(JSONSerializer.toJSON(sa)));
		Object[] o = { 1, "a", true, 'A', sa };
		print("==============Java Object Array >>> JSON Array ==================");
		print(xmlSerializer.write(JSONArray.fromObject(o)));
		print(xmlSerializer.write(JSONSerializer.toJSON(o)));
		print("==============Java String >>> JSON ==================");
		print(xmlSerializer.write(JSONArray.fromObject("['json','is','easy']")).toString());
		print(xmlSerializer.write(JSONObject.fromObject("{'json':'is easy'}")).toString());
		print(xmlSerializer.write(JSONSerializer.toJSON("['json','is','easy']")).toString());
	}

	// XML转Java对象
	@Test
	public void testXML2Object() {
		XMLSerializer xmlSerializer = new XMLSerializer();
		print("============== XML >>>> Java String Array ==================");
		String[] sa = { "a", "b", "c" };
		jsonArray = (JSONArray) xmlSerializer.read(xmlSerializer.write(JSONArray.fromObject(sa)));
		print(jsonArray.toString());
		String[] s = (String[]) JSONArray.toArray(jsonArray, String.class);
		print(s[0].toString());

		print("==============Java Object Array >>> JSON Array ==================");
		Object[] o = { 1, "a", true, 'A', sa };
		jsonArray = (JSONArray) xmlSerializer.read(xmlSerializer.write(JSONArray.fromObject(o)));
		System.out.println(jsonArray.getInt(0));
		System.out.println(jsonArray.get(1));
		System.out.println(jsonArray.getBoolean(2));
		jsonArray = (JSONArray) xmlSerializer.read(xmlSerializer.write(JSONSerializer.toJSON(o)));
		System.out.println(jsonArray.get(4));

		print("==============Java String >>> JSON ==================");
		jsonArray = (JSONArray) xmlSerializer
				.read(xmlSerializer.write(JSONArray.fromObject("['json','is','easy']")).toString());
		s = (String[]) JSONArray.toArray(jsonArray, String.class);
		print(s[0].toString());
		jsonObject = (JSONObject) xmlSerializer
				.read(xmlSerializer.write(JSONObject.fromObject("{'json':'is easy'}")).toString());
		Object obj = JSONObject.toBean(jsonObject);
		System.out.println(obj);
		jsonArray = (JSONArray) xmlSerializer
				.read(xmlSerializer.write(JSONSerializer.toJSON("['json','is','easy']")).toString());
		s = (String[]) JSONArray.toArray(jsonArray, String.class);
		print(s[1].toString());
	}
}

2、Gson（Google）

package com.its.test.util.json;

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.its.test.util.json.entity.Role;
import com.its.test.util.json.entity.User;

public class GsonTest {
	private User bean = null;

	@Before
	public void init() {
		bean = new User();
		bean.setId(1);
		bean.setName("Test");
		bean.setAge(20);
		bean.setSex("1");
		bean.setBirthday(new Date());
		Role role = new Role();
		role.setId(1);
		role.setName("角色1");
		Role role2 = new Role();
		role2.setId(2);
		role2.setName("角色2");
		List<Role> roles = new ArrayList<Role>();
		roles.add(role);
		roles.add(role2);
		bean.setRoles(roles);
	}

	public final void print(String string) {
		System.out.println(string);
	}

	@Test
	public void testObject2JSON() {

		// 1:Gson gson=newGson();
		// 2:通过GsonBuilder 可以配置多种选项
		// Gson gson = new GsonBuilder()
		// .setLenient()// json宽松
		// .enableComplexMapKeySerialization()//支持Map的key为复杂对象的形式
		// .serializeNulls() //智能null
		// .setPrettyPrinting()// 调教格式
		// .disableHtmlEscaping() //默认是GSON把HTML 转义的
		Gson gson = new Gson();
		print(gson.toJson(bean));
		// // 转换Java List集合到JSON
		print("***********************Java List >>> JSON*******************************");
		List<User> list = new ArrayList<User>();
		list.add(bean);
		bean.setName("jack");
		list.add(bean);
		print(gson.toJson(list));
		// Map对象转JSON
		print("*************************Java Map >>> JSON*******************************");
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("A", bean);
		bean.setName("jack");
		map.put("B", bean);
		map.put("name", "json");
		map.put("bool", Boolean.TRUE);
		map.put("int", new Integer(1));
		map.put("arr", new String[] { "a", "b" });
		map.put("func", "function(i){ return this.arr[i]; }");
		print(gson.toJson(map));
	}

	// Json字符串转成Java对象
	@Test
	public void testJSON2Object() {
		Gson gson = new Gson();
		// Json转Bean
		 String objectJson =
		 "{\"id\":1,\"name\":\"Test\",\"age\":20,\"sex\":\"1\",\"birthday\":Nov 29, 2018 10:27:05 AM,\"roles\":[{\"id\":1,\"name\":\"角色1\"},{\"id\":2,\"name\":\"角色2\"}]}";
//		String objectJson = "{\"id\":1,\"name\":\"Test\",\"age\":20,\"sexNo\":\"1\",\"birthday\":1543406407033,\"roles\":[{\"id\":1,\"name\":\"角色1\"},{\"id\":2,\"name\":\"角色2\"}]}";
		User user = gson.fromJson(gson.toJson(bean), User.class);
		print(user.getName());
		// Json转List
		List<User> list = new ArrayList<User>();
		list.add(bean);
		bean.setName("jack");
		list.add(bean);
		Type type = new TypeToken<ArrayList<User>>() {}.getType();
		List<User> userList = gson.fromJson(gson.toJson(list), type);
		print(userList.get(0).getName());
		print("************************Json转Map********************************");
		// Json转Map
		Map<String, User> maps = new HashMap<>();
		maps.put("user1", user);
		maps.put("user2", user);
		Map<String, User> userMaps = gson.fromJson(gson.toJson(maps),new TypeToken<Map<String, User>>() {}.getType());
		print(userMaps.get("user2").getName());
	}

}

3、FastJson（阿里巴巴）

package com.its.test.util.json;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Before;
import org.junit.Test;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.its.test.util.json.entity.Role;
import com.its.test.util.json.entity.User;

public class FastjsonTest {
	private User bean = null;

	@Before
	public void init() {
		bean = new User();
		bean.setId(1);
		bean.setName("Test");
		bean.setAge(20);
		bean.setSex("1");
		bean.setBirthday(new Date());
		Role role = new Role();
		role.setId(1);
		role.setName("角色1");
		Role role2 = new Role();
		role2.setId(2);
		role2.setName("角色2");
		List<Role> roles = new ArrayList<Role>();
		roles.add(role);
		roles.add(role2);
		bean.setRoles(roles);
	}


	public final void print(String string) {
		System.out.println(string);
	}

	@Test
	public void testObject2JSON() {
		print(JSONObject.toJSON(bean).toString());
		// // 转换Java List集合到JSON
		print("***********************Java List >>> JSON*******************************");
		List<User> list = new ArrayList<User>();
		list.add(bean);
		bean.setName("jack");
		list.add(bean);
		print(JSONObject.toJSON(list).toString());
		// Map对象转JSON
		print("*************************Java Map >>> JSON*******************************");
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("A", bean);
		bean.setName("jack");
		map.put("B", bean);
		map.put("name", "json");
		map.put("bool", Boolean.TRUE);
		map.put("int", new Integer(1));
		map.put("arr", new String[] { "a", "b" });
		map.put("func", "function(i){ return this.arr[i]; }");
		print(JSONObject.toJSONString(map));
	}

	// Json字符串转成Java对象
	@Test
	public void testJSON2Object() {
		// Json转Bean
		// String objectJson =
		// "{\"id\":1,\"name\":\"Test\",\"age\":20,\"sex\":\"1\",\"birthday\":1543406407033,\"roles\":[{\"id\":1,\"name\":\"角色1\"},{\"id\":2,\"name\":\"角色2\"}]}";
		String objectJson = "{\"id\":1,\"name\":\"Test\",\"age\":20,\"sexNo\":\"1\",\"birthday\":1543406407033,\"roles\":[{\"id\":1,\"name\":\"角色1\"},{\"id\":2,\"name\":\"角色2\"}]}";
		User user = JSONObject.parseObject(objectJson, User.class);
		print(user.getName());
		user = JSONObject.parseObject(JSONObject.toJSONString(bean), User.class);
		print(user.getRoles().get(0).getName());
		// Json转List
		List<User> list = new ArrayList<User>();
		list.add(bean);
		bean.setName("jack");
		list.add(bean);
		List<User> userList = JSONObject.parseObject(JSONObject.toJSONString(list), new TypeReference<List<User>>() {
		});
		print(userList.get(0).getName());
		print("************************Json转Map********************************");
		// Json转Map
		Map<String, User> maps = new HashMap<>();
		maps.put("user1", user);
		maps.put("user2", user);
		Map<String, User> userMaps = JSONObject.parseObject(JSONObject.toJSONString(maps),
				new TypeReference<Map<String, User>>() {});
		print(userMaps.get("user2").getName());
	}

}

4、Jackson

package com.its.test.util.json;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.its.test.util.json.entity.Role;
import com.its.test.util.json.entity.User;

public class JacksonTest {
	private JsonGenerator jsonGenerator = null;
	private ObjectMapper objectMapper = null;
	private User bean = null;

	@SuppressWarnings("deprecation")
	@Before
	public void init() {
		bean = new User();
		bean.setId(1);
		bean.setName("Test");
		bean.setAge(20);
		bean.setSex("1");
		bean.setBirthday(new Date());
		Role role = new Role();
		role.setId(1);
		role.setName("角色1");
		Role role2 = new Role();
		role2.setId(2);
		role2.setName("角色2");
		List<Role> roles = new ArrayList<Role>();
		roles.add(role);
		roles.add(role2);
		bean.setRoles(roles);
		objectMapper = new ObjectMapper();
		try {
			jsonGenerator = objectMapper.getJsonFactory().createJsonGenerator(System.out, JsonEncoding.UTF8);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@After
	public void destory() {
		try {
			if (jsonGenerator != null) {
				jsonGenerator.flush();
			}
			if (!jsonGenerator.isClosed()) {
				jsonGenerator.close();
			}
			jsonGenerator = null;
			objectMapper = null;
			bean = null;
			System.gc();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public final void print(String string) {
		System.out.println(string);
	}

	@Test
	public void testObject2JSON() {
		try {
			print("***********************jsonGenerator*******************************");
			jsonGenerator.writeObject(bean);
			print("***********************ObjectMapper*******************************");
			print(objectMapper.writeValueAsString(bean));
			// 转换Java List集合到JSON
			print("***********************Java List >>> JSON*******************************");
			List<User> list = new ArrayList<User>();
			list.add(bean);
			bean.setName("jack");
			list.add(bean);
			print(objectMapper.writeValueAsString(list));
			// Map对象转JSON
			print("*************************Java Map >>> JSON*******************************");
			Map<String, Object> map = new HashMap<String, Object>();
			map.put("A", bean);
			bean.setName("jack");
			map.put("B", bean);
			map.put("name", "json");
			map.put("bool", Boolean.TRUE);
			map.put("int", new Integer(1));
			map.put("arr", new String[] { "a", "b" });
			map.put("func", "function(i){ return this.arr[i]; }");
			print(objectMapper.writeValueAsString(map));
			
			print("*************************其他*******************************");
			String[] arr = { "a", "b", "c" };
			System.out.println("jsonGenerator");
			String str = "hello world jackson!";
			// byte
			jsonGenerator.writeBinary(str.getBytes());
			// boolean
			jsonGenerator.writeBoolean(true);
			// null
			jsonGenerator.writeNull();
			// float
			jsonGenerator.writeNumber(2.2f);
			// char
			jsonGenerator.writeRaw("c");
			// String
			jsonGenerator.writeRaw(str, 5, 10);
			// String
			jsonGenerator.writeRawValue(str, 5, 5);
			// String
			jsonGenerator.writeString(str);
			jsonGenerator.writeTree(JsonNodeFactory.instance.pojoNode(str));
			System.out.println();

			// Object
			jsonGenerator.writeStartObject();// {
			jsonGenerator.writeObjectFieldStart("user");// user:{
			jsonGenerator.writeStringField("name", "jackson");// name:jackson
			jsonGenerator.writeBooleanField("sex", true);// sex:true
			jsonGenerator.writeNumberField("age", 22);// age:22
			jsonGenerator.writeEndObject();// }

			jsonGenerator.writeArrayFieldStart("infos");// infos:[
			jsonGenerator.writeNumber(22);// 22
			jsonGenerator.writeString("this is array");// this is array
			jsonGenerator.writeEndArray();// ]

			jsonGenerator.writeEndObject();// }

			// complex Object
			jsonGenerator.writeStartObject();// {
			jsonGenerator.writeObjectField("user", bean);// user:{bean}
			jsonGenerator.writeObjectField("infos", arr);// infos:[array]
			jsonGenerator.writeEndObject();// }
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// Json字符串转成Java对象
	@SuppressWarnings("unchecked")
	@Test
	public void testJSON2Object() {
		try {
			// Json转Bean
			String objectJson = "{\"id\":1,\"name\":\"Test\",\"age\":20,\"sex\":\"1\",\"birthday\":1543406407033,\"roles\":[{\"id\":1,\"name\":\"角色1\"},{\"id\":2,\"name\":\"角色2\"}]}";
			User user = objectMapper.readValue(objectJson, User.class);
			print(user.getName());
			user = objectMapper.readValue(objectMapper.writeValueAsString(bean), User.class);
			print(user.getRoles().get(0).getName());
			// Json转List
			List<User> list = new ArrayList<User>();
			list.add(bean);
			bean.setName("jack");
			list.add(bean);
			List<LinkedHashMap<String, Object>> users = objectMapper.readValue(objectMapper.writeValueAsString(list), List.class);
			for (int i = 0; i < list.size(); i++) {
	            Map<String, Object> map = users.get(i);
	            Set<String> set = map.keySet();
	            for (Iterator<String> it = set.iterator();it.hasNext();) {
	                String key = it.next();
	                System.out.println(key + ":" + map.get(key));
	            }
	        }
			print("************************Json转Map********************************");
			// Json转Map
			Map<String, User> maps = new HashMap<>();
			maps.put("user1", user);
			maps.put("user2", user);
			Map<String, Map<String, Object>> userMaps = objectMapper.readValue(objectMapper.writeValueAsString(maps), Map.class);
			print(userMaps.get("user1").toString());
//			jsonObject = JSONObject.fromObject(mapJson);
//
//			Map<String, Class<?>> clazzMap = new HashMap<String, Class<?>>();// JSON字符串不能直接转化为map对象，要想取得map中的键对应的值需要别的方式，
//			clazzMap.put("user1", User.class);
//			clazzMap.put("user2", User.class);
//			Map<String, User> jsonToMap = (Map<String, User>) JSONObject.toBean(jsonObject, Map.class, clazzMap);
//			System.out.println(jsonToMap.get("user2").getName());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}