老版本的Jackson使用的包名为org.codehaus.jackson，而新版本使用的是com.fasterxml.jackson。

Jackson主要包含了3个模块：

• jackson-core
• jackson-annotations
• jackson-databind
  其中，jackson-annotations依赖于jackson-core，jackson-databind又依赖于jackson-annotations。

Jackson有三种方式处理Json：

1. 使用底层的基于Stream的方式对Json的每一个小的组成部分进行控制
2. 使用Tree Model，通过JsonNode处理单个Json节点
3. 使用databind模块，直接对Java对象进行序列化和反序列化

通常来说，我们在日常开发中使用的是第3种方式，有时为了简便也会使用第2种方式，比如你要从一个很大的Json对象中只读取那么一两个字段的时候，采用databind方式显得有些重，JsonNode反而更简单。

使用ObjectMapper

本文的例子以jackson-databind-2.9.4为例。
创建Person类如下：

public class Person {
    private String name;
    private String address;
    private String mobile;


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getMobile() {
        return mobile;
    }

    public void setMobile(String mobile) {
        this.mobile = mobile;
    }
}

序列化一个Person对象：

   public static void main(String[] args) throws IOException {
        ObjectMapper objectMapper = new ObjectMapper();
        Person person = new Person();
        person.setName("davenkin");
        person.setAddress("");
        System.out.println(objectMapper.writeValueAsString(person));
    }

返回结果：

{"name":"davenkin","address":"","mobile":null}

在默认情况下，ObjectMapper在序列化时，将所有的字段一一序列化，无论这些字段是否有值，或者为null。

另外，序列化依赖于getter方法，如果某个字段没有getter方法，那么该字段是不会被序列化的。由此可见，在序列化时，OjbectMapper是通过反射机制找到了对应的getter，然后将getter方法对应的字段序列化到Json中。请注意，此时ObjectMapper并不真正地检查getter对应的属性是否存在于Person对象上，而是通过getter的命名规约进行调用，比如对于getAbc()方法：

 public String getAbc(){
       return "this is abc";
   }

即便Person上没有abc属性，abc也会被序列化：

{"name":"davenkin","address":"","mobile":null,"abc":"this is abc"}

反序列化一个Json字符串，其中少了一个mobile字段：

public static void main(String[] args) throws IOException {
        ObjectMapper objectMapper = new ObjectMapper();
        Person person = objectMapper.readValue("{\"name\":\"davenkin\",\"address\":\"\"}", Person.class);

        System.out.println("name: " + person.getName());
        System.out.println("address: " + person.getAddress());
        System.out.println("mobile: " + person.getMobile());
    }

输出：

name: davenkin
address: 
mobile: null

可以看出，少了mobile字段，程序依然正常工作，只是mobile的值为null。

另外，如果我们向Json中增加一个Person中没有的字段：

  public static void main(String[] args) throws IOException {
        ObjectMapper objectMapper = new ObjectMapper();
        Person person = objectMapper.readValue("{\"name\":\"davenkin\",\"address\":\"\",\"mobile\":null,\"extra\":\"extra-value\"}", Person.class);

        System.out.println("name: " + person.getName());
        System.out.println("address: " + person.getAddress());
        System.out.println("mobile: " + person.getMobile());
    }

此时运行程序将报错：

Exception in thread "main" com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException: 
Unrecognized field "extra" (class com.shell.b2b.factory.model.Person), not marked as ignorable (3 known properties: "mobile", "name", "address"])

表示在Person对象上找不到对应的extra属性，但是如果我们在Person上增加一个空的setter：

    public void setExtra(String extra) {
    }

那么此时运行成功，由此可见OjbectMapper是通过反射的机制，通过调用Json中字段所对应的setter方法进行反序列化的。并且此时，依赖于Person上有默认构造函数。

综上，在默认情况下（即不对ObjectMapper做任何额外配置，也不对Java对象加任何Annotation），ObjectMapper依赖于Java对象的默认的无参构造函数进行反序列化，并且严格地通过getter和setter的命名规约进行序列化和反序列化。

去除getter和setter

纯粹地为了技术方面的原因而添加getter和setter是不好的，可以通过以下方式去除掉对getter和setter的依赖：

objectMapper.setVisibility(ALL, NONE)
                .setVisibility(FIELD, ANY);

ObjectMapper将通过反射机制直接操作Java对象上的字段。

此时创建Person如下：

public class Person {
    private String name;
    private String address;
    private String mobile;

    public Person(String name, String address, String mobile) {
        this.name = name;
        this.address = address;
        this.mobile = mobile;
    }

}

序列化Person：

public static void main(String[] args) throws IOException {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(ALL, NONE)
                .setVisibility(FIELD, ANY);
        Person person = new Person("name", "address", "mobile");
        System.out.println(objectMapper.writeValueAsString(person));

    }

然而，此时反序列化的时候报错：

Exception in thread "main" com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of `com.shell.b2b.factory.model.Person` (no Creators, like default construct, exist): cannot deserialize from Object value (no delegate- or property-based Creator)

这是因为ObjectMapper在为字段设值之前，无法初始化Person对象，此时有两种解决方式：

1. 为Person增加默认构造函数：

private Person() {
    }

请注意，此时请将该构造函数设置为private的，因为我们不想因为纯技术原因而向外暴露一个会将Person类置于非法状态的构造函数（一个没有名字的Person还有什么用？）。

1. 在已有构造函数上加上@JsonCreator注解，通常与@JsonProperty一起使用：

    @JsonCreator
    public Person(@JsonProperty("name") String name,
                  @JsonProperty("address") String address,
                  @JsonProperty("mobile") String mobile) {
        this.name = name;
        this.address = address;
        this.mobile = mobile;
    }

忽略字段

@JsonIgnore用于字段上，表示该字段在序列化和反序列化的时候都将被忽略。

@JsonIgnoreProperties主要用于类上：

@JsonIgnoreProperties(value = {"mobile","name"},ignoreUnknown = true)

表示对于mobile和name字段，反序列化和序列化均忽略，而对于Json中存在的未知字段，在反序列化时忽略，ignoreUnknown不对序列化起效。

序列化时排除null或者空字符串

@JsonInclude(JsonInclude.Include.NON_NULL)
public class Person {

表示在序列化Person时，将值为null的字段排除掉。

@JsonInclude(JsonInclude.Include.NON_EMPTY)
public class Person {

表示在序列化Person时，将值为null的字段或者空的字符串字段排除掉。

用某个方法的返回值序列化整个对象

有时我们并不想讲对象的所有字段都序列化，而是希望用一个方法的返回值来序列化，比如toString()方法，此时可以用@JsonValue：

@JsonValue
public String toString(){
return "someValue";
}

此时整个对象在序列化后的值将变为“someValue”，需要注意的是，这种方式下，在反序列化时也需要有响应的机制。

或者全局设置：

 objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

反序列化时陈列多余字段

在默认情况下，如果Json数据中有多余的字段，那么在反序列化时Jackson发现无法找到对应的对象字段，便会抛出UnrecognizedPropertyException: Unrecognized field xxx异常，此时可以做如下配置：

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

反序列化时处理缺少字段

在默认情况下，无论是通过@JsonCreator还是直接字段设值的方式，如果json数据中的缺少对象中的字段，那么Jackson默认会为这些值设置为null，或者对于原始类型按照原始类型的默认值（比如int类型设置为0）。如果我们需要某个字段必须出现在json数据中，那么可以通过@JsonProperty的required字段：

 @JsonCreator
    public MobileNumber(@JsonProperty(value = "mobileNumber",required = true) String mobileNumber) {
        this.mobileNumber = mobileNumber;
    }

Java 8 Data/Time API支持

Java 8中引入了全新的时间处理API，比如在多数情况下我们将使用Instant来表示某个事件发生的时间，Instant取代了之前的Timestamp。

但是，如果我们直接使用ObjectMapper来序列化Instant：

public static void main(String[] args) throws IOException {
        ObjectMapper objectMapper = new ObjectMapper();
        System.out.println(objectMapper.writeValueAsString(Instant.now()));

    }

将得到：

{"epochSecond":1520621382,"nano":959000000}

一个Instant需要两个字段来表示，同样的情况也出现在LocalDateTime上，即一个时间需要多个字段表示。

为了克服这种情况，可以引入Jackson的DataType模块：

    compile('com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.9.4')

然后配置ObjectMapper：

objectMapper.findAndRegisterModules();

此时，Instant将会被序列化为：

1520621578.637000000

如果你觉得这个数字不表意，那么可以：

objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);

此时，Instant被序列化为：

"2018-03-09T18:53:48.214Z"

请注意，这个展示的时间是个UTC时区的时间。

使用Jackson的推荐配置

推荐的ObjectMapper配置如下：

 MryObjectMapper objectMapper = new MryObjectMapper();
        objectMapper.findAndRegisterModules()
                .setVisibility(ALL, NONE)
                .setVisibility(FIELD, ANY)
                .registerModule(instantModule())
                .configure(WRITE_DATES_AS_TIMESTAMPS, false)
                .configure(FAIL_ON_UNKNOWN_PROPERTIES, false);

另外，添加对Java 8的支持，在build.gradle文件中加入依赖：

    compile('com.fasterxml.jackson.module:jackson-module-parameter-names:2.9.5')
    compile('com.fasterxml.jackson.datatype:jackson-datatype-jdk8:2.9.5')
    compile('com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.9.5')
    compile('com.fasterxml.jackson.core:jackson-core:2.9.5')
    compile('com.fasterxml.jackson.core:jackson-databind:2.9.5')
    compile('com.fasterxml.jackson.core:jackson-annotations:2.9.5')

以上配置有以下几点：

• 对于所有的使用ObjectMapper的地方，推荐采用直接处理字段的方式，即：

objectMapper.setVisibility(ALL, NONE)
.setVisibility(FIELD, ANY);

• 自动查找并注册Java 8相关模块：

objectMapper.findAndRegisterModules()

• 序列化生成对人友好的日期展示

 objectMapper.configure(WRITE_DATES_AS_TIMESTAMPS, false);

• 不要使用@JsonInclude(JsonInclude.Include.NON_EMPTY)和@JsonInclude(JsonInclude.Include.NON_NULL)，因为这样序列化之后的数据无法展现出数据的schema，对客户端不友好。
• 反序列化时自动忽略多余字段：

objectMapper.configure(FAIL_ON_UNKNOWN_PROPERTIES, false);

这样，如果我们决定在Java中对象中删除某些字段，原来持久化为Json的数据依然可以正确的反序列化；另外，在访问第三方API时，也可以忽略掉不需要的字段。

• 对于Json持久化数据来说（比如使用MySQL的JSON格式存储Java对象），同时使用Spring Boot，此时Jackson承担了两个作用，一是负责与API消费端数据通信的序列化和反序列化，二十对Java对象和数据库之间的序列化和反序列化。以上推荐配置可以做到：

  • 返回给API客户端的数据，或者保存到数据库的数据虽然包含了null和空值，但是却保留了完整的schema
  • 无需setter和getter，直接对字段操作，当然依然可以使用@JsonCreator
  • 如果Java对象需要添加字段，并且新增字段没有默认值（即默认值为null），则既有数据无需做迁移，也无需对应在数据库中增加字段。如果新增字段有默认值，那么需要自己做数据迁移。
  • 如果Java对象需要删除字段，既有数据也无需做迁移，对应字段也无需删除，只是被删除的字段依然保存在数据库中，有人可能认为这是脏数据，但是另一个方面有可以认为我们保留了历史数据。
  • 如果需要对Java对象的某些字段改名，那么此时便需要自己做数据迁移了。