工具类-Fastjson入门使用

简介

什么是Fastjson?

fastjson是阿里巴巴的开源JSON解析库，它可以解析JSON格式的字符串，支持将Java Bean序列化为JSON字符串，也可以从JSON字符串反序列化到JavaBean。
Fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法，把JSON Parse的性能提升到极致，是目前Java语言中最快的JSON库。Fastjson接口简单易用，已经被广泛使用在缓存序列化、协议交互、Web输出、Android客户端等多种应用场景。
主要特点：
快速FAST (比其它任何基于Java的解析器和生成器更快，包括jackson）
强大（支持普通JDK类包括任意Java Bean Class、Collection、Map、Date或enum）
零依赖（没有依赖其它任何类库除了JDK）
开源，使用Apache License 2.0协议开源。
源码：https://github.com/alibaba/fastjson
wiki：https://github.com/alibaba/fastjson/wiki/Quick-Start-CN

Fastjson使用场景

fastjson已经被广泛使用在各种场景，包括cache存储、RPC通讯、MQ通讯、网络协议通讯、Android客户端、Ajax服务器处理程序等等。

Fastjson的优点

1. 速度快
   fastjson相对其他JSON库的特点是快，从2011年fastjson发布1.1.x版本之后，其性能从未被其他Java实现的JSON库超越。
2. 使用广泛
   fastjson在阿里巴巴大规模使用，在数万台服务器上部署，fastjson在业界被广泛接受。在2012年被开源中国评选为最受欢迎的国产开源软件之一。
3. 测试完备
   fastjson有非常多的testcase，在1.2.11版本中，testcase超过3321个。每次发布都会进行回归测试，保证质量稳定。
4. 使用简单
   fastjson的API十分简洁。

String text = JSON.toJSONString(obj); //序列化
Model vo = JSON.parseObject("{...}", Mpode.class); //反序列化

1. 功能完备
   支持泛型，支持流处理超大文本，支持枚举，支持序列化和反序列化扩展。

下载和使用

下载

你可以在maven中央仓库中直接下载：

http://repo1.maven.org/maven2/com/alibaba/fastjson/

或者配置maven依赖

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

其中x.x.x是版本号，跟进需要使用特定版本，建议使用最新版本,目前最新版本为1.2.58

简单使用

JSON这个类是fastjson API的入口，主要的功能都通过这个类提供。
序列化API

package com.alibaba.fastjson;
public abstract class JSON {
    // 将Java对象序列化为JSON字符串，支持各种各种Java基本类型和JavaBean
    public static String toJSONString(Object object, SerializerFeature... features);
    // 将Java对象序列化为JSON字符串，返回JSON字符串的utf-8 bytes
    public static byte[] toJSONBytes(Object object, SerializerFeature... features);
    // 将Java对象序列化为JSON字符串，写入到Writer中
    public static void writeJSONString(Writer writer, Object object,SerializerFeature... features);
    // 将Java对象序列化为JSON字符串，按UTF-8编码写入到OutputStream中
    public static final int writeJSONString(OutputStream os, //
                                           Object object, //
                                            SerializerFeature... features);
}

JSON字符串反序列化API

package com.alibaba.fastjson;
public abstract class JSON {
    // 将JSON字符串反序列化为JavaBean
    public static <T> T parseObject(String jsonStr,
                                    Class<T> clazz,
                                    Feature... features);
    // 将JSON字符串反序列化为JavaBean
    public static <T> T parseObject(byte[] jsonBytes,  // UTF-8格式的JSON字符串
                                    Class<T> clazz,
                                    Feature... features);
    // 将JSON字符串反序列化为泛型类型的JavaBean
    public static <T> T parseObject(String text,
                                    TypeReference<T> type,
                                    Feature... features);
    // 将JSON字符串反序列为JSONObject
    public static JSONObject parseObject(String text);
}

简单示例
parse Tree

import com.alibaba.fastjson.*;
JSONObject jsonObj = JSON.parseObject(jsonStr);

parse POJO

import com.alibaba.fastjson.JSON;
Model model = JSON.parseObject(jsonStr, Model.class);

parse POJO Generic

import com.alibaba.fastjson.JSON;
Type type = new TypeReference<List<Model>>() {}.getType();
List<Model> list = JSON.parseObject(jsonStr, type);

convert POJO to json string

import com.alibaba.fastjson.JSON;
Model model = ...;
String jsonStr = JSON.toJSONString(model);

convert POJO to json bytes

import com.alibaba.fastjson.JSON;
Model model = ...;
byte[] jsonBytes = JSON.toJSONBytes(model);

write POJO as json string to OutputStream

import com.alibaba.fastjson.JSON;
Model model = ...;
OutputStream os;
JSON.writeJSONString(os, model);

write POJO as json string to Writer

import com.alibaba.fastjson.JSON;
Model model = ...;
Writer writer = ...;
JSON.writeJSONString(writer, model);

高级使用

Fastjson 定制序列化

1. 简介

fastjson支持多种方式定制序列化。
通过@JSONField定制序列化
通过@JSONType定制序列化
通过SerializeFilter定制序列化
通过ParseProcess定制反序列化

1. 使用@JSONField配置

可以把@JSONField配置在字段或者getter/setter方法上。例如：

public class VO {
      @JSONField(name="ID")
      private int id;
 }

或者

 public class VO {
      private int id;

      @JSONField(name="ID")
      public int getId() { return id;}

      @JSONField(name="ID")
      public void setId(int value) {this.id = id;}
 }

1. 使用@JSONType配置
   和JSONField类似，但JSONType配置在类上，而不是field或者getter/setter方法上。
2. 通过SerializeFilter定制序列化
   通过SerializeFilter可以使用扩展编程的方式实现定制序列化。fastjson提供了多种SerializeFilter：

• PropertyPreFilter 根据PropertyName判断是否序列化
• PropertyFilter 根据PropertyName和PropertyValue来判断是否序列化
• NameFilter 修改Key，如果需要修改Key,process返回值则可
• ValueFilter 修改Value
• BeforeFilter 序列化时在最前添加内容
  *AfterFilter 序列化时在最后添加内容
  以上的SerializeFilter在JSON.toJSONString中可以使用。

  SerializeFilter filter = ...; // 可以是上面5个SerializeFilter的任意一种。
  JSON.toJSONString(obj, filter);

1. 通过ParseProcess定制反序列化

Fastjson 实例

Fastjson 对象或数组转JSON

Fastjson阿里巴巴工程师开源的一个 json 库：Fastjson，这个库在解析速度和易用性上来说都很不错。
在日志解析，前后端数据传输交互中，经常会遇到String与map、json、xml等格式相互转换与解析的场景，其中json基本成为了跨语言、跨前后端的事实上的标准数据交互格式。应该来说各个语言中解析json的库都一大片（具体 json 格式与三方库的介绍请见：http://www.json.org/json-zh.html ），比如python都集成在了内置库中，成为标准API，今天我们要聊的是java中如何方便的使用json格式。
下面一个示例是如何使用Fastjson 把对象或数组转JSON

package com.ohaotian.feifz.style.study.utils;

/**
 * @author feifz
 * @version 1.0.0
 * @Description alibaba fastjson工具类
 * @createTime 2019年06月10日 11:45:00
 */

import com.alibaba.fastjson.JSON;
import lombok.Data;

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

class FastJsonTest {
    public static void main(String[] args) {
        // 构建用户geust
        User guestUser = new User();
        guestUser.setName("guest");
        guestUser.setAge(28);
        // 构建用户root
        User rootUser = new User();
        rootUser.setName("root");
        guestUser.setAge(35);
        // 构建用户组对象
        UserGroup group = new UserGroup();
        group.setName("admin");
        group.getUsers().add(guestUser);
        group.getUsers().add(rootUser);
        // 用户组对象转JSON串
        String jsonString = JSON.toJSONString(group);
        System.out.println("jsonString:" + jsonString);
        // JSON串转用户组对象
        UserGroup group2 = JSON.parseObject(jsonString, UserGroup.class);
        System.out.println("group2:" + group2);

        // 构建用户对象数组
        User[] users = new User[2];
        users[0] = guestUser;
        users[1] = rootUser;
        // 用户对象数组转JSON串
        String jsonString2 = JSON.toJSONString(users);
        System.out.println("jsonString2:" + jsonString2);
        // JSON串转用户对象列表
        List<User> users2 = JSON.parseArray(jsonString2, User.class);
        System.out.println("users2:" + users2);
    }
}
@Data
class User {
    private String name;
    private int age;
}
@Data
class UserGroup {
    private String name;
    private List<User> users = new ArrayList<>();
}

输出结果：

jsonString:{"name":"admin","users":[{"age":35,"name":"guest"},{"age":0,"name":"root"}]}
group2:UserGroup [name=admin, users=[User [name=guest, age=35], User [name=root, age=0]]]
jsonString2:[{"age":35,"name":"guest"},{"age":0,"name":"root"}]
users2:[User [name=guest, age=35], User [name=root, age=0]]

fastjson通过各方面测试都很好，功能性能都是No.1，喜欢，它的源代码质量很高，作者也煞费苦心，将性能做到了最好，全面超越其他的json类库。
通过fastjson我们可以快速进行开发。

Fastjson Obejct/Map/JSON/String 互转

fastjson主要的使用入口

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。

有关类库的一些说明

  SerializeWriter：相当于StringBuffer
  JSONArray：相当于List<Object>
  JSONObject：相当于Map<String, Object>
  JSON反序列化没有真正数组，本质类型都是List<Object>

示例代码

package com.ohaotian.feifz.style.study.utils;

/**
 * @author feifz
 * @version 1.0.0
 * @Description fastjson 高级应用
 * @createTime 2019年06月10日 15:43:00
 */

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.serializer.SerializeConfig;
import com.alibaba.fastjson.serializer.SimpleDateFormatSerializer;
import lombok.Data;

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

/**
 * @author feifz
 * @version 1.0.0
 * @Description alibaba fastjson高级应用
 * @createTime 2019年06月10日 11:45:00
 */
public class FastjsonTest {
    private static SerializeConfig mapping = new SerializeConfig();

    static {
        mapping.put(Date.class, new SimpleDateFormatSerializer("yyyy-MM-dd HH:mm:ss"));
    }

    public static void main(String[] args) {
        Date date = new Date();
        String text = JSON.toJSONString(date, mapping);
        System.out.println(text);
    }

    public static void json2List() {
        /**List -> JSON array*/
        List<Bar> barList = new ArrayList<Bar>();
        barList.add(new Bar());
        barList.add(new Bar());
        barList.add(new Bar());
        String json = JSON.toJSONString(barList);
        System.out.println(json);
        json = JSON.toJSONString(barList, true);
        System.out.println(json);
        /**JSON array -> List*/
        List<Bar> barList1 = JSON.parseArray(json, Bar.class);
        for (Bar bar : barList1) {
            System.out.println(bar.toString());
        }
    }

    public static void json2Map() {
        //Map -> JSON
        Map<String, Bar> map = new HashMap<String, Bar>();
        map.put("a", new Bar());
        map.put("b", new Bar());
        map.put("c", new Bar());
        String json = JSON.toJSONString(map, true);
        System.out.println(json);
        //JSON -> Map
        Map<String, Bar> map1 = (Map<String, Bar>) JSON.parse(json);
        for (String key : map1.keySet()) {
            System.out.println(key + ":" + map1.get(key));
        }
    }

    public static void array2JSON() {
        String[] arr_String = {"a", "b", "c"};
        String json_arr_String = JSON.toJSONString(arr_String, true);
        System.out.println(json_arr_String);
        JSONArray jsonArray = JSON.parseArray(json_arr_String);
        for (Object o : jsonArray) {
            System.out.println(o);
        }
        System.out.println(jsonArray);
    }

    public static void array2JSON2() {
        Bar[] arr_Bar = {new Bar(), new Bar(), new Bar()};
        String json_arr_Bar = JSON.toJSONString(arr_Bar, true);
        System.out.println(json_arr_Bar);
        JSONArray jsonArray = JSON.parseArray(json_arr_Bar);
        for (Object o : jsonArray) {
            System.out.println(o);
        }
        System.out.println(jsonArray);
    }

    public static void map2JSON() {
        Map map = new HashMap();
        map.put("a", "aaa");
        map.put("b", "bbb");
        map.put("c", "ccc");
        String json = JSON.toJSONString(map);
        System.out.println(json);
        Map map1 = JSON.parseObject(json);
        for (Object o : map.entrySet()) {
            Map.Entry<String, String> entry = (Map.Entry<String, String>) o;
            System.out.println(entry.getKey() + "--->" + entry.getValue());
        }
    }
}

@Data
class Bar {
    public static SerializeConfig mapping = new SerializeConfig();
    private String barName;
    private int barAge;
    private Date barDate = new Date();

    static {
        mapping.put(Date.class, new SimpleDateFormatSerializer("yyyy-MM-dd"));
    }

    {
        Random r = new Random();
        barName = "sss_" + String.valueOf(r.nextFloat());
        barAge = r.nextInt();
    }

    public static void main(String[] args) {
        String x1 = JSON.toJSONString(new Bar(), true);
        System.out.println(x1);
        String x2 = JSON.toJSONString(new Bar(), mapping);
        System.out.println(x2);
    }
}

Fastjson API

• Fastjson JSONField
• Fastjson JSONPath
• Fastjson toJSONString
• Fastjson writeJSONString
• Fastjson parseObject
• Fastjson Api Compare
• Fastjson API Stream
• Fastjson API ParseProcess
• Fastjson API SerializeFilter

Fastjson 常见问题

参考

• https://www.w3cschool.cn/fastjson
• https://www.jianshu.com/p/eaeaa5dce258

结语

欢迎关注微信公众号『码仔zonE』，专注于分享Java、云计算相关内容，包括SpringBoot、SpringCloud、微服务、Docker、Kubernetes、Python等领域相关技术干货，期待与您相遇！