Java jackson常用注解汇总

河曲智叟  金牌会员 | 2023-12-10 12:34:49 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 910|帖子 910|积分 2730

提起 jackson，在日常使用中，由于涉及到各种序列化和反序列化的处理，就不能不提 注解，了解注解的常用方式可以极大地方便我们处理序列化，今天分享一些在使用 jackson 中涉及到的注解。

目录

1.@JsonProperty - 字段命名

@JsonProperty 注解用于在序列化时按照给定的字段名命名，在反序列化时，在 json 串中的注解字段给该字段设置属性值。
下面是注解的简单示例：
  1. package org.example;
  3. import com.fasterxml.jackson.annotation.JsonProperty;
  5. public class PersonProperty {
  6.     @JsonProperty("first_name")
  7.     private String firstName;
  9.     public PersonProperty() {
  10.     }
  12.     public String getFirstName() {
  13.         return firstName;
  14.     }
  16.     public void setFirstName(String firstName) {
  17.         this.firstName = firstName;
  18.     }
  19. }
  21. ---
  22. public static void jsonPropertyDemo() {
  23.     ObjectMapper objectMapper = new ObjectMapper();
  24.     PersonProperty pp = new PersonProperty();
  25.     pp.setFirstName("Alice");
  27.     String jsonString = null;
  28.     try {
  29.         jsonString = objectMapper.writeValueAsString(pp);
  30.         System.out.println("json property: " + jsonString);
  31.     } catch (Exception e) {
  32.         e.printStackTrace();
  33.     }
  35.     try {
  36.         PersonProperty pp1 = objectMapper.readValue(jsonString, PersonProperty.class);
  37.         System.out.println(pp1.getFirstName());
  38.     } catch (Exception e) {
  39.         e.printStackTrace();
  40.     }
  41. }
  42. ---
复制代码
2.@JsonPropertyOrder - 字段序列化顺序

@JsonPropertyOrder加在类上，用以规定数据序列化时字段出现的顺序。
  1. package org.example;
  3. import com.fasterxml.jackson.annotation.JsonPropertyOrder;
  5. // {"name":"Bob","id":"111","age":25,"phone":"12345678910"}
  6. @JsonPropertyOrder({"name", "id", "age", "phone"})
  7. // 没有定义顺序，就按照字典序排列，{"age":25,"id":"111","name":"Bob","phone":"12345678910"}
  8. // @JsonPropertyOrder(alphabetic = true)
  9. public class PersonPropertyOrder {
  10.     private String id;
  12.     private String name;
  14.     private int age;
  16.     private String phone;
  18.     public PersonPropertyOrder() {
  19.     }
  21.     public String getId() {
  22.         return id;
  23.     }
  25.     public void setId(String id) {
  26.         this.id = id;
  27.     }
  29.     public String getName() {
  30.         return name;
  31.     }
  33.     public void setName(String name) {
  34.         this.name = name;
  35.     }
  37.     public int getAge() {
  38.         return age;
  39.     }
  41.     public void setAge(int age) {
  42.         this.age = age;
  43.     }
  45.     public String getPhone() {
  46.         return phone;
  47.     }
  49.     public void setPhone(String phone) {
  50.         this.phone = phone;
  51.     }
  52. }
  54. ---
  55. public static void jsonPropertyOrder() {
  56.     ObjectMapper objectMapper = new ObjectMapper();
  57.     PersonPropertyOrder ppo = new PersonPropertyOrder();
  58.     ppo.setAge(25);
  59.     ppo.setId("111");
  60.     ppo.setName("Bob");
  61.     ppo.setPhone("12345678910");
  63.     String jsonString = null;
  64.     try {
  65.         jsonString = objectMapper.writeValueAsString(ppo);
  66.         System.out.println("json property: " + jsonString);
  67.     } catch (Exception e) {
  68.         e.printStackTrace();
  69.     }
  70. }
  72. ---
复制代码
3.@JsonAlias - 字段别名，反序列化

在数据反序列化时，通过 @JsonAlias 注解来设置字段的值，只要是 alias中的和字段本身都可以正常反序列化。
  1. package org.example;
  3. import com.fasterxml.jackson.annotation.JsonAlias;
  5. public class PersonAlias {
  6.     @JsonAlias({"firstName", "personName"})
  7.     private String name;
  9.     public PersonAlias() {
  10.     }
  12.     public String getName() {
  13.         return name;
  14.     }
  16.     public void setName(String name) {
  17.         this.name = name;
  18.     }
  19. }
  20. ---
  21. public static void jsonAlias() {
  22.     String jsonString1 = "{"name":"Bob"}";
  23.     String jsonString2 = "{"firstName":"Bob"}";
  24.     String jsonString3 = "{"personName":"Bob"}";
  26.     ObjectMapper objectMapper = new ObjectMapper();
  27.     try {
  28.         PersonAlias p1 = objectMapper.readValue(jsonString1, PersonAlias.class);
  29.         PersonAlias p2 = objectMapper.readValue(jsonString2, PersonAlias.class);
  30.         PersonAlias p3 = objectMapper.readValue(jsonString3, PersonAlias.class);
  32.         System.out.printf("p1: %s, p2: %s, p3: %s", p1.getName(),p2.getName(), p3.getName());
  33.     } catch (Exception e) {
  34.         e.printStackTrace();
  35.     }
  36. }
  37. ---
复制代码
4.@JsonIgnore -序列化时忽略字段

@JsonIgnore 加在字段上，用以在序列化时，忽略其，在反序列化时，仅赋值null。
  1. package org.example;
  3. import com.fasterxml.jackson.annotation.JsonIgnore;
  6. public class PersonIgnore {
  7.     private String name;
  8.     @JsonIgnore // 不将其序列化，忽略该字段
  9.     private String[] hobbies;
  11.     public PersonIgnore() {
  12.     }
  14.     public String getName() {
  15.         return name;
  16.     }
  18.     public void setName(String name) {
  19.         this.name = name;
  20.     }
  22.     public String[] getHobbies() {
  23.         return hobbies;
  24.     }
  26.     public void setHobbies(String[] hobbies) {
  27.         this.hobbies = hobbies;
  28.     }
  29. }
  31. ---
  32. public static void jsonIgnore() {
  33.     ObjectMapper objectMapper = new ObjectMapper();
  34.     String jsonString = null;
  36.     try {
  37.         PersonIgnore pi = new PersonIgnore();
  38.         pi.setName("Cathy");
  39.         pi.setHobbies(null);
  41.         jsonString = objectMapper.writeValueAsString(pi);
  42.         System.out.println(jsonString);
  43.     } catch (Exception e) {
  44.         e.printStackTrace();
  45.     }
  46. }   
  47. ---
复制代码
5.@JsonIgnoreProperties - 序列化时忽略某些字段

@JsonIgnoreProperties 加在类上，用于在序列化时，忽略给定的某些字段。
  1. package org.example;
  3. import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
  5. @JsonIgnoreProperties({"age"})
  6. public class PersonIgnoreProperties {
  7.     private String name = "Alice";
  8.     private int age;
  10.     public PersonIgnoreProperties() {
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  21.     public int getAge() {
  22.         return age;
  23.     }
  25.     public void setAge(int age) {
  26.         this.age = age;
  27.     }
  28. }
  29. ---
  30. public static void jsonIgnoreProperties() {
  31.     ObjectMapper objectMapper = new ObjectMapper();
  32.     PersonIgnoreProperties pip = new PersonIgnoreProperties();
  33.     pip.setName("Bob");
  34.     pip.setAge(18);
  36.     try {
  37.         String jsonString = objectMapper.writeValueAsString(pip);
  38.         System.out.println(jsonString);
  39.     } catch (Exception e) {
  40.         e.printStackTrace();
  41.     }
  42. }
  43. ---
复制代码
6.@JsonInclude - 序列化时作用于满足条件的

@JsonInclude可以加在类上，也可以加在字段上。该注解表示满足某些条件(
NON_NULL,
NON_ABSENT,
NON_EMPTY,
NON_DEFAULT,
等)的才能序列化，e.g.如果加在类上，表示只要对象有null 就忽略该对象，加在字段上，如果字段是null，则忽略该字段。
  1. package org.example;
  3. import com.fasterxml.jackson.annotation.JsonInclude;
  5. @JsonInclude(JsonInclude.Include.NON_NULL)
  6. public class PersonInclude {
  7.     private int id;
  9.     private String name;
  10.     @JsonInclude(JsonInclude.Include.NON_NULL)
  11.     private String[] hobbies;
  13.     public PersonInclude() {
  14.     }
  16.     public int getId() {
  17.         return id;
  18.     }
  20.     public void setId(int id) {
  21.         this.id = id;
  22.     }
  24.     public String getName() {
  25.         return name;
  26.     }
  28.     public void setName(String name) {
  29.         this.name = name;
  30.     }
  32.     public String[] getHobbies() {
  33.         return hobbies;
  34.     }
  36.     public void setHobbies(String[] hobbies) {
  37.         this.hobbies = hobbies;
  38.     }
  39. }
  40. ---
  41. public static void jsonInclude() {
  42.     ObjectMapper objectMapper = new ObjectMapper();
  43.     PersonInclude pi = new PersonInclude();
  45.     pi.setName("Cathy");
  46.     pi.setId(1111);
  48.     try {
  49.         String jsonString = objectMapper.writeValueAsString(pi);
  50.         System.out.println(jsonString);
  51.     } catch (Exception e) {
  52.         e.printStackTrace();
  53.     }
  54. }
  55. ---
复制代码
7.@JsonFormat - 设置格式，如日期时间等

用于设置时间格式，或者是数字，或者是日期格式。
  1. package org.example;
  3. import com.fasterxml.jackson.annotation.JsonFormat;
  5. import java.time.LocalDate;
  6. import java.util.Date;
  8. public class PersonFormat {
  9.     @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd hh:mm:ss", timezone = "GMT+8")
  10.     private Date birthDate;
  12.     public PersonFormat() {
  13.     }
  15.     public Date getBirthDate() {
  16.         return birthDate;
  17.     }
  19.     public void setBirthDate(Date birthDate) {
  20.         this.birthDate = birthDate;
  21.     }
  22. }
  24. ---
  25. public static void jsonFormat() {
  26.     ObjectMapper objectMapper = new ObjectMapper();
  27.     PersonFormat pf = new PersonFormat();
  28.     pf.setBirthDate(new Date());
  30.     try {
  31.         String jsonString = objectMapper.writeValueAsString(pf);
  32.         System.out.println(jsonString);
  33.     } catch (Exception e) {
  34.         e.printStackTrace();
  35.     }
  36. }
  37. ---
复制代码
8.@JacksonInject - 反序列化时注入到 java 对象

该注解用于在数据反序列化时将其他字段注入进 Java对象。
  1. package org.example;
  3. import com.fasterxml.jackson.annotation.JacksonInject;
  5. import java.time.LocalDate;
  6. import java.time.LocalDateTime;
  8. public class PersonInject {
  10.     private String name;
  11.    
  12.     private int age;
  13.    
  14.     @JacksonInject("responseTime")
  15.     private LocalDateTime responseTime;
  17.     public PersonInject() {
  18.     }
  20.     public String getName() {
  21.         return name;
  22.     }
  24.     public void setName(String name) {
  25.         this.name = name;
  26.     }
  28.     public int getAge() {
  29.         return age;
  30.     }
  32.     public void setAge(int age) {
  33.         this.age = age;
  34.     }
  36.     public LocalDateTime getResponseTime() {
  37.         return responseTime;
  38.     }
  40.     public void setResponseTime(LocalDateTime responseTime) {
  41.         this.responseTime = responseTime;
  42.     }
  43. }
  45. ---
  47. public static void jsonInject() {
  48.     InjectableValues.Std iv = new InjectableValues.Std();
  49.     ObjectMapper objectMapper = new ObjectMapper();
  50.     iv.addValue("responseTime", LocalDateTime.now());
  52.     //将JSON字符串反序列化为java对象
  53.     String jsonString = "{"name":"Alice","age":23}";
  54.     objectMapper.setInjectableValues(iv);
  56.     try {
  57.         PersonInject pi = objectMapper.readValue(jsonString, PersonInject.class);
  58.         System.out.println(pi.getResponseTime());
  59.     } catch (Exception e) {
  60.         e.printStackTrace();
  61.     }
  62. }
  63. ---
复制代码
9.@JsonCreator && @ConstructorProperties - 反序列化时采用的构造方法

@JsonCreator 用于在json数据反序列化到实例对象时采用哪个构造方法，同时搭配 @JsonProperty 注解用于相关属性的。
  1. package org.example;
  3. import com.fasterxml.jackson.annotation.JsonCreator;
  4. import com.fasterxml.jackson.annotation.JsonProperty;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  7. public class PersonCreator {
  8.     private String name;
  10.     private int age;
  12.     // 构造方法1
  13.     public PersonCreator(String name) {
  14.         this.name = name;
  15.     }
  17.     // 构造方法2
  18.     @JsonCreator // 用于反序列化时的处理
  19.     public PersonCreator(@JsonProperty("username") String name,
  20.                          @JsonProperty("age") int age) {
  21.         this.name = name;
  22.         this.age = age;
  23.     }
  25.     @Override
  26.     public String toString() {
  27.         return "Test{" +
  28.                 "name='" + name + ''' +
  29.                 ", age='" + age + ''' +
  30.                 '}';
  31.     }
  33.     public static void main(String[] args) throws Exception {
  34.         String jsonString = "{"username": "Alice", "age": 18}"; // username -> name
  35.         ObjectMapper objectMapper = new ObjectMapper();
  37.         try {
  38.             PersonCreator pc = objectMapper.readValue(jsonString, PersonCreator.class);
  39.             System.out.println(pc);
  40.         } catch (Exception e) {
  41.             e.printStackTrace();
  42.         }
  43.     }
  44. }
复制代码
@ConstructorProperties 也用于构造方法，但相比 @JsonCreator 的使用要简单，可以认为 @ConstructorProperties = @JsonCreator + @JsonProperty。
  1. package org.example;
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  5. import java.beans.ConstructorProperties;
  7. public class PersonConstructorProperties {
  8.     private String username;
  10.     private int age;
  12.     public PersonConstructorProperties(String username) {
  13.         this.username = username;
  14.     }
  16.     @ConstructorProperties({"name", "age"})
  17.     public PersonConstructorProperties(String username, int age) {
  18.         System.out.println("全参构造函数...");
  19.         this.username = username;
  20.         this.age = age;
  21.     }
  23.     @Override
  24.     public String toString() {
  25.         return "Test{" +
  26.                 "username='" + username + ''' +
  27.                 ", age='" + age + ''' +
  28.                 '}';
  29.     }
  31.     public static void main(String[] args) {
  32.         String jsonString = "{"name": "Bob", "age": 29}";
  33.         ObjectMapper objectMapper = new ObjectMapper();
  35.         try {
  36.             PersonConstructorProperties pcp = objectMapper.readValue(jsonString, PersonConstructorProperties.class);
  37.             System.out.println(pcp);
  38.         } catch (Exception e) {
  39.             e.printStackTrace();
  40.         }
  41.     }
  42. }
复制代码
10.@JsonSerialize && @JsonDeserialize - 自定义序列化方法

这两个注解用于实现自定义的序列化和反序列化的处理，比如我们有个需求，需要将小数的某个字段规定精确位数，为空时输出空字符串。
@JsonSerialize
  1. package org.example;
  3. import com.fasterxml.jackson.core.JsonGenerator;
  4. import com.fasterxml.jackson.databind.JsonSerializer;
  5. import com.fasterxml.jackson.databind.SerializerProvider;
  6. import com.fasterxml.jackson.databind.annotation.JsonSerialize;
  8. import java.io.IOException;
  9. import java.math.RoundingMode;
  10. import java.text.DecimalFormat;
  12. public class PersonSerialize {
  13.     @JsonSerialize(using = CustomDoubleSerialize.class, nullsUsing = NullNumberSerialize.class)
  14.     private Double model;
  16.     @JsonSerialize(nullsUsing = NullNumberSerialize.class)
  17.     private Double business;
  19.     private String name;
  21.     public PersonSerialize() {
  22.     }
  24.     public Double getModel() {
  25.         return model;
  26.     }
  28.     public void setModel(Double model) {
  29.         this.model = model;
  30.     }
  32.     public Double getBusiness() {
  33.         return business;
  34.     }
  36.     public void setBusiness(Double business) {
  37.         this.business = business;
  38.     }
  40.     public String getName() {
  41.         return name;
  42.     }
  44.     public void setName(String name) {
  45.         this.name = name;
  46.     }
  47. }
  49. /**
  50. * Double保留4位小数，输出string
  51. */
  52. class CustomDoubleSerialize extends JsonSerializer<Double> {
  53.     private static final DecimalFormat df = new DecimalFormat("#.####");
  55.     @Override
  56.     public void serialize(Double value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
  57.         df.setRoundingMode(RoundingMode.HALF_UP); // 4
  58.         gen.writeString(df.format(value));
  59.     }
  60. }
  62. /**
  63. * 任意类型null值，改为空字符串输出
  64. */
  65. class NullNumberSerialize extends JsonSerializer<Object> {
  67.     @Override
  68.     public void serialize(Object value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
  69.         gen.writeString("");
  70.     }
  71. }
  73. ---
  74. public static void jsonSerialize() {
  75.     ObjectMapper objectMapper = new ObjectMapper();
  76.     PersonSerialize ps = new PersonSerialize();
  77.     ps.setName("Alice");
  78.     ps.setModel(1.2345678);
  80.     try {
  81.         String jsonString = objectMapper.writeValueAsString(ps);
  82.         System.out.println(jsonString); // {"model":"1.2346","business":"","name":"Alice"}
  83.     } catch (Exception e) {
  84.         e.printStackTrace();
  85.     }
  86. }
  87. ---
复制代码
@JsonDeserialize
  1. package org.example;
  3. import com.fasterxml.jackson.core.JsonGenerator;
  4. import com.fasterxml.jackson.core.JsonParser;
  5. import com.fasterxml.jackson.databind.DeserializationContext;
  6. import com.fasterxml.jackson.databind.JsonDeserializer;
  7. import com.fasterxml.jackson.databind.JsonSerializer;
  8. import com.fasterxml.jackson.databind.SerializerProvider;
  9. import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
  10. import com.fasterxml.jackson.databind.annotation.JsonSerialize;
  12. import java.io.IOException;
  13. import java.time.LocalDateTime;
  14. import java.time.format.DateTimeFormatter;
  15. import java.time.format.FormatStyle;
  17. public class PersonDeserialize {
  18.     @JsonSerialize(using = LocalDatetimeSerialize.class)
  19.     @JsonDeserialize(using = LocalDatetimeDeserialize.class)
  20.     private LocalDateTime birthDate;
  22.     private String name;
  24.     public PersonDeserialize() {
  25.     }
  27.     public LocalDateTime getBirthDate() {
  28.         return birthDate;
  29.     }
  31.     public void setBirthDate(LocalDateTime birthDate) {
  32.         this.birthDate = birthDate;
  33.     }
  35.     public String getName() {
  36.         return name;
  37.     }
  39.     public void setName(String name) {
  40.         this.name = name;
  41.     }
  42. }
  44. class LocalDatetimeSerialize extends JsonSerializer<LocalDateTime> {
  45.     static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);
  47.     @Override
  48.     public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider provider) throws IOException {
  49.         String str = value.format(DATE_FORMATTER);
  50.         gen.writeString(str);
  51.     }
  52. }
  54. class LocalDatetimeDeserialize extends JsonDeserializer<LocalDateTime> {
  55.     @Override
  56.     public LocalDateTime deserialize(JsonParser p, DeserializationContext ctx) throws IOException {
  57.         String str = p.getText();
  58.         return LocalDateTime.parse(str, LocalDatetimeSerialize.DATE_FORMATTER);
  59.     }
  60. }
  61. ---
  62. public static void jsonDeserialize() {
  63.     ObjectMapper objectMapper = new ObjectMapper();
  64.     PersonDeserialize pd = new PersonDeserialize();
  65.     pd.setName("Dav");
  66.     pd.setBirthDate(LocalDateTime.of(2000, 12, 5, 0, 0));
  68.     String jsonString = null;
  70.     // serialize
  71.     try {
  72.         jsonString = objectMapper.writeValueAsString(pd);
  73.         System.out.println(jsonString); // {"birthDate":"2000年12月5日 00:00:00","name":"Dav"}
  74.     } catch (Exception e) {
  75.         e.printStackTrace();
  76.     }
  78.     // deserialize
  79.     try {
  80.         PersonDeserialize pd1 = objectMapper.readValue(jsonString, PersonDeserialize.class);
  81.         // person -> name: Dav, birthdate: 2000-12-05T00:00
  82.         System.out.printf("person -> name: %s, birthdate: %s\n", pd1.getName(), pd1.getBirthDate());
  83.     } catch (Exception e) {
  84.         e.printStackTrace();
  85.     }
  86. }
  87. ---
复制代码
11.@JsonAnyGetter && @JsonANySetter - 序列化对map字段的处理

这两个注解用于在序列化和反序列化时 map 结构的处理，具体说来：

  • @JsonAnyGetter，加在 getField() 上，用于序列化时将此map字段的键值对移至json中的键值对
  • @JsonAnySetter，加在字段上或者 setField() 都可以，加一个即可，用于反序列化时构造类实例，设置类实例属性，将json中的非明确定义的键值对都设置到map结构的字段中
  1. package org.example;
  3. import com.fasterxml.jackson.annotation.JsonAnyGetter;
  4. import com.fasterxml.jackson.annotation.JsonAnySetter;
  6. import java.util.HashMap;
  7. import java.util.Map;
  9. public class PersonGetAndSet {
  10.     private String username;
  12.     private String pwd;
  14.     private int age;
  16.     // @JsonAnySetter // 加方法或者属性都可以，但1个即可
  17.     private Map<String, String> map;
  19.     public PersonGetAndSet() {
  20.         this.map = new HashMap<>();
  21.     }
  23.     public String getUsername() {
  24.         return username;
  25.     }
  27.     public void setUsername(String username) {
  28.         this.username = username;
  29.     }
  31.     public String getPwd() {
  32.         return pwd;
  33.     }
  35.     public void setPwd(String pwd) {
  36.         this.pwd = pwd;
  37.     }
  39.     public int getAge() {
  40.         return age;
  41.     }
  43.     public void setAge(int age) {
  44.         this.age = age;
  45.     }
  47.     @JsonAnyGetter // serialize, {"username":"Ada","pwd":"123456","age":26,"key1":"val1","key2":"val2"}
  48.     public Map<String, String> getMap() {
  49.         return map;
  50.     }
  52.     @JsonAnySetter // deserialize, pwd: 123456, age: 26, map: {key1=val1, key2=val2}
  53.     public void setMap(String key, String value) {
  54.         this.map.put(key, value);
  55.     }
  56. }
  57. ---
  58. public static void jsonGetterAndSetter() {
  59.     PersonGetAndSet pgs = new PersonGetAndSet();
  60.     pgs.setUsername("Ada");
  61.     pgs.setAge(26);
  62.     pgs.setPwd("123456");
  63.     pgs.setMap("key1", "val1");
  64.     pgs.setMap("key2", "val2");
  66.     ObjectMapper objectMapper = new ObjectMapper();
  68.     String jsonString = null;
  70.     try {
  71.         jsonString = objectMapper.writeValueAsString(pgs);
  72.         System.out.println(jsonString);
  73.     } catch (Exception e) {
  74.         e.printStackTrace();
  75.     }
  77.     try {
  78.         PersonGetAndSet pgs1 = objectMapper.readValue(jsonString, PersonGetAndSet.class);
  79.         System.out.printf("person -> username: %s, pwd: %s, age: %d, map: %s\n", pgs1.getUsername(), pgs1.getPwd(), pgs1.getAge(), pgs1.getMap());
  80.     } catch (Exception e) {
  81.         e.printStackTrace();
  82.     }
  83. }
  84. ---
复制代码
12.@JsonNaming - 序列化时输出格式

@JsonNaming 加在类上，用以规范序列化时输出的字段键值的形式，主要有以下格式：

  • SnakeCaseStrategy, 蛇形体， 如 first_name
  • UpperCamelCaseStrategy, 大写驼峰体，如 FirstName
  • LowerCaseStratey, 小写连体，如 firstname
  • LowerDotCaseStratey, 小写点分，如 first.name
  1. package org.example;
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  4. import com.fasterxml.jackson.databind.PropertyNamingStrategy;
  5. import com.fasterxml.jackson.databind.annotation.JsonNaming;
  7. //@JsonNaming(value = PropertyNamingStrategy.SnakeCaseStrategy.class) // 蛇形体：{"first_name":"Matt","second_name":"Damon"}
  8. //@JsonNaming(value = PropertyNamingStrategy.UpperCamelCaseStrategy.class)  // {"FirstName":"Matt","SecondName":"Damon"}
  9. //@JsonNaming(value = PropertyNamingStrategy.LowerCaseStrategy.class)  // {"firstname":"Matt","secondname":"Damon"}
  10. @JsonNaming(value = PropertyNamingStrategy.LowerDotCaseStrategy.class)  // {"first.name":"Matt","second.name":"Damon"}
  11. public class PersonNaming {
  12.     private String firstName;
  14.     private String secondName;
  16.     public PersonNaming() {
  17.     }
  19.     public PersonNaming(String firstName, String secondName) {
  20.         this.firstName = firstName;
  21.         this.secondName = secondName;
  22.     }
  24.     public String getFirstName() {
  25.         return firstName;
  26.     }
  28.     public void setFirstName(String firstName) {
  29.         this.firstName = firstName;
  30.     }
  32.     public String getSecondName() {
  33.         return secondName;
  34.     }
  36.     public void setSecondName(String secondName) {
  37.         this.secondName = secondName;
  38.     }
  40.     public static void main(String[] args) {
  41.         PersonNaming pn = new PersonNaming();
  42.         pn.setFirstName("Matt");
  43.         pn.setSecondName("Damon");
  45.         ObjectMapper objectMapper = new ObjectMapper();
  47.         try {
  48.             String jsonString = objectMapper.writeValueAsString(pn);
  49.             System.out.println(jsonString);
  50.         } catch (Exception e) {
  51.             e.printStackTrace();
  52.         }
  53.     }
  54. }
复制代码
13.staic 和 transient 字段

如果字段属性中有这两个修饰符，则在序列化处理时忽略相关字段。
参考：

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

河曲智叟

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表