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

亦凉 2024-04-01 09:31 59阅读 0赞

**目录**

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

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

2.1 序列化

2.2 反序列化

三、快速演示：

四、思考

五、web案例demo演示

--------------------

针对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 中的值的类型。

1.  数据结构:
    
    `JSON.toJSONString()` 方法将对象转换为 JSON 格式的字符串，而 `user.toString()` 只是将 `user` 对象转换成 String 类型。因此，前者将在 Redis 中存储一个 JSON 对象，后者将在 Redis 中存储一个简单的 String字符串。
2.  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);
        }

![02370d7fdeb34437abdff997d15da60f.png][]

![3236ccb4c5464dd68851086fd5f808fe.png][]

> 反序列化

@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();
        }

![59d8c1f5ddfb4f678da8c603c07569b1.png][]

![e8d4b246c246414bae80cfd9535d993c.png][]

> 集合序列化

@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);
        }

![182b4c0e3a334fc8a8caf9c295233058.png][]

![49d2798e941f4c76a6d6830e79af86d2.png][]

> 集合反序列化

@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();
        }

![981bbb48879d4989955dc10cac9a0c4f.png][]

![364c7eecfe124e0bad652dd634136b4e.png][]

[02370d7fdeb34437abdff997d15da60f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/aeab16c2ce944c82b6532a038333f5e5.png
[3236ccb4c5464dd68851086fd5f808fe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/8b52cec76b464df4bd9069f918d1fb22.png
[59d8c1f5ddfb4f678da8c603c07569b1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/cafefc0158494cb9b8aa7893e73dcc2c.png
[e8d4b246c246414bae80cfd9535d993c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/769d1ca970e4494585a584bb31316a39.png
[182b4c0e3a334fc8a8caf9c295233058.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/254d349922b345b69b84864401ea608c.png
[49d2798e941f4c76a6d6830e79af86d2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/dc608799cfb543ab9fc87d14796e2d4d.png
[981bbb48879d4989955dc10cac9a0c4f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/901bdd3939e24305bb69e19e52e93a10.png
[364c7eecfe124e0bad652dd634136b4e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/85418c78919a4c3a96e611aca13b888f.png