一 、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();
}
}
}
相关推荐
3. JSON解析基本步骤： - 读取JSON字符串：通常从网络请求、文件或数据库中获取JSON数据。 - 创建映射对象：定义与JSON结构匹配的Java类，包含对应的属性。 - 解析JSON：使用Jackson或Gson的API将JSON字符串转化...
Ajax，全称Asynchronous JavaScript and XML，虽然名字中包含XML，但实际上它并不仅限于XML，而是广泛使用JSON作为数据交换格式，因为JSON解析和生成的速度更快，且更易于阅读和编写。 在"JsonRpc小实例"中，我们...
本篇将聚焦于如何巧妙地使用`eval`函数来解析JSON对象，虽然在实际开发中，由于安全考虑我们通常会避免使用`eval`，但理解其工作原理对于学习JavaScript和JSON解析至关重要。 首先，JSON对象本质上是符合JSON语法的...
Json解析工具使用的 json-smart，曾经对比过Java的fastjson、gson。Scala的json4s、lift-json。其中 json-smart 解析速度是最快的。 <groupId>net.minidev</groupId> <artifactId>json-smart <version>2.3 ...
只需定义一个Objective-C类，该类继承自JSONModel，并标注属性类型，然后就可以直接将JSON字符串转化为这个类的实例。这样，你就可以在Model层直接使用这些对象，无需手动解析JSON。 MJExtension是另一个常用的...
JSON（JavaScript Object Notation）则是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。在IT和BIM领域中，JSON因其简洁和高效，常被用于传输和存储数据。 在Revit模型转JSON的过程中，...
JSON是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成，因此在Web服务中被广泛应用。 首先，让我们详细解释TCP协议。TCP是一种面向连接的、可靠的传输协议，它在数据传输前会建立连接，并...
本文将深入探讨“iOS JSON Demo”中涉及的JSON解析技术，包括三种主流的第三方类库以及iOS系统自带的解析方法。 首先，我们要了解iOS内置的JSON解析方法。苹果在Foundation框架中提供了`NSJSONSerialization`类，它...
JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。它基于JavaScript的一个子集，但被广泛应用于各种编程语言中，包括Java。在本主题中，我们将深入探讨...
4. **解码难度**：XML的解析方式主要有两种：文档模型解析和节点遍历。而JSON在JavaScript环境下解析更为便捷，尤其是当事先知道JSON结构时。 #### 实例比较 假设我们需要表示中国的部分省市数据： **XML 示例**...
2. JSON与XML的对比：讨论JSON相对于XML的优势，如更小的体积、更快的解析速度以及更直观的结构。 3. JSON的解析与生成：解释如何在各种编程语言中解析JSON字符串为数据结构，以及如何将数据结构转换为JSON字符串。 ...
例如，你可以使用`parseObject()`方法将JSON字符串解析为Java对象，或者使用`toJSONString()`方法将Java对象转换为JSON字符串。 另一方面，json-lib是一个广泛使用的JSON库，其中`net.sf.json.JSONObject`类同样...
1. **JSON解析与生成**：学习如何使用Delphi的内置JSON类，如TJSONObject和TJSONArray，创建和解析JSON对象。 2. **网络通信**：了解如何在Delphi中实现HTTP请求或WebSocket连接，以发送和接收JSON数据。 3. **...
4. **JSON与XML的对比**：JSON比XML更简洁，解析速度更快，但XML提供了更丰富的结构和元数据支持。在Web服务和浏览器交互中，JSON通常比XML更为常见。 5. **优点**：轻量级，易于阅读和编写，同时也易于机器解析和...
这个过程涉及到JSON解析、类型映射以及自动判断类型等功能。`swift-macapp根据json字符串创建模型类自动判断类型`是一个针对这个问题的解决方案，它帮助开发者更高效地实现JSON到Swift模型类的转换。 首先，Swift...
JSON采用了一种类似于XML的文本形式来表示数据，但相较于XML而言，JSON具有更加紧凑、快速且易于解析的特点。 ##### 1.1 什么是JSON？ JSON是一种用来存储和交换文本信息的标准格式。其设计初衷是为了让数据更加...
JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成。在ECharts中，地图JSON文件通常包含了各个地区的地理坐标信息，这些信息用于在地图上正确绘制出各个...
4. **JSON解析**：可以使用`JSONObject.getString()`, `JSONObject.getInt()`, `JSONObject.getJSONArray()`等方法获取JSON对象中的值。对于JSON数组，可以遍历`JSONArray`并调用`JSONObject`的方法获取数据。 5. *...