Jackson进行JSON解析和序列化

Java下常见的Json类库有Gson、JSON-lib和Jackson等，Jackson相对来说比较高效，在项目中主要使用Jackson进行JSON和Java对象转换.

1.准备工作

Jackson有1.x系列和2.x系列，2.x系列有3个jar包需要下载：
jackson-core-2.2.3.jar（核心jar包）
jackson-annotations-2.2.3.jar（该包提供Json注解支持）
jackson-databind-2.2.3.jar

在maven中更加方便

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

public class User {
    private String name;
    private Integer age;
    private Date birthday;
    private String email;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    @Override
    public String toString() {
        return "User [name=" + name + ", age=" + age + ", birthday=" + birthday + ", email=" + email + "]";
    }
}

2.原理

import com.fasterxml.jackson.databind.ObjectMapper

ObjectMapper时JSON操作的核心，Jackson的所有JSON操作都是在ObjectMapper中实现
ObjectMapper有多个JSON序列化的方法，可以把JSON字符串保存File、OutputStream等不同的介质中。
writeValue(File arg0, Object arg1)把arg1转成json序列，并保存到arg0文件中。
writeValue(OutputStream arg0, Object arg1)把arg1转成json序列，并保存到arg0输出流中。
writeValueAsBytes(Object arg0)把arg0转成json序列，并把结果输出成字节数组。
writeValueAsString(Object arg0)把arg0转成json序列，并把结果输出成字符串。

readValue(JsonParser p, JavaType valueType),转化成java对象.

2.java对象转换成json数据

public class PojoToJson {
    private ObjectMapper mapper = null;
    @Before
    public void init() {
        mapper = new ObjectMapper();
    }
    //对象转化成json
    @Test
    public void ObjectToJson() throws Exception {
        User user = new User();
        user.setName("严狗");
        user.setAge(22);
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        user.setBirthday(dateFormat.parse("1996-11-07"));
        
        ObjectMapper mapper = new ObjectMapper();
        String jsonUser = mapper.writeValueAsString(user);
        System.out.println(jsonUser);
    }
    //将list对象转换成json
    @Test
    public void listToJson() throws Exception {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        User user = new User();
        user.setName("严狗");
        user.setAge(22);
        user.setBirthday(dateFormat.parse("1996-11-07"));
        User user1 = new User();
        user1.setName("陈立其");
        user1.setAge(22);
        user1.setBirthday(dateFormat.parse("1996-11-09"));
        ArrayList<User> list = new ArrayList<>();
        list.add(user);
        list.add(user1);
        String jsonList = mapper.writeValueAsString(list);
        System.out.println(jsonList);
    }
}

3.json数据转化成java类

public class JsonToPojo {
    
    private ObjectMapper mapper = null;
    
    @Before
    public void init() {
        mapper = new ObjectMapper();
    }
    //json数据转换成java对象
    @Test
    public void jsonToPojo() throws Exception {
        String json = "{\"name\":\"严狗\",\"age\":22,\"birthday\":847296000000,\"email\":null}";
        User user = (User)mapper.readValue(json, User.class);
        System.out.println(user);
    }
    //json数据转换成list对象
    @Test
    public void jsonToList() throws Exception {
        String json = "[{\"name\":\"严狗\",\"age\":22,\"birthday\":847296000000,\"email\":null},"
                + "{\"name\":\"陈立其\",\"age\":22,\"birthday\":847468800000,\"email\":null}]";
        //JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
        JavaType javaType = mapper.getTypeFactory().constructParametricType(List.class, User.class);
        List<User> users = mapper.readValue(json, javaType);
        for(User user:users) {
            System.out.println(user);
        }
        //mapper.readValue(src, valueType)
    }
}

 

4.json注解

Jackson对java对象的字段提供了一系列注解，方便对JSON序列化和反序列化进行控制.
@JsonIgnore 此注解用于属性上，作用是进行JSON操作时忽略该属性。
@JsonFormat 此注解用于属性上，作用是把Date类型直接转化为想要的格式，如@JsonFormat(pattern = "yyyy-MM-dd HH-mm-ss")。
@JsonProperty 此注解用于属性上，作用是把该属性的名称序列化为另外一个名称，如把trueName属性序列化为name，@JsonProperty("name")。

public class Student {
    
    private String name;
    //不JSON序列化
    @JsonIgnore
    private Integer age;
    //格式化日期
    @JsonFormat(pattern = "yyyy年MM月dd日")
    private Date birthday;
    
    @JsonProperty("my_email")
    private String email;
}

public class JsonAnnotation {
    private ObjectMapper mapper = null;
    
    @Before
    public void init() {
        mapper = new ObjectMapper();
    }
    @Test
    public void ObjectToJson() throws Exception {
        Student student = new Student();
        student.setName("xxx");
        student.setAge(20);
        SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd");
        student.setBirthday(dateformat.parse("1999-12-12"));
        student.setEmail("5287624552@qq.com");
        
        String json = mapper.writeValueAsString(student);
        System.out.println(json);//{"name":"xxx","birthday":"1999年12月11日","my_email":"5287624552@qq.com"}
    }
    
    @Test
    public void jsonToObject() throws Exception {
        String json = "{\"name\":\"xxx\",\"birthday\":\"1999年12月11日\",\"my_email\":\"5287624552@qq.com\"}";
        Student student = mapper.readValue(json, Student.class);
        System.out.println(student);
    }
}

5.JsonUtils

public class JsonUtils {
     private static final ObjectMapper MAPPER = new ObjectMapper();
        /**
         * 将对象转换成json字符串。
         * <p>Title: pojoToJson</p>
         * <p>Description: </p>
         * @param data
         * @return
         */
        public static String objectToJson(Object data) {
            try {
                String string = MAPPER.writeValueAsString(data);
                return string;
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
            return null;
        }
        
        /**
         * 将json结果集转化为对象
         * 
         * @param jsonData json数据
         * @param clazz 对象中的object类型
         * @return
         */
        public static <T> T jsonToPojo(String jsonData, Class<T> beanType) {
            try {
                T t = MAPPER.readValue(jsonData, beanType);
                return t;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
        
        /**
         * 将json数据转换成pojo对象list
         * <p>Title: jsonToList</p>
         * <p>Description: </p>
         * @param jsonData
         * @param beanType
         * @return
         */
        public static <T>List<T> jsonToList(String jsonData, Class<T> beanType) {
            JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
            try {
                List<T> list = MAPPER.readValue(jsonData, javaType);
                return list;
            } catch (Exception e) {
                e.printStackTrace();
            }
            
            return null;
        }
}