寸_铁

这个屌丝很懒，什么也没留下！

热门标签

FastJson 框架详解

作者：寸_铁 | 2024-07-26 00:46:19

踩

fastjson

1. Fastjson的官方地址

Fastjson：地址

Springboot 自带的json解析框架是jackson，如果要想使用fastjson的话，可以采用以下的两种方式：

方式一：用bean替代默认解析器（推荐）

注意的是：这里的bean并不是将原来的jackson给直接替换掉，而是springboot会采用我们设置的更高优先级的fastjson来解析。


@Configuration
public class WebConfig {
 
    @Bean
    public HttpMessageConverters fastJsonMessageConverters() {
        List<HttpMessageConverter<?>> converters = new ArrayList<>();
        //需要定义一个convert转换消息的对象;
        FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
        //添加fastJson的配置信息;
        FastJsonConfig fastJsonConfig = new FastJsonConfig();
        fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);
        //全局时间配置
        fastJsonConfig.setDateFormat("yyyy-MM-dd HH:mm:ss");    
        //在convert中添加配置信息.
        fastConverter.setFastJsonConfig(fastJsonConfig);
        converters.add(0, fastConverter);
        return new HttpMessageConverters(converters);
    }
}

方式二：实现WebMvcConfigurer


@Configuration
public class FastjsonCon implements WebMvcConfigurer {
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        FastJsonHttpMessageConverter fastJsonHttpMessageConverter = new FastJsonHttpMessageConverter();
        //自定义FastJson配置
        FastJsonConfig config = new FastJsonConfig();
        config.setSerializerFeatures(SerializerFeature.QuoteFieldNames,
                SerializerFeature.WriteEnumUsingToString,
                /*SerializerFeature.WriteMapNullValue,*/
                SerializerFeature.WriteDateUseDateFormat,
                SerializerFeature.DisableCircularReferenceDetect);
        fastJsonHttpMessageConverter.setFastJsonConfig(config);
        converters.add(fastJsonHttpMessageConverter);
    }
}

2. FastJson 的三个主要类和基本 Api

FastJson 主要的三个类：JSON、JSONArray、JSONObject。JSONObject和JSONArray继承自JSON。

可以发现，JSONObject代表json对象，JSONArray代表json对象数组，JSON代表JSONObject和JSONArray的转化。

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


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

序列化：

String jsonString = JSON.toJSONString(obj);

反序列化：

VO vo = JSON.parseObject("...", VO.class);

泛型反序列化：


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

2.1 JSON

JSON类中的方法主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。

1. toJSONString ()

toJSONString ()方法经过多次重载，但最终都是实现json对象转化为json字符串和javabean对象转化为json字符串。其中，有关键字transient修饰的toJSONString()用于json对象序列化过程中，希望某个"键：值"对数据不变的应用中。

2. parseObject()

JSON类之parseObject()方法，实现json字符串转换为json对象或javabean对象

2.2 JSONObject

public class JSONObject extends JSON implements Map<String, Object>, Cloneable, Serializable, InvocationHandler {

JSONObject 实现了Map接口，而json对象中的数据都是以键值对形式出现，因此JSONObject底层操作是由Map实现的。

JSONObject 类中主要都是get()方法，通过"键：值"对中的键来获取其对应的值，且方法的输入参数几乎皆为String类型，这是因为json对象中，"键：值"对的键都是String类型的。

1. getString(String key)


public String getString(String key) {
        Object value = this.get(key);
        return value == null ? null : value.toString();
}

getString(String key)方法，该方法输入参数为String key（键），输出为String ，用于获取json对象中的字符串型数据。例如通过该方法获取 “name”："bob"键值对中name这个键所对应的值bob。通过查看源码发现内部主要由Map接口中的get()方法实现。


public Object get(Object key) {
        Object val = this.map.get(key);
        if (val == null && (key instanceof Number || key instanceof Boolean || key instanceof Character)) {
            val = this.map.get(key.toString());
        }
 
        return val;
}

2. getInteger(String key)


 public Integer getInteger(String key) {
        Object value = this.map.get(key);
        if (value == null) {
            return null;
        } else if (value instanceof Integer) {
            return (Integer)value;
        } else if (value instanceof Number) {
            return ((Number)value).intValue();
        } else if (value instanceof String) {
            String str = (String)value;
            if (!str.isEmpty() && !"null".equalsIgnoreCase(str)) {
                return str.indexOf(46) != -1 ? (int)Double.parseDouble(str) : Integer.parseInt(str);
            } else {
                return null;
            }
        } else {
            throw new JSONException("Can not cast '" + value.getClass() + "' to Integer");
        }
    }

JSONObject中的getInteger(String key)该方法获取json对象中的整型数据，例如获取"age：20"键值对中age对应的整型数值20。

JSONObject中其它的get方法与上述两个方法极为相似，比较常用的有如下几个：


public <T> T getObject(String key, Type type, Feature... features)
 
public Long getLong(String key)
 
public Float getFloat(String key)
 
public Date getDate(String key)
 
public java.sql.Date getSqlDate(String key)

总结：JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。

2.3 JSONArray

JSONArray 其内部是由List接口中的方法来完成操作的。

JSONArray代表json对象数组，json数组对象中存储的是一个个json对象，所以类中的方法主要用于直接操作json对象。比如这其中的add()，remove()，containsAll()方法，对应于json对象的添加，删除与判断。其内部主要有List接口中的对应方法来实现。

add()：


public boolean add(Object item) {
        return this.list.add(item);
}

remove()：


public boolean remove(Object o) {
        return this.list.remove(o);
}

containsAll()：


public boolean containsAll(Collection c) {
        return this.list.containsAll(c);
}

listIterator():


public ListIterator listIterator() {
        return this.list.listIterator();
}

JSONArray里面也有一些get()方法，不过都不常用，最有用的应该是getJSONObject(int index)方法，该方法用于获取json对象数组中指定位置的JSONObject对象

简单测试：


public class TestFastJson {
 
    @Test
    public void testFastJson(){
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name","yao");
        jsonObject.put("age",12);
        System.out.println(jsonObject);
    }
 
    @Test
    public void testFastJsonStringToJsonObj(){
        User user1 = new User("张三","中国",26);
        String jsonString = JSON.toJSONString(user1);
        System.out.println("jsonString:" + jsonString);
 
        JSONObject jsonObject = JSON.parseObject(jsonString);
        System.out.println("jsonObject:" + jsonObject);
 
        User user = JSON.parseObject(jsonString, User.class);
        System.out.println("user:" + user);
 
        User user2 = new User("李四","中国",27);
        User user3 = new User("王五","中国",25);
        List<User> list = new ArrayList<>();
        list.add(user2);
        list.add(user3);
 
        String jsonString1 = JSON.toJSONString(list);
        System.out.println("jsonString1:" + jsonString1);
 
        List<Object> objects = JSON.parseArray(jsonString1, new Type[]{String.class, User.class});
        System.out.println("jsonArray:" + objects);
 
        List<User> list1 = JSON.parseArray(jsonString1, User.class);
        System.out.println("list1:" + list1);
 
    }
}
@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
class User {
    private String name;
    private String region;
    private Integer age;
}

运行结果：


jsonString:{"age":26,"name":"张三","region":"中国"}
jsonObject:{"name":"张三","region":"中国","age":26}
user:User(name=张三, region=中国, age=26)
jsonString1:[{"age":27,"name":"李四","region":"中国"},{"age":25,"name":"王五","region":"中国"}]
jsonArray:[{"age":27,"name":"李四","region":"中国"}, User(name=王五, region=中国, age=25)]
list1:[User(name=李四, region=中国, age=27), User(name=王五, region=中国, age=25)]

3. Fastjson 定制序列化

3.1 使用@JSONField配置


public @interface JSONField {
    // 配置序列化和反序列化的顺序，1.1.42版本之后才支持
    int ordinal() default 0;
 
     // 指定字段的名称
    String name() default "";
 
    // 指定字段的格式，对日期格式有用
    String format() default "";
 
    // 是否序列化
    boolean serialize() default true;
 
    // 是否反序列化
    boolean deserialize() default true;
 
    //使用serializeUsing制定属性的序列化类
    Class<?> serializeUsing() default Void.class;
 
    //使用deserializeUsing制定属性的反序列化类
    Class<?> deserializeUsing() default Void.class;
    
    //参与反序列化时候的别名
    String[] alternateNames() default {};
   
    //对象映射到父对象上。不进行子对象映射
    boolean unwrapped() default false;
 
    //当你有⼀个字段是json字符串的数据，你希望直接输出，而不是经过转义之后再输出
    boolean jsonDirect() default false;
}

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

配置在字段上


public class VO {
     @JSONField(name="ID")
     private int id;
 
     @JSONField(name="birthday",format="yyyy-MM-dd")
     public Date date;
}

配置在 Getter/Setter 上


public class VO {
    private int id;
 
    @JSONField(name="ID")
    public int getId() { return id;}
 
    @JSONField(name="ID")
    public void setId(int id) {this.id = id;}
}

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

使用format配置日期格式化


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

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


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

使用ordinal指定字段的顺序


public static class VO {
    @JSONField(ordinal = 3)
    private int f0;
 
    @JSONField(ordinal = 2)
    private int f1;
 
    @JSONField(ordinal = 1)
    private int f2;
}

使用unwrapped


public class JSONController {
    public static void main(String[] args) {
        QSM qsm = new QSM();
        qsm.setName("传闻中的陈芊芊");
        qsm.setCity("花垣城");
        QSM qsm2 = new QSM();
        qsm2.setName("传闻中的韩烁");
        qsm2.setCity("玄虎城");
 
        Nation nation1 = Nation.builder().name("中国").qsm(qsm).qsm2(qsm2).build();
        System.out.println(JSON.toJSONString(nation1));
    }
 
}
 
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
class Nation {
    private String name;
 
    @JSONField(unwrapped = true)
    private QSM qsm;
 
    @JSONField(unwrapped = false)
    private QSM qsm2;
}
 
@Data
class QSM {
    String name;
    String city;
}

{"name":"中国","city":"花垣城","name":"传闻中的陈芊芊","qsm2":{"city":"玄虎城","name":"传闻中的韩烁"}}

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


public static class Student{
    @JSONField(serializeUsing = ModelValueSerializer.class)
    public int value;
}
 
public static class ModelValueSerializer implements ObjectSerializer {
    @Override
    public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType,
                      int features) throws IOException {
        Integer value = (Integer) object;
        String text = id+ "号";
        serializer.write(text);
    }
}


Student student= new Student();
student.id= 100;
String json = JSON.toJSONString(student);
Assert.assertEquals("{\"value\":\"100号\"}", json);

3.2 使用@JSONType配置


@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface JSONType {
    boolean asm() default true;
 
    String[] orders() default {};
 
    String[] includes() default {};
 
    String[] ignores() default {};
 
    SerializerFeature[] serialzeFeatures() default {};
 
    Feature[] parseFeatures() default {};
 
    boolean alphabetic() default true;
 
    Class<?> mappingTo() default Void.class;
 
    Class<?> builder() default Void.class;
 
    String typeName() default "";
 
    String typeKey() default "";
 
    Class<?>[] seeAlso() default {};
 
    Class<?> serializer() default Void.class;
 
    Class<?> deserializer() default Void.class;
 
    boolean serializeEnumAsJavaBean() default false;
 
    PropertyNamingStrategy naming() default PropertyNamingStrategy.CamelCase;
 
    Class<? extends SerializeFilter>[] serialzeFilters() default {};
}

和JSONField类似，但JSONType配置在类上，而不是field或者getter/setter方法上。

String[] ignores() default {};: 指定需要忽略的字段列表。该属性是一个字符串数组，可以列出不需要被序列化和反序列化的字段名。
String[] includes() default {};: 指定需要包含的字段列表。与 ignores 属性相反，该属性是一个字符串数组，可以列出需要被序列化和反序列化的字段名。
String typeKey() default "": 指定用于标识类型的字段名。如果 Fastjson 需要在序列化时包含类信息，则会使用该字段来指定类型。默认值为@type。
String[] orders() default {}: 指定字段的顺序。该属性是一个字符串数组，可以按照指定的顺序对字段进行序列化。
PropertyNamingStrategy: 指定字段命名策略。该属性接受一个类类型作为参数，用于指定字段命名的策略。
SerializerFeature[] serialzeFeatures() default {}: 序列化配置数组。

4. SpringMVC 整合 Fastjson

这里简单介绍一下在SpringMVC 中如何整合Fastjson的，这里采用配置类的方式（xml配置的方式可以参考官方文档）

在 Spring 中集成 Fastjson · alibaba/fastjson Wiki · GitHub

1、引入 Maven 的依赖


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

2、Fastjson 自定义配置

如果使用 Spring MVC 来构建 Web 应用并对性能有较高的要求的话，可以使用 Fastjson 提供的FastJsonHttpMessageConverter来替换 Spring MVC 默认的 HttpMessageConverter 以提高 @RestController @ResponseBody @RequestBody 注解的 JSON序列化速度。下面是配置方式，非常简单。


@Configuration
public class WebMvcConfigurer extends WebMvcConfigurerAdapter {
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
        //自定义配置...
        //FastJsonConfig config = new FastJsonConfig();
        //config.set ...
        //converter.setFastJsonConfig(config);
        converters.add(0, converter);
    }
}

注：如果你使用的 Fastjson 版本小于1.2.36的话(强烈建议使用最新版本)，在与Spring MVC 4.X 版本集成时需使用 FastJsonHttpMessageConverter4。

注2：SpringBoot 2.0.1版本中加载WebMvcConfigurer的顺序发生了变动，故需使用converters.add(0, converter);指定FastJsonHttpMessageConverter在converters内的顺序，否则在SpringBoot 2.0.1及之后的版本中将优先使用Jackson处理。

3、Fastjson 常用配置说明

FastJsonConfig是用于配置FastJson序列化和反序列化的配置类。它可以设置各种序列化和反序列化的参数，包括日期格式、序列化特性、过滤器、自定义序列化器和反序列化器等。

3.1 序列化特性（SerializerFeature）

序列化特性用于控制JSON输出格式，例如禁用循环引用、输出空置字段、美化输出格式等。SerializerFeature是一个枚举类型

枚举值	含义	默认值
QuoteFieldNames	输出key时是否使用双引号	true
UseSingleQuotes	使用单引号而不是双引号	false
WriteMapNullValue	是否输出值为null的字段	false
WriteEnumUsingToString	Enum 输出使用 toString() 方法	false
UseISO8601DateFormat	Date使用ISO8601格式输出	false
WriteNullListAsEmpty	List字段如果为null，输出为[]	false
WriteNullStringAsEmpty	字符类型字段如果为null，输出为”“	false
WriteNullNumberAsZero	数值字段如果为null，输出为0	false
WriteNullBooleanAsFalse	Boolean字段如果为null，输出为false	false
SkipTransientField	transient修饰的方法或字段在序列化时将会被忽略	true
SortField	按字段名称排序后输出	false
以下不推荐：
WriteTabAsSpecial	把\t做转义输出	false
PrettyFormat	美化输出格式，使其更易读	false
WriteClassName	序列化时写入类型信息	false
DisableCircularReferenceDetect	禁用循环引用检测	false
WriteSlashAsSpecial	对斜杠'/'进行转义	false
BrowserCompatible	启用浏览器兼容模式	false
WriteDateUseDateFormat	Date 类型字段的格式化输出	false
DisableCheckSpecialChar	禁用特殊字符检查	false
NotWriteRootClassName	不写入根类名称	false
BeanToArray	序列化时将 Bean 对象转换成数组	false
NotWriteDefaultValue	不写默认值	false
WriteNonStringKeyAsString	将非字符串类型的 key 转换为字符串	false
IgnoreNonFieldGetter	忽略非字段的 getter	false
WriteEnumUsingName	Enum 输出使用枚举的名称	false
BrowserSecure	启用浏览器兼容模式	false

可以使用以下代码进行配置：


FastJsonConfig fastJsonConfig = new FastJsonConfig();
fastJsonConfig.setSerializerFeatures(
    SerializerFeature.PrettyFormat, 
    SerializerFeature.WriteMapNullValue,
    SerializerFeature.DisableCircularReferenceDetect,
    SerializerFeature.WriteDateUseDateFormat
);

3.2 日期格式（DateFormat）

FastJson默认使用ISO-8601格式输出日期，例如"2019-12-01T12:00:00.000Z"。我们可以通过设置DateFormat来指定输出格式，例如"yyyy-MM-dd HH:mm:ss"。


FastJsonConfig fastJsonConfig = new FastJsonConfig();
fastJsonConfig.setDateFormat("yyyy-MM-dd HH:mm:ss");

3.3 过滤器（SerializeFilter）

过滤器可以用于在序列化时进行字段过滤、属性重命名等操作。FastJson提供了多种过滤器，例如PropertyPreFilter、NameFilter、ValueFilter、BeforeFilter、AfterFilter等。

3.3.1 ValueFilter ：修改Value值——修改属性的值

ValueFilter 其中的 apply 方法，如果需要自定义序列化过程，可以自己实现 ValueFilter，重写里面的 process 方法，其中的三个参数：

1、Object object ：表示当前的对象，例如 User(name=赵六, region=中国, age=12)

2、String name ：表示当前属性名称，例如 s:age

3、Object value：表示当前属性的值，例如 o1:12


package com.alibaba.fastjson.serializer;
 
public interface ValueFilter extends SerializeFilter, com.alibaba.fastjson2.filter.ValueFilter {
    Object process(Object var1, String var2, Object var3);
 
    default Object apply(Object object, String name, Object value) {
        return this.process(object, name, value);
    }
}

测试代码：


    @Test
    public void testValueFilter(){
        User user = new User("赵六","中国",12);
 
        // FastJson 1
        ValueFilter valueFilter = new ValueFilter() {
            @Override
            public Object process(Object o, String s, Object o1) {
                System.out.println("o:" + o);
                System.out.println("s:" + s);
                System.out.println("o1:" + o1);
                if(s.equals("name")){
                    o1 = o1 + "用户";
                    return o1;
                }
                return o1;
            }
        };
 
        String jsonString = JSON.toJSONString(user, valueFilter);
        System.out.println(jsonString);
 
        User user1 = JSON.parseObject(jsonString, User.class);
        System.out.println(user1);
    }


o:User(name=赵六, region=中国, age=12)
s:age
o1:12
o:User(name=赵六, region=中国, age=12)
s:name
o1:赵六
o:User(name=赵六, region=中国, age=12)
s:region
o1:中国
{"age":12,"name":"赵六用户","region":"中国"}
User(name=赵六用户, region=中国, age=12)

3.3.2 NameFilter：修改属性的名称

NameFilter其中的 process 方法，如果需要自定义序列化过程，可以自己实现 NameFilter，重写里面的 process 方法，其中的三个参数同 ValueFilter 。


package com.alibaba.fastjson.serializer;
 
public interface NameFilter extends SerializeFilter, com.alibaba.fastjson2.filter.NameFilter {
    String process(Object var1, String var2, Object var3);
}

测试代码：


    @Test
    public void testNameFilter() {
        User user = new User("赵六","中国",12);
        NameFilter nameFilter = new NameFilter() {
            @Override
            public String process(Object o, String s, Object o1) {
                System.out.println("o:" + o);
                System.out.println("s:" + s);
                System.out.println("o1:" + o1);
                if(s.equals("name")){
                    return "xingming";
                }
                return s;
            }
        };
        String jsonString = JSON.toJSONString(user, nameFilter);
        System.out.println(jsonString);
    }


o:User(name=赵六, region=中国, age=12)
s:age
o1:12
o:User(name=赵六, region=中国, age=12)
s:name
o1:赵六
o:User(name=赵六, region=中国, age=12)
s:region
o1:中国
{"age":12,"xingming":"赵六","region":"中国"}
 
Process finished with exit code 0

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

BeforeFilter 抽象类中，当我们实例化一个BeforeFilter 对象的时候，需要重写里面的抽象方法 writeBefore，在此方法中可以配置自己在序列化前端进行的操作。


public abstract class BeforeFilter extends com.alibaba.fastjson2.filter.BeforeFilter implements SerializeFilter {
    public BeforeFilter() {
    }
}


public abstract class BeforeFilter implements Filter {
    private static final ThreadLocal<JSONWriter> serializerLocal = new ThreadLocal();
 
    public BeforeFilter() {
    }
 
    public void writeBefore(JSONWriter serializer, Object object) {
        JSONWriter last = (JSONWriter)serializerLocal.get();
        serializerLocal.set(serializer);
        this.writeBefore(object);
        serializerLocal.set(last);
    }
 
    protected final void writeKeyValue(String key, Object value) {
        JSONWriter serializer = (JSONWriter)serializerLocal.get();
        boolean ref = serializer.containsReference(value);
        serializer.writeName(key);
        serializer.writeColon();
        serializer.writeAny(value);
        if (!ref) {
            serializer.removeReference(value);
        }
 
    }
 
    public abstract void writeBefore(Object var1);
}

观察 BeforeFilter 的源码可以发现：writeBefore方法调用了重载的抽象方法writeBefore，也就是重写的那个方法，此外，在 BeforeFilter 还有一个 writeKeyValue 方法，可以在重写的writeBefore方法中调用此方法对 json 进行添加。


    @Test
    public void testBeforeFilter() {
        User user = new User("赵六","中国",12);
        BeforeFilter beforeFilter = new BeforeFilter() {
            @Override
            public void writeBefore(Object o) {
                System.out.println("序列化前是我，哈哈哈哈哈");
            }
        };
        String jsonString = JSON.toJSONString(user, beforeFilter);
        System.out.println(jsonString);
    }


序列化前是我，哈哈哈哈哈
{"age":12,"name":"赵六","region":"中国"}

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

AfterFilter抽象类中，当我们实例化一个AfterFilter对象的时候，需要重写里面的抽象方法 writeAfter，在此方法中可以配置自己在序列化末端进行的操作。


    @Test
    public void testAfterFilter() {
        User user = new User("赵六","中国",12);
        AfterFilter afterFilter = new AfterFilter() {
            @Override
            public void writeAfter(Object o) {
                System.out.println("我是序列化之后的输出！");
            }
        };
        String jsonString = JSON.toJSONString(user, afterFilter);
        System.out.println(jsonString);
    }


我是序列化之后的输出！
{"age":12,"name":"赵六","region":"中国"}

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

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


    @Test
    public void testPropertyFilter() {
        User user = new User("赵六","中国",12);
        PropertyFilter propertyFilter = new PropertyFilter() {
            @Override
            public boolean apply(Object o, String s, Object o1) {
                if("age".equals(s)){
                    return (int)o1 == 10;
                }
                return false;
            }
        };
        String jsonString = JSON.toJSONString(user, propertyFilter);
        System.out.println(jsonString);
    }

{}

3.3.6 PropertyPreFilter：根据PropertyName判断是否序列化

PropertyPreFilter（属性前置过滤器）是 Fastjson 提供的一种过滤器接口，用于在序列化时控制哪些属性需要被序列化。与 PropertyFilter相比，PropertyPreFilter允许在序列化开始之前预先过滤掉不需要序列化的属性，而不是在序列化过程中动态地进行过滤。

PropertyPreFilter接口定义了一个 apply 方法，该方法接收一个对象和对象的属性名，返回一个布尔值来指示是否需要序列化这个属性。如果返回 true，则表示需要序列化该属性，如果返回 false，则表示不需要序列化该属性。

使用 PropertyPreFilter可以实现更细粒度的属性过滤控制，尤其适用于一些复杂的序列化场景。


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.PropertyPreFilter;
import java.util.HashMap;
import java.util.Map;
 
public class Example {
    public static void main(String[] args) {
        Map<String, Object> data = new HashMap<>();
        data.put("name", "John");
        data.put("age", 30);
        data.put("gender", "male");
 
        PropertyPreFilter filter = (object, name, value) -> !"gender".equals(name);
 
        String jsonString = JSON.toJSONString(data, filter);
        System.out.println(jsonString);
    }
}

3.4 自定义序列化器和反序列化器

在 FastJson 中，你可以通过实现 SerializeFilter 和 ObjectSerializer 接口来自定义序列化过程，通过实现 ParserConfig 和 ObjectDeserializer 接口来自定义反序列化过程。

自定义序列化：


import com.alibaba.fastjson.serializer.JSONSerializer;
import com.alibaba.fastjson.serializer.ObjectSerializer;
import java.io.IOException;
import java.lang.reflect.Type;
 
public class CustomObjectSerializer implements ObjectSerializer {
 
    @Override
    public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException {
        // 在这里实现自定义的序列化逻辑
        // 这里只是一个简单示例，可以根据需求实现具体的逻辑
        serializer.out.writeString("CustomSerializedValue");
    }
}
 
 
 
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializeConfig;
 
public class Main {
    public static void main(String[] args) {
        SerializeConfig config = new SerializeConfig();
        config.put(MyClass.class, new CustomObjectSerializer());
 
        MyClass obj = new MyClass();
        System.out.println(JSON.toJSONString(obj, config));
    }
}

自定义反序列化：


import com.alibaba.fastjson.parser.DefaultJSONParser;
import com.alibaba.fastjson.parser.deserializer.ObjectDeserializer;
import java.lang.reflect.Type;
 
public class CustomObjectDeserializer implements ObjectDeserializer {
 
    @Override
    public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
        // 在这里实现自定义的反序列化逻辑
        // 这里只是一个简单示例，可以根据需求实现具体的逻辑
        return (T) new MyClass();
    }
 
    @Override
    public int getFastMatchToken() {
        return 0;
    }
}```
 
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
 
public class Main {
    public static void main(String[] args) {
        ParserConfig.getGlobalInstance().putDeserializer(MyClass.class, new CustomObjectDeserializer());
 
        String jsonString = "{\"field\":\"value\"}";
        MyClass obj = JSON.parseObject(jsonString, MyClass.class);
        System.out.println(obj);
    }
}

5. FastJson 2 较 FastJson1.0 的变更

5.1 Maven 依赖引入


<dependency>
    <groupId>com.alibaba.fastjson2</groupId> 
    <artifactId>fastjson2</artifactId>
    <version>2.0.27</version>
</dependency>

优化1：整体继承类的修改:

Fastjson1 的JSONObject 只是简单实现Map接口，是无序的map容器
Fastjson2 的JSONObject 实现了链结构的Map，是有序的Map容器
无论是JSONObject或者JSONArray都摆脱了JSON的类，而且JSON由抽象类——>接口

版本V1

//1.Fastjson 1 JSONObject类定义

public class JSONObject extends JSON implements Map<String,Object> ...{

}

//2.Fastjson 1 JSONArray类定义

public class JSONArray extends JSON implements List<Object>... {

}

版本V2

//1.Fastjson2 JSONObject类定义

public class JSONObject extends LinkedHashMap<String, Object> implements InvocationHandler{

}

//2.Fastjson2 JSONArray类定义

public class JSONArray extends ArrayList<Object> {

}

优化2：常见类型的优化

时间转化类由原来使用SimpleDateFormat转化为 JDK8 提供的java.time API，吸收了 joda-time的部分精华，功能更强大，性能也更好。同时，DateTimeFormatter 是线程安全的。

未完待续。。。。后续会更新fastjson2

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/寸_铁/article/detail/882722