FastJson快速上手【Json解析工具】

何苏三月

已于 2023-05-15 18:08:02 修改

阅读量1.9k

点赞数 2

文章标签： java json spring boot

于 2022-10-22 14:52:08 首次发布

本文链接：https://blog.csdn.net/YuanFudao/article/details/127461740

版权

一、spring boot工程中引入FastJson依赖

二、调用JSON类的静态方法直接进行json序列化和反序列化

针对JSON序列化和反序列化，为了方便快捷，我们一般使用json序列化工具进行操作

常见的json序列化工具有Gson和FastJson

FastJson是阿里巴巴开源的项目，号称是速度最快的json解析工具。

以FastJson为例，演示基本使用方法：

一、spring boot工程中引入FastJson依赖

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

二、调用JSON类的静态方法直接进行json序列化和反序列化

一般主要用的方法就下面四个~

2.1 序列化

Javabean对象序列化         成为json字符串
List集合序列化         成为json字符串
Map集合序列化         成为json字符串

public static String toJSONString(Object object)

2.2 反序列化

json字符串反序列化成为Javabean对象或任意类：

public static <T> T parseObject(String text, Class<T> clazz)

json字符串反序列化成为List集合：

public static <T> List<T> parseArray(String text, Class<T> clazz)

json字符串反序列化成为Map集合：

public static <T> T parseObject(String text, TypeReference<T> type, Feature... features)

注意：new TypeReference<T>(){}是匿名对象，其泛型应设置为转换后的Map类型。

三、快速演示：

package com.hssy.newcustomer;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.hssy.newcustomer.dto.fastjson.JsonDetailModule;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

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

@SpringBootTest
class NewcustomerApplicationTests {

    //测试Java对象进行json序列化成json字符串
    @Test
    void contextLoads() {
        JsonDetailModule module = new JsonDetailModule();
        module.setId(2);
        module.setName("张菲");
        List<String> hobbys = new ArrayList<>();
        hobbys.add("唱歌");
        hobbys.add("书法");
        hobbys.add("三国演绎");
        module.setHobby(hobbys);
        String jsonString = JSON.toJSONString(module);
        System.out.println(jsonString);
//        {"hobby":["唱歌","书法","三国演绎"],"id":2,"name":"张菲"}
    }

    //测试将List集合进行json序列化成json字符串
    @Test
    void testListToJson(){
        List<JsonDetailModule> list = new ArrayList<>();
        for (int i = 0; i < 2; i++) {
            JsonDetailModule module = new JsonDetailModule();
            module.setId(i);
            module.setName("用户："+ i);
            List<String> hobbys = new ArrayList<>();
            hobbys.add("随机爱好："+(char) (0x4e00 + (int) (Math.random() * (0x9fa5 - 0x4e00 + 1))));
            hobbys.add("随机爱好："+(char) (0x4e00 + (int) (Math.random() * (0x9fa5 - 0x4e00 + 1))));
            module.setHobby(hobbys);
            list.add(module);
        }
        String jsonString = JSON.toJSONString(list);
        System.out.println(jsonString);

//        [{"hobby":["随机爱好：武","随机爱好：畧"],"id":0,"name":"用户：0"},{"hobby":["随机爱好：穊","随机爱好：丠"],"id":1,"name":"用户：1"}]
    }

    @Test
    void testMapToJson(){
        HashMap<String, List<String>> map = new HashMap<>();
        List<String> hobbys = new ArrayList<>();
        hobbys.add("唱");
        hobbys.add("跳");
        hobbys.add("rap");
        hobbys.add("篮球");
        List<String> genders = new ArrayList<>();
        genders.add("男");
        genders.add("女");
        map.put("爱好",hobbys);
        map.put("性别",genders);
        String jsonString = JSON.toJSONString(map);
        System.out.println(jsonString);
//        {"爱好":["唱","跳","rap","篮球"],"性别":["男","女"]}
    }



    //测试json字符串反序列化成Java对象
    @Test
    void testJsonToJava(){
        String jsonString = "{\"hobby\":[\"唱歌\",\"书法\",\"三国演绎\"],\"id\":2,\"name\":\"张菲\"}";
        JsonDetailModule jsonDetialModule = JSON.parseObject(jsonString, JsonDetailModule.class);
        System.out.println(jsonDetialModule);  //JsonDetailModule(id=2, name=张菲, hobby=[唱歌, 书法, 三国演绎])
    }

    @Test
    void testJsonToList(){
        String jsonString = " [{\"hobby\":[\"随机爱好：武\",\"随机爱好：畧\"],\"id\":0,\"name\":\"用户：0\"},{\"hobby\":[\"随机爱好：穊\",\"随机爱好：丠\"],\"id\":1,\"name\":\"用户：1\"}]";
        List<JsonDetailModule> jsonDetailModules = JSON.parseArray(jsonString, JsonDetailModule.class);
        System.out.println(jsonDetailModules);
//        [JsonDetailModule(id=0, name=用户：0, hobby=[随机爱好：武, 随机爱好：畧]), JsonDetailModule(id=1, name=用户：1, hobby=[随机爱好：穊, 随机爱好：丠])]
        for (JsonDetailModule item : jsonDetailModules) {
            System.out.println(item);
        }
//            JsonDetailModule(id=0, name=用户：0, hobby=[随机爱好：武, 随机爱好：畧])
//            JsonDetailModule(id=1, name=用户：1, hobby=[随机爱好：穊, 随机爱好：丠])
    }

    @Test
    void testJsonToMap(){
        String jsonString ="{\"爱好\":[\"唱\",\"跳\",\"rap\",\"篮球\"],\"性别\":[\"男\",\"女\"]}";
//        JSONObject jsonObject = JSON.parseObject(jsonString);
        //使用JSON.parseObject(jsonString)直接进行反序列化是没有泛型的，没有泛型是不安全的集合
        //我们要求转后的集合必须有泛型
        //因此，调用parseObject方法，还必须多穿一个TypeReference类型的参数，TypeReference类的泛型中，传递转换后的Map集合
        Map<String, List<String>> map = JSON.parseObject(jsonString, new TypeReference<Map<String, List<String>>>(){});
        for (String key: map.keySet()) {
            System.out.println(key +":--:"+map.get(key));
        }
//        爱好:--:[唱, 跳, rap, 篮球]
//        性别:--:[男, 女]
    }





}

四、思考

思考：以下二者有什么区别？

redisTemplate.opsForValue().set("user", JSON.toJSONString(user));

redisTemplate.opsForValue().set("user", user.toString());

区别在于存储到 Redis 中的值的类型。

数据结构:

JSON.toJSONString() 方法将对象转换为 JSON 格式的字符串，而 user.toString() 只是将 user 对象转换成 String 类型。因此，前者将在 Redis 中存储一个 JSON 对象，后者将在 Redis 中存储一个简单的 String字符串。
Redis 存储结构：

使用 JSON.toJSONString() 将对象转换为 JSON 字符串，Redis 存储的值类型为 string。存储后取出时需要进行反序列化操作。

而使用 toString() 将对象转换为 String，Redis 存储的值也是 String 类型。但是其不支持反序列化，即取出来的仍然是 String 类型而不是原对象。

综上所述，如果你要存储一个完整的对象，建议使用 JSON.toJSONString() 将对象转换为 JSON 格式的字符串再存储；如果只需存储一个字符串或字符串拼接的值，那么就两种方式都可以使用。

五、web案例demo演示

序列化

    @ApiOperation(value = "存")
    @GetMapping("save")
    public Result<String> t1(){
        User user = new User();
        user.setId(1);
        user.setName("高启强");
        user.setBirthday(LocalDateTime.now());
        user.setGender(1);
        user.setAddress("京海市人民路86号");
        String substring = UUID.randomUUID().toString().substring(0, 5);
        redisTemplate.opsForValue().set("user-"+substring, JSON.toJSONString(user));
        return Result.success("user-"+substring);
    }

反序列化

    @ApiOperation(value = "查")
    @GetMapping("select")
    public Result<User> t2(String redisKey){
        String value = redisTemplate.opsForValue().get(redisKey);
        System.out.println(value);
        User user = JSON.parseObject(value, User.class);
        System.out.println(user);
        return Result.success();
    }

集合序列化

    @ApiOperation(value = "存集合")
    @GetMapping("saveList")
    public Result<String> t3(){
        ArrayList<User> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            User user = new User();
            user.setId(1);
            user.setName("高启强");
            user.setBirthday(LocalDateTime.now());
            user.setGender(1);
            user.setAddress("京海市人民路86号");
            list.add(user);
        }
        String substring = UUID.randomUUID().toString().substring(0, 5);
        redisTemplate.opsForValue().set("user-"+substring, JSON.toJSONString(list));
        return Result.success("user-"+substring);
    }

集合反序列化

    @ApiOperation(value = "查集合")
    @GetMapping("selectList")
    public Result<User> t4(String redisKey){
        String value = redisTemplate.opsForValue().get(redisKey);
        System.out.println(value);
        List<User> users = JSON.parseArray(value, User.class);
        System.out.println(users);
        return Result.success();
    }

何苏三月

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
FastJson快速上手【Json解析工具】

针对JSON序列化和反序列化，为了方便快捷，我们一般使用json序列化工具进行操作常见的json序列化工具有Gson和FastJsonFastJson是阿里巴巴开源的项目，号称是速度最快的json解析工具。
复制链接

扫一扫