java对象和json间转化

一、hutool

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.5.7</version>
</dependency>

1、对象转json

对象转json

String userJson = JSONUtil.toJsonStr(user);

集合转json

String userListJson = JSONUtil.toJsonStr(userList);

2、json转对象

User user1 = JSONUtil.toBean(userJson, User.class);

3、json转集合

List<User> users = JSONUtil.toList(userListJson, User.class);

二、fastjson

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

1、对象转json

对象转json

String userJson = JSON.toJSONString(user);

集合转json

String userListJson = JSON.toJSONString(userList);

2、json转对象

User user1 = JSON.parseObject(userJson, User.class);

3、json转集合

List<User> users = JSON.parseArray(userListJson, User.class);

三、jackson

springMVC使用的就是该方法

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

1、对象转json

// jackson : 实体类对象（包括集合）转json
ObjectMapper MAPPER = new ObjectMapper();
String userJson = MAPPER.writeValueAsString(user);

2、json转对象

// jackson : json转对象
ObjectMapper MAPPER = new ObjectMapper();
User user = MAPPER.readValue(userJson, User.class);

3、json转集合

// jackson : json转集合
ObjectMapper MAPPER = new ObjectMapper();
JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, User.class);
List<User> list = MAPPER.readValue(userListjson, javaType);

4、指定属性不解析为json

当我们返回前端的实体类中，有一些字段不可返回，即使这些字段为空也不行。此时便可使用jackson 提供的注解 @JsonInclude 来解决

public class User{
    // 当id的值为空并返回前端时，不会将id解析为json
    @JsonInclude(value = JsonInclude.Include.NON_NULL)
    private Long id;
}

public enum Include {
    /**
    * 解析为 JSON 时，始终包含该值
    */
    ALWAYS,

    /**
    * 解析为 JSON 时，当属性值不为null时，包含该值
    */
    NON_NULL,

    /**
    * 当属性值为下面几种时，不解析为 JSON：
    * 1、null
    * 2、不存在的引用类型：如 Java8 的Optional，或 JUC 的 AtomicReference
    *     也就是说，它不会遵从非空值。此选项主要用于“Optional”(Java 8, Guava)
    */
    NON_ABSENT,

    /**
    * 当属性值为 null 或者 被认为空时不会被解析
    * 以下情况的值会被认为是空值：
    * 1、值为 null
    * 2、不存在的值，详见上面的NON_ABSENT
    * 3、集合Collection和Map的isEmpty()为true
    * 4、集合的长度为 0 
    * 5、String 的长度为 0 
    * 以上时被认为空值的情况，注意，这个默认处理可以被自定义覆盖
    * 自定义校验空值的方式可以实现JsonSerializer，并重写isEmpty()方法
    * 该方法用于调用它来查看非空值是否为空(null总是被认为为空)。
    * 特殊的：基础类型的默认值，如int=0，boolean=false     
    */
    NON_EMPTY,

    /**
    * 此设置的含义取决于上下文:
    * 1、如果注解在实体类上：当实体类中的属性不为默认值时，才会被解析
    *（默认值可在实体类的属性中直接定义，如 int i = 1）
    * 工作原理是通过空参构造创建一个实体类，并通过 equals() 比较解析对象的属性值和默认值
    * 2、如果注解时用在属性上，则默认值参考上面的NON_EMPTY，只有非默认值才会被解析
    */
    NON_DEFAULT,

    /**
    * 使用自定义过滤器判断属性是否排除
    * JsonInclude#valueFilter用于值本身
    * JsonInclude#contentFilter用于结构化类型的内容
    * Filter的equals()方法会在属性被序列化之前调用，如果返回 true 则属性将被排除
    */
    CUSTOM,

    /**
    * 伪值，用于表示更高级别的默认值是有意义的，以避免重写包含值。
    * 例如，如果为一个属性返回，这将使用包含属性的类的默认值，如果有定义;
    * 如果没有为此定义，则全局序列化包含详细信息。
    */
    USE_DEFAULTS;
}

5、指定解析后属性名

注解作用，在解析成json格式时，将属性名count更改为value

@JsonProperty("value")
private Integer count;

6、封装工具类

package com.bie.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.bie.nationalpolicy.po.Student;

import java.util.ArrayList;
import java.util.List;

public class JsonUtils {


    // 定义jackson对象
    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 beanType 对象中的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;
    }


    public static void main(String[] args) {
        // Java内部类创建对象，要想直接创建内部类的对象，必须使用外部类的对象来创建内部类对象
        List<Student> students = new ArrayList<Student>();
        for (int i = 0; i < 20; i++) {
            Student student = new Student();
            student.setId(1008611 + i);
            student.setName("张三三" + i);
            student.setAddress("北京市西城区什刹海街道西什库大街31号院" + i);

            // 1、将实体类对象转换为json格式
            String objectToJson = JsonUtils.objectToJson(student);
            System.out.println("1、将实体类对象转换为json格式: " + objectToJson);

            students.add(student);
        }

        // 2、将Json格式的数据转换为实体类
        String jsonToPojo = JsonUtils.objectToJson(students);
        System.out.println("2、将Json格式的数据转换为实体类: " + jsonToPojo);

        // 3、将json数据转换成pojo对象list
        List<Student> jsonToList = JsonUtils.jsonToList(jsonToPojo, Student.class);
        System.out.println("3、将json数据转换成pojo对象list: " + jsonToList.toString());
    }
}