java学习之json篇——java-json、gson、fastjson、jackson的使用

最新推荐文章于 2024-04-16 02:23:43 发布
最新推荐文章于 2024-04-16 02:23:43 发布
阅读量610 收藏
点赞数
分类专栏： 技术 文章标签： java json gson
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51134729/article/details/121385139
版权

建立实体类

user

package com.jock168.entity;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;

import java.time.LocalDate;
/**
 * @Description TODO
 * @Author Jock
 * @Date 2021/11/14
 */
// 用于指定生成JSON串的属性顺序
@JsonPropertyOrder({"age", "user_name"})
public class User {
    // 重命名属性的注解
    @JsonProperty("user_name")
    private String name;
    @JsonProperty("age")
    private int age;
    // 指定日期格式的注解
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd")
    private LocalDate birth;
    // 指定在JSON串中不生成此属性
    @JsonIgnore
    private String gender;

    public User() {
    }

    public User(String name, int age, LocalDate birth) {
        this.name = name;
        this.age = age;
        this.birth = birth;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public LocalDate getBirth() {
        return birth;
    }

    public void setBirth(LocalDate birth) {
        this.birth = birth;
    }

    public String getGender() {
        return gender;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", birth=" + birth +
                '}';
    }
}

student

package com.open.entity;

/**
 * @Description TODO
 * @Author Jock
 * @Date 2021/11/11
 *
 * alt+insert
 */
public class Student {
    private int id;
    private String name;
    private int age;
    private String gender;

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }

    public Student() {
    }

    public Student(int id, String name, int age, String gender) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getGender() {
        return gender;
    }

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

使用java-json实现json格式转字符串和字符串转json

package com.open.test;

import com.open.entity.Student;
import org.json.JSONObject;
import org.junit.Test;

/**
 * @Description TODO
 * @Author Jock
 * @Date 2021/11/11
 * ctrl+shift+enter，自动补全 alt+/   alt+enter
 */
public class JsonTest {
    @Test
    public void testJsonToStudent() {
        // 1. 提供要转换的 JSON 字符串
        String json = "{\"gender\":\"男\",\"name\":\"张三\",\"id\":1,\"age\":20}";
        // 2. 创建 JSONObject 对象
        JSONObject object = new JSONObject(json);
        // 3. 调用 get(String key)
        Student student = new Student();
        student.setId(object.getInt("id"));
        student.setName(object.getString("name"));
        student.setAge(object.getInt("age"));
        student.setGender(object.getString("gender"));
        System.out.println(student);
    }

    @Test
    public void testStudentToJson() {
        // 把 Student 对象转换为 JSON 字符串
        Student student = new Student(1, "张三", 20, "男");

        // JSON-java 中的方法
        // 要想使用 JSON官网提供的解析JSON工具，必须先创建 JSONObject对象
        JSONObject object = new JSONObject(student);
        // 调用 JSONObject 对象的 toString() 方法就会生成JSON字符串了
        String json = object.toString();
        System.out.println(json);
    }
}

gson

package com.xianopen.test;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;
import com.xianopen.entity.Student;
import org.junit.Test;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Gson 提供了 fromJson()  和 toJson() 两个直接用于解析和生成的方法，前者实现反序列化，后者实现了序列化。
 *
 * 创建Gson 对象有两种方式：
 * 1. 调用构造器创建
 *   Gson gson = new Gson();
 * 2. 调用 Builder 创建
 *   Gson gson = new GsonBuilder();
 *
 *   Gson gson = new GsonBuilder()
 *     	// 宽松
 *     	.setLenient()
 *         // 序列化null
 *         .serializeNulls()
 *     	// 支持 Map 复杂对象
 *         .enableComplexMapKeySerialization()
 *         // 设置日期时间格式，在序列化和反序化时均生效
 *         .setDateFormat("yyyy-MM-dd")
 *         // 禁此序列化内部类
 *         .disableInnerClassSerialization()
 *         // 生成不可执行的Json（多了 )]}' 这4个字符）
 *         .generateNonExecutableJson()
 *         // 禁止转义html标签
 *         .disableHtmlEscaping()
 *         // 格式化输出
 *         .setPrettyPrinting()
 *         .create();
 */
public class GsonTest {
    @Test
    public void testJsonToMap() {
        String json = "{\"1\":{\"id\":1,\"name\":\"张三\",\"age\":20},\"2\":{\"id\":2,\"name\":\"李四\",\"age\":21},\"3\":{\"id\":3,\"name\":\"王五\",\"age\":22},\"4\":{\"id\":4,\"name\":\"赵六\",\"age\":23}}";

        Gson gson = new Gson();
        Map<Integer, Student> map = gson.fromJson(json, new TypeToken<Map<Integer, Student>>() {
        }.getType());
        System.out.println(map);
    }
    @Test
    public void testMapToJson() {
        Map<Integer, Student> stus = new HashMap<>();
        stus.put(1, new Student(1, "张三", 20));
        stus.put(2, new Student(2, "李四", 21));
        stus.put(3, new Student(3, "王五", 22));
        stus.put(4, new Student(4, "赵六", 23));

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

    @Test
    public void testJsonToList() {
        //List<Student> List<Object>
        String json = "[{\"id\":1,\"name\":\"张三\",\"age\":20},{\"id\":2,\"name\":\"李四\",\"age\":21},{\"id\":3,\"name\":\"王五\",\"age\":22},{\"id\":4,\"name\":\"赵六\",\"age\":23}]";
        Gson gson = new Gson();
        List list = gson.fromJson(json, new TypeToken<List<Student>>(){}.getType());
        System.out.println(list);
        System.out.println(list.size());
        System.out.println(list.get(0));
        //System.out.println(list.get(0).getId());
    }

    @Test
    public void testListToJson() {
        // 复制的快捷键 ctrl + d
        List<Student> stus = new ArrayList<>();
        stus.add(new Student(1, "张三", 20));
        stus.add(new Student(2, "李四", 21));
        stus.add(new Student(3, "王五", 22));
        stus.add(new Student(4, "赵六", 23));
        Gson gson = new Gson();
        String json = gson.toJson(stus);
        System.out.println(json);
    }



    @Test
    public void testReflact() throws Exception {
        Class<Student> clazz = Student.class;

        Student stu = clazz.getDeclaredConstructor().newInstance();

        // 获取字段
        //Field[] fields = clazz.getFields();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getName());
            field.setAccessible(true);
            if (field.getName().equals("id")) {
                field.set(stu, 5);
            }
            if (field.getName().equals("name")) {
                field.set(stu, "王五");
            }
        }
        System.out.println(stu);

    }

    @Test
    public void testJsonToStudent() {
        // 1. JSON字符串
        String json = "{\"id\":1,\"name\":\"张三\",\"age\":18}";

        // 2. 创建Gson对象
        Gson gson = new GsonBuilder().create();

        // 3. 调用fromJson()
        Student student = gson.fromJson(json, Student.class);
        System.out.println(student);
    }
    @Test
    public void testStudentToJson() {
        // 1. 创建被转换的对象
        Student student = new Student();
        /*student.setId(1);
        student.setName("张三");
        student.setAge(18);*/

        // 2. 创建 Gson 对象
        Gson gson = new Gson();

        // 3. 调用 toJson() 方法
        String json = gson.toJson(student);
        System.out.println(json);
    }
}

fastjson

package com.jock168.test;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.jock168.entity.User;
import org.junit.Test;

import java.util.*;

public class FastJsonTest {
    @Test
    public void testMapToJSON() {
        Map<Integer, User> map = new HashMap<>();
        map.put(1, new User("张三", 18, new Date()));
        map.put(2, new User("李四", 20, new Date()));

        // 序列化
        String json = JSON.toJSONString(map);
        System.out.println(json);
        // 反序列化
        Map<Integer, User> users = JSON.parseObject(json, new TypeReference<Map<Integer, User>>() {
        });
        System.out.println(users);
    }
    @Test
    public void testListToJSON() {
        List<User> users = new ArrayList<>();
        users.add(new User("张三", 18, new Date()));
        users.add(new User("李四", 20, new Date()));

        // 序列化为JSON
        String json = JSON.toJSONString(users);
        System.out.println(json);

        // 反序列化
        List<User> us = JSON.parseObject(json, new TypeReference<List<User>>(){});
        System.out.println(us);
    }
    @Test
    public void testBeanToJSON() {
        User user = new User();
        user.setName("张三");
        user.setAge(18);
        user.setBirth(new Date());

        // Bean转JSON
        String json = JSON.toJSONString(user);
        System.out.println(json);

        // JSON 转Bean
        User u = JSON.parseObject(json, User.class);
        System.out.println(u);
    }
}

jackson

package com.jock168.test;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.CollectionType;
import com.fasterxml.jackson.databind.type.MapType;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.jock168.entity.User;
import org.junit.Test;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/*
Jackson常用统一配置：
//在反序列化时忽略在 json 中存在但 Java 对象不存在的属性
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
//在序列化时日期格式默认为 yyyy-MM-dd'T'HH:mm:ss.SSSZ
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
//在序列化时自定义时间日期格式
mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
//在序列化时忽略值为 null 的属性
mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
//在序列化时忽略值为默认值的属性
mapper.setDefaultPropertyInclusion(JsonInclude.Include.NON_DEFAULT);

如果项目使用的是 JDK 8 中的日期对象，那么需要额外添加 jar 支持
1. 添加 jackson-datatype-jsr310-2.13.0.jar 到项目中
2. 给 mapper 对象注册参数
    mapper.registerModule(new JavaTimeModule());

 */
public class JacksonTest {
    @Test
    public void testMapToJSON() throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule());
        Map<Integer, User> users = new HashMap<>();

        User user = new User();
        user.setName("张三");
        user.setAge(20);
        user.setBirth(LocalDate.now());
        users.put(1, user);

        user = new User();
        user.setName("李四");
        user.setAge(21);
        user.setBirth(LocalDate.now());
        users.put(2, user);

        // 序列化
        String json = mapper.writeValueAsString(users);
        System.out.println(json);

        // 反序列化
        MapType mapType = mapper.getTypeFactory().constructMapType(Map.class, Integer.class, User.class);
        Map<Integer, User> userMap = mapper.readValue(json, mapType);

        //Map<Integer, User> userMap = mapper.readValue(json, new TypeReference<Map<Integer, User>>() { });
        System.out.println(userMap);
    }
    @Test
    public void testListToJSON() throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule());

        List<User> users = new ArrayList<>();

        User user = new User();
        user.setName("张三");
        user.setAge(20);
        user.setBirth(LocalDate.now());
        users.add(user);

        user = new User();
        user.setName("李四");
        user.setAge(21);
        user.setBirth(LocalDate.now());
        users.add(user);

        // 序列化
        String json = mapper.writeValueAsString(users);
        System.out.println(json);

        // 反序列化
        CollectionType javaType = mapper.getTypeFactory().constructCollectionType(List.class, User.class);
        List<User> us = mapper.readValue(json, javaType);

        //List<User> us = mapper.readValue(json, new TypeReference<List<User>>() { });
        //us.forEach(System.out::println);
        //us.forEach(u -> System.out.println(u));
        /*for (User u : us) {
            System.out.println(u);
        }*/
        for (int i = 0; i < us.size(); i++) {
            System.out.println(us.get(i));
        }
    }
    @Test
    public void testBeanToJSON() throws JsonProcessingException {
        User user = new User();
        user.setName("张三");
        user.setAge(20);
        user.setBirth(LocalDate.now());

        // 创建ObjectMapper对象
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule());

        // 序列化
        String json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);
        System.out.println(json);

        // 反序列化
        User u = mapper.readValue(json, User.class);
        System.out.println(u);
    }
}
一条小咸鱼儿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java四大json库gson+fastjson+jackson+json-lib
11-22
Java常用四大json库,包含目前最新版gson,fastjson,jackson,json-lib
Gson、FastJson、Jackson区别
bianezhuang8827的博客
01-11 8377
Gson、FastJson、Jackson都是第三方序列化/反序列化 JSON格式的 Java库。JSON 是一种文本形式的数据交换格式，它比XML更轻量、比二进制容易阅读和编写，调式也更加方便。 一、Gson 介绍 Gson是Google提供的用来在Java对象和JSON数据之间进行映射的Java类库。Gson 最初是为在 Google 内部使用而创建的，后面进行了开源，Gson可以将一个Json字符转成一个Java对象，或者将一个Java转化为Json字符串。 关于性能和扩展性 .
Spring(24) Json序列化的三种方式（Jackson、FastJSON、Gson）史上最全！
ACGkaka的博客
04-16 1689
Spring(24) Json序列化的三种方式（Jackson、FastJSON、Gson）史上最全！
Java 解析 JSON 数据 Gson、FastJson、Jackson
KingCruel的专栏
02-13 505
常用的 JSON 解析类库 Gson：谷歌开发的 JSON 库，功能十分全面。 FastJson：阿里巴巴开发的 JSON 库，性能十分优秀。 Jackson：社区十分活跃且更新速度很快。Gson 项目地址：https://github.com/google/gson Gson 谷歌开发的 JSON 库，功能十分全面。是目前功能最全的Json解析神器，Gson当初是为因应Google公司内部需求而由Google自行研发而来，但自从在2008年五月公开发布第一版后已被许多公司或用户应用。 Gson的应用主要为
json，fastjson，Jackson，Gson区别对比
qq_35146885的博客
11-19 1057
json，fastjson，Jackson，Gson区别对比
java系列 - fastjson, jackjson, Gson三者异同
ifredom
05-09 2611
起源 当后端接口向前端返回数据时，有时response数据是null, 十分不利于前端处理。 因此为了统一格式，需要返回在： 接口返回得数据是String类型时，不返回null，而返回 “” 接口返回得数据是Map类型时，不返回null，而返回 {} 接口返回得数据是List类型时，不返回null，而返回 [] 为了解决这个问题，就到了选择json序列化工具得时候，目前有三种工具： fastjson 是阿里巴巴2011年的开源 json 解析库 jackjson 是 spring boot 官方内置
json-gson-fastjson-jar包
06-07
Fastjson是阿里巴巴的一个高性能的JSON库，它的性能在很多测试中都超过了其他同类库，如Jackson和Gson。Fastjson提供了简单的API，使得解析JSON和生成JSON变得非常方便。例如，`JSON.parseObject()`可以将JSON字符...
java如何利用FastJSON、Gson、Jackson三种Json格式工具自定义时间序列化
10-19
这个问题可以通过使用FastJSON、Gson和Jackson这三种流行的JSON库来解决，每种库都有其特性和方法来实现自定义时间序列化。 1. **FastJSON**： FastJSON是阿里巴巴开发的高性能JSON处理器。尽管它在解析速度上表现...
Java读取json文件，并转化为map取值
05-12
Java标准库并不直接支持JSON操作，所以我们通常会使用第三方库，如`org.json`或`com.google.gson`。在这个案例中，我们将使用`com.fasterxml.jackson.databind`库，因为它提供了强大的功能和灵活性。确保你的项目中...
Json对象和Java对象互转md，学习代码
最新发布
06-21
Java提供了多种库，如Jackson、Gson、Fastjson等，来实现JSON与Java对象之间的转换。 1. **JSON对象转Java对象**：这个过程通常称为反序列化。例如，当我们从服务器接收到一个JSON字符串时，我们需要将其转换为Java...
使用gson，java对象和json字符串之间相互转化
05-18
一个gson例子：java对象和json字符串之间相互转化
Java的JSON格式转换库GSON的初步使用笔记
10-22
GSON是Google开发并在在GitHub上开源的Java对象与JSON互转功能类库,在Android开发者中也大受欢迎,这里我们就来看一下Java的JSON格式转换库GSON的初步使用笔记:
Java中GSON的使用
晨曦的博客
04-16 9979
1.1 GSON简介 JSON(JavaScript Object Notation)是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。 Gson是Google提供的用来在Java对象和JSON数据之间进行映射的Java类库。可以将一个JSON字符串转成一个Java对象(反序列化)，或者反过来(序列化)。 GSON地址：google/gson (github.com) 引入GSON： implementation 'com.google.code.gson:gson:2.9
常见JSON工具包之Gson的简单运用
黄勇的博客
01-01 2024
  想必大家在日常编码过程中肯定少不了使用一些JSON工具包的吧，比如 Gson、FastJson、JackSon、Json lib 等等，它们都属于 JSON 工具包。我个人比较喜欢 Gson，接下来咋们使用 Gson 进行一些常规的 Json 转换等简单运用吧。
Java操作JSON的三种库对比 Jackson Gson fastjson 未完....
热门推荐
Myth的博客
05-30 1万+
前言 Gson Maven构件地址 | Github地址 目前最新版为 2.8.5 其jar大小为 235kb 使用方式 // Gradle引入依赖 compile group: 'com.google.code.gson', name: 'gson', version: '2.8.5' // 例如转化一个类型不固定的List, 自定义类型同理 Gson gson ...
FastJson、Jackson、Gson进行Java对象转换Json的细节处理
Thancks
07-05 1万+
Java对象转换Json的细节处理 前言 Java对象在转json的时候，如果对象里面有属性值为null的话，那么在json序列化的时候要不要序列出来呢？对比以下json转换方式 一、fastJson 1、fastJson在转换java对象为json的时候，默认是不序列化null值对应的key的，也就是说当对象里面的属性为空的时候，在转换成json时，不序列化那些为null值的属性
Java里的json工具类（fastjson、Jackson（即ObjectMapper）、Gson）的使用
w8y56f的专栏
02-13 3878
Java里的json工具类（fastjson、Jackson（即ObjectMapper）、Gson）的使用 说明 本文探讨 JSON 的工具类：Fastjson、Jackson（ObjectMapper）、Gson Fastjson：这是阿里巴巴的json工具类 Jackson：这是spring框架自带的（就是那个ObjectMapper类） Gson：是谷歌的工具类 本文给出了通用的Jso...
Gson、fastjson和Jackson比较
时光吹老了好男孩
04-10 1739
转自https://blog.csdn.net/jason201710/article/details/78657469
JSON中fastjson、jackson、gson如何选择.docx
01-20
"探讨了JSON解析库fastjson、jackson和gson在Java开发中的选择，强调了它们的适用场景和性能对比。" 在Java开发中，JSON解析库的选择对于应用程序的性能和效率至关重要。文档提到了三个主流的JSON库：fastjson...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值