Jackson注解使用分析

编程语言 2023-07-25 21:05:58 阅读次数: 0

文章目录

Jackson常用注解

1. 常用注解汇总

注解 作用范围 主要属性 描述
JsonProperty 字段、方法 value：指定json字段名
access：指定权限
required：
index：
defaultValue：		 指定序列化、反序列化字段Json字段名
JsonPropertyOrder 类 value：字段顺序数组，未配字段排在后面 指定序列化时字段排序
JsonIgnore 字段、get与set方法 value：默认为true，为false不忽略 指定序列化、反序列化忽略字段
JsonIgnoreType 类 value：默认为true，为false不忽略 指定序列化、反序列化忽略类型（当该类作为别的类的属性时，忽略该类的所有字段）
JsonIgnoreProperties 类 value: 数组，指定要忽略的字段
ignoreUnknown：默认false，忽略不知道字段
allowGetters： 默认false，允许从get方法获取值
allowSetters：默认false，允许set方法设置值		 指定序列化、反序列化忽略字段集合
JsonGetter getter方法 value：指定json字段名 指定序列化时的Json字段名，用于get方法上，优先级高于@JsonProperty
JsonSetter setter方法 value：指定json字段名 指定反序列化时的Json字段名，用于set方法上，优先级高于@JsonProperty
JsonInclude 类、字段、方法 value：序列化规则 指定序列化规则
JsonRootName 类 value：根节点名称 指定序列化、反序列化的根节点名称
JsonFormat 字段、方法、参数 pattern：时间格式
timezone：时区		 设置序列化时的时间格式化格式
JsonAnyGetter 方法 enabled：是否启用，默认true 作用于方法上，可以灵活地把类型为Map的属性作为标准属性序列化到JSON字符串中。方法返回值必须是Map。序列化时将Map中的key/value对展开到当前类的同一级
JsonAnySetter 方法、字段 enabled：是否启用，默认true 一般作用于方法上，方法的入参必须有key、value。反序列化时，Json中与类不匹配的属性将会调用指定JsonAnySetter注解的方法，传入属性和属性值
JsonNaming 类 value：属性命名策略 指定序列化、反序列化的属性命名策略。
JsonCreator 构造方法 mode：指定模式 指定反序列化使用的构造方法，需和JsonProperty注解配合使用，如：
@JsonCreator
public User(@JsonProperty(“id”)String id) {…}
JsonAutoDetect 类 指定字段、方法的可见性
JsonUnwrapped 字段、方法、参数 enabled：是否开启，默认true
prefix：属性名称前缀
suffix：属性名称后缀		 将其属性上拉移一个层级展开
JacksonInject 字段、方法、参数 value：字段标识
userInput：Json属性值是否覆盖默认值，默认TRUE		 指定反序列化时，Json字段值是否覆盖实体类属性默认值
JsonAlias 字段、方法、参数 value：别名集合 反序列化时，指定能匹配实体类属性的多个Json字段名称
JsonValue 字段、方法 value：是否启用 一个类只能用一个，当加上JsonValue注解时，序列化时只返回这一个字段的值，而不是这个类的所有属性键值对。
一个类最多只能有一个JsonValue注解，否则会抛出异常；但多个类中可同时有一个JsonValue注解，序列化正常
JsonMerge 字段、方法、参数 value：是否启用合并 反序列化时，将Json集合字段的元素与实体类对应属性默认元素合并
JsonRawValue 字段、方法 value：是否启用 序列化时，属性值原样输出，属性值不会含转义和加引号（也就是属性值会自动去转义和去多余的引号）
JsonEnumDefaultValue 字段 - 反序列化时，当枚举字段遇到未知的枚举值，使用JsonEnumDefaultValue注解指定的默认枚举值
需要注意：该注解需要开启DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE才生效
JsonFilter 类、字段、方法、参数 value：指定过滤器ID 序列化时，过滤掉不需要的属性
JsonSerialize 类、字段、方法、参数 using：非null时使用的序列化器
nullsUsing：null时使用的序列化器		 序列化时，指定字段序列化使用的序列化器
JsonDeserialize 类、字段、方法、参数 using：非null时使用的序列化器
nullsUsing：null时使用的序列化器		 反序列化时，指定字段反序列化使用的反序列化器
JacksonAnnotation 注解类 - Jackson注解的元注解，注解上使用JacksonAnnotation表示该注解时Jackson相关注解
JacksonAnnotationsInside 注解类 - Jackson注解的元注解，可以将其他注解封装成一个组合注解，通常用于Jackson自定义注解
JsonView
JsonAppend 类 attrs：序列化时要包括的一组虚拟属性
props：序列化时要包括的一组通用虚拟属性
prepend：虚拟属性附加在常规属性前面还是右面，默认false（后面）		 用于在序列化对象时向对象添加虚拟属性
JsonIdentityInfo 类、字段、方法、参数 property：对象标识的属性名
generator：对象标识的生成器		 用于处理对象的循环引用（序列化、反序列化），在第一次遇到时序列化为完整的对象，之后再遇到同一个对象，都以对象的标识符代替。能解决一对一、一对多、多对多的循环引用
JsonIdentityReference 类、字段、方法、参数 alwaysAsId：是否总是序列化为对象标识 可以强制序列化为对象标识，而不是将第一个实例序列化为完整的 POJO，第二次才序列化为对象标识。必须与@JsonIdentityInfo 一起使用
JsonBackReference 字段、方法 @JsonBackReference标注的属性在序列化（serialization，即将对象转换为json数据）时，会被忽略（即结果中的json数据不包含该属性的内容）。
在序列化时，@JsonBackReference的作用相当于@JsonIgnore
JsonManagedReference 字段、方法 如果有@JsonManagedReference，则会自动注入@JsonBackReference标注的属性
JsonPOJOBuilder 类 buildMethodName: 无参数方法的名称，用于在将JSON字段绑定到bean的属性之后实例化预期的bean。默认名称为“build”
withPrefix: 用于自动检测JSON和bean属性之间的匹配的名称前缀。默认前缀是 with		 用于配置构建器类，以自定义JSON文档的反序列化，以便在命名约定与默认约定不同的情况下恢复POJO。

2. 注解使用分析

@JsonInclude

序列化规则：

  • JsonInclude.Include. ALWAYS：默认，全部序列化

  • JsonInclude.Include.NON_NULL：非null字段序列化

  • JsonInclude.Include.NON_EMPTY：非null、非空字符串、非空数组、非空引用Optional、非空引用AtomicReference的字段序列化

  • JsonInclude.Include.NON_DEFAULT：值有变动的字段序列化

    何为有变动的字段：

    • 默认值：调用实体的无参构造函数创建一个实例，调用属性对应的get方法，将其返回值作为属性的默认值
    • 值有变动：属性的值与默认值不相同时，视为值有变动

  • JsonInclude.Include.NON_ABSENT：

  • JsonInclude.Include.CUSTOM：

@JsonAnyGetter

@JsonAnyGetter注解 可以灵活地把类型为Map的属性作为标准属性序列化到JSON字符串中，有如下特点：

  • 方法为非静态方法，并且方法不带任何参数,方法名没有特殊约定（随意定义方法名称）
  • 方法返回值必须是Map类型
  • 在一个实体类中只能用在一个方法上
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;

    private Map<String, String> other;

    @JsonAnyGetter
    public Map<String, String> findOther() {
    
    
        return other;
    }

    public void addOther( String key,  String value) {
    
    
        if (other == null) {
    
    
            other = new HashMap<>();
        }
        other.put(key, value);
    }

    public String getId() {
    
    
        return id;
    }

    public User setId(String id) {
    
    
        this.id = id;
        return this;
    }

    public String getUserName() {
    
    
        return userName;
    }

    public User setUserName(String userName) {
    
    
        this.userName = userName;
        return this;
    }

    public String getPassWord() {
    
    
        return passWord;
    }

    public User setPassWord(String passWord) {
    
    
        this.passWord = passWord;
        return this;
    }
}

    private static void object2JsonStr() {
    
    
        User user = new User();
        user.setId("999");
        user.setUserName("小五");
        user.setPassWord("888888");
        user.addOther("email", "[email protected]");
        user.addOther("email1", "[email protected]");
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
        try {
    
    
            String jsonStr = objectMapper.writeValueAsString(user);
            System.out.println(jsonStr);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

输出

{
    
    
  "id" : "999",
  "userName" : "小五",
  "passWord" : "888888",
  "email1" : "[email protected]",
  "email" : "[email protected]"
}

@JsonAnySetter

public class User {
    
    
    private String id;
    private String userName;
    private String passWord;

    private Map<String, String> other;

    public Map<String, String> findOther() {
    
    
        return other;
    }

    @JsonAnySetter
    public void addOther( String key,  String value) {
    
    
        if (other == null) {
    
    
            other = new HashMap<>();
        }
        other.put(key, value);
    }

    public String getId() {
    
    
        return id;
    }

    public User setId(String id) {
    
    
        this.id = id;
        return this;
    }

    public String getUserName() {
    
    
        return userName;
    }

    public User setUserName(String userName) {
    
    
        this.userName = userName;
        return this;
    }

    public String getPassWord() {
    
    
        return passWord;
    }

    public User setPassWord(String passWord) {
    
    
        this.passWord = passWord;
        return this;
    }
}

    private static void jsonStr2Object() {
    
    
        String jsonStr = "{\"id\":\"999\",\"userName\":\"小五\",\"passWord\":\"888888\",\"email\":\"[email protected]\",\"nickName\":null,\"sex\":\"女\",\"createTime\":null}";
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE);
        try {
    
    
            User user = objectMapper.readValue(jsonStr, User.class);
            System.out.println(user);
        } catch (JsonProcessingException e) {
    
    
            e.printStackTrace();
        }
    }

user对象
在这里插入图片描述

@JsonNaming

PropertyNamingStrategy：属性命名策略，具体策略有：

策略名称 描述 举例
PropertyNamingStrategy 小驼峰（默认策略） userName
SnakeCaseStrategy 小写+下划线 user_name
UpperCamelCaseStrategy 大驼峰 UserName
LowerCaseStrategy 小写 username
KebabCaseStrategy 小写+连字符 user-name
LowerDotCaseStrategy 小写+点号 user.name

匹配的优先级：JsonProperty注解指定的字段名称优先级高于JsonNaming注解指定的属性命名策略对应的字段名称

@JsonAutoDetect

默认情况下，Jackson 只使用 public 的字段进行序列化和反序列化。没有 public 字段时，会使用 public 的 getters/setters。通过@JsonAutoDetect可以指定字段、方法的可见性规则。

注解的属性：

  • getterVisibility：get方法的可见性，默认JsonAutoDetect.Visibility.DEFAULT
  • isGetterVisibility：is方法的可见性，默认JsonAutoDetect.Visibility.DEFAULT
  • setterVisibility：set方法的可见性，默认JsonAutoDetect.Visibility.DEFAULT
  • creatorVisibility：构造方法（非无参构造方法）的可见性，默认JsonAutoDetect.Visibility.DEFAULT
  • fieldVisibility：字段的可见性，默认JsonAutoDetect.Visibility.DEFAULT

JsonAutoDetect.Visibility：可见性枚举类

  • ANY：都可见
  • NON_PRIVATE：除private修饰的，其它都可见
  • PROTECTED_AND_PUBLIC：protected和public修饰的可见，其它不可见
  • PUBLIC_ONLY：只有public修饰的可见，其它都不可见
  • NONE：都不可见
  • DEFAULT：

java可见性修饰符：public、protected、默认、private

@JacksonInject

useInput属性，值为OptBoolean枚举类型

  • OptBoolean.TRUE：属性值覆盖默认值。
  • OptBoolean.FALSE：属性值不覆盖默认值，相当于定死了这个字段的值为默认值。
  • OptBoolean.DEFAULT：默认值，等同于OptBoolean.TRUE。该值主要是为了向后兼容（2.8 和更早版本始终允许绑定输入值）。
@Data
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;
    private String email;
    @JacksonInject(value = "nickName")
    private String nickName;
    private Date createTime;
}

    private static void jsonStr2Object() {
    
    
        String jsonStr = "{\"id\":\"999\",\"userName\":\"小五\",\"passWord\":\"888888\",\"email\":null,\"createTime\":null}";
        ObjectMapper objectMapper = new ObjectMapper();
        InjectableValues.Std injectableValues = new InjectableValues.Std();
        injectableValues.addValue("nickName","小明");
        objectMapper.setInjectableValues(injectableValues);
        try {
    
    
            User user = objectMapper.readValue(jsonStr, User.class);
            System.out.println(user);
        } catch (JsonProcessingException e) {
    
    
            e.printStackTrace();
        }
    }
    // 输出：User(id=999, userName=小五, passWord=888888, email=null, nickName=小明, createTime=null)

    private static void jsonStr2Object() {
    
    
        String jsonStr = "{\"id\":\"999\",\"userName\":\"小五\",\"passWord\":\"888888\",\"email\":null,\"nickName\":null,\"createTime\":null}";
        ObjectMapper objectMapper = new ObjectMapper();
        InjectableValues.Std injectableValues = new InjectableValues.Std();
        injectableValues.addValue("nickName","小明");
        objectMapper.setInjectableValues(injectableValues);
        try {
    
    
            User user = objectMapper.readValue(jsonStr, User.class);
            System.out.println(user);
        } catch (JsonProcessingException e) {
    
    
            e.printStackTrace();
        }
    }
    // 输出：User(id=999, userName=小五, passWord=888888, email=null, nickName=null, createTime=null)

@JsonAlias

@Data
public class User {
    
    
    private String id;
    @JsonAlias({
    
    "userName1", "userName2" })
    private String userName;
    private String passWord;
    private String email;
    private String nickName;
    private Date createTime;
}

    private static void jsonStr2Object() {
    
    
        String jsonStr = "{\"id\":\"999\",\"userName\":\"小五\",\"passWord\":\"888888\",\"email\":null,\"nickName\":null,\"createTime\":null}";
        ObjectMapper objectMapper = new ObjectMapper();
        try {
    
    
            User user = objectMapper.readValue(jsonStr, User.class);
            System.out.println(user);
        } catch (JsonProcessingException e) {
    
    
            e.printStackTrace();
        }
    }
    // 输出：User(id=999, userName=小五, passWord=888888, email=null, nickName=null, createTime=null)

    private static void jsonStr2Object() {
    
    
        String jsonStr = "{\"id\":\"999\",\"userName1\":\"小五\",\"passWord\":\"888888\",\"email\":null,\"nickName\":null,\"createTime\":null}";
        ObjectMapper objectMapper = new ObjectMapper();
        try {
    
    
            User user = objectMapper.readValue(jsonStr, User.class);
            System.out.println(user);
        } catch (JsonProcessingException e) {
    
    
            e.printStackTrace();
        }
    }
    // 输出：User(id=999, userName=小五, passWord=888888, email=null, nickName=null, createTime=null)

    private static void jsonStr2Object() {
    
    
        String jsonStr = "{\"id\":\"999\",\"userName2\":\"小五\",\"passWord\":\"888888\",\"email\":null,\"nickName\":null,\"createTime\":null}";
        ObjectMapper objectMapper = new ObjectMapper();
        try {
    
    
            User user = objectMapper.readValue(jsonStr, User.class);
            System.out.println(user);
        } catch (JsonProcessingException e) {
    
    
            e.printStackTrace();
        }
    }
    // 输出：User(id=999, userName=小五, passWord=888888, email=null, nickName=null, createTime=null)

@JsonValue

JsonValue注解一般用在属性字段或者get方法上。当加上@JsonValue注解时，序列化时只返回这一个字段的值，而不是这个类的所有属性键值对。
需要注意：

  • 一个类最多只能有一个JsonValue注解，否则会抛出异常
  • 多个类中可同时有一个JsonValue注解，序列化正常
    private static void object2JsonStr() {
    
    
        User user = new User();
        user.setId("999");
        user.setUserName("小五");
        user.setPassWord("888888");
        user.setCardInfo(new CardInfo("1", "123445"));
        ObjectMapper objectMapper = new ObjectMapper();
        try {
    
    
            String jsonStr = objectMapper.writeValueAsString(user);
            System.out.println(jsonStr);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

例1：

@Data
public class User {
    
    
    private String id;
    private String userName;
    @JsonValue
    private String passWord;
    private String email;
    private String nickName;
    private Date createTime;
    private CardInfo cardInfo;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class CardInfo {
    
    

    private String cardType;
    private String cardNum;
}

输出

"888888"

例2：

@Data
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;
    private String email;
    private String nickName;
    private Date createTime;
    private CardInfo cardInfo;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class CardInfo {
    
    

    @JsonValue
    private String cardType;
    private String cardNum;
}

输出

{
    
    "id":"999","userName":"小五","passWord":"888888","email":null,"nickName":null,"createTime":null,"cardInfo":"1"}

例3：

@Data
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;
    private String email;
    private String nickName;
    private Date createTime;
    private CardInfo cardInfo;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class CardInfo {
    
    

    @JsonValue
    private String cardType;
    @JsonValue
    private String cardNum;
}

输出

com.fasterxml.jackson.databind.JsonMappingException: Problem with definition of [AnnotedClass com.joker.test.json.CardInfo]: Multiple 'as-value' properties defined ([field com.joker.test.json.CardInfo#cardType] vs [field com.joker.test.json.CardInfo#cardNum]) (through reference chain: com.joker.test.json.User["cardInfo"])
	at com.fasterxml.jackson.databind.JsonMappingException.from(JsonMappingException.java:292)
	at com.fasterxml.jackson.databind.SerializerProvider.reportMappingProblem(SerializerProvider.java:1223)
	at com.fasterxml.jackson.databind.SerializerProvider._createAndCacheUntypedSerializer(SerializerProvider.java:1341)
	at com.fasterxml.jackson.databind.SerializerProvider.findPrimaryPropertySerializer(SerializerProvider.java:668)
	at com.fasterxml.jackson.databind.ser.impl.PropertySerializerMap.findAndAddPrimarySerializer(PropertySerializerMap.java:64)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter._findAndAddDynamic(BeanPropertyWriter.java:897)
	at com.fasterxml.jackson.databind.ser.BeanPropertyWriter.serializeAsField(BeanPropertyWriter.java:705)
	at com.fasterxml.jackson.databind.ser.std.BeanSerializerBase.serializeFields(BeanSerializerBase.java:722)
	at com.fasterxml.jackson.databind.ser.BeanSerializer.serialize(BeanSerializer.java:166)
	at com.fasterxml.jackson.databind.ser.DefaultSerializerProvider._serialize(DefaultSerializerProvider.java:480)
	at com.fasterxml.jackson.databind.ser.DefaultSerializerProvider.serializeValue(DefaultSerializerProvider.java:319)
	at com.fasterxml.jackson.databind.ObjectMapper._configAndWriteValue(ObjectMapper.java:4094)
	at com.fasterxml.jackson.databind.ObjectMapper.writeValueAsString(ObjectMapper.java:3404)
	at com.joker.test.json.JacksonTest.object2JsonStr(JacksonTest.java:152)
	at com.joker.test.json.JacksonTest.main(JacksonTest.java:267)

一个类出现多个JsonValue注解，序列化会抛出异常。

例4：

@Data
public class User {
    
    

    private String id;
    private String userName;
    @JsonValue
    private String passWord;
    private String email;
    private String nickName;
    private Date createTime;
    private CardInfo cardInfo;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class CardInfo {
    
    

    @JsonValue
    private String cardType;
    private String cardNum;
}

输出

"888888"

多个类中同时有一个JsonValue注解，序列化正常。

@JsonMerge

反序列化时，将Json集合字段的元素与实体类对应属性默认元素合并。

@Data
public class User {
    
    

    private String id;
    private String userName;
    private String passWord;
    private String email;
    private String nickName;
    private Date createTime;
    private CardInfo cardInfo;
    @JsonMerge
    private List<String> list = new ArrayList<>(Collections.singletonList("篮球"));
}

    private static void jsonStr2Object() {
    
    
        String jsonStr = "{\"id\":\"999\",\"userName\":\"小五\",\"passWord\":\"888888\",\"email\":null,\"nickName\":null,\"createTime\":null,\"cardInfo\":{\"cardType\":\"1\",\"cardNum\":\"123445\"},\"list\":[\"排球\",\"足球\",\"乒乓球\"]}";
        ObjectMapper objectMapper = new ObjectMapper();
        try {
    
    
            User user = objectMapper.readValue(jsonStr, User.class);
            System.out.println(user);
        } catch (JsonProcessingException e) {
    
    
            e.printStackTrace();
        }
    }

输出

User(id=999, userName=小五, passWord=888888, email=null, nickName=null, createTime=null, cardInfo=CardInfo(cardType=1, cardNum=123445), list=[篮球, 排球, 足球, 乒乓球])

list集合将默认元素"篮球"和Json串中list字段的元素"排球","足球","乒乓球"进行了合并。

@JsonRawValue

序列化时，属性值原样输出，属性值不会含转义和加引号（也就是属性值会自动去转义和去多余的引号）

@Data
public class User {
    
    

    private String id;
    private String userName;
    private String passWord;
    @JsonRawValue
    private String email;
    private String nickName;
    private Date createTime;
}

    private static void object2JsonStr() {
    
    
        User user = new User();
        user.setId("999");
        user.setUserName("小五");
        user.setPassWord("888888");
        user.setEmail("[email protected]\\");
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
        try {
    
    
            String jsonStr = objectMapper.writeValueAsString(user);
            System.out.println(jsonStr);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

输出

{
    
    
  "id" : "999",
  "userName" : "小五",
  "passWord" : "888888",
  "email" : 111111@qq.com\,
  "nickName" : null,
  "createTime" : null,
  "cardInfo" : {
    
    
    "cardType" : "1",
    "cardNum" : "123445"
  }
}

@JsonEnumDefaultValue

@Data
public class User {
    
    

    private String id;
    private String userName;
    private String passWord;
    private String email;
    private String nickName;
    private Date createTime;
    private SexEnum sex;
}
enum SexEnum {
    
    
    @JsonEnumDefaultValue
    MAN,
    WOMAN
}

    private static void jsonStr2Object() {
    
    
        String jsonStr = "{\"id\":\"999\",\"userName\":\"小五\",\"passWord\":\"888888\",\"email\":null,\"nickName\":null,\"createTime\":null,\"sex\":\"男\"}";
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE);
        try {
    
    
            User user = objectMapper.readValue(jsonStr, User.class);
            System.out.println(user);
        } catch (JsonProcessingException e) {
    
    
            e.printStackTrace();
        }
    }

输出

User(id=999, userName=小五, passWord=888888, email=null, nickName=null, createTime=null, sex=MAN)

@JsonFilter

JsonFilter 注解的作用是通过属性名过滤要序列化的属性。

它指定一个过滤器的ID，通过ObjectMapper注册真正的过滤器，过滤器需要实现接口 com.fasterxml.jackson.databind.ser.PropertyFilter。一般使用SimpleBeanPropertyFilter过滤器。

SimpleBeanPropertyFilterde的主要方法：

  • serializeAllExcept：过滤掉指定字段，保留其它字段
  • filterOutAllExcept：保留指定的字段，过滤掉其它字段

1. 用于类上

@Data
@JsonFilter("userFilter")
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;
    private String email;
    private String nickName;
    private Date createTime;
    private CardInfo cardInfo;
}

    private static void objectFiilter2JsonStr() {
    
    
        User user = new User();
        user.setId("999");
        user.setUserName("小五");
        user.setPassWord("888888");
        user.setEmail("[email protected]");
        user.setCardInfo(new CardInfo("1", "500210190001017771"));

        SimpleFilterProvider filterProvider = new SimpleFilterProvider();
        // filterProvider.addFilter("userFilter",SimpleBeanPropertyFilter.filterOutAllExcept("passWord"));// 保留指定的字段，过滤掉其它字段
        filterProvider.addFilter("userFilter",SimpleBeanPropertyFilter.serializeAllExcept ("passWord"));// 过滤掉指定字段，保留其它字段

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
        objectMapper.setFilterProvider(filterProvider);

        try {
    
    
            String jsonStr = objectMapper.writeValueAsString(user);
            System.out.println(jsonStr);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

输出:

{
    
    
  "id" : "999",
  "userName" : "小五",
  "email" : "[email protected]",
  "nickName" : null,
  "createTime" : null,
  "cardInfo" : {
    
    
    "cardType" : "1",
    "cardNum" : "500210190001017771"
  }
}

过滤掉了
2. 用于字段上

@Data
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;
    private String email;
    private String nickName;
    private Date createTime;
    @JsonFilter("userFilter")
    private CardInfo cardInfo;
}

@Data
class CardInfo {
    
    

    // @JsonValue
    private String cardType;
    private String cardNum;

    public CardInfo() {
    
    
    }

    public CardInfo(String cardType, String cardNum) {
    
    
        this.cardType = cardType;
        this.cardNum = cardNum;
    }
}

    private static void objectFiilter2JsonStr() {
    
    
        User user = new User();
        user.setId("999");
        user.setUserName("小五");
        user.setPassWord("888888");
        user.setEmail("[email protected]");
        user.setCardInfo(new CardInfo("1", "500210190001017771"));

        SimpleFilterProvider filterProvider = new SimpleFilterProvider();
        filterProvider.addFilter("userFilter",SimpleBeanPropertyFilter.serializeAllExcept ("cardNum"));// 过滤掉指定字段，保留其它字段

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
        objectMapper.setFilterProvider(filterProvider);

        try {
    
    
            String jsonStr = objectMapper.writeValueAsString(user);
            System.out.println(jsonStr);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

输出：

{
    
    
  "id" : "999",
  "userName" : "小五",
  "passWord" : "888888",
  "email" : "[email protected]",
  "nickName" : null,
  "createTime" : null,
  "cardInfo" : {
    
    
    "cardType" : "1"
  }
}

@JsonSerialize

序列化时，指定字段序列化使用的序列化器。

JsonSerialize注解的部分属性：

  • using：指定非null值时使用的序列化器
  • nullsUsing：指定null值时使用的序列化器

若要自定义序列化器，一般通过继承StdSerializer或者JsonSerializer实现。

@Data
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;
    private String email;
    @JsonSerialize(using = SexEnumSerializer.class)
    private SexEnum sex;
    private String nickName;
    private Date createTime;
}

enum SexEnum {
    
    
    MAN("男"),
    WOMAN("女");

    private String value;

    SexEnum(String value) {
    
    
        this.value = value;
    }

    public String getValue() {
    
    
        return value;
    }

    public SexEnum setValue(String value) {
    
    
        this.value = value;
        return this;
    }

    public static SexEnum getByValue(String value) {
    
    
        for (SexEnum sexEnum : SexEnum.values()) {
    
    
            if (sexEnum.getValue().equals(value)) {
    
    
                return sexEnum;
            }
        }
        return null;
    }
}

// 方式1：继承StdSerializer
public class SexEnumSerializer extends StdSerializer<SexEnum> {
    
    

    public SexEnumSerializer() {
    
    
        this(null);
    }

    public SexEnumSerializer(Class<SexEnum> t) {
    
    
        super(t);
    }

    @Override
    public void serialize(SexEnum value, JsonGenerator gen, SerializerProvider provider) throws IOException {
    
    
        gen.writeString(value.getValue());
    }
}

// 方式2：继承JsonSerializer
public class SexEnumSerializer extends JsonSerializer<SexEnum> {
    
    

    @Override
    public void serialize(SexEnum value, JsonGenerator gen, SerializerProvider provider) throws IOException {
    
    
        gen.writeString(value.getValue());
    }
}

    private static void object2JsonStr() {
    
    
        User user = new User();
        user.setId("999");
        user.setUserName("小五");
        user.setPassWord("888888");
        user.setEmail("[email protected]");
        user.setSex(SexEnum.MAN);
        user.setCreateTime(new Date());
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
        try {
    
    
            String jsonStr = objectMapper.writeValueAsString(user);
            System.out.println(jsonStr);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

输出

{
    
    
  "id" : "999",
  "userName" : "小五",
  "passWord" : "888888",
  "email" : "[email protected]",
  "sex" : "男",
  "nickName" : null,
  "createTime" : 1673157947671
}

@JsonDeserialize

反序列化时，指定字段反序列化使用的反序列化器。

JsonDeserialize注解的部分属性：

  • using：指定非null值时使用的反序列化器
  • nullsUsing：指定null值时使用的反序列化器

若要自定义反序列化器，一般通过继承StdDeserializer或者JsonDeserializer实现。

@Data
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;
    private String email;
    @JsonDeserialize(using = SexEnumDeserializer.class)
    private SexEnum sex;
    private String nickName;
    private Date createTime;
}

enum SexEnum {
    
    
    @JsonEnumDefaultValue
    MAN("男"),
    WOMAN("女");

    private String value;

    SexEnum(String value) {
    
    
        this.value = value;
    }

    public String getValue() {
    
    
        return value;
    }

    public SexEnum setValue(String value) {
    
    
        this.value = value;
        return this;
    }

    public static SexEnum getByValue(String value) {
    
    
        for (SexEnum sexEnum : SexEnum.values()) {
    
    
            if (sexEnum.getValue().equals(value)) {
    
    
                return sexEnum;
            }
        }
        return null;
    }
}

// 方式1：继承StdDeserializer
public class SexEnumDeserializer extends StdDeserializer<SexEnum> {
    
    

    public SexEnumDeserializer() {
    
    
        this(null);
    }

    public SexEnumDeserializer(Class<String> t) {
    
    
        super(t);
    }

    @Override
    public SexEnum deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    
    
        String value = p.getText();
        return SexEnum.getByValue(value);
    }
}

// 方式2：继承StdDeserializer
public class SexEnumDeserializer extends JsonDeserializer<SexEnum> {
    
    

    @Override
    public SexEnum deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    
    
        String value = p.getText();
        return SexEnum.getByValue(value);
    }
}

    private static void jsonStr2Object() {
    
    
        String jsonStr = "{\"id\":\"999\",\"userName\":\"小五\",\"passWord\":\"888888\",\"email\":\"[email protected]\",\"nickName\":null,\"sex\":\"女\",\"createTime\":null}";
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE);
        try {
    
    
            User user = objectMapper.readValue(jsonStr, User.class);
            System.out.println(user);
        } catch (JsonProcessingException e) {
    
    
            e.printStackTrace();
        }
    }

输出

User(id=999, userName=小五, passWord=888888, email=111111@qq.com, sex=WOMAN, nickName=null, createTime=null)

@JacksonAnnotation

注解上使用JacksonAnnotation表示该注解时Jackson相关注解。

所有的Jsonson注解类上都有JacksonAnnotation元注解。

@JacksonAnnotationsInside

Jackson注解的元注解，可以将其他注解封装成一个组合注解，通常用于Jackson自定义组合注解。

@Data
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;
    private String email;
    @JsonSerialize(using = SexEnumSerializer.class)
    @JsonDeserialize(using = SexEnumDeserializer.class)
    private SexEnum sex;
    private String nickName;
    private Date createTime;
}

enum SexEnum {
    
    
    MAN("男"),
    WOMAN("女");

    private String value;

    SexEnum(String value) {
    
    
        this.value = value;
    }

    public String getValue() {
    
    
        return value;
    }

    public SexEnum setValue(String value) {
    
    
        this.value = value;
        return this;
    }

    public static SexEnum getByValue(String value) {
    
    
        for (SexEnum sexEnum : SexEnum.values()) {
    
    
            if (sexEnum.getValue().equals(value)) {
    
    
                return sexEnum;
            }
        }
        return null;
    }
}

通过@JacksonAnnotationsInside自定义注解可改为

@Target({
    
    ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@JsonSerialize(using = SexEnumSerializer.class)
@JsonDeserialize(using = SexEnumDeserializer.class)
@JacksonAnnotationsInside
public @interface JsonSexSerializeDeserialize {
    
    

}

@Data
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;
    private String email;
    @JsonSexSerializeDeserialize
    private SexEnum sex;
    private String nickName;
    private Date createTime;
}

enum SexEnum {
    
    
    MAN("男"),
    WOMAN("女");

    private String value;

    SexEnum(String value) {
    
    
        this.value = value;
    }

    public String getValue() {
    
    
        return value;
    }

    public SexEnum setValue(String value) {
    
    
        this.value = value;
        return this;
    }

    public static SexEnum getByValue(String value) {
    
    
        for (SexEnum sexEnum : SexEnum.values()) {
    
    
            if (sexEnum.getValue().equals(value)) {
    
    
                return sexEnum;
            }
        }
        return null;
    }
}

@JsonAppend

@JsonAppend注解用于在序列化对象时向对象添加虚拟属性。

当我们希望直接向序列化后JSON字符串中添加补充信息而不是更改类定义时，可以使用@JsonAppend。
注解的主要属性：

  • attrs：序列化时要包括的一组虚拟属性
  • props：序列化时要包括的一组通用虚拟属性
  • prepend：虚拟属性附加在常规属性前面还是右面，默认false（后面）

例1：使用attrs属性

@Data
@JsonAppend(attrs = {
    
    @JsonAppend.Attr(value = "age"),@JsonAppend.Attr(value = "sex")})
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;
    private String email;
    private String nickName;
    private Date createTime;
}

    private static void object2JsonStr() {
    
    
        User user = new User();
        user.setId("999");
        user.setUserName("小五");
        user.setPassWord("888888");
        user.setEmail("[email protected]");
        user.setCreateTime(new Date());
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
        try {
    
    
            String jsonStr = objectMapper.writerFor(User.class).withAttribute("age", "20").withAttribute("sex", "男").writeValueAsString(user);
            System.out.println(jsonStr);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

输出

{
    
    
  "id" : "999",
  "userName" : "小五",
  "passWord" : "888888",
  "email" : "[email protected]",
  "nickName" : null,
  "createTime" : 1675151635581,
  "age" : "20",
  "sex" : "男"
}

例2：使用props属性

@Data
@JsonAppend(props = {
    
    @JsonAppend.Prop(value =TestWriter.class ,type = String.class,name = "idcard")}, prepend = true)
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;
    private String email;
    private String nickName;
    private Date createTime;
}

@NoArgsConstructor
class TestWriter extends VirtualBeanPropertyWriter {
    
    


    private TestWriter(BeanPropertyDefinition propDef, Annotations contextAnnotations, JavaType declaredType) {
    
    
        super(propDef, contextAnnotations, declaredType);
    }


    @Override
    protected Object value(Object bean, JsonGenerator gen, SerializerProvider prov) throws Exception {
    
    
        return "5002001564564565";
    }

    @Override
    public VirtualBeanPropertyWriter withConfig(MapperConfig<?> config, AnnotatedClass declaringClass, BeanPropertyDefinition propDef, JavaType type) {
    
    
        return new TestWriter(propDef, declaringClass.getAnnotations(), type);
    }
}

    private static void object2JsonStr() {
    
    
        User user = new User();
        user.setId("999");
        user.setUserName("小五");
        user.setPassWord("888888");
        user.setEmail("[email protected]");
        user.setCreateTime(new Date());
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
        try {
    
    
            String jsonStr = objectMapper.writeValueAsString(user);
            System.out.println(jsonStr);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

输出

{
    
    
  "idcard" : "5002001564564565",
  "id" : "999",
  "userName" : "小五",
  "passWord" : "888888",
  "email" : "[email protected]",
  "nickName" : null,
  "createTime" : 1675151702894
}

@JsonIdentityInfo

@JsonIdentityInfo用于处理对象的循环引用，方法是只在第一次遇到时序列化为完整的对象，之后再遇到同一个对象，都以对象的标识符代替。

生成对象标识符有两种方法:

  • 使用生成器(标准生成器或自定义生成器之一)
  • 直接使用属性的值（通过使用占位符生成器标记ObjectIdGenerators.PropertyGenerator）

对象标识目前不支持JSON数组类型(Java数组或列表)或Java Map类型。

注解的主要属性：

  • property：对象标识的属性名
  • generator：对象标识的生成器
@Data
@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;
    private String email;
    private String nickName;
    private Date createTime;
    private User user;
}

1. 循环引用

    private static void object2JsonStr() {
    
    
        User user = new User();
        user.setId("999");
        user.setUserName("小五");
        user.setPassWord("888888");
        user.setEmail("[email protected]");
        user.setCreateTime(new Date());
        user.setUser(user);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
        try {
    
    
            String jsonStr = objectMapper.writeValueAsString(user);
            System.out.println(jsonStr);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

输出

{
    
    
  "id" : "999",
  "userName" : "小五",
  "passWord" : "888888",
  "email" : "[email protected]",
  "nickName" : null,
  "createTime" : 1675156428169,
  "user" : "999"
}

2. 非循环引用

    private static void object2JsonStr() {
    
    
        User user = new User();
        user.setId("999");
        user.setUserName("小五");
        user.setPassWord("888888");
        user.setEmail("[email protected]");
        user.setCreateTime(new Date());
        User user1 = new User();
        user1.setId("888");
        user1.setUserName("小六");
        user.setUser(user1);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
        try {
    
    
            String jsonStr = objectMapper.writeValueAsString(user);
            System.out.println(jsonStr);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

输出

{
    
    
  "id" : "999",
  "userName" : "小五",
  "passWord" : "888888",
  "email" : "[email protected]",
  "nickName" : null,
  "createTime" : 1675156549005,
  "user" : {
    
    
    "id" : "888",
    "userName" : "小六",
    "passWord" : null,
    "email" : null,
    "nickName" : null,
    "createTime" : null,
    "user" : null
  }
}

@JsonIdentityReference

@JsonIdentityReference 必须与 @JsonIdentityInfo 一起使用。

@JsonIdentityInfo在第二次遇到时才序列化为对象标识，@JsonIdentityReference可以强制序列化为对象标识，而不是将第一个实例序列化为完整的POJO。

注解的主要属性：

  • alwaysAsId：是否总是序列化为对象标识，默认false。当为true时，在第一次时就会序列化为对象标识，而不是等到第二次cai序列化为对象标识（@JsonIdentityInfo的规则）

注意事项：

  • 使用@JsonIdentityInfo标识遇到循环引用时，将第一个实例序列化为完整的POJO，第二次才序列化为对象标识。
  • 如果加上了@JsonIdentityReference，表示第一次就直接序列化为对象标识（无论是否是循环引用）
@Data
@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")
@JsonIdentityReference(alwaysAsId = true)
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;
    private String email;
    private String nickName;
    private Date createTime;
    private User user;
}

1. 循环引用

    private static void object2JsonStr() {
    
    
        User user = new User();
        user.setId("999");
        user.setUserName("小五");
        user.setPassWord("888888");
        user.setEmail("[email protected]");
        user.setCreateTime(new Date());
        user.setUser(user);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
        try {
    
    
            String jsonStr = objectMapper.writeValueAsString(user);
            System.out.println(jsonStr);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

输出

"999"

2. 非循环引用

    private static void object2JsonStr() {
    
    
        User user = new User();
        user.setId("999");
        user.setUserName("小五");
        user.setPassWord("888888");
        user.setEmail("[email protected]");
        user.setCreateTime(new Date());
        User user1 = new User();
        user1.setId("888");
        user1.setUserName("小六");
        user.setUser(user1);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
        try {
    
    
            String jsonStr = objectMapper.writeValueAsString(user);
            System.out.println(jsonStr);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

输出

"999"

@JsonBackReference

与下面@JsonManagedReference一起分析

@JsonManagedReference

Jackson中的@JsonBackReference和@JsonManagedReference，以及@JsonIgnore均是为了解决对象中存在双向引用导致的无限递归问题。这些标注均可用在属性或对应的get、set方法中。

@JsonBackReference和@JsonManagedReference两个标注通常配对使用，通常用在父子关系中。

@JsonIgnore、@JsonBackReference、@JsonManagedReference对比：

  • @JsonIgnore：直接忽略某个属性，以断开无限递归，序列化或反序列化均忽略。

    当然如果标注在get、set方法中，则可以分开控制，序列化对应的是get方法，反序列化对应的是set方法。

    在父子关系中，当反序列化时，@JsonIgnore不会自动注入被忽略的属性值（父或子），这是它跟@JsonBackReference和@JsonManagedReference最大的区别。

  • @JsonBackReference：@JsonBackReference标注的属性在序列化时，会被忽略。

    在序列化时，@JsonBackReference的作用相当于@JsonIgnore，此时可以没有@JsonManagedReference。

    但在反序列化（deserialization，即json数据转换为对象）时，如果没有@JsonManagedReference，则不会自动注入@JsonBackReference标注的属性（被忽略的父或子）

  • @JsonManagedReference：用于在反序列化时，自动注入@JsonBackReference标注的属性

public class Test {
    
    
    public static void main(String[] args) throws IOException {
    
    

        Order order = new Order();
        Customer customer = new Customer();

        customer.setId(2);
        customer.setName("Peter");
        customer.setOrder(order);

        order.setOrderId(1);
        order.setItemIds(Stream.of(10, 30).collect(Collectors.toList()));
        order.setCustomer(customer);

        ObjectMapper om = new ObjectMapper();
        String serializing = om.writeValueAsString(customer);

        Customer deserializing = om.readValue(serializing, Customer.class);
    }
}

@Data
class Customer {
    
    
    private int id;
    private String name;
    @JsonManagedReference
    private Order order;
}

@Data
class Order {
    
    
    private int orderId;
    private List<Integer> itemIds;
    @JsonBackReference
    private Customer customer;
}

调试过程：
在这里插入图片描述
可见：

  • 序列化时，忽略了order中的customer属性
  • 反序列化时，又自动注入了order中的customer属性

@JsonPOJOBuilder

@JsonPOJOBuilder注解用于配置构建器类，以自定义JSON文档的反序列化，以便在命名约定与默认约定不同的情况下恢复POJO。

@JsonPOJOBuilder主要用与bean的属性名称与JSON字符串中的字段名称不同的场景。

注解的主要属性：

  • buildMethodName: 无参数方法的名称，用于在将JSON字段绑定到bean的属性之后实例化预期的bean。默认名称为“build”。
  • withPrefix: 用于自动检测JSON和bean属性之间的匹配的名称前缀。默认前缀是 with。
@Data
@JsonDeserialize(builder = UserBuilder.class)
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;
    private String email;
    private String nickName;
    private Date createTime;

    public User() {
    
    
    }

    public User(String id, String userName) {
    
    
        this.id = id;
        this.userName = userName;
    }
}

@JsonPOJOBuilder(buildMethodName = "createBean", withPrefix = "construct")
class UserBuilder {
    
    
    private String userId;
    private String name;

    public UserBuilder constructUserId(String userId) {
    
    
        this.userId = userId;
        return this;
    }

    public UserBuilder constructName(String name) {
    
    
        this.name = name;
        return this;
    }

    public User createBean() {
    
    
        return new User(userId, name);
    }
}

    private static void jsonStr2Object() {
    
    
        String jsonStr = "{\"userId\":\"999\",\"name\":\"小五\"}";
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE);
        try {
    
    
            User user = objectMapper.readValue(jsonStr, User.class);
            System.out.println(user);
        } catch (JsonProcessingException e) {
    
    
            e.printStackTrace();
        }
    }

输出

User(id=999, userName=小五, passWord=null, email=null, nickName=null, createTime=null)

3. 自定义Jackson组合注解

Jackson通过JacksonAnnotationsInside注解来自定义Jackson组合注解。

例如：自定义Jackson组合注解：JsonSexSerializeDeserialize。

该注解的作用：

  • 序列化时，将枚举对象SexEnum转化为字符串值"男"或"女"
  • 反序列化时，将字符串值"男"或"女"转化为枚举对象SexEnum
@Target({
    
    ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@JsonSerialize(using = SexEnumSerializer.class)
@JsonDeserialize(using = SexEnumDeserializer.class)
@JacksonAnnotationsInside
public @interface JsonSexSerializeDeserialize {
    
    

}

public class SexEnumSerializer extends JsonSerializer<SexEnum> {
    
    

    @Override
    public void serialize(SexEnum value, JsonGenerator gen, SerializerProvider provider) throws IOException {
    
    
        gen.writeString(value.getValue());
    }
}

public class SexEnumDeserializer extends JsonDeserializer<SexEnum> {
    
    

    @Override
    public SexEnum deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    
    
        String value = p.getText();
        return SexEnum.getByValue(value);
    }
}

@Data
public class User {
    
    
    private String id;
    private String userName;
    private String passWord;
    private String email;
    @JsonSexSerializeDeserialize
    private SexEnum sex;
    private String nickName;
    private Date createTime;
}

enum SexEnum {
    
    
    MAN("男"),
    WOMAN("女");

    private String value;

    SexEnum(String value) {
    
    
        this.value = value;
    }

    public String getValue() {
    
    
        return value;
    }

    public SexEnum setValue(String value) {
    
    
        this.value = value;
        return this;
    }

    public static SexEnum getByValue(String value) {
    
    
        for (SexEnum sexEnum : SexEnum.values()) {
    
    
            if (sexEnum.getValue().equals(value)) {
    
    
                return sexEnum;
            }
        }
        return null;
    }
}

猜你喜欢

转载自blog.csdn.net/JokerLJG/article/details/128573849
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022