Json常用处理方式

2020-06-11 tools json, tools 0 评论

概述

作为 面向对象 开发的程序员，每天的业务代码会遇到大量的 Json 处理。本文从最常见的几个类库 gson, fastjson, jackson 进行基本操作, 仅作记录。

基础准备

首先创建java对象用于测试

角色

/**
 * @author 当我遇上你
 * @公众号 当我遇上你
 * @since 2020-06-10
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Role {

    private String roleName;

}

这里我们创建一个复合嵌套对象user

/**
 * @author 当我遇上你
 * @公众号 当我遇上你
 * @since 2020-06-10
 */
@Data
public class User {

    private String userName;
    private List<Role> roles;
}

用户组

/**
 * @author 当我遇上你
 * @公众号 当我遇上你
 * @since 2020-06-11
 */
@Data
public class UserGroup implements Serializable {

    private String groupName;
    private Map<String, User> idNumber;

}

菜单

/**
 * @author 当我遇上你
 * @公众号 当我遇上你
 * @since 2020-06-10
 */
@Data
@AllArgsConstructor
public class Menu {

    @SerializedName("menu_name")
    private String menuName;

}

部门

/**
 * @author 当我遇上你
 * @公众号 当我遇上你
 * @since 2020-06-11
 */
@Data
@AllArgsConstructor
public class Dept {
    private String deptName;
}

类型适配器

/**
 * @author 当我遇上你
 * @公众号 当我遇上你
 * @since 2020-06-11
 */
public class DeptAdapter implements JsonSerializer<Dept> {

    @Override
    public JsonElement serialize(Dept dept, Type type, JsonSerializationContext jsonSerializationContext) {

        JsonObject deptObject = new JsonObject();
        deptObject.addProperty("dept_name", dept.getDeptName());

        return deptObject;
    }
}

Gson

maven依赖

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
</dependency>

单元测试

/**
 * @author 当我遇上你
 * @公众号 当我遇上你
 * @since 2020-06-10
 */
class GsonTest {

    /**
     * {"userName":"admin","roles":[{"roleName":"系统管理员"},{"roleName":"普通管理员"}]}
     */
    @Test
    void toJson() {
        Role role1 = new Role("系统管理员");
        Role role2 = new Role("普通管理员");
        User user = new User();
        user.setUserName("admin");
        user.setRoles(Arrays.asList(role1, role2));

        // 对象转json
        String json = new Gson().toJson(user);
        System.out.println(json);
    }

    /**
     * {"userName":"admin","roles":[{"roleName":"系统管理员"},{"roleName":"普通管理员"}]}
     */
    @Test
    void toJson2() {
        Role role1 = new Role("系统管理员");
        Role role2 = new Role("普通管理员");
        User user = new User();
        user.setUserName("admin");
        user.setRoles(Arrays.asList(role1, role2));

        String json = new GsonBuilder().create().toJson(user);
        System.out.println(json);
    }

    /**
     * User(userName=admin, roles=[Role(roleName=系统管理员), Role(roleName=普通管理员)])
     */
    @Test
    void fromJson() {
        String json = "{\"userName\":\"admin\",\"roles\":[{\"roleName\":\"系统管理员\"},{\"roleName\":\"普通管理员\"}]}";
        User user = new Gson().fromJson(json, User.class);
        System.out.println(user);
    }

    /**
     * admin
     * {"userName":"admin","roles":{"roleName":"超级管理员"}}
     */
    @Test
    void createJsonObject() {

        JsonObject role = new JsonObject();
        role.addProperty("roleName", "超级管理员");

        JsonObject user = new JsonObject();
        user.addProperty("userName", "admin");
        user.add("roles", role);

        String username = user.get("userName").getAsString();
        System.out.println(username);
        System.out.println(user);
    }

    /**
     * admin
     */
    @Test
    void json2Object() {

        String json = "{\"userName\":\"admin\",\"roles\":[{\"roleName\":\"系统管理员\"},{\"roleName\":\"普通管理员\"}]}";

        JsonObject jsonObject = JsonParser.parseString(json).getAsJsonObject();
        String userName = jsonObject.get("userName").getAsString();
        System.out.println(userName);
    }


    /**
     * [{"roleName":"系统管理员"},{"roleName":"普通管理员"}]
     */
    @Test
    void list2Json() {

        Role role1 = new Role("系统管理员");
        Role role2 = new Role("普通管理员");
        String json = new Gson().toJson(Arrays.asList(role1, role2));

        System.out.println(json);
    }

    /**
     * [Role(roleName=系统管理员), Role(roleName=普通管理员)]
     */
    @Test
    void json2List() {
        String json = "[{\"roleName\":\"系统管理员\"},{\"roleName\":\"普通管理员\"}]";
        List<Role> roles = new Gson().fromJson(json, new TypeToken<List<Role>>() {}.getType());

        System.out.println(roles);
    }

    /**
     * [{"roleName":"系统管理员"},{"roleName":"普通管理员"}]
     */
    @Test
    void json2Array() {
        String json = "[{\"roleName\":\"系统管理员\"},{\"roleName\":\"普通管理员\"}]";
        JsonArray jsonArray = JsonParser.parseString(json).getAsJsonArray();

        System.out.println(jsonArray);
    }

    /**
     * {"userName":"admin"}
     */
    @Test
    void map2Json() {
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("userName", "admin");

        String json = new Gson().toJson(hashMap);
        System.out.println(json);
    }

    /**
     * admin
     */
    @Test
    void json2Map() {
        String json = "{\"userName\":\"admin\"}";
        HashMap hashMap = new Gson().fromJson(json, new TypeToken<HashMap<String, String>>() {}.getType());

        System.out.println(hashMap.get("userName"));
    }


    /**
     * 默认的字段转换规则，字段名不变
     * {"roleName":"超级管理员"}
     */
    @Test
    void setFieldNamingPolicy1() {

        Gson gson = new GsonBuilder()
                .setFieldNamingPolicy(FieldNamingPolicy.IDENTITY)
                .create();

        Role role = new Role("超级管理员");
        String json = gson.toJson(role);
        System.out.println(json);
    }

    /**
     * 将json中的字段名转换为首字母大写的格式
     * {"RoleName":"超级管理员"}
     */
    @Test
    void setFieldNamingPolicy2() {

        Gson gson = new GsonBuilder()
                .setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE)
                .create();

        Role role = new Role("超级管理员");
        String json = gson.toJson(role);
        System.out.println(json);
    }

    /**
     * 将json中的字段名转换为首字母大写，单词之间以空格分割的格式
     * {"Role Name":"超级管理员"}
     */
    @Test
    void setFieldNamingPolicy3() {

        Gson gson = new GsonBuilder()
                .setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE_WITH_SPACES)
                .create();

        Role role = new Role("超级管理员");
        String json = gson.toJson(role);
        System.out.println(json);
    }

    /**
     * 将json中的字段名转换为小写字母，单词之间以下划线分割的格式
     * {"role_name":"超级管理员"}
     */
    @Test
    void setFieldNamingPolicy4() {

        Gson gson = new GsonBuilder()
                .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
                .create();

        Role role = new Role("超级管理员");
        String json = gson.toJson(role);
        System.out.println(json);
    }

    /**
     * 将json中的字段名转换为小写字母，单词之间以分隔线分割的格式
     * {"role-name":"超级管理员"}
     */
    @Test
    void setFieldNamingPolicy5() {

        Gson gson = new GsonBuilder()
                .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_DASHES)
                .create();

        Role role = new Role("超级管理员");
        String json = gson.toJson(role);
        System.out.println(json);
    }

    /**
     * 将json中的字段名转换为小写字母，单词之间以点分割的格式
     * {"role.name":"超级管理员"}
     */
    @Test
    void setFieldNamingPolicy6() {

        Gson gson = new GsonBuilder()
                .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_DOTS)
                .create();

        Role role = new Role("超级管理员");
        String json = gson.toJson(role);
        System.out.println(json);
    }

    /**
     * 属性重命名
     * {"menu_name":"系统管理"}
     */
    @Test
    void serializedName() {
        Menu menu = new Menu("系统管理");

        String json = new Gson().toJson(menu);
        System.out.println(json);
    }

    /**
     * {"dept_name":"产品研发部"}
     */
    @Test
    void adapter() {
        Gson gson = new GsonBuilder()
                //为Dept注册TypeAdapter
                .registerTypeAdapter(Dept.class, new DeptAdapter())
                .create();

        Dept dept = new Dept("产品研发部");
        String json = gson.toJson(dept);

        System.out.println(json);
    }

}

FastJson

maven依赖

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

单元测试

public class FastJsonTest {

    /**
     * {"roles":[{"roleName":"系统管理员"},{"roleName":"普通管理员"}],"userName":"admin"}
     */
    @Test
    void toJson() {
        Role role1 = new Role("系统管理员");
        Role role2 = new Role("普通管理员");
        User user = new User();
        user.setUserName("admin");
        user.setRoles(Arrays.asList(role1, role2));

        String userJson = JSON.toJSONString(user);
        System.out.println(userJson);
    }

    /**
     * admin
     * {"roles":[{"roleName":"系统管理员"},{"roleName":"普通管理员"}],"userName":"admin"}
     */
    @Test
    void jsonParse() {
        String json = "{\"roles\":[{\"roleName\":\"系统管理员\"},{\"roleName\":\"普通管理员\"}],\"userName\":\"admin\"}";
        JSONObject jsonObject = JSON.parseObject(json);

        System.out.println(jsonObject.getString("userName"));
        System.out.println(jsonObject);
    }

    /**
     * [{"roleName":"系统管理员"},{"roleName":"普通管理员"}]
     */
    @Test
    void list2Json() {
        Role role1 = new Role("系统管理员");
        Role role2 = new Role("普通管理员");

        String jsonString = JSON.toJSONString(Arrays.asList(role1, role2));

        System.out.println(jsonString);
    }

    /**
     * [{"roleName":"系统管理员"},{"roleName":"普通管理员"}]
     */
    @Test
    void json2List() {
        String json = "[{\"roleName\":\"系统管理员\"},{\"roleName\":\"普通管理员\"}]";

        JSONArray jsonArray = JSON.parseArray(json);
        System.out.println(jsonArray);
    }

    /**
     * [Role(roleName=系统管理员), Role(roleName=普通管理员)]
     */
    @Test
    void json2List2() {
        String json = "[{\"roleName\":\"系统管理员\"},{\"roleName\":\"普通管理员\"}]";

        List<Role> users = JSON.parseArray(json, Role.class);
        System.out.println(users);
    }

    /**
     * User(userName=admin, roles=[Role(roleName=系统管理员), Role(roleName=普通管理员)])
     */
    @Test
    void json2Bean() {
        String json = "{\"roles\":[{\"roleName\":\"系统管理员\"},{\"roleName\":\"普通管理员\"}],\"userName\":\"admin\"}";

        User user = JSON.parseObject(json, User.class);
        System.out.println(user);
    }

    /**
     * User(userName=admin, roles=[Role(roleName=系统管理员), Role(roleName=普通管理员)])
     */
    @Test
    void json2Bean2() {
        String json = "{\"roles\":[{\"roleName\":\"系统管理员\"},{\"roleName\":\"普通管理员\"}],\"userName\":\"admin\"}";

        User user = JSON.parseObject(json, new TypeReference<User>(){});
        System.out.println(user);
    }

    /**
     * {"userName":"admin"}
     */
    @Test
    void map2Json() {
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("userName", "admin");

        String jsonString = JSON.toJSONString(hashMap);
        System.out.println(jsonString);
    }

    /**
     * admin
     */
    @Test
    void json2Map() {
        String json = "{\"userName\":\"admin\"}";

        Map<String, String> map = (Map<String, String>) JSON.parse(json);
        System.out.println(map.get("userName"));
    }

    /**
     * {"userName":"admin"}
     */
    @Test
    void json2Map2() {
        String json = "{\"userName\":\"admin\"}";

        Map map = JSON.parseObject(json);
        System.out.println(map);
    }

    /**
     * {"groupName":"分组1","idNumber":{"001":{"roles":[{"roleName":"系统管理员"},{"roleName":"普通管理员"}],"userName":"admin"}}}
     */
    @Test
    void obj2Json() {
        Role role1 = new Role("系统管理员");
        Role role2 = new Role("普通管理员");
        User user = new User();
        user.setUserName("admin");
        user.setRoles(Arrays.asList(role1, role2));

        HashMap<String, User> map = new HashMap<>();
        map.put("001", user);
        UserGroup userGroup = new UserGroup();
        userGroup.setGroupName("分组1");
        userGroup.setIdNumber(map);

        String jsonString = JSON.toJSONString(userGroup);
        System.out.println(jsonString);
    }

    /**
     * UserGroup(groupName=分组1, idNumber={001=User(userName=admin, roles=[Role(roleName=系统管理员), Role(roleName=普通管理员)])})
     */
    @Test
    void json2Obj() {
        String json = "{\"groupName\":\"分组1\",\"idNumber\":{\"001\":{\"roles\":[{\"roleName\":\"系统管理员\"},{\"roleName\":\"普通管理员\"}],\"userName\":\"admin\"}}}";

        UserGroup userGroup = JSON.parseObject(json, UserGroup.class);
        System.out.println(userGroup);
    }

}

Jackson

单元测试

/**
 * @author 当我遇上你
 * @公众号 当我遇上你
 * @since 2020-06-11
 */
public class JacksonTest {

    /**
     * {"userName":"admin","roles":[{"roleName":"系统管理员"},{"roleName":"普通管理员"}]}
     * @throws JsonProcessingException
     */
    @Test
    void Obj2Json() throws JsonProcessingException {
        Role role1 = new Role("系统管理员");
        Role role2 = new Role("普通管理员");
        User user = new User();
        user.setUserName("admin");
        user.setRoles(Arrays.asList(role1, role2));

        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(user);

        System.out.println(json);
    }

    /**
     * 需要无参构造方法
     * User(userName=admin, roles=[Role(roleName=系统管理员), Role(roleName=普通管理员)])
     * @throws JsonProcessingException
     */
    @Test
    void json2Obj() throws JsonProcessingException {
        String json = "{\"userName\":\"admin\",\"roles\":[{\"roleName\":\"系统管理员\"},{\"roleName\":\"普通管理员\"}]}";

        ObjectMapper mapper = new ObjectMapper();
        User user = mapper.readValue(json, User.class);
        System.out.println(user);
    }

    /**
     * admin
     * @throws JsonProcessingException
     */
    @Test
    void json2Obj2() throws JsonProcessingException {
        String json = "{\"userName\":\"admin\",\"roles\":[{\"roleName\":\"系统管理员\"},{\"roleName\":\"普通管理员\"}]}";

        ObjectMapper mapper = new ObjectMapper();
        JsonNode jsonNode = mapper.readTree(json);

        String userName = jsonNode.get("userName").asText();
        System.out.println(userName);
    }

    /**
     * [{"roleName":"系统管理员"},{"roleName":"普通管理员"}]
     * @throws JsonProcessingException
     */
    @Test
    void list2Json() throws JsonProcessingException {
        Role role1 = new Role("系统管理员");
        Role role2 = new Role("普通管理员");

        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(Arrays.asList(role1, role2));

        System.out.println(json);
    }

    /**
     * 需要无参构造方法
     * [Role(roleName=系统管理员), Role(roleName=普通管理员)]
     * @throws JsonProcessingException
     */
    @Test
    void json2List() throws JsonProcessingException {
        String json = "[{\"roleName\":\"系统管理员\"},{\"roleName\":\"普通管理员\"}]";

        ObjectMapper mapper = new ObjectMapper();
        List<Role> roles = mapper.readValue(json, new TypeReference<List<Role>>() {
        });

        System.out.println(roles);
    }
}

配置

json序列化去除value=null的key

1	@JsonInclude(JsonInclude.Include.NON_NULL)

序列化重命名

/**
 * Json反序列化: 将Json Data转化为Java Object
 * Json的序列化: 将Java Object转化为JSON Data
 *
 * 将java中[name]字段序列化为json中的[NAME]字段.
 * 注意: 反序列化时也必须用[NAME]字段, 否则会报: UnrecognizedPropertyException: Unrecognized field "name"
 */
@JsonProperty("NAME")
private String name;

反序列化重命名

/**
 * 将json中的age_alias字段反序列化为java的[age]字段
 */
@JsonAlias("age_alias")
private Integer age;

LocalDateTime格式化

/**
 * @DateTimeFormat 是将String转换成Date，一般前台给后台传值时用
 * @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")  将Date转换成String, 一般后台传值给前台时
 * 东八区（UTC/GMT+08:00）比世界协调时间（UTC）/格林尼治时间（GMT）快8小时
 */
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private LocalDateTime date;

Java实体驼峰序列化为下划线(全局配置)

ObjectMapper objectMapper = new ObjectMapper();
// 反序列化时, 当JSON字符串某个属性在Java POJO对象中未定义时，是否解析失败，默认值为true
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
// 表明该类为NULL的字段不参加序列化
objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
// Java实体驼峰序列化为下划线
objectMapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);

序列化携带 class 信息

package cn.idea360.jpa;

import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.io.Serializable;

/**
 * @author cuishiying
 */
@Slf4j
class JsonTest {

    @Data
    public static class Student implements Serializable {
        private String name;
    }

    @Data
    public static class Child implements Serializable {
        private String name;
    }

    @Data
    public static class Father implements Serializable {
        private Child[] children;
    }

    @Data
    public static class Teacher implements Serializable {

        /**
         * 序列化携带类信息
         */
        @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, property = "@class")
        private Student student;

        @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, property = "@class")
        private Child[] children;
    }

    private Student student;
    private Father father;
    private Teacher teacher;

    @BeforeEach
    void init() {
        student = new Student();
        student.setName("admin");
        Child child = new Child();
        child.setName("张三");

        father = new Father();
        father.setChildren(new Child[]{child});

        teacher = new Teacher();
        teacher.setStudent(student);
        teacher.setChildren(new Child[]{child});
    }

    @Test
    void toJson() throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        String json = objectMapper.writeValueAsString(student);
        log.info(json);
    }

    @Test
    void toJsonWithClass1() throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        String json = objectMapper.writeValueAsString(teacher);
        log.info(json);
    }

    @Test
    void toJsonWithClass2() throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        // 序列化携带类信息
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.NONE).setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
        String json = objectMapper.writeValueAsString(father);
        log.info(json);
        Father father = objectMapper.readValue(json, Father.class);
        log.info(String.valueOf(father));
    }
}

最后

本文到此结束，感谢阅读。如果您觉得不错，请关注公众号【当我遇上你】，您的支持是我写作的最大动力。

参考

https://github.com/duanxinyuan/json-utils

本文链接： https://idea360.cn/2020/06/11/json-handle/

版权声明： 本博客所有文章除特别声明外，均采用 CC BY 4.0 CN协议许可协议。转载请注明出处！