菜单 搜索
首页 前端知识 FastJson 框架详解

FastJson 框架详解

2024-05-05 12:05:31 前端知识 前端哥 298 802 我要收藏

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方法上。

  1. String[] ignores() default {};: 指定需要忽略的字段列表。该属性是一个字符串数组，可以列出不需要被序列化和反序列化的字段名。

  2.  String[] includes() default {};: 指定需要包含的字段列表。与 ignores 属性相反，该属性是一个字符串数组，可以列出需要被序列化和反序列化的字段名。

  3. String typeKey() default "": 指定用于标识类型的字段名。如果 Fastjson 需要在序列化时包含类信息，则会使用该字段来指定类型。默认值为@type。

  4. String[] orders() default {}: 指定字段的顺序。该属性是一个字符串数组，可以按照指定的顺序对字段进行序列化。

  5. PropertyNamingStrategy: 指定字段命名策略。该属性接受一个类类型作为参数，用于指定字段命名的策略。

  6. 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，输出为0false
WriteNullBooleanAsFalseBoolean字段如果为null，输出为falsefalse
SkipTransientFieldtransient修饰的方法或字段在序列化时将会被忽略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    忽略非字段的 getterfalse
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

转载请注明出处或者链接地址：https://www.qianduange.cn//article/6982.html
标签
后端
上一篇：HTML基本结构及基本标签
评论
相关文章

前端哥

前端哥

发布的文章

flutter 使用FlutterJsonBeanFactory/FlutterJsonToDart工具遇到的问题

2024-05-09 11:05:04

JSONArray操作汇总,排序,筛选,分组

2024-05-09 11:05:04

String转Json的几种方式

2024-05-09 11:05:04

iOS ------ JSONModel源码

2024-05-09 11:05:02

MySql中使用JSON_TABLE 函数来实现json类型的数据查询

2024-05-09 11:05:02

可视化JSON数据工具推荐：JSON Viewer Pro和JSONGrid

2024-05-09 11:05:02

轻松掌握数据库中JSON数据提取：json_extract函数用法详解

2024-05-09 11:05:01

从 JSON 转 Java 实体的多种方法详解

2024-05-09 11:05:01

解决微信小程序报[ app.json 文件内容错误] app.json: app.json 未找到，未找到入口 app.json 文件,或者文件读取失败,请检查后重新编译

2024-05-09 11:05:58

java去除 json 中的 \n, \t, \r

2024-05-09 11:05:57

大家推荐的文章
1

轻松掌握数据库中JSON数据提取：json_extract函数用法详解

2024-05-09 11:05:011000
2

HTML5(六)——Canvas 高级操作

2024-05-09 10:05:191000
3

UE4.27支持HTML5

2024-05-07 13:05:261000
4

前端vue项目使用Decimal.js做加减乘除求余运算

2024-04-23 21:04:401000
5

js数组常用方法（19种）|你会的到底有多少呢？

2024-04-08 11:04:211000
6

【Echarts系列】—— 实现电池图、3D立体圆形柱状图

2024-03-03 11:03:011000
7

ECharts 饼状图颜色设置

2024-02-16 14:02:001000
8

echarts实现动态渲染多柱图

2024-02-12 14:02:341000
9

移动端css布局大全

2024-02-06 15:02:421000
10

使用HTML5和JS实现日期下拉框功能

2024-02-04 11:02:521000

rss订阅 百度xml 谷歌xml 搜狗xml soxml 神马搜索xml 网站地图

Copyright © 2018-2022 前端哥 陕ICP备2023000550号-1 前端哥

讲个笑话：程序员心理活动：看别人的代码，这都写得什么玩意儿，垃圾！！看自己一个月前的代码：这TM谁写得代码，垃圾！再一看，这代码怎么这么眼熟？我自己写得？仔细一看，卧槽！还TM的真是我自己写的！！

前端技术交流源码工具分享网站

会员中心 联系我 留言建议 回顶部
复制成功！