FastJson 笔记

什么是fastjson

官方：fastjson是阿里巴巴的开源JSON解析库，它可以解析JSON格式的字符串，支持将Java Bean序列化为JSON字符串，也可以从JSON字符串反序列化到JavaBean。

优点

  1. 速度快
  2. 使用广泛
  3. 测试完备
  4. 使用简单
  5. 功能完备

项目引入

maven项目引入fastjson相关包：

  1. <dependency>
  2.    <groupId>com.alibaba</groupId>
  3.    <artifactId>fastjson</artifactId>
  4.    <version>1.2.56</version>
  5. </dependency>

JSON格式字符串与JSON对象之间的转换

该模块转自：高性能JSON框架之FastJson的简单使用

首先定义三个json格式的字符串

  1. //json字符串-简单对象型
  2.     private static final String JSON_OBJ_STR = "{\"studentName\":\"lily\",\"studentAge\":12}";
  4.     //json字符串-数组类型
  5.     private static final String JSON_ARRAY_STR = "[{\"studentName\":\"lily\",\"studentAge\":12},{\"studentName\":\"lucy\",\"studentAge\":15}]";
  7.     //复杂格式json字符串
  8.     private static final String COMPLEX_JSON_STR = "{\"teacherName\":\"crystall\",\"teacherAge\":27,\"course\":{\"courseName\":\"english\",\"code\":1270},\"students\":[{\"studentName\":\"lily\",\"studentAge\":12},{\"studentName\":\"lucy\",\"studentAge\":15}]}";

json字符串-简单对象型与JSONObject之间的转换

  1. /**
  2.  * json字符串-简单对象型到JSONObject的转换
  3.  */
  4. @Test
  5. public void testJSONStrToJSONObject() {
  7.     JSONObject jsonObject = JSONObject.parseObject(JSON_OBJ_STR);
  9.     System.out.println("studentName:  " + jsonObject.getString("studentName") + ":" + "  studentAge:  "
  10.             + jsonObject.getInteger("studentAge"));
  12. }
  14. /**
  15.  * JSONObject到json字符串-简单对象型的转换
  16.  */
  17. @Test
  18. public void testJSONObjectToJSONStr() {
  20.     //已知JSONObject,目标要转换为json字符串
  21.     JSONObject jsonObject = JSONObject.parseObject(JSON_OBJ_STR);
  22.     // 第一种方式
  23.     String jsonString = JSONObject.toJSONString(jsonObject);
  25.     // 第二种方式
  26.     //String jsonString = jsonObject.toJSONString();
  27.     System.out.println(jsonString);
  28. }

json字符串(数组类型)与JSONArray之间的转换

  1. /**
  2.  * json字符串-数组类型到JSONArray的转换
  3.  */
  4. @Test
  5. public void testJSONStrToJSONArray() {
  7.     JSONArray jsonArray = JSONArray.parseArray(JSON_ARRAY_STR);
  9.     //遍历方式1
  10.     int size = jsonArray.size();
  11.     for (int i = 0; i < size; i++) {
  13.         JSONObject jsonObject = jsonArray.getJSONObject(i);
  14.         System.out.println("studentName:  " + jsonObject.getString("studentName") + ":" + "  studentAge:  "
  15.                 + jsonObject.getInteger("studentAge"));
  16.     }
  18.     //遍历方式2
  19.     for (Object obj : jsonArray) {
  21.         JSONObject jsonObject = (JSONObject) obj;
  22.         System.out.println("studentName:  " + jsonObject.getString("studentName") + ":" + "  studentAge:  "
  23.                 + jsonObject.getInteger("studentAge"));
  24.     }
  25. }
  27. /**
  28.  * JSONArray到json字符串-数组类型的转换
  29.  */
  30. @Test
  31. public void testJSONArrayToJSONStr() {
  33.     //已知JSONArray,目标要转换为json字符串
  34.     JSONArray jsonArray = JSONArray.parseArray(JSON_ARRAY_STR);
  35.     //第一种方式
  36.     String jsonString = JSONArray.toJSONString(jsonArray);
  38.     // 第二种方式
  39.     //String jsonString = jsonArray.toJSONString(jsonArray);
  40.     System.out.println(jsonString);
  41. }

复杂json格式字符串与JSONObject之间的转换

  1. /**
  2.  * 复杂json格式字符串到JSONObject的转换
  3.  */
  4. @Test
  5. public void testComplexJSONStrToJSONObject() {
  7.     JSONObject jsonObject = JSONObject.parseObject(COMPLEX_JSON_STR);
  9.     String teacherName = jsonObject.getString("teacherName");
  10.     Integer teacherAge = jsonObject.getInteger("teacherAge");
  12.     System.out.println("teacherName:  " + teacherName + "   teacherAge:  " + teacherAge);
  14.     JSONObject jsonObjectcourse = jsonObject.getJSONObject("course");
  15.      //获取JSONObject中的数据
  16.     String courseName = jsonObjectcourse.getString("courseName");
  17.     Integer code = jsonObjectcourse.getInteger("code");
  19.     System.out.println("courseName:  " + courseName + "   code:  " + code);
  21.     JSONArray jsonArraystudents = jsonObject.getJSONArray("students");
  22.     // JSONArray 转java的list 还可以如下
  23.     // List list1 = jsonArraystudents.toJavaList(String.class);
  24.     //遍历JSONArray
  25.     for (Object object : jsonArraystudents) {
  27.         JSONObject jsonObjectone = (JSONObject) object;
  28.         String studentName = jsonObjectone.getString("studentName");
  29.         Integer studentAge = jsonObjectone.getInteger("studentAge");
  31.         System.out.println("studentName:  " + studentName + "   studentAge:  " + studentAge);
  32.     }
  33. }
  35. /**
  36.  * 复杂JSONObject到json格式字符串的转换
  37.  */
  38. @Test
  39. public void testJSONObjectToComplexJSONStr() {
  41.    //复杂JSONObject,目标要转换为json字符串
  42.     JSONObject jsonObject = JSONObject.parseObject(COMPLEX_JSON_STR);
  44.     //第一种方式
  45.     //String jsonString = JSONObject.toJSONString(jsonObject);
  47.     //第二种方式
  48.     String jsonString = jsonObject.toJSONString();
  49.     System.out.println(jsonString);
  51. }

java对象序列化成json字符串

  1. // Lombok
  2. @Data
  3. class Test01 {
  4.     String name, password, message;
  5.     int age;
  6. }
  9.     @Test
  10.     public void test01() {
  11.         Test01 test01=new Test01();
  12.         test01.setAge(1);
  13.         test01.setMessage("fastjson");
  14.         test01.setName("meyoung");
  15.         test01.setPassword("123");
  17. //        默认情况下 javaBean 映射成json object
  18. //        {"age":1,"message":"fastjson","name":"meyoung","password":"123"}
  19.         String jsonString =  JSON.toJSONString(test01);
  20.         log.info(jsonString);
  22. //        设置JavaBean 映射为json array
  23. //        [1,"fastjson","meyoung","123"]
  24.         String jsonArr = JSON.toJSONString(test01, SerializerFeature.BeanToArray);
  25.         log.info(jsonArr);
  27. //         美化输出映射后的json
  28.         String jsonPre = JSON.toJSONString(test01, SerializerFeature.PrettyFormat);
  29.         log.info(jsonPre);
  30.     }

上面都是默认情况的序列化，如果需要对输出的json格式的数据进行定制，例如key用单引号，String类型为空输出“”等等，当然上面的美化输出也是其中一种等等，你可以通过com.alibaba.fastjson.serializer.SerializerFeature枚举类来设定特性。

  1. String jsonPre = JSON.toJSONString(test01, SerializerFeature.PrettyFormat,
  2.                                    SerializerFeature.WriteNullStringAsEmpty,
  3.                                    SerializerFeature.UseSingleQuotes);

这块详细可以参考：fastjson SerializerFeature详解 - 孤天浪雨 - CSDN博客

json字符串反序列化成java对象

  1. @Test
  2.     public void test02(){
  3.         String string01 =" {\"age\":1,\"message\":\"fastjson\",\"name\":\"meyoung\",\"password\":\"123\"}";
  4.         Test01 test = JSON.parseObject(string01,Test01.class);
  5.         log.info(test.getMessage());
  6.         log.info(test.getName());
  7.         log.info(test.getPassword());
  8.         log.info(String.valueOf(test.getAge()));
  9.     }
  11.         @Test
  12.     public void test02(){
  13.         String string01 =" [{\"age\":1,\"message\":\"fastjson\",\"name\":\"meyoung\",\"password\":\"123\"}]";
  14.         List<Test01> test11 = JSON.parseArray(string01,Test01.class);
  15.         Test01 test =  test11.get(0);
  16.         log.info(test.getMessage());
  17.         log.info(test.getName());
  18.         log.info(test.getPassword());
  19.         log.info(String.valueOf(test.getAge()));
  20.     }

泛型反序列化

TypeReference · alibaba/fastjson Wiki · GitHub
fastjson通过TypeReference来实现泛型的反序列化，以下是一个简单的例子程序。首先定义了BaseDTO用于所有DTO的父类，代码如下：

  1. public class BaseDTO implements Serializable {
  3.     private static final long  serialVersionUID = 2230553030766621644L;
  5.     @Override
  6.     public String toString() {
  7.         return JSONObject.toJSONString(this);
  8.     }
  10. }

RequestDTO用于抽像所有的请求DTO，里面有个泛型参数，代码如下：

  1. public final class RequestDTO<T extends BaseDTO> extends BaseDTO {
  3.     private static final long serialVersionUID = -2780042604928728379L;
  5.     /**
  6.      * 调用方的名称
  7.      */
  8.     private String caller;
  10.     /**
  11.      * 请求参数
  12.      */
  13.     private T param;
  16.     public String getCaller() {
  17.         return caller;
  18.     }
  20.     public void setCaller(String caller) {
  21.         this.caller = caller;
  22.     }
  24.     /**
  25.      * 获取请求参数
  26.      */
  27.     public T getParam() {
  28.         return param;
  29.     }
  31.     /**
  32.      * 设置请求参数
  33.      *
  34.      * @param param 请求参数
  35.      */
  36.     public void setParam(T param) {
  37.         this.param = param;
  38.     }
  40. }

定义一个具体的业务对象， PersonDTO代码如下：

  1. @Data
  2. public class PersonDTO extends BaseDTO {
  4.     private static final long serialVersionUID = 4637634512292751986L;
  6.     private int id;
  7.     private int age;
  8.     private String name;
  10. }

测试：

  1. @Test
  2.     public void test03(){
  3.         RequestDTO<PersonDTO> requestDTO = new RequestDTO<PersonDTO>();
  4.         requestDTO.setCaller("callerId");
  5.         PersonDTO personDTO = new PersonDTO();
  6.         personDTO.setAge(11);
  7.         personDTO.setName("张三");
  8.         requestDTO.setParam(personDTO);
  10.         String jsonString = JSON.toJSONString(requestDTO);
  11.         //{"caller":"callerId","param":{"age":11,"id":0,"name":"张三"}}
  12.         System.out.println(jsonString);
  13.         //这行是关键代码
  14.         requestDTO = JSON.parseObject(jsonString, new TypeReference<RequestDTO<PersonDTO>>(){});
  15.         // 张三
  16.         System.out.println(requestDTO.getParam().getName());
  17.     }

JSONField 介绍

fastjson提供了JSONField对序列化和反序列化进行定制。先看下 JSONField的部分源码：

  1. public @interface JSONField {
  2.     /**
  3.      * config encode/decode ordinal
  4.      * @since 1.1.42
  5.      * @return
  6.      */
  7.     // 配置序列化和反序列化的顺序
  8.     int ordinal() default 0;
  10.      // 指定字段的名称
  11.     String name() default "";
  13.     // 指定字段的格式，对日期格式有用
  14.     String format() default "";
  16.     // 是否序列化
  17.     boolean serialize() default true;
  19.     // 是否反序列化
  20.     boolean deserialize() default true;
  22.     //字段级别的SerializerFeature
  23.     SerializerFeature[] serialzeFeatures() default {};
  25.         Feature[] parseFeatures() default {};
  26.    //给属性打上标签， 相当于给属性进行了分组
  27.     String label() default "";
  29.     boolean jsonDirect() default false;
  31.         //制定属性的序列化类
  32.     Class<?> serializeUsing() default Void.class;
  34.          //制定属性的反序列化类
  35.     Class<?> deserializeUsing() default Void.class;
  37.     String[] alternateNames() default {};
  39.     boolean unwrapped() default false;

JSONField注解的使用

注意：若属性是私有的，必须有set*方法。否则无法反序列化。

  1. // 配置在get*/set*上
  2. @JSONField(name="ID")
  3. public int getId() {return id;}
  5. // 配置在field上
  6. @JSONField(name="ID")
  7. public int id;
  9. // 配置date序列化和反序列使用日期格式
  10. @JSONField(format="yyyyMMdd")
  11. public Date date1;  
  13.  // 不序列化
  14.  @JSONField(serialize=false)
  15.  public Date date2;
  17.  // 不反序列化
  18.  @JSONField(deserialize=false)
  19.  public Date date3;
  21. //缺省fastjson序列化一个java bean，是根据fieldName的字母序进行序列化的，你可以通过ordinal指定字段的顺序。这个特性需要1.1.42以上版本。
  22.  // 按ordinal排序
  23.  @JSONField(ordinal = 2)
  24.  private int f1;
  26.  @JSONField(ordinal = 1)
  27.  private int f2;

属性序列化和反序列化定制

JSONField提供的serializeUsing与deserializeUsing可以用于对特定属性字段的序列化与反序列化进行定制化。

假设我们现在有一个Users.java,代码详细如下：

  1. import lombok.Data;
  3. @Data
  4. class Users {
  6.     String name, password, message;
  7.     int age;
  9.     boolean sex;
  10. }

这时我们定义的sex属性是boolean类型，这种明显不太合适，那么我们可以通过serializeUsing与deserializeUsing定制sex的序列化和反序列化。

serializeUsing定制序列化

我们新建个 UsersSerializer.java ，实现 ObjectSerializer 接口。 定制规则如果sex字段不为空或者为true则，序列化为男。

属性序列化定制
  1. public class UsersSerializer implements ObjectSerializer {
  2.     //    序列化对sex属性额外处理
  3.     @Override
  4.     public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException {
  6.         Boolean value = (Boolean) object;
  7.         String text = "女";
  8.         if (value != null && value.equals(true)) {
  9.             text = "男";
  10.         }
  11.         serializer.write(text);
  12.     }
  13.     }

注册

我们在Users.java类中给sex属性加上JSONField注解，如下：

  1. @JSONField(serializeUsing = UsersSerializer.class)
  2.     boolean sex;

使用
  1. @Test
  2.     public void test01() {
  3.         Users test01 = new Users();
  4.         test01.setAge(1);
  5.         test01.setMessage("fastjson");
  6.         test01.setName("meyoung");
  7.         test01.setPassword("123");
  8.         test01.setSex(true);
  9. //        {"age":1,"message":"fastjson","name":"meyoung","password":"123","sex":"男"}
  10.         String jsonString = JSON.toJSONString(test01);
  11.         log.info(jsonString);
  12.         }

deserializeUsing定制反序列化

我们还是沿用上面的User.java类为例，定制反序列化定制的代码。

属性反序列化定制

我这里偷懒，直接用上面的 UsersSerializer.java 继续实现 ObjectDeserializer接口，并实现接口方法，最后ObjectDeserializer.java代码如下：

  1. public class UsersSerializer implements ObjectSerializer, ObjectDeserializer {
  2.     //    序列化对sex属性额外处理
  3.     @Override
  4.     public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException {
  6.         Boolean value = (Boolean) object;
  7.         String text = "女";
  8.         if (value != null && value.equals(true)) {
  9.             text = "男";
  10.         }
  11.         serializer.write(text);
  12.     }
  15.     //  反序列化对sex属性额外处理
  16.     @SuppressWarnings("unchecked")
  17.     @Override
  18.     public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
  19.         String sex = parser.parseObject(String.class);
  20.         if (sex.equals("男")) {
  21.             return (T) Boolean.TRUE;
  22.         } else {
  23.             return (T) Boolean.FALSE;
  24.         }
  25.     }
  27.     @Override
  28.     public int getFastMatchToken() {
  29.         return JSONToken.UNDEFINED;
  30.     }
  32. }

注册

我们在Users.java类中给sex属性加上JSONField注解，如下：

  1. @JSONField(serializeUsing = UsersSerializer.class,deserializeUsing = UsersSerializer.class)
  2.     boolean sex;

使用
  1. @Test
  2.     public void test02() {
  3.             String string01 = "{\"age\":1,\"message\":\"fastjson\",\"name\":\"meyoung\",\"password\":\"123\",\"sex\":\"男\"}";
  4.             Users test = JSON.parseObject(string01, Users.class);
  5. //            true
  6.             log.info(String.valueOf(test.sex));
  8.     }

JSONType注解的使用

JSONType和JSONField类似，但JSONType配置在类上，而不是field或者getter/setter方法上。这里就不再demo，也可以查看官方文档学习：
JSONType_serializer · alibaba/fastjson Wiki · GitHub

自定义序列化之过滤器

fastjson通过SerializeFilter编程扩展的方式定制序列化fastjson支持以下SerializeFilter用于不同常景的定制序列化：

PropertyFilter

根据PropertyName和PropertyValue来判断是否序列化,接口定义如下：

  1. package com.alibaba.fastjson.serializer;
  3. /**
  4.  * @author wenshao[szujobs@hotmail.com]
  5.  */
  6. public interface PropertyFilter extends SerializeFilter {
  8.     /**
  9.      * @param object the owner of the property
  10.      * @param name the name of the property
  11.      * @param value the value of the property
  12.      * @return true if the property will be included, false if to be filtered out
  13.     * 根据 属性的name与value判断是否进行序列化
  14.      */
  15.     boolean apply(Object object, String name, Object value);
  16. }

DEMO:
Samples PropertyFilter · alibaba/fastjson Wiki · GitHub

PropertyPreFilter

根据PropertyName判断是否序列化

  1. package com.alibaba.fastjson.serializer;
  3. public interface PropertyPreFilter extends SerializeFilter {
  5. //根据 object与name判断是否进行序列化
  6.     boolean apply(JSONSerializer serializer, Object object, String name);
  7. }

DEMO:
使用SimplePropertyPreFilter过滤属性 · alibaba/fastjson Wiki · GitHub

NameFilter

序列化时修改Key

  1. package com.alibaba.fastjson.serializer;
  3. public interface NameFilter extends SerializeFilter {
  4. //根据 name与value的值，返回json字段key的值
  5.     String process(Object object, String name, Object value);
  6. }

ValueFilter

序列化时修改Value

  1. package com.alibaba.fastjson.serializer;
  3. public interface ValueFilter extends SerializeFilter {
  4.   //根据name与value定制输出json的value
  5.     Object process(Object object, String name, Object value);
  6. }

BeforeFilter

在序列化对象的所有属性之前执行某些操作

  1. package com.alibaba.fastjson.serializer;
  3. public abstract class BeforeFilter implements SerializeFilter {
  5.     private static final ThreadLocal<JSONSerializer> serializerLocal = new ThreadLocal<JSONSerializer>();
  6.     private static final ThreadLocal<Character>      seperatorLocal  = new ThreadLocal<Character>();
  8.     private final static Character                   COMMA           = Character.valueOf(',');
  10.     final char writeBefore(JSONSerializer serializer, Object object, char seperator) {
  11.         serializerLocal.set(serializer);
  12.         seperatorLocal.set(seperator);
  13.         writeBefore(object);
  14.         serializerLocal.set(null);
  15.         return seperatorLocal.get();
  16.     }
  18.     protected final void writeKeyValue(String key, Object value) {
  19.         JSONSerializer serializer = serializerLocal.get();
  20.         char seperator = seperatorLocal.get();
  21.         serializer.writeKeyValue(seperator, key, value);
  22.         if (seperator != ',') {
  23.             seperatorLocal.set(COMMA);
  24.         }
  25.     }
  26. //需要实现的方法，在实际实现中可以调用writeKeyValue增加json的内容
  27.     public abstract void writeBefore(Object object);
  28. }

AfterFilter

在序列化对象的所有属性之后执行某些操作

  1. package com.alibaba.fastjson.serializer;
  3. /**
  4.  * @since 1.1.35
  5.  */
  6. public abstract class AfterFilter implements SerializeFilter {
  8.     private static final ThreadLocal<JSONSerializer> serializerLocal = new ThreadLocal<JSONSerializer>();
  9.     private static final ThreadLocal<Character>      seperatorLocal  = new ThreadLocal<Character>();
  11.     private final static Character                   COMMA           = Character.valueOf(',');
  13.     final char writeAfter(JSONSerializer serializer, Object object, char seperator) {
  14.         serializerLocal.set(serializer);
  15.         seperatorLocal.set(seperator);
  16.         writeAfter(object);
  17.         serializerLocal.set(null);
  18.         return seperatorLocal.get();
  19.     }
  21.     protected final void writeKeyValue(String key, Object value) {
  22.         JSONSerializer serializer = serializerLocal.get();
  23.         char seperator = seperatorLocal.get();
  24.         serializer.writeKeyValue(seperator, key, value);
  25.         if (seperator != ',') {
  26.             seperatorLocal.set(COMMA);
  27.         }
  28.     }
  30. //子类需要实现的方法，实际使用的时候可以调用writeKeyValue增加内容
  31.     public abstract void writeAfter(Object object);
  32. }

LabelFilter

根据 JsonField配置的label来判断是否进行输出

  1. package com.alibaba.fastjson.serializer;
  3. //根据 JsonField配置的label来判断是否进行输出
  4. public interface LabelFilter extends SerializeFilter {
  5.     boolean apply(String label);
  6. }

参考文档

JSONField · alibaba/fastjson Wiki · GitHub
JSON最佳实践 | kimmking’s blog
fastjson SerializerFeature详解 - 孤天浪雨 - CSDN博客
fastjson详解 - 简书