FastJson
FastJson
- JSONArray : 相当于List
- JSONObject: 相当于Map<String,Object>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.7</version>
</dependency>
FastJson将对象转JSON格式
//对象（可以是任何你能想到的格式，简单对象，集合，对象集合等）
Object object=new Object();
String json=JSON.toJSONString(object);
注意：JSON.toJSONString(对象)，打印的结果你会发现，不仅仅是属性值，还包括一些其他的值，就是类里面getXXX()的，toJSONString主要是去调用get方法
此时的json就是转化后的json格式数据，根据object的类型来决定格式，
如果是对象的话，格式为：{“key”:“value”,“key”:“value”},如果为
集合的话，格式为:[Object,Object]。
注意，这里不管是对象还是集合，对于里面的值的类型是没有限制的，也就是对面里面的value可以放集合也可以放对象，集合里面可以放集合也可以放对象，但是放集合的话必须要是key:value的键值对格式(其实就是对象)，例如：[{“list1”:[],“list2”:[]},{“list1”:[],“list2”:[]}]
FastJson将JSON格式转为对象或集合
//这里我只介绍我用的比较多的几种转化
//1.JSON==>Map
String json = "{\"demo\":\"123\"}";
Map<String,Object> map=JSON.parseObject(json,Map.class);
//2.JSON==>List
String json = "[{\"demo\":\"123\"}]";
List list=JSON.parseObject(json,List.class);
注意这里的第二个参数，很关键~~~
这里的第二个参数在parseObject的时候代表的是将json格式的字符串转化为
这个参数类型的对象。什么意思呢，就是如果你写的是Map.class，那么这里就是
将这个json转成Map对象，如果是List.class，那么就会转为List集合对象。
那么有的小伙伴可能就有疑问了,那这个方法是不是就可以满足所有需求呢，答案当时不是啦，对于集合而言，FastJson提供了另一个方法供我们使用：
String json="[1,2,3]";
//注意这里使用了泛型，大部分时候List肯定是要用泛型的
List<Integer> list=JSON.parseArray(json,Integer.class);
这里大家有没有发现我使用的是parseArray这个方法，这个方法的第二个参数大家就要注意了，他的含义和parseObject的第二个参数可不一样。他代表的是集合的泛型的类型。这里的意思就是将json转成Integer类型的集合。举个例子：
String json = "[{\"demo\":\"123\"}]";
//还是这个json，但是这里使用另一种方式转化
List<Map<String,Object>> list=JSON.parseArray(json,Map.class);
/*
这里大家就会发现，上面这个是不行的，发现会提示提供的参数类型与需要的不匹配，
需要的是Map<String,Object>,而提供的是Map,那这种情况怎么办呢，我们就换一种
方法，用parseObject来解决
*/
List<Map<String,Object>> list=JSON.parseObject(json,List.class);
/*
但是要注意，这个时候是会提示未经检查的分配，将List转为
List<Map<String,Object>>，这里可以使用new TypeReference<>(){}来完成泛型
的转换，示例如下：
*/
List<Map<String,Object>> list= JSON.parseObject(json, new TypeReference<List<Map<String,Object>>>(){});
这里提一下，如果需要在parseObject或者parseArray里面转化的时候，第一个参数一定要是json格式的字符串，这里不建议大家使用手动拼接，建议直接使用JSON.toJSONString(),来转化，有的时候手动拼接费时费力而且容易出现错误，导致格式不对然后一堆问题，比如给前台数据变为字符串等等，所以大家要注意了~
fastjson组件序列化反序列化
//序列化
String text = JSON.toJSONString(obj);
//反序列化
VO vo = JSON.parse(); //解析为JSONObject类型或者JSONArray类型
VO vo = JSON.parseObject("{...}"); //JSON文本解析成JSONObject类型
VO vo = JSON.parseObject("{...}", VO.class); //JSON文本解析成VO.class类
fastjson组件使用
先构建需要序列化的User类：
User.java
package com.fastjson;
public class User {
private String name;
private int age;
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;
}
}
再使用fastjson组件
package com.fastjson;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
public class Main {
public static void main(String[] args) {
//创建一个用于实验的user类
User user1 = new User();
user1.setName("lala");
user1.setAge(11);
//序列化
String serializedStr = JSON.toJSONString(user1);
注意：JSON.toJSONString(对象)，打印的结果你会发现，不仅仅是属性值，还包括一些其他的值，就是类里面getXXX()的，toJSONString主要是去调用get方法
System.out.println("serializedStr="+serializedStr);
//通过parse方法进行反序列化，返回的是一个JSONObject
Object obj1 = JSON.parse(serializedStr);
System.out.println("parse反序列化对象名称:"+obj1.getClass().getName());
System.out.println("parse反序列化："+obj1);
//通过parseObject,不指定类，返回的是一个JSONObject
Object obj2 = JSON.parseObject(serializedStr);
System.out.println("parseObject反序列化对象名称:"+obj2.getClass().getName());
System.out.println("parseObject反序列化:"+obj2);
//通过parseObject,指定类后返回的是一个相应的类对象
Object obj3 = JSON.parseObject(serializedStr,User.class);
System.out.println("parseObject反序列化对象名称:"+obj3.getClass().getName());
System.out.println("parseObject反序列化:"+obj3);
}
}
以上使用了三种形式反序列化
结果如下：
//序列化
serializedStr={"age":11,"name":"lala"}
//parse({..})反序列化
parse反序列化对象名称:com.alibaba.fastjson.JSONObject
parse反序列化：{"name":"lala","age":11}
//parseObject({..})反序列化
parseObject反序列化对象名称:com.alibaba.fastjson.JSONObject
parseObject反序列化:{"name":"lala","age":11}
//parseObject({},class)反序列化
parseObject反序列化对象名称:com.fastjson.User
parseObject反序列化:com.fastjson.User@3d71d552
参考：https://xz.aliyun.com/t/7027
String eneity3 = " {enetities:[{\"sex\": 1}]}";
//反序列化
Map<String,List<Map<String,Integer>>> obj = JSON.parseObject(eneity3,new TypeReference<Map<String,List<Map<String,Integer>>>>(){});
//输出会调用obj对象的tooString函数
System.out.println(obj.get("enetities").get(0).get("sex"));
参考：https://xz.aliyun.com/t/7027
如何取JSONObject中的值
JSONOnject obj = new JSONObject();
//如果我们需要判断json中是否包含这个键值对，
(1).boolean b = obj.containKey("key");
(2).String res = obj.getString("key");
if (res != null) {
System.out.println(res);
}
//如果想继续得到JSONObject
JSONObject obj1 =obj.getJSONObject(str2);
//如果想继续得到值为字符串键值对;
String jsonStr = obj.getString("");
//如果是得到Object,适合得到对应的值，下面没有数据
Onject obj2 = obj.get(str2);
//如果知道对应值得类型，还可以直接得到该类型的数据，基本类型必须是它的包装类，举例
int num = obj.getInteger("num");
String s2 = obj.getBoolean("name");
JSONObject的常用方法
/新建JSONObject对象
JSONObject object1 = new JSONObject();
//1.在JSONObject对象中放入键值对
object1.put("name", "张三");
object1.put("name1", "张三1");
object1.put("name2", "张三2");
//2.根据key获取value
String name = (String) object1.get("name");
System.out.println(name);
//3.获取JSONObject中的键值对个数
int size = object1.size();
System.out.println(size);
//4.判断是否为空
boolean result = object1.isEmpty();
System.out.println(result);
//5.是否包含对应的key值，包含返回true，不包含返回false
boolean isContainsKeyResult = object1.containsKey("name");
System.out.println(isContainsKeyResult);
//6.是否包含对应的value值，包含返回true，不包含返回false
boolean isContainsValueResult = object1.containsValue("王五");
System.out.println(isContainsValueResult);
//7.JSONObjct对象中的value是一个JSONObject对象，即根据key获取对应的JSONObject对象；
JSONObject object2 = new JSONObject();
//将jsonobject对象作为value进行设置
object2.put("student1", object1);
JSONObject student =object2.getJSONObject("student1");
System.out.println(student);
//8.如果JSONObject对象中的value是一个JSONObject数组，既根据key获取对应的JSONObject数组；
JSONObject objectArray = new JSONObject();
//创建JSONArray数组
JSONArray jsonArray = new JSONArray();
//在JSONArray数组设值:jsonArray.add(int index, Object value);
jsonArray.add(0, "this is a jsonArray value");
jsonArray.add(1, "another jsonArray value");
objectArray.put("testArray", jsonArray);
//获取JSONObject对象中的JSONArray数组
JSONArray jsonArray2 = objectArray.getJSONArray("testArray");
System.out.println(jsonArray2);
//9.remove.根据key移除JSONObject对象中的某个键值对
object1.remove("name");
System.out.println(object1);
//10.取得JSONObject对象中key的集合
Set<String> keySet= object1.keySet();
for (String key : keySet) {
System.out.print(" "+key);
}
System.out.println();
//11.取得JSONObject对象中的键和值的映射关系
Set<Map.Entry<String, Object>> entrySet = object1.entrySet();
for (Entry<String, Object> entry : entrySet) {
System.out.println(entry);
}
//12.转换为json字符串
String str1 = object1.toJSONString();
System.out.println(str1);
String str2 =object1.toString();
System.out.println(str2);
}
参考：https://www.cnblogs.com/zjdxr-up/p/9736755.html
参考：http://www.yiidian.com/fastjson/fastjson-json-javabean.html
https://www.cnblogs.com/dmego/p/9033080.html
补充
JSONObject 有 parseObject(String text, Class
但它们都需要传入一个Class对象作为参数，换句话说，必须先有一个Class对应的实体类，而很多时候我们只会将其中的键值对解析出来用一次，只临时使用它一次就去创建一个新的实体类，将会导致类爆炸。
换种思路，JSONArray.parseArray(String text)将返回一个JSONArray对象。根据其add(Object obj)的方法入参类型是Object，那么其元素类型可能是一个实体类也可能是一个普通的json对象JSONObject,。但当前我们调用parseArray(String text)静态方法传入了的一个json字符串，以此构建出一个json数组，那么可以肯定其内部的元素类型一定是JSONObject，因此将其中的每个元素从Object强制转换为JSONObject类型，然后再从每个JSONObject取出键值对。
@Test
public void parseJsonText()
{
String menuList = "[{'id':1,'locked':false,'loginedTime':'2014-01-21'},"
+ "{'id':2,'locked':true,'loginedTime':'2015-03-22'},]";
/*
* 有属性名与之对应的User类，则可以写成这种形式，但目前并不存在User类，
* 所以无法实现 List<User> uList=JSONArray.parseArray(menuList, User.class);
*/
JSONArray jUsers = JSONArray.parseArray(menuList);
/**
* 这个for循环也可以
* for(int i=0;i<jUsers.size();i++){
JSONObject user=jUsers.getJSONObject(i);
}
*/
for (Object userObj : jUsers)
{
JSONObject jUser = (JSONObject)userObj; // 强制类型转换，因为知道其元素的具体类型是JSONObject，那么就不会出错
/**
* {'id':1}键值对的值1没加引号，FastJson认为它是数字，
* 如果是{'id':'1'}格式，FastJson认为它是字符串，转换为Integer将出错
*/
Integer id = (Integer)jUser.get("id");
/*
* {'locked':false}键值对的值没加引号，FastJson视作boolean类型，
* 如果是{'locked':'false'}格式，FastJson视作String类型,强制转换为boolean将运行时出错
*
*/
boolean locked = (boolean)jUser.get("locked");
String loginTime = (String)jUser.get("loginedTime");
System.out.println("用户id：" + id + " ，锁定了吗？ " + locked + " 登录时间:" + loginTime);
}
}
I can feel you forgetting me。。 有一种默契叫做我不理你,你就不理我
