1. 编程号首页

快速上手FastJSON

编程小号 • • 未分类

快速上手FastJSON作为一名后端开发而言肯定会接触数据，把数据提供给前端或者把数据存储起来，目前比较火热的传输格式是json，给前端传json是再常见不过啦，甚至是往db里面直接存入json。

前言

作为一名后端开发而言肯定会接触数据，把数据提供给前端或者把数据存储起来，目前比较火热的传输格式是json，给前端传json是再常见不过啦，甚至是往db里面直接存入json。

在java层面来说json只不过就是一个字符串而已，json对我们的意义是把一个对象或者map序列化成json字符串。这样json就可以在进行网络io了，同样你把一个对象序列化成了一个json串存入到db，当你从db中读取出来的时候，你读出来的也是一个json的字符串，你还需要进行反序列化让它重新变成对象。

FastJSON就是一个帮助你序列号和反序列化java对象的工具，这里不会讲很高阶的用法，只讲大家工作中每天都会使用到的常见用法。这里多说一句，大家可能会看到网上天天说FastJSON这不好那不好….我也知道它有漏洞，可是它很快而且很方便，大部分小公司都依然还会选择使用FastJSON来作为序列化工具。

开始之前先导包

/*这里查找最新的包 https://mvnrepository.com/artifact/com.alibaba/fastjson */
<dependency>
 		<groupId>com.alibaba</groupId>
 		<artifactId>fastjson</artifactId>
 		<version>1.2.57</version>
</dependency>

序列化

  1. 如果你不清楚JSON格式的话，在序列化这里我会简单介绍一下JSON的格式，因为你把java对象变成json后你可以对比看，json是如何把你的对象变成字符串存储的。

  2. 简单介绍FastJSON(下成FJ)

    首先FJ有一个JSON的静态工具类，里面都是我们接下来会用到的方法。然后FJ也提供一些其他的别名类，例如JSONObject，JSONArray，看到名字都应该能秒懂，一个操作对象一个操作集合的，但是这里面提供的方法JSON这个静态工具类都有。所以大家用哪个都可以，下面我统一使用JSON类

  3. 如何使用，序列化就是把一个对象变成方便传输方便存储的格式。

    JSON.toJSONString(你要放入的对象)就可以把一个对象变成json格式

    // 把map变成json
public class MultiTest {
    public static void main(String[] args) {
        // 这里快速生成一个map
        Map<String, String> stuMap = MapUtil.builder("name", "小明").
                put("gender", "男").build();
        // 使用JSON对这个map对象序列化
        String stuJson = JSON.toJSONString(stuMap);
        // 输出结果是 {"gender":"男","name":"小明"}
        System.out.println(stuJson);
    }
}

    // 把对象编程json
public class MultiTest {

    @Data
    @Builder
    private static class Student {
        private String name;
        private String gender;
    }

    public static void main(String[] args) {
        // 这里快速生成一个map
        Map<String, String> stuMap = MapUtil.builder("name", "小明").
                put("gender", "男").build();
        // 使用JSON对这个map对象序列化
        String stuJson = JSON.toJSONString(stuMap);
        // 输出结果是 {"gender":"男","name":"小明"}
        System.out.println(stuJson);
    }
    
}

  4. 上面这个例子，可以看到map和实体类的序列化结果是一致的，为什么呢，因为实体类和map本质上差不多，都是一个key，一个value。name是key，小红是value，gender是key，男是value。

    然后我们看序列化后的结果，{"gender":"男","name":"小明"}。我们可以格式化一下就变成（网上有很多工具可以美化json，例如www.json.cn）

    {
    "gender": "男",
    "name": "小明"
}

    美化以后，我们看起来就简单多了，首先json的标志一个花括号包裹{}，其次里面存储的也是键值对，键值对里面使用:来分割，左边是key，右边是value。键值对之间使用逗号分割。这个你肯定看的名单，但是键值对的value还有疯狂套娃，里面可能还是json或者是一个数组，甚至是一个json数组。你可以自己尝试使用JSON.toJSONString序列号一些你经常使用到的对象，看看他的结果是什么样子的。

反序列化

既然你把我的java对象变成了json字符串，那肯定有办法要变回来并且这个操作很常见。

  • 把json解析成JSONObject对象-JSON.parseObject(放入json串)

    这里解释一下JSONObject是什么，JSONObject你可以你把它理解成map，他是FJ对map的实现，如果你没有指定把json解析成什么他会默认转成JSONObject对象。这个对象就当map使用，用法一样，下面是例子

        public static void main(String[] args) {
        // 这里快速生成一个map
        Map<String, String> stuMap = MapUtil.builder("name", "小明").
                put("gender", "男").build();
        // 使用JSON对这个map对象序列化
        String stuJson = JSON.toJSONString(stuMap);

        // 把它转成JSONObject
        JSONObject jsonObj = JSON.parseObject(stuJson);
        // %s为类c占位符, 显示后面变量内容
        System.out.printf("这位同学的名字是%s,性别是%s%n",
                jsonObj.get("name"),
                jsonObj.get("gender"));
        
        // 输出结果为 这位同学的名字是小明,性别是男
    }

  • JSONObject有一些比map好的地方，emmm也不能说比map好，所不相同的地方吧。因为你把一个对象变成了json，其实你已经丢掉了它的类型，或者说我原来有泛型来约束，但是不见了，或者就是说我原来Map<String, Object>，你每次从map里面取出元素以后是需要强转一下的。JSONObject它没有泛型，但是它每次get都方法帮你去安全的cast转化一下。所以在JSONObject你可以很方便的get出你想要的类型啦

    image-20210410162257019

JSONObject可以get出的类型

所以刚刚的例子里面的sout里面语句可以写成

        // %s为类c占位符, 显示后面变量内容
        System.out.printf("这位同学的名字是%s,性别是%s%n",
                jsonObj.getString("name"),
                jsonObj.getString("gender"));

  • 把json解析成Map对象-JSON.parseObject(放入json串， Map.class)

    其实很简单，只要在parseObject的括号里面加入Map.class，指定你要转成map就好了

        public static void main(String[] args) {
        // 这里快速生成一个map
        Map<String, String> stuMap = MapUtil.builder("name", "小明").
                put("gender", "男").build();
        // 使用JSON对这个map对象序列化
        String stuJson = JSON.toJSONString(stuMap);

        // 把它转成JSONObject
        Map jsonMap = JSON.parseObject(stuJson ,Map.class);
        // %s为类c占位符, 显示后面变量内容
        System.out.printf("这位同学的名字是%s,性别是%s%n",
                jsonMap.get("name"),
                jsonMap.get("gender"));
        // 输出结果为 这位同学的名字是小明,性别是男
    }

    这里有一个要注意的，这样你转出来是没有泛型约束的，是不安全的，或者说…是看起来很丑的(毕竟你会在意不安全吗)…我们可以改传一个typeReference。大家不用在意是什么道理，这也不是很重要，看不懂也没关系。

        public static void main(String[] args) {
        // 这里快速生成一个map
        Map<String, String> stuMap = MapUtil.builder("name", "小明").
                put("gender", "男").build();
        // 使用JSON对这个map对象序列化
        String stuJson = JSON.toJSONString(stuMap);

        // 把它转成JSONObject
        Map<String, Object> jsonMap = JSON.parseObject(stuJson,
                // 把Map和泛型放入这个reference里面，注意这里是一个匿名内部类
                new TypeReference<Map<String, Object>>() {});
        // %s为类c占位符, 显示后面变量内容
        System.out.printf("这位同学的名字是%s,性别是%s%n",
                jsonMap.get("name"),
                jsonMap.get("gender"));
        // 输出结果为 这位同学的名字是小明,性别是男
    }

  • 把json解析成Map对象-JSON.parseObject(放入json串，对象.class)

    public class MultiTest {

    @Data
    @Builder
    private static class Student {
        private String name;
        private String gender;
    }

    public static void main(String[] args) {
        // 这里快速生成一个map
        Map<String, String> stuMap = MapUtil.builder("name", "小明").
                put("gender", "男").build();
        // 使用JSON对这个map对象序列化
        String stuJson = JSON.toJSONString(stuMap);

        // 把它转成JSONObject
        Student stuObj = JSON.parseObject(stuJson, Student.class);
        // %s为类c占位符, 显示后面变量内容
        System.out.printf("这位同学的名字是%s,性别是%s%n",
                stuObj.getName(),
                stuObj.getGender());
        // 输出结果为 这位同学的名字是小明,性别是男
    }

}

  • 把json解析成JSONArray–JSON.parseArray(放入json串)

    这里的JSONArray就类似于Java的list，因为它是FJ对List的实现，它也是没有泛型的，get的时候可以指定需要取出来的类型，这里就不多说啦。注意啦，他这个get()的入参是索引下标，这可是list。

    public class MultiTest {

    @Data
    @Builder
    private static class Student {
        private String name;
        private String gender;
    }

    public static void main(String[] args) {
        // 这里快速生成几个Map
        Map<String, String> stuMap1 = MapUtil.builder("name", "小明").
                put("gender", "男").build();
        Map<String, String> stuMap2 = MapUtil.builder("name", "小刚").
                put("gender", "男").build();
        Map<String, String> stuMap3 = MapUtil.builder("name", "小红").
                put("gender", "女").build();
        // 把map放到list中
        List<Map<String, String>> stuList = Arrays.asList(stuMap1, stuMap2, stuMap3);
        // 把list序列化成json
        String stuListJson = JSON.toJSONString(stuList);

        // 把json反序列化成list
        JSONArray stuJsonArray = JSON.parseArray(stuListJson);
        // 0号元素取出来变成JSONObject
        JSONObject stu1 = stuJsonArray.getJSONObject(0);
        // 1号元素取出来变成map,这里也可以使用TypeReference设置泛型
        Map stu2 = stuJsonArray.getObject(1, Map.class);
        // 甚至可以直接转成实体类, 毕竟里面的元素也是json啊
        Student stu3 = stuJsonArray.getObject(2, Student.class);

    }

}

  • 把json解析成List-JSON.parseArray(放入json串，list元素类型.class)

    这个一般用的比较多，因为可以直接指定里面的泛型，返回来就帮你转好了

    public class MultiTest {

    @Data
    @Builder
    private static class Student {
        private String name;
        private String gender;
    }

    public static void main(String[] args) {
        // 这里快速生成几个Map
        Map<String, String> stuMap1 = MapUtil.builder("name", "小明").
                put("gender", "男").build();
        Map<String, String> stuMap2 = MapUtil.builder("name", "小刚").
                put("gender", "男").build();
        Map<String, String> stuMap3 = MapUtil.builder("name", "小红").
                put("gender", "女").build();
        // 把map放到list中
        List<Map<String, String>> stuList = Arrays.asList(stuMap1, stuMap2, stuMap3);
        // 把list序列化成json
        String stuListJson = JSON.toJSONString(stuList);

        // 把json反序列化成list,里面每个元素都是student
        List<Student> studentList = JSON.parseArray(stuListJson, Student.class);

    }

}

后言

以上就是比较常见的对象和json互转的方法，其实非常家的简单其实没几个，这样我再来复盘一下

对象变json JSON.toJSONString(obj)

json变回对象 JSON.parseObject(json, 你要变成的对象类型.class)

json变lsit JSON.parseArray(json, list中元素的类型.class)

是不是十分简单，其实规则就是他们互转，FJ给我们提供了非常健壮方便的互转方式，可以自己去看看源码，我怕说太多不太常用大家看的不耐烦….祝大家用的愉快~

更多有意思的文章欢迎大家来我的个人blog挖掘，点击这里

今天的文章快速上手FastJSON分享到此就结束了，感谢您的阅读。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
如需转载请保留出处：https://bianchenghao.cn/19365.html

赞 (0)
编程小号编程小号
0

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注