TUNANのBlogHomeArchivesTagsCategories
FastJson的使用
|Java
Word count: 2.2k|Reading time: 10 min

前言

最近在开发过程中使用了大量的json作为前后端数据交换的方式,由于之前没有对json做过系统的学习,所有在使用过程中查阅了大量的文档与资料,这里主要记录了我在开发后对json以及FastJson使用的总结

Json介绍

JSON(javaScript Object Notation)是一种轻量级的数据交换格式。主要采用键值对({"name": "json"})的方式来保存和表示数据。JSON是JS对象的字符串表示法，它使用文本表示一个JS对象的信息，本质上是一个字符串。更多简介见介绍JSON。

FastJson 简介

在日志解析,前后端数据传输交互中,经常会遇到字符串(String)与json,XML等格式相互转换与解析，其中json以跨语言，跨前后端的优点在开发中被频繁使用，基本上可以说是标准的数据交换格式。fastjson是一个java语言编写的高性能且功能完善的JSON库，它采用一种“假定有序快速匹配”的算法，把JSON Parse 的性能提升到了极致。它的接口简单易用，已经被广泛使用在缓存序列化，协议交互，Web输出等各种应用场景中。

FastJson 常用 API

导入Jar包

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

FastJson API 入口类是com.alibaba.FastJson.JSON,常用的序列化操作都可以在JSON类上的静态方法直接完成。

public static final Object parse(String text); // 把JSON文本parse为JSONObject或者JSONArray 
public static final JSONObject parseObject(String text)； // 把JSON文本parse成JSONObject    
public static final <T> T parseObject(String text, Class<T> clazz); // 把JSON文本parse为JavaBean 
public static final JSONArray parseArray(String text); // 把JSON文本parse成JSONArray 
public static final <T> List<T> parseArray(String text, Class<T> clazz); //把JSON文本parse成JavaBean集合 
public static final String toJSONString(Object object); // 将JavaBean序列化为JSON文本 
public static final String toJSONString(Object object, boolean prettyFormat); // 将JavaBean序列化为带格式的JSON文本 
public static final Object toJSON(Object javaObject); //将JavaBean转换为JSONObject或者JSONArray。

使用方法举例

//将JSON文本转换为java对象
import com.alibaba.FastJson.JSON;
Model model = JSON.parseObject(jsonStr, Model.class);

有关类库的一些说明

  • JSONArray : 相当于List
  • JSONObject: 相当于Map<String,Object>

FastJson 使用实例

Java对象与Json字符串的互转

User测试类

package com.tunan.json.user;

/**
 * @description:
 * @author: tunan
 * @create: 2020-03-07 09:54
 * @since: 1.0.0
 **/
public class User {

    private String username;
    private String password;

    public User() {
    }

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

UserGroup测试类

package com.tunan.json.user;

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

/**
 * @description:
 * @author: tunan
 * @create: 2020-03-07 09:55
 * @since: 1.0.0
 **/
public class UserGroup {

    private String name;
    private List<User> users= new ArrayList<User>();

    public UserGroup() {
    }

    public UserGroup(String name, List<User> users) {
        this.name = name;
        this.users = users;
    }

    public String getName() {
        return name;
    }

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

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }
}

fastJson测试类

package com.tunan.json.user;

import com.alibaba.fastjson.JSON;

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

/**
 * @description:
 * @author: tunan
 * @create: 2020-03-07 09:58
 * @since: 1.0.0
 **/
public class TestFastJosn {

    public static void main(String[] args) {
        objectToJson();
        JsonToObject();
    }

    //java对象转 json字符串
    static public void objectToJson(){
        //简单java类转json
        User user = new User("tunan","123456");
        String userJson = JSON.toJSONString(user);
        System.out.println("简单java类转字符串： "+userJson);

        //List<Object>转Json字符串
        User user1 = new User("xiaoqi", "961228");
        User user2 = new User("tunan", "123456");
        List<User> users = new ArrayList<User>();
        users.add(user1);
        users.add(user2);
        String listJson = JSON.toJSONString(users);
        System.out.println("List<Object>转Json字符串： "+listJson);

        //复杂java转json字符串
        UserGroup userGroup = new UserGroup("student", users);
        String userGroupJson = JSON.toJSONString(userGroup);
        System.out.println("复杂java转json字符串： "+userGroupJson);
    }

    //Json字符串 转Java类
    //注：字符串中使用双引号需要转义 (" --> \"),这里使用的是单引号
    static public void JsonToObject(){
        /*
         * json字符串转简单java对象
         * 字符串：{"password":"123456","username":"dmego"}
         */
        String userJson = "{'password':'123456','username':'dmego'}";
        User user = JSON.parseObject(userJson, User.class);
        System.out.println("json字符串转简单java对象: "+user.toString());

        /*
         * json字符串转List<Object>对象
         * 字符串：[{"password":"123123","username":"zhangsan"},{"password":"321321","username":"lisi"}]
         */
        String listUserJson = "[{'password':'123123','username':'zhangsan'},{'password':'321321','username':'lisi'}]";
        List<User> userList = JSON.parseArray(listUserJson, User.class);
        System.out.println("json字符串转List<Object>对象: "+userList.toString());

        /*json字符串转复杂java对象
         * 字符串：{"name":"userGroup","users":[{"password":"123123","username":"zhangsan"},{"password":"321321","username":"lisi"}]}
         * */
        String userGroupJson = "{'name':'userGroup','users':[{'password':'123123','username':'zhangsan'},{'password':'321321','username':'lisi'}]}";
        UserGroup userGroup = JSON.parseObject(userGroupJson, UserGroup.class);
        System.out.println("json字符串转复杂java对象: "+userGroup.toString());
    }
}

结果

简单java类转字符串： {"password":"123456","username":"tunan"}
List<Object>转Json字符串： [{"password":"961228","username":"xiaoqi"},{"password":"123456","username":"tunan"}]
复杂java转json字符串： {"name":"student","users":[{"password":"961228","username":"xiaoqi"},{"password":"123456","username":"tunan"}]}

json字符串转简单java对象: User{username='dmego', password='123456'}
json字符串转List<Object>对象: [User{username='zhangsan', password='123123'}, User{username='lisi', password='321321'}]
json字符串转复杂java对象: UserGroup{name='userGroup', users=[User{username='zhangsan', password='123123'}, User{username='lisi', password='321321'}]}

通过结果看代码:

我们可以看到，在JavaBean转Json的时候，使用了JSON.toJSONString()方法

  1. 该方法中传入的是对象，即生成对象的Json字符串
  2. 如果传入的是List，生成的就是对象的Json字符串数组
  3. 如果传入的是复杂类型既有对象，又有对象数组，那么生成的就是个Json对象，这个对象中包括对象的Json字符串和对象的Json字符串数组，Json的字符串数组中又包含对象的Json字符串。

在Json转JavaBean的时候，会根据调用JSON.parseObject()和JSON.parseArray()的不同，输出不同的结果

  1. 传入对象的Json字符串和需要生成的Java对象，需要调用JSON.parseObject()方法，输出的就是一个普通的对象
  2. 传入对象的Json字符串数组和要生成的Java对象，需要调用JSON.parseArray()方法，输出是一个Java对象数组
  3. 传入的即包含对象的Json字符串，又包含对象的Json字符串数组，那么需要调用一个JSON.parseObject()方法，该方法会输出一个复杂的Java对象，该对象既包括对象又包括对象数组。

FastJson解析复杂嵌套Json字符串

这个实例是我在开发中用到的，先给出要解析的Json字符串

[
    {
        "id": "user_list",
        "key": "id",
        "tableName": "用户列表",
        "className": "cn.dmego.domain.User",
        "column": [
            {
                "key": "rowIndex",
                "header": "序号",
                "width": "50",
                "allowSort": "false"
            },
            {
                "key": "id",
                "header": "id",
                "hidden": "true"
            },
            {
                "key": "name",
                "header": "姓名",
                "width": "100",
                "allowSort": "true"
            }
        ]
    },
    {
        "id": "role_list",
        "key": "id",
        "tableName": "角色列表",
        "className": "cn.dmego.domain.Role",
        "column": [
            {
                "key": "rowIndex",
                "header": "序号",
                "width": "50",
                "allowSort": "false"
            },
            {
                "key": "id",
                "header": "id",
                "hidden": "true"
            },
            {
                "key": "name",
                "header": "名称",
                "width": "100",
                "allowSort": "true"
            }
        ]
    }
]

要想解析这种复杂的字符串，首先得先定义好与之相符的Java POJO 对象，经过观察，我们发现，这个是一个Json对象数组，每一个对象里包含了许多属性，其中还有一个属性的类型也是对象数组。所有，我们从里到外，先定义最里面的对象：

public class Column {
    private String key;
    private String header;
    private String width;
    private String allowSort;
    private String hidden;
    
    @Override
    public String toString() {
        return "Column{" +
                "key='" + key + '\'' +
                ", header='" + header + '\'' +
                ", width='" + width + '\'' +
                ", allowSort='" + allowSort + '\'' +
                ", hidden='" + hidden + '\'' +
                '}';
    }
    //这里省略部分getter与setter方法 
}

再定义外层的对象：

public class Query {

    private String id;
    private String key;
    private String tableName;
    private String className;
    private List<Column> column;

    @Override
    public String toString() {
        return "Query{" +
                "id='" + id + '\'' +
                ", key='" + key + '\'' +
                ", tableName='" + tableName + '\'' +
                ", className='" + className + '\'' +
                ", column=" + column +
                '}';
    }

     //这里省略部分getter与setter方法 
}

我的这个Json文件放置在类路径下，最后想将这个Json字符串转化为List对象，并且将column 对象数组转化为query对象里的List属性

/**
 * @description: 将这个json字符串转化为List对象
 * @author: tunan
 * @create: 2020-03-07 10:47
 * @since: 1.0.0
 **/
public class RoleTest {
    public static void main(String[] args) throws IOException {
        RoleTest roleTest = new RoleTest();
        List<Query> queries = roleTest.JsonToObject();
        //生成的是个List，需要循环输出
        queries.forEach(System.out::println);
    }
    public  List<Query> JsonToObject() throws IOException {
        ClassLoader loader = this.getClass().getClassLoader();
        InputStream in = loader.getResourceAsStream("query.json");
        //这里是一次全部读出来了，大数据处理时需要按行读取
        String jsonTxet = IOUtils.toString(in, "utf8");
        List<Query> query = JSON.parseArray(jsonTxet, Query.class);
        return query;
    }
}

结果

Query{id='user_list', key='id', tableName='用户列表', className='cn.dmego.domain.User', column=[Column{key='rowIndex', header='序号', width='50', allowSort='false', hidden='null'}, Column{key='id', header='id', width='null', allowSort='null', hidden='true'}, Column{key='name', header='姓名', width='100', allowSort='true', hidden='null'}]}

Query{id='role_list', key='id', tableName='角色列表', className='cn.dmego.domain.Role', column=[Column{key='rowIndex', header='序号', width='50', allowSort='false', hidden='null'}, Column{key='id', header='id', width='null', allowSort='null', hidden='true'}, Column{key='name', header='名称', width='100', allowSort='true', hidden='null'}]}
Author: Tunan
Link: http://yerias.github.io/2020/03/07/java/9/
Copyright Notice: All articles in this blog are licensed under CC BY-NC-SA 4.0 unless stating additionally.
Java