FastJson 枚举自定义序列化成枚举属性值_fastjson2 枚举

FastJson 枚举自定义序列化成枚举属性值

前言

类中如果有使用枚举，fastjson序列化不做处理时就会被序列化成 枚举的名字，今天刚好遇到，记录一下使用自定义序列化，反序列化的方式使得 枚举序列化时使用枚举里的属性，而不是枚举的名称。

pom

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

代碼案例

（一）Person 枚举

/**
 * @author lvzb
 * @date 2022/11/22  15:40
 **/
public enum Person {
    BOY("男"), GIRL("女"), NEUTRAL("中性人");

    public final String name;

    Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

（二）PersonEnumSerializer自定义序列化器

/**
 * @author lvzb
 * @date 2022/11/22  15:41
 **/
public class PersonEnumSerializer implements ObjectSerializer {
    @Override
    public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException {
        // 强制把值转换为Gender
        Person person = (Person) object;
        // 序列化为自定义的name属性，输出就行
        serializer.out.writeString(person.getName());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

（三）PersonEnumDeserializer自定义反序列化器

/**
 * @author lvzb
 * @date 2022/11/22  15:41
 **/
public class PersonEnumDeserializer implements ObjectDeserializer {
    @Override
    public <T> T deserialze(DefaultJSONParser parser, Type type, Object o) {
        // 解析值为字符串
        String value = parser.parseObject(String.class);
        // 遍历所有的枚举实例
        for (Person person : Person.values()) {
            if (person.getName().equals(value)) {
                // 成功匹配，返回实例
                return (T) person;
            }
        }
        // 没有匹配到，可以抛出异常或者返回null
        return null;
    }

    @Override
    public int getFastMatchToken() {
        // 仅仅匹配字符串类型的值
        return JSONToken.LITERAL_STRING;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

（四）User类

/**
 * @author lvzb
 * @date 2022/11/22  15:40
 **/
@Builder
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer id;

    // 标识注解，指定枚举的序列化。反序列化实现类
    @JSONField(serializeUsing = PersonEnumSerializer.class, deserializeUsing = PersonEnumDeserializer.class)
    private Person person;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

（五）测试类

import org.junit.jupiter.api.Test;

/**
 * @author lvzb
 * @date 2022/11/22  15:42
 **/
public class Test1 {
    @Test
    void test() {
        // 直接序列化枚举，输出的是 "NEUTRAL"
        System.out.println(JSON.toJSONString(Person.NEUTRAL));

        // 序列化为JSON输出，枚举值为 getName()
        User user = new User(2, Person.NEUTRAL);
        String jsonString = JSON.toJSONString(user);
        // {"id":2,"person":"中性人"}
        System.out.println(jsonString);

        // 反序列化为对象
        user = JSON.parseObject(jsonString, User.class);
        // 输出 NEUTRAL
        System.out.println(user.getPerson());
        System.out.println(user.getPerson() == Person.NEUTRAL);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

执行后打印如下内容：

"NEUTRAL"
{"id":2,"person":"中性人"}
NEUTRAL
true

Process finished with exit code 0
1
2
3
4
5
6