JSON解析之Jackson

JSON简介

　　JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，易于人阅读和编写，同时也易于机器解析和生成(一般用于提升网络传输速率)。
　　在Java中有多种工具可以用来解析或者生成Json，如下图所示。
　　
　　参考官网
　　其中较常用到的有JSON-java、Jackson、Json-lib。
　　Jackson可以轻松地将Java对象转换成json和xml文档，同样，也可以容易地将json或者xml文档转换成Java对象。

1.准备

1)下载Jackson的jar包，在maven工程里面，导入代码如下：

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.7.1</version>
        </dependency>

2)在maven中导入JUnit的jar包：

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>

3)新建一个JUnit测试类，JacksonTest.java
4)在maven工程的src/main/resources/目录下准备好几个Json文件，用于后面将Json文档转化为相应的Java类型。
　　map.json

{
"class1":{"id":"11","name":"mason","gender":"male","age":24},
"class2":{"id":"14","name":"jane","gender":"female","age":20}
}

　　array.json

[
{"id":"11","name":"mason","gender":"male","age":24},{"id":"16","name":"jame","gender":"male","age":24}
]

　　list.json

[
{"id":"11","name":"mason","gender":"male","age":24},{"id":"19","name":"jack","gender":"male","age":26}
]

2.编码

1)准备一个Bean类，用于转换成json或从json接收数据，命名为StudentBean.java

public class StudentBean {
    private String id;
    private String name;
    private String gender;
    private Integer age;

    public StudentBean() {
    }

    public StudentBean(String id, String name, String gender, Integer age) {
        super();
        this.id = id;
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Integer getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "StudentBean [id=" + id + ", name=" + name + ", gender=" + gender + ", age=" + age + "]";
    }

}

2)编写主要的测试类，JacksonTest.java

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
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 bean.StudentBean;

public class JacksonTest {

    private JsonGenerator generator = null;
    private ObjectMapper mapper = null;
    private StudentBean student = null;

    @Before
    public void setUp() throws Exception {
        student = new StudentBean("11","mason","male",24);
        mapper = new ObjectMapper();
        generator = mapper.getFactory().createGenerator(System.out,JsonEncoding.UTF8);
    }

    @After
    public void tearDown() throws Exception {
        if(generator != null) {
            generator.flush();
        }
        if(!generator.isClosed()) {
            generator.close();
        }
        generator = null;
        mapper = null;
        student = null;
        System.gc();
    }

    /*
     * JsonGenerator的writeObject方法和ObjectMapper的writeValue方法
     * 都可以完成对Java对象的转换，只是二者传递的参数及构造的方式不同。
     * JsonGenerator的创建依赖于ObjectMapper对象，也就是说如果你要使用JsonGenerator
     * 来转换JSON，那么你必须创建一个ObjectMapper，
     * 但是你用ObjectMapper来转换JSON，则不需要JSONGenerator。
     * objectMapper的writeValue方法可以将一个Java对象转换成JSON，
     * 这个方法的参数一，需要提供一个输出流，转换后可以通过这个流来输出转换后的内容，
     * 或是提供一个File，将转换后的内容写入到File中，
     * 当然，这个参数也可以接收一个JSONGenerator，然后通过JSONGenerator来输出转换后的信息，
     * 第二个参数是将要被转换的Java对象。
     */
    @Test
    public void beanToJson() {
        System.out.println("StudentBean对象转换成Json文档：");
        try {
            //使用JsonGenerator来转换
            generator.writeObject(student);
            System.out.println();
            //使用ObjectMapper来转换
            mapper.writeValue(System.out, student);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void mapToJson() {
        System.out.println("Map<String,StudentBean>集合对象转换成Json文档：");
        try {
            Map<String,StudentBean> map = new HashMap<String,StudentBean>();
            map.put("class1", student);
            StudentBean student2 = new StudentBean("14","jane","female",20);
            map.put("class2", student2);
            //使用JsonGenerator来转换
            generator.writeObject(map);
            System.out.println();
            //使用ObjectMapper来转换
            mapper.writeValue(System.out, map);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Test
    public void listToJson() {
        System.out.println("List<StudentBean>集合对象转换成Json文档：");
        try {
            List<StudentBean> list = new ArrayList<StudentBean>();
            StudentBean student3 = new StudentBean("19","jack","male",26);
            list.add(student);
            list.add(student3);
            //使用JsonGenerator来转换
            generator.writeObject(list);
            System.out.println();
            //使用ObjectMapper来转换
            mapper.writeValue(System.out, list);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Test
    public void arrayToJson() {
        System.out.println("StudentBean数组对象转换成Json文档：");
        StudentBean[] arr = new StudentBean[2];
        StudentBean student4 = new StudentBean("16","jame","male",24);
        arr[0] = student;
        arr[1] = student4;
        try {
            //使用JsonGenerator来转换
            generator.writeObject(arr);
            System.out.println();
            //使用ObjectMapper来转换
            mapper.writeValue(System.out, arr);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /*
     * 用到了ObjectMapper这个对象的readValue这个方法,
     * 这个方法需要提供2个参数:第一个参数就是解析的JSON字符串，第二个参数是即将将这个JSON解析成什么Java对象。
     */
    @Test
    public void jsonToBean() {
        System.out.println("Json文档转换为StudentBea对象：");
        //需要使用转义字符
        String  json = "{\"id\":\"22\",\"name\":\"lily\",\"gender\":\"female\",\"age\":33}";
        try {
            StudentBean student5 = mapper.readValue(json, StudentBean.class);
            System.out.println(student5);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /*
     * 并不能转换成Map<String,StudentBean>的形式
     * 而是装换成多层的Map结构
     */
    @Test
    public void jsonToMap() {
        System.out.println("Json文档转换为Map对象：");
        File src = new File("src/main/resources/map.json");
        try {
            Map<String,Map<String,Object>> map = mapper.readValue(src, Map.class);
            Set<String> keys = map.keySet();
            Iterator<String> it = keys.iterator();
            while(it.hasNext()) {
                String className = it.next();
                System.out.println(className+":"+map.get(className));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Test
    public void jsonToArray() {
        System.out.println("Json文档转换为Array对象：");
        File src = new File("src/main/resources/array.json");
        try {
            StudentBean[] students = mapper.readValue(src, StudentBean[].class);
            for (StudentBean studentBean : students) {
                System.out.println(studentBean);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Test
    public void jsonToList() {
        System.out.println("Json文档转换为List对象：");
        File src = new File("src/main/resources/list.json");
        try {
            List<LinkedHashMap<String,Object>> list = mapper.readValue(src, List.class);
            for (LinkedHashMap<String, Object> linkedHashMap : list) {
                System.out.println(linkedHashMap);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

3.运行结果

4.总结

　　Jackson的使用比较简洁，越来越多的项目都开始使用它来解析Json数据。本文内容参考了Jackson 框架，轻易转换JSON