java：json操作一、fastjon

最新推荐文章于 2024-05-12 19:21:09 发布
最新推荐文章于 2024-05-12 19:21:09 发布
阅读量408 收藏
点赞数
分类专栏： Java 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a232884c/article/details/123228675
版权

java：json操作一、fastjon

1 依赖配置

在https://search.maven.org/搜索fastjson，依赖如下：

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

前言：

序列化和反序列化：网络传输时，使用的是Byte进行传输，速度、效率会更好。将对象转换成Byte，就是序列化；反之，将Byte转换成对象，就是反序列化。Json的序列化，即是将对象转换成json字符串；反序列化，就是将json字符串转换成对象。

2 使用

2.1 序列化
在这里插入图片描述
在这里插入图片描述
（1）序列化及null值属性的展示：

UseFastJson：

package com.xiaoxu.json.core;

import com.alibaba.fastjson.JSON;
import com.xiaoxu.json.vo.Drinks;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.Date;

/**
 * @author xiaoxu
 * @date 2022-03-03
 * spring_boot:com.xiaoxu.json.core.UseFastJson
 */
@Service
public class UseFastJson {
    public void toJson(Drinks d){
        String s = JSON.toJSONString(d);
        System.out.println("Drinks的对象转为JSON字符串:"+s);
    }
    public Drinks buildDrinks(){
        Drinks d = new Drinks();
        d.setDrinkId(123L);
        d.setDrinkName("东鹏特饮");
        d.setProduceDate(new Date());
        d.setSaleDate(LocalDateTime.now());
        return d;
    }
}

Drinks：

package com.xiaoxu.json.vo;

import lombok.Data;

import java.time.LocalDateTime;
import java.util.Date;

/**
 * @author xiaoxu
 * @date 2022-03-03
 * spring_boot:com.xiaoxu.json.vo.Drinks
 */
@Data
public class Drinks {
    /*
    * 饮料id
    * */
    long drinkId;
    /*
    * 饮料名称
    * */
    String drinkName;
    /*
    * 生产地址
    * */
    String produceAddress;
    /*
    * 生产日期
    * */
    Date produceDate;
    /*
    * 销售日期
    * */
    LocalDateTime saleDate;
}

TestFastJson：

package json;

import com.xiaoxu.boot.MainApplication;
import com.xiaoxu.json.core.UseFastJson;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @author xiaoxu
 * @date 2022-03-03
 * spring_boot:json.TestFastJson
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = MainApplication.class)
public class TestFastJson {
    @Autowired
    UseFastJson u;

    @Test
    public void test_01(){
        u.toJson(u.buildDrinks());
    }
}

结果：

Drinks的对象转为JSON字符串:{"drinkId":123,"drinkName":"东鹏特饮","produceDate":1646283066154,"saleDate":"2022-03-03T12:51:06.158"}

可见，对象中缺少了produceAddress，希望null值也可以打印出来，修改如下：

public void toJson(Drinks d){
    String s = JSON.toJSONString(d, SerializerFeature.WriteMapNullValue);
    System.out.println("Drinks的对象转为JSON字符串:"+s);
}

重新执行：

Drinks的对象转为JSON字符串:{"drinkId":123,"drinkName":"东鹏特饮","produceAddress":null,"produceDate":1646283485906,"saleDate":"2022-03-03T12:58:05.910"}

（2）日期时间的格式化：

修改需序列化的pojo：

package com.xiaoxu.json.vo;

import com.alibaba.fastjson.annotation.JSONField;
import lombok.Data;

import java.time.LocalDateTime;
import java.util.Date;

/**
 * @author xiaoxu
 * @date 2022-03-03
 * spring_boot:com.xiaoxu.json.vo.Drinks
 */
@Data
public class Drinks {
    /*
    * 饮料id
    * */
    long drinkId;
    /*
    * 饮料名称
    * */
    String drinkName;
    /*
    * 生产地址
    * */
    String produceAddress;
    /*
    * 生产日期
    * */
    @JSONField(format = "yyyy-MM-dd HH:mm:ss")
    Date produceDate;
    /*
    * 销售日期
    * */
    @JSONField(format = "yyyy-MM-dd HH:mm:ss")
    LocalDateTime saleDate;
}

执行结果如下：

Drinks的对象转为JSON字符串:{"drinkId":123,"drinkName":"东鹏特饮","produceAddress":null,"produceDate":"2022-03-03 13:02:39","saleDate":"2022-03-03 13:02:39"}

（3）fastJson之引用探测：

修改UseFastJson：

package com.xiaoxu.json.core;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.xiaoxu.json.vo.Drinks;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.Date;

/**
 * @author xiaoxu
 * @date 2022-03-03
 * spring_boot:com.xiaoxu.json.core.UseFastJson
 */
@Service
public class UseFastJson {
    public void toJson(Object d){
        String s = JSON.toJSONString(d, SerializerFeature.WriteMapNullValue);
        System.out.println("Drinks的对象转为JSON字符串:"+s);
    }
    public Drinks buildDrinks(){
        Drinks d = new Drinks();
        d.setDrinkId(123L);
        d.setDrinkName("东鹏特饮");
        d.setProduceDate(new Date());
        d.setSaleDate(LocalDateTime.now());
        return d;
    }
}

增加单测test_02：

package json;

import com.xiaoxu.boot.MainApplication;
import com.xiaoxu.json.core.UseFastJson;
import com.xiaoxu.json.vo.Drinks;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

/**
 * @author xiaoxu
 * @date 2022-03-03
 * spring_boot:json.TestFastJson
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = MainApplication.class)
public class TestFastJson {
    @Autowired
    UseFastJson u;

    @Test
    public void test_01(){
        u.toJson(u.buildDrinks());
    }

    @Test
    public void test_02(){
        Drinks drinks = u.buildDrinks();
        List<Drinks> l = new ArrayList<Drinks>(){{
            for (int i = 0; i < 3; i++) {
                add(drinks);
            }
        }};
        u.toJson(l);
    }
}

执行test_02：

Drinks的对象转为JSON字符串:[{"drinkId":123,"drinkName":"东鹏特饮","produceAddress":null,"produceDate":"2022-03-03 13:06:35","saleDate":"2022-03-03 13:06:35"},{"$ref":"$[0]"},{"$ref":"$[0]"}]

$ref就是fastJson的引用探测，对于同一个引用对象（地址相同），那么fastjson打印出来的list集合就会包含： $ref。
取消引用探测如下修改：

public void toJson(Object d){
    String s = JSON.toJSONString(d, SerializerFeature.DisableCircularReferenceDetect);
    System.out.println("Drinks的对象转为JSON字符串:"+s);
}

再次执行：

Drinks的对象转为JSON字符串:[{"drinkId":123,"drinkName":"东鹏特饮","produceDate":"2022-03-03 13:10:39","saleDate":"2022-03-03 13:10:39"},{"drinkId":123,"drinkName":"东鹏特饮","produceDate":"2022-03-03 13:10:39","saleDate":"2022-03-03 13:10:39"},{"drinkId":123,"drinkName":"东鹏特饮","produceDate":"2022-03-03 13:10:39","saleDate":"2022-03-03 13:10:39"}]

（4）filter定制处理：

增加单测test_03:

package json;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.NameFilter;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.xiaoxu.boot.MainApplication;
import com.xiaoxu.json.core.UseFastJson;
import com.xiaoxu.json.vo.Drinks;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

/**
 * @author xiaoxu
 * @date 2022-03-03
 * spring_boot:json.TestFastJson
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = MainApplication.class)
public class TestFastJson {
    @Autowired
    UseFastJson u;

    @Test
    public void test_01(){
        u.toJson(u.buildDrinks());
    }

    @Test
    public void test_02(){
        Drinks drinks = u.buildDrinks();
        List<Drinks> l = new ArrayList<Drinks>(){{
            for (int i = 0; i < 3; i++) {
                add(drinks);
            }
        }};
        u.toJson(l);
    }

    @Test
    public void test_03(){
        NameFilter nameFilter = (o, name, value) -> {
            //o是整个Drinks对象（u.buildDrinks()），name是成员变量名称，value是其set对应的值
            return name.toUpperCase(Locale.ROOT);
        };
        System.out.println(JSON.toJSONString(u.buildDrinks(), nameFilter, SerializerFeature.WriteMapNullValue));
    }
}

执行test_03：

{"DRINKID":123,"DRINKNAME":"东鹏特饮","PRODUCEADDRESS":null,"PRODUCEDATE":1646284560146,"SALEDATE":"2022-03-03T13:16:00.170"}

json字符串的对象的成员变量key，全部改为了大写。

2.2 反序列化

（1）json字符串转为Drinks对象：
在这里插入图片描述
在这里插入图片描述
这里使用：

package json;

import com.alibaba.fastjson.JSON;
import com.xiaoxu.json.core.UseFastJson;
import com.xiaoxu.json.vo.Drinks;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @author xiaoxu
 * @date 2022-03-03
 * spring_boot:json.TestContraryFastJSon
 */
public class TestContraryFastJSon {
    @Autowired
    UseFastJson useFastJson;

    @Test
    public void test_01(){
        String a = "{\"drinkId\":123,\"drinkName\":\"东鹏特饮\",\"produceDate\":\"2022-03-03 13:31:13\",\"saleDate\":\"2022-03-03 13:31:13\"}";
        Drinks drinks = JSON.parseObject(a, Drinks.class);
        System.out.println(drinks);
    }
}

执行结果如下：

Drinks(drinkId=123, drinkName=东鹏特饮, produceAddress=null, produceDate=Thu Mar 03 13:31:13 CST 2022, saleDate=2022-03-03T13:31:13)

（2）反序列化的泛型处理：

泛型结果如下：

package json;

import lombok.Data;

/**
 * @author xiaoxu
 * @date 2022-03-03
 * spring_boot:json.BaseResult
 */
@Data
public class BaseResult<T> {
    private boolean isSuccess = Boolean.TRUE;
    private T data;

    public static <T> BaseResult<T> buildRes(T my_data){
        BaseResult<T> res = new BaseResult<>();
        res.setData(my_data);
        return res;
    }
}

单测如下：

package json;

import com.alibaba.fastjson.JSON;
import com.xiaoxu.json.core.UseFastJson;
import com.xiaoxu.json.vo.Drinks;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @author xiaoxu
 * @date 2022-03-03
 * spring_boot:json.TestContraryFastJSon
 */
public class TestContraryFastJSon {
    @Autowired
    UseFastJson useFastJson;

    @Test
    public void test_01(){
        String a = "{\"drinkId\":123,\"drinkName\":\"东鹏特饮\",\"produceDate\":\"2022-03-03 13:31:13\",\"saleDate\":\"2022-03-03 13:31:13\"}";
        Drinks drinks = JSON.parseObject(a, Drinks.class);
        System.out.println(drinks);
        //将BaseResult返回
        BaseResult<Drinks> res = BaseResult.buildRes(drinks);
        String s1 = JSON.toJSONString(res);
        System.out.println(s1);
        //此时前端需要把s1反序列化为对象
        BaseResult baseResult = JSON.parseObject(s1, BaseResult.class);
        System.out.println(baseResult);
        //问题在于这种情况下，getData拿到的是Object，不是Drinks：
        Object data = baseResult.getData();
        System.out.println(data);
    }
}

执行结果：

Drinks(drinkId=123, drinkName=东鹏特饮, produceAddress=null, produceDate=Thu Mar 03 13:31:13 CST 2022, saleDate=2022-03-03T13:31:13)
{"data":{"drinkId":123,"drinkName":"东鹏特饮","produceDate":"2022-03-03 13:31:13","saleDate":"2022-03-03 13:31:13"},"success":true}
BaseResult(isSuccess=true, data={"drinkId":123,"produceDate":"2022-03-03 13:31:13","saleDate":"2022-03-03 13:31:13","drinkName":"东鹏特饮"})
{"drinkId":123,"produceDate":"2022-03-03 13:31:13","saleDate":"2022-03-03 13:31:13","drinkName":"东鹏特饮"}

可见，问题在于反序列化后拿不到泛型类型，强制转换会失去泛型的优势，故而作如下修改：

package json;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.xiaoxu.json.core.UseFastJson;
import com.xiaoxu.json.vo.Drinks;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @author xiaoxu
 * @date 2022-03-03
 * spring_boot:json.TestContraryFastJSon
 */
public class TestContraryFastJSon {
    @Autowired
    UseFastJson useFastJson;

    @Test
    public void test_01(){
        String a = "{\"drinkId\":123,\"drinkName\":\"东鹏特饮\",\"produceDate\":\"2022-03-03 13:31:13\",\"saleDate\":\"2022-03-03 13:31:13\"}";
        Drinks drinks = JSON.parseObject(a, Drinks.class);
        System.out.println(drinks);
        //将BaseResult返回
        BaseResult<Drinks> res = BaseResult.buildRes(drinks);
        String s1 = JSON.toJSONString(res);
        System.out.println(s1);
        //此时前端需要把s1反序列化为对象
//        BaseResult baseResult = JSON.parseObject(s1, BaseResult.class);
//        System.out.println(baseResult);
//        //问题在于这种情况下，getData拿到的是Object，不是Drinks：
//        Object data = baseResult.getData();
//        System.out.println(data);

        //需要反序列化什么类型，就在TypeReference中传入什么类型
        BaseResult<Drinks> drinksBaseResult = JSON.parseObject(s1, new TypeReference<BaseResult<Drinks>>() {
        });
        System.out.println("反序列化后的对象:"+drinksBaseResult);
        Drinks data = drinksBaseResult.getData();
        System.out.println("data数据为："+data);
    }
}

再次执行：

Drinks(drinkId=123, drinkName=东鹏特饮, produceAddress=null, produceDate=Thu Mar 03 13:31:13 CST 2022, saleDate=2022-03-03T13:31:13)
{"data":{"drinkId":123,"drinkName":"东鹏特饮","produceDate":"2022-03-03 13:31:13","saleDate":"2022-03-03 13:31:13"},"success":true}
反序列化后的对象:BaseResult(isSuccess=true, data=Drinks(drinkId=123, drinkName=东鹏特饮, produceAddress=null, produceDate=Thu Mar 03 13:31:13 CST 2022, saleDate=2022-03-03T13:31:13))
data数据为：Drinks(drinkId=123, drinkName=东鹏特饮, produceAddress=null, produceDate=Thu Mar 03 13:31:13 CST 2022, saleDate=2022-03-03T13:31:13)

2.3 fastJson通用配置

前言：格式缩进美化：

（1）prettyFormat：

package json;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.NameFilter;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.xiaoxu.boot.MainApplication;
import com.xiaoxu.json.core.UseFastJson;
import com.xiaoxu.json.vo.Drinks;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

/**
 * @author xiaoxu
 * @date 2022-03-03
 * spring_boot:json.TestFastJson
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = MainApplication.class)
public class TestFastJson {
    @Autowired
    UseFastJson u;

    @Test
    public void test_01(){
        u.toJson(u.buildDrinks());
    }

    @Test
    public void test_02(){
        Drinks drinks = u.buildDrinks();
        List<Drinks> l = new ArrayList<Drinks>(){{
            for (int i = 0; i < 3; i++) {
                add(drinks);
            }
        }};
        u.toJson(l);
    }

    @Test
    public void test_03(){
        NameFilter nameFilter = (o, name, value) -> {
            //o是整个Drinks对象（u.buildDrinks()），name是成员变量名称，value是其set对应的值
            return name.toUpperCase(Locale.ROOT);
        };
        System.out.println(JSON.toJSONString(u.buildDrinks(), nameFilter, SerializerFeature.WriteMapNullValue));
    }

    @Test
    public void test_04(){
        System.out.println(JSON.toJSONString(u.buildDrinks(), true));
    }
}

执行test_04：

{
	"drinkId":123,
	"drinkName":"东鹏特饮",
	"produceDate":"2022-03-03 13:58:18",
	"saleDate":"2022-03-03 13:58:18"
}

效果上，类似python的indent参数：

json.dumps(test_dict, indent=2).encode("utf-8").decode("unicode-escape")

（2）通用配置：

package com.xiaoxu.json.vo;

import com.alibaba.fastjson.annotation.JSONField;
import lombok.Data;

import java.time.LocalDateTime;
import java.util.Date;

/**
 * @author xiaoxu
 * @date 2022-03-03
 * spring_boot:com.xiaoxu.json.vo.Drinks
 */
@Data
public class Drinks {
    /*
    * 饮料id
    * */
    long drinkId;
    /*
    * 饮料名称
    * */
    //作用：指定属性名drinkName和json字符串的keydName是对应的关系    
    @JSONField(name = "dName")
    String drinkName;
    /*
    * 生产地址
    * */
    String produceAddress;
    /*
    * 生产日期
    * */
    @JSONField(format = "yyyy-MM-dd HH:mm:ss")
    Date produceDate;
    /*
    * 销售日期
    * */
    @JSONField(format = "yyyy-MM-dd HH:mm:ss")
    LocalDateTime saleDate;
}

执行test_04：
在这里插入图片描述
比如反序列化的时候，如果json字符串中没有dName这个值，同理，在转换成Drinks对象的时候，也是不能对应起来的。

还有，通用配置某个字段序列化、反序列化不参与转换的：

package com.xiaoxu.json.vo;

import com.alibaba.fastjson.annotation.JSONField;
import lombok.Data;

import java.time.LocalDateTime;
import java.util.Date;

/**
 * @author xiaoxu
 * @date 2022-03-03
 * spring_boot:com.xiaoxu.json.vo.Drinks
 */
@Data
public class Drinks {
    /*
    * 饮料id
    * */
    //意思是序列化和反序列化的时候，这个字段不参与
    @JSONField(serialize = false,deserialize = false)
    long drinkId;
    /*
    * 饮料名称
    * */
    //作用：指定属性名drinkName和json字符串的keydName是对应的关系
    @JSONField(name = "dName")
    String drinkName;
    /*
    * 生产地址
    * */
    String produceAddress;
    /*
    * 生产日期
    * */
    @JSONField(format = "yyyy-MM-dd HH:mm:ss")
    Date produceDate;
    /*
    * 销售日期
    * */
    @JSONField(format = "yyyy-MM-dd HH:mm:ss")
    LocalDateTime saleDate;
}

执行test_04：

@Test
public void test_04(){
    System.out.println(JSON.toJSONString(u.buildDrinks(), true));
}

序列化结果如下：

{
	"dName":"东鹏特饮",
	"produceDate":"2022-03-03 14:08:44",
	"saleDate":"2022-03-03 14:08:44"
}

反序列化结果如下：
在这里插入图片描述

小徐也要努力鸭
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JSONJava:JSON Java
04-28
JSONJava JSON Java Eclipse项目 JSON API：
jsonld-java:Java的JSON-LD实现
04-29
JSONLD-Java正在寻找维护者JSONLD-JAVA 这是和的Java实现。用法从Maven <dependency> <groupId>com.github.jsonld-java</groupId> <artifactId>jsonld-java</artifactId> <version>0.13.3</version></dependency>...
FastJson详解
Lyouths的移动笔记本
01-10 9025
一、Fastjson介绍 Fastjson是一个Java库，可用于将Java对象转换为其JSON表示形式。它还可以用于将JSON字符串转换为等效的Java对象。Fastjson可以与任意Java对象一起使用，包括您没有源代码的现有对象。 关于Json的处理，还有Google开发的Gson包，其他形式的如net.sf.json包，都可以实现json的转换。方法名称不同而已，最后的实现结果都是一样的。...
JSONObject 自定义过滤配置
weixin_34050427的博客
11-15 830
v一、自定义过滤器说明 　　PropertyPreFilter 根据PropertyName判断是否序列化 PropertyFilter 根据PropertyName和PropertyValue来判断是否序列化 NameFilter 修改Key，如果需要修改Key,process返回值则可 ValueFilter 修改Value Before...
fastjson2使用
最新发布
qq_42108331的博客
05-12 1178
fastjson2使用
SerializeFilter——NameFilter
qq_41792853的博客
03-08 644
NameFilter SerializeFilter是通过编程扩展的方式定制序列化。fastjson支持6种SerializeFilter，用于不同场景的定制序列化。NameFilter是其中之一。 NameFilter用于修改Key，如果需要修改Key,process返回值则可，意思就是可以修改原字段名，具体情况如下代码 package com.jy.demo.SerializeFilter; import com.alibaba.fastjson.JSON; import com.alibaba.fa
java json fastjson_高性能JSON框架之FastJson的简单使用
weixin_42520580的博客
02-21 147
1.前言1.1.FastJson的介绍:JSON协议使用方便，越来越流行,JSON的处理器有很多,这里我介绍一下FastJson,FastJson是阿里的开源框架,被不少企业使用,是一个极其优秀的Json框架,Github地址: FastJson1.2.FastJson的特点:1.FastJson数度快,无论序列化和反序列化,都是当之无愧的fast2.功能强大(支持普通JDK类包括任意Java B...
在Java中处理JSON数据：fastjson的简单使用
技术篮子
10-10 1381
一、JSON基础 1.JSON语法 JSON是一种由双引号包裹的，名称-值对为组成形式的数据格式，如 "MyNamIs":"json" 注意：JSON名称和值对中都可以使用空格和特殊字符(除a~z 0~9以外的字符)。但是这样会影响移植性，所以为了保证最大的移植性，应该尽量避免使用。 2.JSON对象与JSON数组 JSON对象 JSON对象是使用逗号分隔的名称-值对构成的集合，并使用花括号{}包裹，如： { "one":"1", "two":"1", "three":"1", "o
jsonapi-java:jsonapi规范的实现(http
05-29
JsonApi java JsonApi 旨在提供将任何对象转换为其超媒体表示的简单方法。 核心库是实现Identifiable接口的任何对象之上的简单信封，它为开发人员提供了基于JSON Api文档的便捷方法。 它允许开发人员从任何对象...
jwtoken-java:JSON Web令牌的实现
05-26
JSON Web令牌（JWT）是一个开放标准（RFC 7519），它定义了一种紧凑且自包含的方式，用于在各方之间安全地将信息作为JSON对象传输。 由于此信息是经过数字签名的，因此可以被验证和信任。 可以使用秘密（使用HMAC...
jwt-java:JSON Web Tokens的简单java实现
06-18
jwt-java JSON Web Tokens的简单java实现
java使用fastJson处理复杂Json字符串，直接获取key对应的value值
08-10
java使用fastJson处理复杂Json字符串，直接获取key对应的value值
java fast json 基本操作
sunyaoxjtu的博客
09-24 407
####引入jar包 <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.58</version> </dependency> ####使用 ...
FastJson各种用法
qq_41589166的博客
06-01 8325
json背景JSON在短时间内迅速风靡全球，原因有很多如WEB2.0的推动、JSON易用、高性能等等，互联网科技巨头也出了自家json，google有GSON阿里有fastjson，今天我主要讲下fastjson的编程开发案例。JSON优点JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。JSON具体“自我描述性”【方便人阅读和编写。同时也易于机器解析和...
FastJson的介绍与使用（一）
热门推荐
JL
04-11 1万+
FastJson的介绍与使用（一）1.FastJson背景：      FastJson是啊里巴巴的的开源库，用于对JSON格式的数据进行解析和打包。2.FastJson介绍：       FastJson特点如下：        （1）能够支持将java bean序列化成JSON字符串，也能够将JSON字符串反序列化成Java bean。        （2）顾名思义，FastJson操作JSO...
FastJson 快捷教程
zhanglinlang的专栏
11-18 601
1、对象 to JsonObject User u = new User(); u.setName("zs"); u.setId(1); //对象 转 Map Map<String,Object> toMap = (JSONObject) JSON.toJSON(u); //对象 转 JSON
各个JSON技术的比较
weixin_34210740的博客
09-30 1481
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...
java使用fastjson库实体类转json，json转JSONObject
每一个不曾起舞的日子，都是对生命的辜负
05-18 8619
java使用fastjson库实体类转json，json转JSONObject Fastjson简介，https://github.com/alibaba/fastjson Fastjson是一个Java语言编写的JSON处理器,由阿里巴巴公司开发。 1、遵循http://json.org标准，为其官方网站收录的参考实现之一。 2、功能强大，支持JDK的各种类型，包括基本的JavaBean、Collection、Map、Date、Enum、泛型。 3、无依赖，不需要例外额外的jar，能够直接跑在JDK上。
fastjson值java对象与JSON串互转
ibigboy
07-29 3475
JSONObject时经常会用到它的转换方法，包括Java对象转成JSON串、JSON对象，JSON串转成java对象、JSON对象，JSON对象转换Java对象、JSON串等，使用方法总结如下，持续更新…如果student对象内有一个对象集合hobbies，相应的，JSON字符串转Map时如果不做处理，hobbies内的字段顺序可能会和原始hobbies字段值不一样。JSONObject.toJavaObject(JSON对象实例,Java对象.class);...
java:json转实体
10-20
你可以使用fastjson或者Gson来实现json转实体类的操作。下面是具体的步骤： 1. fastjson实现json转实体类： ``` String json = "{\"name\":\"张三\",\"age\":18}"; Person person = JSON.parseObject(json, Person.class); ``` 2. Gson实现json转实体类： ``` String json = "{\"name\":\"张三\",\"age\":18}"; Gson gson = new Gson(); Person person = gson.fromJson(json, Person.class); ``` 其中，Person是你定义的实体类，需要与json数据中的字段对应。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值