初识fastjson

什么是fastjson

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

优点

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

引入相应的Maven包

<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.62</version>
</dependency>

主要的API

Fastjson入口类是 com.alibaba.fastjson.JSON，主要的 API 是 JSON.toJSONString 和 parseObject。

package com.alibaba.fastjson;
public abstract class JSON {
      // Java对象转换为JSON字符串
      public static final String toJSONString(Object object);
      //JSON字符串转换为Java对象
      public static final <T> T parseObject(String text, Class<T> clazz, Feature... features);
}

• 序列化：
  String jsonString = JSON.toJSONString(obj);
• 反序列化：
  VO vo = JSON.parseObject("...", VO.class);
• 泛型反序列化：
  对进行泛型的反序列化，使用TypeReference可以明确的指定反序列化的类型
  是把字符串planjson转化为相应的JSONObject对象，“键值对”形式，然后通过new TypeReference(){ }匿名内部类来把planjson的JSONObject转化为Plan对象不属于plan对象本身的属性，通过TypeReference只把属于plan对象属性的参数和值组装成plan对象

import com.alibaba.fastjson.TypeReference;
List<Plan> list = JSON.parseObject(planjson, new TypeReference<List<Plan>>() {});

将对象的空值输出

在fastjson中，缺省是不输出空值的。无论Map中的null和对象属性中的null，序列化的时候都会被忽略不输出，这样会减少产生文本的大小。但如果需要输出空值怎么做呢？
如果你需要输出空值，需要使用SerializerFeature.WriteMapNullValue

Model obj = ...;
JSON.toJSONString(obj, SerializerFeature.WriteMapNullValue);

几种空值特别处理方式，可以同时选择多个：

值	说明
WriteNullListAsEmpty	将Collection类型字段的字段空值输出为[]
WriteNullStringAsEmpty	将字符串类型字段的空值输出为空字符串 “”
WriteNullNumberAsZero	将数值类型字段的空值输出为0
WriteNullBooleanAsFalse	将Boolean类型字段的空值输出为false

class Model {
      public List<Objec> items;
}

Model obj = ....;

String text = JSON.toJSONString(obj, SerializerFeature.WriteMapNullValue, SerializerFeature.WriteNullListAsEmpty);

fastjson处理日期

JSON.toJSONStringWithDateFormat(date, "yyyy-MM-dd HH:mm:ss.SSS")
使用ISO-8601日期格式
JSON.toJSONString(obj, SerializerFeature.UseISO8601DateFormat);
全局修改日期格式

JSON.DEFFAULT_DATE_FORMAT = "yyyy-MM-dd";
JSON.toJSONString(obj, SerializerFeature.WriteDateUseDateFormat);

反序列化能够自动识别如下日期格式：

• ISO-8601日期格式
• yyyy-MM-dd
• yyyy-MM-dd HH:mm:ss
• yyyy-MM-dd HH:mm:ss.SSS
• 毫秒数字
• 毫秒数字字符串
• .NET JSON日期格式
• new Date(198293238)

Fastjson 的定制序列化

fastjson支持多种方式定制序列化。

• 通过@JSONField定制序列化
• 通过@JSONType定制序列化
• 通过SerializeFilter定制序列化
• 通过ParseProcess定制反序列化

通过@JSONField定制序列化

1.注解属性及作用

• 配置序列化和反序列化的顺序，1.1.42版本之后才支持
  int ordinal() default 0;
• 指定字段的名称
  String name() default "";
• 指定字段的格式，对日期格式有用
  String format() default "";
• 是否序列化
  boolean serialize() default true;
• 是否反序列化
  boolean deserialize() default true;

2.使用

可以把@JSONField配置在字段或者getter/setter方法上，都是可以的。

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

2.1使用name指定字段名称

说明：指定字段名称，修改在序列化和反序列化时对应的字段名称。
举个例子来说明把@JSONField(name = "XXX")标在getter/setter上的区别->目的：区分放在get和set上的区别
实体类

package ink.poesy.pojo;

import com.alibaba.fastjson.annotation.JSONField;
import lombok.AccessLevel;
import lombok.Data;
import lombok.Getter;
import lombok.Setter;

@Data
public class SYS_PhysicalHost {
    private String name;

    @Setter(AccessLevel.NONE)
    private String department;

    @Getter(AccessLevel.NONE)
    private String age;

    @Getter(AccessLevel.NONE)
    @Setter(AccessLevel.NONE)
    private String poesy;

	/**
	 * 创建set不get用例
	 */
    @JSONField(name = "bumen")
    public void setDepartment(String department) {
        this.department = department;
    }

	/**
	 * 创建get不set用例
	 */
    @JSONField(name = "nianling")
    public String getAge() {
        return age;
    }

	/**
	 * 创建get和set用例
	 */
    @JSONField(name = "geyan")
    public String getPoesy() {
        return poesy;
    }
    @JSONField(name = "geyan")
    public void setPoesy(String poesy) {
        this.poesy = poesy;
    }
}

测试类

package ink.poesy.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import ink.poesy.pojo.SYS_PhysicalHost;

/**
 * @description: 测试@JSONField作用范围
 * @author: WenLeiWang
 * @date: Created in 2019/11/6 10:08
 * @version: 1.0
 * @modified By:
 */
public class Test {
    private static String human1 = "{\"name\":\"wwl\",\"department\":\"ruanjian1\",\"age\":23,\"poesy\":\"hsb1\"}";
    private static String human2 = "{\"name\":\"gt\",\"bumen\":\"ruanjian2\",\"nianling\":23,\"geyan\":\"hsb2\"}";

    public static void main(String[] args) {
        SYS_PhysicalHost sys_physicalHost1 = JSON.parseObject(human1, new TypeReference<SYS_PhysicalHost>() {});
        System.out.println(sys_physicalHost1.toString());
        SYS_PhysicalHost sys_physicalHost2 = JSON.parseObject(human2, new TypeReference<SYS_PhysicalHost>() {});
        System.out.println(sys_physicalHost2.toString());

    }
}

测试结果

结果说明

• get 上写JSONFeild => 以name提供的字段 序列化 也就是你要把bean转成json
• set 上写JSONFeild => 以name提供的字段反序列化 也就是把json转成bean

2.2使用format配置日期格式化

可以定制化配置各个日期字段的格式化

public class A {
      // 配置date序列化和反序列使用yyyyMMdd日期格式
      @JSONField(format="yyyyMMdd")
      public Date date;
 }

2.3使用serialize/deserialize指定字段不序列化

public class A {
      @JSONField(serialize=false)
      public Date date;
 }

 public class A {
      @JSONField(deserialize=false)
      public Date date;
 }

2.4使用ordinal指定字段的顺序

缺省Fastjson序列化一个java bean，是根据fieldName的字母序进行序列化的，你可以通过ordinal指定字段的顺序。这个特性需要1.1.42以上版本。

public static class VO {
    @JSONField(ordinal = 3)
    private int f0;

    @JSONField(ordinal = 2)
    private int f1;

    @JSONField(ordinal = 1)
    private int f2;
}

2.5使用serializeUsing制定属性的序列化类

通过@JSONType定制序列化

1.简介

和JSONField类似，但JSONType配置在类上，而不是field或者getter/setter方法上。
SerializeFilter是通过编程扩展的方式定制序列化。fastjson支持6种SerializeFilter，用于不同场景的定制序列化。

• PropertyPreFilter 根据PropertyName判断是否序列化
• PropertyFilter 根据PropertyName和PropertyValue来判断是否序列化
• NameFilter 修改Key，如果需要修改Key,process返回值则可
• ValueFilter 修改Value
• BeforeFilter 序列化时在最前添加内容
• AfterFilter 序列化时在最后添加内容

2.使用

2.1PropertyFilter 根据PropertyName和PropertyValue来判断是否序列化

public interface PropertyFilter extends SerializeFilter {
    boolean apply(Object object, String propertyName, Object propertyValue);
 }

可以通过扩展实现根据object或者属性名称或者属性值进行判断是否需要序列化。例如：

PropertyFilter filter = new PropertyFilter() {

    public boolean apply(Object source, String name, Object value) {
        if ("id".equals(name)) {
            int id = ((Integer) value).intValue();
            return id >= 100;
        }
        return false;
    }
};

JSON.toJSONString(obj, filter); // 序列化的时候传入filter

2.2PropertyPreFilter 根据PropertyName判断是否序列化

和PropertyFilter不同只根据object和name进行判断，在调用getter之前，这样避免了getter调用可能存在的异常。

public interface PropertyPreFilter extends SerializeFilter {
      boolean apply(JSONSerializer serializer, Object object, String name);
  }

2.3NameFilter 序列化时修改Key

如果需要修改Key,process返回值则可

public interface NameFilter extends SerializeFilter {
    String process(Object object, String propertyName, Object propertyValue);
}

fastjson内置一个PascalNameFilter，用于输出将首字符大写的Pascal风格。 例如：

import com.alibaba.fastjson.serializer.PascalNameFilter;

Object obj = ...;
String jsonStr = JSON.toJSONString(obj, new PascalNameFilter());

2.4ValueFilter 序列化时修改Value

public interface ValueFilter extends SerializeFilter {
  Object process(Object object, String propertyName, Object propertyValue);
}

2.5BeforeFilter 序列化时在最前添加内容

在序列化对象的所有属性之前执行某些操作,例如调用 writeKeyValue 添加内容

public abstract class BeforeFilter implements SerializeFilter {
   protected final void writeKeyValue(String key, Object value) { ... }
    // 需要实现的抽象方法，在实现中调用writeKeyValue添加内容
    public abstract void writeBefore(Object object);
}

2.6AfterFilter 序列化时在最后添加内容

在序列化对象的所有属性之后执行某些操作,例如调用 writeKeyValue 添加内容

 public abstract class AfterFilter implements SerializeFilter {
  protected final void writeKeyValue(String key, Object value) { ... }
    // 需要实现的抽象方法，在实现中调用writeKeyValue添加内容
    public abstract void writeAfter(Object object);
}

通过ParseProcess定制反序列化

1.简介

ParseProcess是编程扩展定制反序列化的接口。fastjson支持如下ParseProcess：

• ExtraProcessor 用于处理多余的字段
• ExtraTypeProvider 用于处理多余字段时提供类型信息

2.使用

使用ExtraProcessor 处理多余字段

public static class VO {
    private int id;
    private Map<String, Object> attributes = new HashMap<String, Object>();
    public int getId() { return id; }
    public void setId(int id) { this.id = id;}
    public Map<String, Object> getAttributes() { return attributes;}
}
    
ExtraProcessor processor = new ExtraProcessor() {
    public void processExtra(Object object, String key, Object value) {
        VO vo = (VO) object;
        vo.getAttributes().put(key, value);
    }
};
    
VO vo = JSON.parseObject("{\"id\":123,\"name\":\"abc\"}", VO.class, processor);
Assert.assertEquals(123, vo.getId());
Assert.assertEquals("abc", vo.getAttributes().get("name"));

使用ExtraTypeProvider 为多余的字段提供类型

public static class VO {
    private int id;
    private Map<String, Object> attributes = new HashMap<String, Object>();
    public int getId() { return id; }
    public void setId(int id) { this.id = id;}
    public Map<String, Object> getAttributes() { return attributes;}
}
    
class MyExtraProcessor implements ExtraProcessor, ExtraTypeProvider {
    public void processExtra(Object object, String key, Object value) {
        VO vo = (VO) object;
        vo.getAttributes().put(key, value);
    }
    
    public Type getExtraType(Object object, String key) {
        if ("value".equals(key)) {
            return int.class;
        }
        return null;
    }
};
ExtraProcessor processor = new MyExtraProcessor();
    
VO vo = JSON.parseObject("{\"id\":123,\"value\":\"123456\"}", VO.class, processor);
Assert.assertEquals(123, vo.getId());
Assert.assertEquals(123456, vo.getAttributes().get("value")); // value本应该是字符串类型的，通过getExtraType的处理变成Integer类型了。

---

本文为学习笔记来源整理自网络，如有侵犯留言联系。
以上内容如有争议、指正，留言给我~