import com.fasterxml.jackson.annotation.*;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import org.junit.Test;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class AnnotationsDemo {

    /**
     * @throws JsonProcessingException
     * @JsonAnySetter注解测试
     */
    @Test
    public void test1() throws JsonProcessingException {

        String str = "{\"id\"   : 1234,\"name\" : \"John\"  }";

        ObjectMapper objectMapper = new ObjectMapper();
        Bag bag = objectMapper.readValue(str, Bag.class);
        System.out.println(bag);
    }


    /**
     * @throws JsonProcessingException
     * @JsonCreator注解测试
     */
    @Test
    public void test2() throws JsonProcessingException {

        String str = "{\"id\"   : 1234,\"name\" : \"John\"  }";

        ObjectMapper objectMapper = new ObjectMapper();
        PersonImmutable personImmutable = objectMapper.readValue(str, PersonImmutable.class);
        System.out.println(personImmutable);
    }

    /**
     * @throws JsonProcessingException
     * @JacksonInject注解测试
     */
    @Test
    public void test3() throws JsonProcessingException {
        String personStr = "{\"id\":1,\"name\":\"tom\"}";
        InjectableValues inject = new InjectableValues.Std().addValue("source", "jenkov.com");
        PersonInject personInject = new ObjectMapper().reader(inject)
                .forType(PersonInject.class)
                .readValue(personStr);
        System.out.println(personInject);
    }

    /**
     * @JsonDeserialize测试
     */
    @Test
    public void test4() throws JsonProcessingException {
        String personStr = "{\"id\":1,\"name\":\"tom\",\"enabled\":1}";
        PersonDeserialize person = new ObjectMapper()
                .readerFor(PersonDeserialize.class)
                .readValue(personStr);
        System.out.println(person);
    }

    /**
     * @throws JsonProcessingException
     * @JsonInclude测试
     * @JsonInclude 告诉 Jackson 仅在某些情况下包含属性。
     */
    @Test
    public void test5() throws JsonProcessingException {
        PersonInclude personInclude = new PersonInclude();
        personInclude.name = null;
        personInclude.personId = 10;
        String string = new ObjectMapper().writeValueAsString(personInclude);
        System.out.println(string);
    }

}

/**
 * @JsonIgnoreProperties 注释用于指定要忽略的类的属性列表。
 * @JsonAutoDetect 注释用于告诉 Jackson 在读取和写入对象时包含非公开的属性。
 */
@JsonIgnoreProperties({"firstName", "lastName"})
@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY)
class PersonIgnore {

    /**
     * @JsonIgnoreType 注释用于标记整个类型（类）在使用该类型的任何地方都将被忽略。
     */
    @JsonIgnoreType
    public class Address {
        public String streetName = null;
        public String houseNumber = null;
        public String zipCode = null;
        public String city = null;
        public String country = null;
    }


    public long personId = 0;

    public String firstName = null;
    public String lastName = null;

    /**
     * 注解 @JsonIgnore 用于告诉Jackson 忽略Java 对象的某个属性（字段）。
     * 将 JSON 读入 Java 对象和将 Java 对象写入 JSON 时，都会忽略该属性。
     */
    @JsonIgnore
    private Integer age;

    public long getPersonId() {
        return personId;
    }

    /**
     * @param personId
     * @JsonSetter 注释指示 Jackson 对给定的 JSON 字段使用 setter 方法。
     * @JsonSetter 注释中指定的值是与此 setter 方法匹配的 JSON 字段的名称。
     * 在这种情况下，名称是 id，因为这是我们要映射到 setPersonId() setter 方法的 JSON 对象中的字段的名称。
     */
    @JsonSetter("id")
    public void setPersonId(long personId) {
        this.personId = personId;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

class Bag {

    private Map<String, Object> properties = new HashMap<>();


    @JsonAnySetter
    public void set(String fieldName, Object value) {
        this.properties.put(fieldName, value);
    }

    public Object get(String fieldName) {
        return this.properties.get(fieldName);
    }

    @Override
    public String toString() {
        return "Bag{" +
                "properties=" + properties +
                '}';
    }
}

class PersonImmutable {

    private long id = 0;
    private String name = null;

    /**
     * 注解@JsonCreator 用于告诉Jackson Java 对象有一个构造函数（一个“创建者”），它可以将JSON 对象的字段与Java 对象的字段匹配。
     *
     * @param id
     * @param name
     * @JsonCreator 注释在无法使用 @JsonSetter 注释的情况下很有用。
     */
    @JsonCreator
    public PersonImmutable(
            @JsonProperty("id") long id,
            @JsonProperty("name") String name) {

        this.id = id;
        this.name = name;
    }

    public long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "PersonImmutable{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

class PersonInject {

    public long id = 0;
    public String name = null;

    /**
     * 注释 @JacksonInject 用于将值注入到解析的对象中，而不是从 JSON 中读取这些值。
     */
    @JacksonInject("source")
    public String source = null;

    @Override
    public String toString() {
        return "PersonInject{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", source='" + source + '\'' +
                '}';
    }
}

class PersonDeserialize {

    public long id = 0;
    public String name = null;

    @JsonDeserialize(using = OptimizedBooleanDeserializer.class)
    public boolean enabled = false;

    @Override
    public String toString() {
        return "PersonDeserialize{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", enabled=" + enabled +
                '}';
    }
}

class OptimizedBooleanDeserializer extends JsonDeserializer<Boolean> {

    @Override
    public Boolean deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {

        String text = jsonParser.getText();
        if ("0".equals(text)) {
            return false;
        }
        return true;
    }
}

/**
 * @JsonInclude 告诉 Jackson 仅在某些情况下包含属性。
 */
@JsonInclude(JsonInclude.Include.NON_EMPTY)
class PersonInclude {
    @JsonProperty("id")
    public long personId = 0;
    public String name = null;

    @Override
    public String toString() {
        return "PersonInclude{" +
                "personId=" + personId +
                ", name='" + name + '\'' +
                '}';
    }
}

class PersonGetter {

    private long personId = 0;

    /**
     * @JsonGetter 注释用于告诉 Jackson 应该通过调用 getter 方法而不是通过直接字段访问来获取某个字段值。
     */
    @JsonGetter("id")
    public long personId() {
        return this.personId;
    }

    @JsonSetter("id")
    public void personId(long personId) {
        this.personId = personId;
    }

}

/**
 * @JsonAnyGetter 注释使您能够使用 Map 作为要序列化为 JSON 的属性的容器。
 */
class PersonAnyGetter {

    private Map<String, Object> properties = new HashMap<>();

    @JsonAnyGetter
    public Map<String, Object> properties() {
        return properties;
    }
}

/**
 * @JsonPropertyOrder 注释可用于指定 Java 对象的字段应以何种顺序序列化为 JSON。
 */
@JsonPropertyOrder({"name", "personId"})
class PersonPropertyOrder {

    public long personId = 0;
    public String name = null;

}

class PersonRawValue {

    public long personId = 0;
    /**
     * @JsonRawValue 注释告诉 Jackson 这个属性值应该直接写入 JSON 输出
     */
    @JsonRawValue
    public String address = "{ \"street\" : \"Wall Street\", \"no\":1}";
}

class PersonValue {

    public long personId = 0;
    public String name = null;

    /**
     * @return
     * @JsonValue 告诉 Jackson 不应该尝试序列化对象本身，而是调用对象上的方法将对象序列化为 JSON 字符串。
     */
    @JsonValue
    public String toJson() {
        return this.personId + "," + this.name;
    }
}

class PersonSerializer {

    public long personId = 0;
    public String name = "John";
    /**
     * @JsonSerialize 注释用于为 Java 对象中的字段指定自定义序列化程序。
     */
    @JsonSerialize(using = OptimizedBooleanSerializer.class)
    public boolean enabled = false;
}

class OptimizedBooleanSerializer extends JsonSerializer<Boolean> {

    @Override
    public void serialize(Boolean aBoolean, JsonGenerator jsonGenerator,
                          SerializerProvider serializerProvider)
            throws IOException, JsonProcessingException {

        if (aBoolean) {
            jsonGenerator.writeNumber(1);
        } else {
            jsonGenerator.writeNumber(0);
        }
    }
}