Jackson 通过注解实现 POJO 序列化与反序列化规则，包含以下功能：
属性命名
属性包含
属性文档、元数据
序列化和反序列化细节
反序列化细节
序列化细节
类型处理
对象引用、标识
元注解
本文展示了如何快速上手 Jackson 内建属性以及如何创建自定义命名策略。
属性命名
`@JsonProperty` 用来表示序列化结果中的属性名称：
`@JsonProperty.value`：使用的名称
`@JsonProperty.index`: 物理索引
`@JsonProperty.defaultValue`: 默认文本，定义为元数据
例如：
```java
import com.fasterxml.jackson.annotation.JsonProperty;
public class BeanToTest {
/*
* 可以为属性名称指定字符串常量
* 这时无论采取何种命名机制,
* 都会覆盖 PropertyNamingStrategy, 只返回 “fieldOne”
*/
@JsonProperty("fieldOne")
private String fieldOne;
@JsonProperty("fieldTwo")
private String fieldTwo;
public String getFieldOne() {
return fieldOne;
}
public void setFieldOne(String fieldOne) {
this.fieldOne = fieldOne;
}
public String getFieldTwo() {
return fieldTwo;
}
public void setFieldTwo(String kFieldTwo) {
this.fieldTwo = kFieldTwo;
}
}
```@JsonNaming
`@JsonNaming` 注解用来指定属性序列化使用的命名策略，覆盖默认实现。可以通过 `value` 属性指定策略，包括自定义策略。
除了默认的 LOWER_CAMEL_CASE 机制，比如 `lowerCamelCase` 外，Jackson 还提供了四种内置命名策略：
KEBAB_CASE：“Lisp” 风格，采用小写字母、连字符作为分隔符，例如 “lower-case” 或 “first-name”
LOWER_CASE：所有的字母小写，没有分隔符，例如 lowercase
SNAKE_CASE：所有的字母小写，下划线作为名字之间分隔符，例如 snake_case.
UPPER_CAMEL_CASE：所有名字（包括第一个字符）都以大写字母开头，后跟小写字母，没有分隔符，例如 UpperCamelCase
"注意："上述规则可应用于某个类，也可以作为所有类的全局命名规则。
>>>
`@JsonNaming(PropertyNamingStrategy.KebabCaseStrategy.class)` 用于单个类的注解命名，
`objectMapper.setPropertyNamingStrategy(PropertyNamingStrategy.KEBAB_CASE)` 用作全局命名
>>>
下面的示例展示了如何配置两种策略。这里通过单元测试进行演示：
```java
import java.io.IOException;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.databind.annotation.JsonNaming;
@RunWith(JUnit4.class)
public class JacksonBeanNamingKebabTest {
@Test
public void testBeanNames() throws JsonGenerationException, JsonMappingException, IOException {
ObjectMapper mapper = new ObjectMapper();
// 为 ObjectMapper 设置全局 PropertyNamingStrategy
mapper.setPropertyNamingStrategy(PropertyNamingStrategy.KEBAB_CASE);
BeanToTest bt = new BeanToTest();
bt.setFieldOne("field one data.");
bt.setFieldTwo("field two data.");
mapper.writeValue(System.out, bt);
}
// 为单个类设置 PropertyNamingStrategy 应使用 @JsonNaming
@JsonNaming(PropertyNamingStrategy.SnakeCaseStrategy.class)
private class BeanToTest {
private String fieldOne;
private String fieldTwo;
public String getFieldOne() {
return fieldOne;
}
public void setFieldOne(String fieldOne) {
this.fieldOne = fieldOne;
}
public String getFieldTwo() {
return fieldTwo;
}
public void setFieldTwo(String kFieldTwo) {
this.fieldTwo = kFieldTwo;
}
}
}
```"注意："如果同时设置了全局规则和某个类的命名规则，后者会覆盖全局设置。
运行上面的测试，输出如下：
```
{
"field_one":"field one data.",
"field_two":"field two data."
}
```在某些情况下，上述方法可能还不能满足要求，例如使用了其他库或工具生成代码，包含 getter 和 setter。让我们看下面这个例子。
假设类定义如下：
```java
public class BeanToTest {
@JsonProperty("fielOne")
private String fieldOne;
@JsonProperty("kFieldTwo")
private String kFieldTwo;
public String getFieldOne() {
return fieldOne;
}
public void setFieldOne(String fieldOne) {
this.fieldOne = fieldOne;
}
public String getKFieldTwo() {
return kFieldTwo;
}
public void setKFieldTwo(String kFieldTwo) {
this.kFieldTwo = kFieldTwo;
}
}
```可以注意到，kFieldTwo 的 getter/setter 方法显得有些不同。它们的命名并不遵守 bean 命名规则，即首字母应该大写。运行结果如下：
```
{
"kfieldTwo":"field constant.",
"fielOne":"field one data",
"kFieldTwo":"field constant."
}
```可以看到，结果引入了一个多余字段 `kfieldTwo`。Jackson 支持增加自定义属性命名策略，这时可以派上用场。
```java
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.databind.cfg.MapperConfig;
import com.fasterxml.jackson.databind.introspect.AnnotatedField;
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
@RunWith(JUnit4.class)
public class JacksonBeanNamingCustomTest {
@Test
public void testBeanNames() throws JsonGenerationException, JsonMappingException, IOException {
ObjectMapper mapper = new ObjectMapper();
mapper.setPropertyNamingStrategy(new PropertyNamingStrategy() {
@Override
public String nameForField(MapperConfig<?> config, AnnotatedField field, String defaultName) {
return field.getName();
}
@Override
public String nameForGetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName) {
return convert(method, defaultName);
}
@Override
public String nameForSetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName) {
return convert(method, defaultName);
}
/**
* 获取 getter/setter 方法所在类的名称
*
* @param method
* @param defaultName
* - jackson 生成的名字
* @return 正确的属性名
*/
private String convert(AnnotatedMethod method, String defaultName) {
Class<?> clazz = method.getDeclaringClass();
List<Field> flds = getAllFields(clazz);
for (Field fld : flds) {
if (fld.getName().equalsIgnoreCase(defaultName)) {
return fld.getName();
}
}
return defaultName;
}
/**
* 获取类中所有字段名
*
* @param currentClass
* - 不允许为 null
* @return 当前类与父类中所有字段
*/
private List<Field> getAllFields(Class<?> currentClass) {
List<Field> flds = new ArrayList<>();
while (currentClass != null) {
Field[] fields = currentClass.getDeclaredFields();
Collections.addAll(flds, fields);
if (currentClass.getSuperclass() == null)
break;
currentClass = currentClass.getSuperclass();
}
return flds;
}
});
BeanToTest bt = new BeanToTest();
bt.setFieldOne("field one data");
bt.setKFieldTwo("field constant.");
mapper.writeValue(System.out, bt);
}
private class BeanToTest {
@JsonProperty("fielOne")
private String fieldOne;
@JsonProperty("kFieldTwo")
private String kFieldTwo;
public String getFieldOne() {
return fieldOne;
}
public void setFieldOne(String fieldOne) {
this.fieldOne = fieldOne;
}
public String getKFieldTwo() {
return kFieldTwo;
}
public void setKFieldTwo(String kFieldTwo) {
this.kFieldTwo = kFieldTwo;
}
}
}
```输出：
```
{
"kFieldTwo":"field constant.",
"fielOne":"field one data"
}
```从上面结果可以看出，我们可以根据自己的需求修改默认命名策略。
也可以为 `PropertyNamingStrategy` 新建文件，使用 `@JsonNaming(…)` 对单个类应用自定义规则。