Jackson、Gosn、FastJson基本使用

为什么要使用json ：

1. json格式好理解

2. json格式数据在多种语言中，比较容易处理。 使用java， javascript读写json格式的数据比较容易。

3. json格式数据他占用的空间下，在网络中传输快， 用户的体验好。

处理json的工具库： gson（google), fastjson（阿里）, jackson, json-lib…

本篇文章介绍jackson和gson的简单使用方法

使用Jackson工具包

导入Jackson依赖

<!-- jackson依赖 -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.10.1</version>
</dependency>
           

// JSON 在 java 中的使用(使用jackson工具包)
public class TestJson {
    public static void main(String[] args) throws JsonProcessingException {
    	
    	// 1.将java对象转为json格式  --- 序列化
        Province shanghai = new Province(10,"上海","沪","直辖市");
		
        // 创建ObjectMapper对象
        ObjectMapper mapper = new ObjectMapper();
        
        // 调用writeValueAsString(Object o) 将o对象转为json格式的字符串返回
        String json = mapper.writeValueAsString(shanghai);
        
        // 2. list集合转json数组
        // 这个方法可以接受list集合或者map集合, 序列化成为json数组
        String json = mapper.writeValueAsString(list);
        System.out.println(json);

		// 3. 将json格式的字符串, 转为Java对象, 反序列化
        // 都是ObjectMapper.read()的相关方法
        // 使用readValue(String json, Class<T> valueType) 返回这个java对象
        Province p = mapper.readValue(json, Province.class);
        System.out.println(p);
        
        // 4. 将json格式的数组,反序列化回list集合
        List<Province> listPro = mapper.readValue(json, new TypeReference<List<Province>>() {});
        listPro.forEach(province -> System.out.println(province.toString()));
        
    }
}
           

使用gson工具包

导入gson依赖

<!-- gson依赖 -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.5</version>
</dependency>
           

// JSON 在 java 中的使用(使用gson工具包)
        // 1. javaBean(java对象) 和 json 的互转
        @Test
        public void test1(){
            Person person = new Person(1,"迪丽热巴");
            // 创建 Gson 对象实例
            Gson gson = new Gson();
            
            // toJson 方法可以把 java 对象转换成为 json 字符串
            String personJsonString = gson.toJson(person);
            System.out.println(personJsonString);
            
            // fromJson 把 json 字符串转换回 Java 对象
            // 第一个参数是 json 字符串
            // 第二个参数是转换回去的 Java 对象类型的字节码
            Person person1 = gson.fromJson(personJsonString, Person.class);
            System.out.println(person1);
        } 
        
        // 2. List 和 json 的互转
        @Test
        public void test2() {
            List<Person> personList = new ArrayList<>();
            personList.add(new Person(1, "迪丽热巴"));
            personList.add(new Person(2, "古力娜扎"));
            
            Gson gson = new Gson();
            // 把 List 转换为 json 字符串
            String personListJsonString = gson.toJson(personList);
            System.out.println(personListJsonString);
            
            // 将 json 转为 list
            List<Person> list = gson.fromJson(personListJsonString, new PersonListType().getType());
            System.out.println(list);
            Person person = list.get(0);
            System.out.println(person);
        }
        
        // 3. map 和 json 的互转
        @Test
        public void test3(){
            Map<Integer,Person> personMap = new HashMap<>();
            personMap.put(1, new Person(1, "迪丽热巴"));
            personMap.put(2, new Person(2, "马尔扎哈"));
            
            Gson gson = new Gson();
            
            // 把 map 集合转换成为 json 字符串
            String personMapJsonString = gson.toJson(personMap);
            System.out.println(personMapJsonString);
            
            // Map<Integer,Person> personMap2 = gson.fromJson(personMapJsonString, new
            PersonMapType().getType());
            
            Map<Integer,Person> personMap2 = gson.fromJson(personMapJsonString, new
                    TypeToken<HashMap<Integer,Person>>(){}.getType());
            System.out.println(personMap2);
            Person p = personMap2.get(1);
            System.out.println(p);
        }
           

使用fastjson工具包

导入fastjson依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.73</version>
</dependency>
           

序列化:
String jsonString = JSON.toJSONString(obj);

反序列化:
VO vo = JSON.parseObject("jsonString", VO.class);

泛型反序列化:

List<VO> list = JSON.parseObject("jsonString", new TypeReference<List<VO>>(){});

注意：VO必须有默认无参构造方法