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就是转化后的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);
        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 clazz) 静态方法，将json字符串解析成T类型的java对象；而 JSONArray也有parseArray(String text, Class clazz) 将json字符串解析成List的集合对象。

但它们都需要传入一个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);
        }
    }

参考：https://www.cnblogs.com/gocode/p/parse-key_value-without-entity-and-concat-nested-json-by-fastjson.html