Gson和FastJson

最新推荐文章于 2024-07-16 21:34:16 发布
最新推荐文章于 2024-07-16 21:34:16 发布
阅读量238 收藏
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36901488/article/details/86623369
版权

Gson

解决循环引用问题

第一种:在需要转的属性上面加@Expose注解

@Test
    public void demo21(){
        GsonBuilder gsonBuilder = new GsonBuilder().excludeFieldsWithoutExposeAnnotation();
        Gson gson = gsonBuilder.create();
        Person person = new Person();
        Student student = new Student();
        person.setStudent(student);
        student.setPerson(person);
        String s = gson.toJson(student);
        System.out.println(s);
    }

package com.nyh.json;

import com.google.gson.annotations.Expose;
import com.nyh.reflect.Student;

/**
 * @author nyh
 * @create 2019-01-23  16:26
 **/
public class Person {
    @Expose
    String name;

    Student student;

    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    public String getName() {
        return name;
    }

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


package com.nyh.reflect;

import com.google.gson.annotations.Expose;
import com.nyh.json.Person;

/**
 * @author nyh
 * @create 2019-01-23  10:41
 **/
public class Student {
    @Expose
    private String name;
    @Expose
    private int age;
    @Expose
    String PhoneNumber;
    @Expose
    int id;
    @Expose
    Person person;

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }

    public Student() {
    }

    public Student(String name, int age, String phoneNumber, int id) {

        this.name = name;
        this.age = age;
        this.PhoneNumber = phoneNumber;
        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 getPhoneNumber() {
        return PhoneNumber;
    }

    public void setPhoneNumber(String phoneNumber) {
        PhoneNumber = phoneNumber;
    }

    public int getId() {
        return id;
    }

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

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

第二个办法:在不需要转的属性前面用transient(瞬态)

public void demo21(){
//        GsonBuilder gsonBuilder = new GsonBuilder().excludeFieldsWithoutExposeAnnotation();
//        Gson gson = gsonBuilder.create();
        Person person = new Person();
        Student student = new Student();
        person.setStudent(student);
        student.setPerson(person);
        String s = gson.toJson(student);
        System.out.println(s);
    }

transient 会阻止序列化

transient Student student;

public class TestJson {
    Gson gson = null;
    @Before
    public void before(){
        gson = new Gson();
    }

    @Test
    public void demo1(){
        Person person = new Person();
        person.setAge(18);
        person.setName("东东");
        String s = gson.toJson(person);
        System.out.println(s);
    }
    @Test
    public void demo2(){
        Person person = gson.fromJson("{\"name\":\"东东\",\"age\":18}", Person.class);
        System.out.println(person);
    }

    @Test
    public void demo3(){
        Person person = new Person();
        person.setName("小龙");
        person.setAge(15);
        Student student = new Student();
        student.setNumber("123456");
        person.setStudent(student);
        String s = gson.toJson(person);
        System.out.println(s);
    }

    @Test
    public void demo4() {
        Person person = gson.fromJson("{\"name\":\"小龙\",\"age\":15,\"student\":{\"number\":\"123456\"}}", Person.class);
        System.out.println(person);
    }

    /**
     *  解决循环引用
     *      两个方法
     *          第一个注解
     *              @Expose 代表属性需要转Json（排除没有公开注释的字段）
     *                  创建Gson对象需要用 Gson g = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();
     *          第二种方式
     *              在不需要转的前面加瞬态关键字 Transient
     *                  创建Gson   需要用 Gson g = new Gson();
     */
    @Test
    public void demo5() throws  Exception {
        //excludeFieldsWithoutExposeAnnotation 过滤不带注解的字段
//        GsonBuilder gsonBuilder = new GsonBuilder().excludeFieldsWithoutExposeAnnotation();
//        Gson gson = gsonBuilder.create();
        Student student = new Student();
        student.setNumber("123");
        Person person = new Person();
        person.setStudent(student);
        person.setAge(18);
        person.setName("小小");
        student.setPerson(person);

        String s = gson.toJson(person);
        System.out.println(s);
    }

    @Test
    public void demo6() throws Exception {
        List<String> lists = new ArrayList<>();
        lists.add("a");
        lists.add("b");
        lists.add("c");
        String s = gson.toJson(lists);
        System.out.println(s);
    }

    @Test
    public void demo7(){
        List list = gson.fromJson("[\"a\",\"b\",\"c\"]", List.class);
        System.out.println(list);
    }
    @Test
    public void demo8() throws Exception {
        Set<String> sets = new HashSet<>();
        sets.add("a");
        sets.add("b");
        sets.add("c");
        String s = gson.toJson(sets);
        System.out.println(s);

    }

    @Test
    public void demo9(){
        Set sets = gson.fromJson("[\"a\",\"b\",\"c\"]", Set.class);
        System.out.println(sets);
    }

    @Test
    public void demo91(){
        Map<String,String> maps = new HashMap<>();
        maps.put("1","a");
        maps.put("2","b");
        maps.put("3","c");

        String s = gson.toJson(maps);
        System.out.println(s);
    }

    @Test
    public void demo92(){
        Map map = gson.fromJson("{\"1\":\"a\",\"2\":\"b\",\"3\":\"c\"}", Map.class);
        System.out.println(map);
    }


    @Test
    public void demo93(){

        List<Student> students = new ArrayList<>();
        students.add(new Student("123"));
        students.add(new Student("456"));
        String s = gson.toJson(students);
        System.out.println(s);

    }

    @Test
    public void demo94(){
        List<Student> list = gson.fromJson("[{\"number\":\"123\"},{\"number\":\"456\"}]", new TypeToken<List<Student>>(){}.getType());
        System.out.println(list.get(0).getNumber());
    }
}

FastJson

public class TestPerson {

    @Test
    public void demo1(){
        Person person = new Person();
        person.setAge(30);
        person.setName("小李");
        String s = JSON.toJSONString(person);
        System.out.println(s);
    }

    @Test
    public void demo2(){
        Person person = JSON.parseObject("{\"age\":30,\"name\":\"小李\"}", Person.class);
        System.out.println(person);
    }

    /**
     *  循环引用
     */
    @Test
    public void demo4(){
        List<Person> lists = new ArrayList<Person>();
        Person person = new Person();
        person.setAge(11);
        person.setName("小华");
        lists.add(person);
        lists.add(person);
        lists.add(person);
        /*
         [{"age":11,"name":"小华"},{"$ref":"$[0]"},{"$ref":"$[0]"}] 发生了循环引用的问题
         SerializerFeature.DisableCircularReferenceDetect 解决循环引用（禁用循环引用检测）
         加上了这个属性后就不会出现上面这种情况了 
         [{"age":11,"name":"小华"},{"age":11,"name":"小华"},{"age":11,"name":"小华"}]
         */
        String s1 = JSON.toJSONString(lists,SerializerFeature.DisableCircularReferenceDetect);
        System.out.println(s1);
    }

    @Test
    public void demo3(){
        Person person = new Person();
        Animal animal = new Animal();
        person.setName("嘻嘻");
        person.setAge(11);

        animal.setColor("red");
        animal.setName("小黑");

        animal.setPerson(person);
        person.setAnimal(animal);
		/**
		*	这里也是循环引用问题
		*	用以下方式解决:
			// 代表次属性不去转json
    		@JSONField(serialize = false)
    		private Person person;
		*/
        String s = JSON.toJSONString(person,SerializerFeature.DisableCircularReferenceDetect);
        System.out.println(s);

    }
    @Test
    public void demo5(){

        List<String> lists = new ArrayList<String>();
        lists.add("a");
        lists.add("b");
        lists.add("c");
        String s = JSON.toJSONString(lists);
        System.out.println(s);

    }
    @Test
    public void demo6(){
//        List<String> strings = JSON.parseObject("[\"a\",\"b\",\"c\"]", new TypeReference<List<String>>() {
//        });
        Set list = JSON.parseObject("[\"a\",\"b\",\"c\"]", Set.class);
        System.out.println(list);
    }

    @Test
    public void demo7(){
        Map<String,String> maps = new HashMap<>();
        maps.put("1","a");
        maps.put("2","b");
        String s = JSON.toJSONString(maps);
        System.out.println(s);
    }

    @Test
    public void demo8(){
        Map map = JSON.parseObject("{\"1\":\"a\",\"2\":\"b\"}", Map.class);
        System.out.println(map);
    }
    @Test
    public void demo(){
        List<Person> lists = new ArrayList<>();
        Person person = new Person();
        person.setName("大佬");
        person.setAge(50);
        lists.add(person);

        String s = JSON.toJSONString(lists);
        System.out.println(s);
    }
    @Test
    public void demo9(){
    	 /*
         	如果不用 TypeReference ,只能获取对象,对象里面的属性是拿不到的
         */
        List<Person> people = JSON.parseObject("[{\"age\":50,\"name\":\"大佬\"}]",new TypeReference<List<Person>>(){});
        System.out.println(people.get(0).getAge());
    }

}
qq_36901488
关注
专栏目录
【fastJson和Gson】
m0_67250699的博客
05-04 959
一、数据类型转换，解析工具 1、json-lib：是apache提供的json-lib小工具，它可以方便的使用Java语言来创建JSON字符串。也可以把JavaBean转换成JSON字符串。 2、jackson:是用来解析 JSON 的框架。JSON （JavaScript Object Notation）是一种数据格式，用来在客户端和服务器之间，或系统组件之间交换数据。 3、Gson：google提供的一个json类型转换类，gson和其他现有java json类库最大的不同时gson需要序列化得.
浅谈Gson和fastjson使用中的坑
程序猿刘川枫
06-09 480
相信大家在代码编写中都用过Gson和fastjson吧，用来进行 Java对象和json字符串之间的转换。 本篇文章就主要介绍博主在工作中使用这两款工具时遇到的坑和对应的解决办法。 觉得有用的可以点个赞哈~ 1.前言 看了下我上一篇文章的发布时间，已然是两个月前了，这两个月工作确实很忙，加班也不少，空闲的时间都去研究别的技术了（后面会写文章），这次先用此篇文章记录我这段时间工作中遇到的坑，其实写文章的主要目的也是想记录一下问题，便于帮助他人也便于自己以后查看，废话不多说，开始说明问题~ 2.Gson和f.
Gson 与 FastJson 对比
热门推荐
做一只强悍的蜜獾
07-10 2万+
参考：https://www.cnblogs.com/yanduanduan/p/7508992.html 一、Google的Gson Gson是目前功能最全的Json解析神器，Gson的应用主要为toJson与fromJson两个转换函数，无依赖，不需要例外额外的jar，能够直接跑在JDK上。 而在使用这种对象转换之前需先创建好对象的类型以及其成员才能成功的将JSON字符串成功转换成相...
Java学习｜JSON 处理库：Gson、FastJson、Jackson的比较与使用指南
最新发布
weixin_44435110的博客
07-16 2336
在Java开发中，处理JSON数据是一个常见需求。Gson、FastJson、Jackson是最受欢迎的三大JSON处理库。本文将详细比较它们的特点、使用注意事项，并提供代码示例和常见面试问答，帮助开发者在不同场景下做出最优选择。
Fastjson和Gson
m0_58680865的博客
05-29 520
Fastjson 1、什么是Fastjson Fastjson 是一个 Java 库，可以将 Java 对象转换为 JSON 格式，当然它也可以将 JSON 字符串转换为 Java 对象。 Fastjson 源码地址：https://github.com/alibaba/fastjson Fastjson 中文 Wiki：https://github.com/alibaba/fastjson/wiki/Quick-Start-CN 2、下载和使用 maven仓库：https://repo1.maven
gson与fastjson
盖丽男
07-23 1288
关于json，我在代码里，最常用的有两个地方，一个是做类型转换的时候用，另一个是偷懒，在调用第三方接口的时候接数据用。从速度上来说，fastjson是比gson快的，我们的服务目前来说，还没有到考虑性能的时候，所以目前从fastjson切换到gson，先暂时不解决性能问题。...
Gson和Fastjson
weixin_33814685的博客
05-07 66
1。PersonBean package com.louis.fastjsondemo; /** * Created by Administrator on 2016/2/26. */ public class PersonBean { private int id; private String name; private String address; pu...
Jackson、Gson和Fastjson
chikai1的专栏
06-06 2010
一、三种常用的Json转化工具 1.开源的Jackson Jackson所依赖的jar包较少，简单易用并且性能也要相对高些。 而且Jackson社区相对比较活跃，更新速度也比较快。 Jackson对于复杂类型的json转换bean会出现问题 2.Google的Gson Gson是目前功能最全的Json解析神器，Gson当初是为因应Google公司内部需求而由Google自行研发而来， ...
Gson和Fastjson 使用Demo
11-11
Gson和Fastjson是两个非常流行且高效的库，专门用于处理这种任务。本文将深入探讨Gson和Fastjson的使用，以及它们各自的特点。 **Gson** Gson是由Google提供的一个开源库，它能够将Java对象转换为JSON字符串，反之...
Json包包含Gson和FastJson
11-05
里边包含了Json所需要的 两个包 Gson和FastJson
GSon和FastJson框架包
04-20
本文将深入探讨两个流行的Java JSON处理库：GSon和FastJson，以及它们的核心功能、优缺点和使用场景。 **GSon** GSon是由Google开发的开源库，它能够将Java对象转换为JSON字符串，反之亦然。GSon的主要优点在于它...
各个JSON技术的比较
weixin_34210740的博客
09-30 1512
JSON技术的调研报告一 、各个JSON技术的简介和优劣1.json-libjson-lib最开始的也是应用最广泛的json解析工具，json-lib 不好的地方确实是依赖于很多第三方包，包括commons-beanutils.jar，commons-collections-3.2.jar，commons-lang-2.6.jar，commons-logging-1.1.1.jar，ezmorph...
json之Gson和FastJson
Android学习之旅
08-13 2657
关于json是什么，在这里就不做介绍，相信看这篇文章的同学都知道。 Gson--是一款Google公司的用来解析json数据格式的库 Fastjson--是一款阿里巴巴的用来解析json数据格式的库，据说目前最快。 首先介绍Gson的使用（下载前需要去下载,www.json.org都有链接，自己去找） 1、将一个JavaBen转换为json字符串 方便起见，把所有的类写在同一个文
Gson和FastJson工具类
weixin_49250451的博客
04-13 980
对于Java开发来说，数据的序列化和反序列化是一项基本操作，Gson和FastJson是两个常用的数据解析工具类，以下简单的说说两者的使用和区别Gson是Google开发的一款Java库，用于将Java对象转换为JSON字符串，或者将JSON字符串转换为Java对象，Gson可以自动解析和映射Java对象和JSON数据的关系。首先，在项目中导入依赖
JSON格式及解析
tuziud233的博客
10-18 379
目录JSON对象格式数组格式案例Java中的JSONGsonFastJson JSON JSON:JavaScript Object Notation(JS对象简谱),是一种轻量级的数据交换格式. 对象格式 一本书 书名 简介 java class Book{ private String name; private String info; get/set... } js: var b=new Object(); v.name="金苹果"; v.info="
Gson与FastJson
InternetBigMan的博客
01-20 169
Java与JSON 做什么? 将Java中的对象 快速的转换为 JSON格式的字符串. 将JSON格式的字符串, 转换为Java的对象. Gson 将对象转换为JSON字符串 转换JSON字符串的步骤: 1. 引入JAR包 2. 在需要转换JSON字符串的位置编写如下代码即可: String json = new Gson().toJSON(要转换的对象); 案例: Book b = BookDao.find(); String json =
Gson与FastJson比较
吹雪的专栏
06-21 8056
一. 简介和优劣 1.Google的Gson Gson是目前功能最全的Json解析神器，Gson当初是为因应Google公司内部需求而由Google自行研发而来，但自从在2008年五月公开发布第一版后已被许多公司或用户应用。Gson的应用主要为toJson与fromJson两个转换函数，无依赖，不需要例外额外的jar，能够直接跑在JDK上。 而在使用这种对象转换之前需先创建好对象的类型以...
JSON解析之Gson与FastJson
Vampire_Zhang的博客
08-12 267
使用Gson来解析JSON 一、将对象转换为JSON字符串 步骤： 1.引入JAR包 2.在需要转换JSON字符串的位置编写如下代码： String json = new Gson().toJson(需要转换的对象); 举个栗子：Book对象是自己创建的，有id(数的编号)、name(书名)、info(简介) 这三个属性 //1. 创建Gson对象 Gson g = new Gson(); //2. 转换 ...
Gson和FastJson使用
qq_35559783的博客
03-22 145
Gson和FastJson使用 首先创建公共使用的类 import java.util.Objects; public class Person { private String name; private int age; public Person() { } public Person(String name,int age) { this.name = name; this.age = age; } pub
2017 Java高级面试：Json解析库比较及Jackson、Gson和FastJson优劣
Gson支持无依赖的直接使用，并能很好地处理复杂类型的转换，只需类具有get和set方法。但它的性能相较于FastJson略逊一筹。 4. **阿里巴巴 Fastjson**: Fastjson是由阿里巴巴开发的高性能JSON处理器，同样无需额外...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值