출처 : https://www.baeldung.com/jackson-annotations

1. 개요

이 튜토리얼에서는 Jackson 주석 에 대해 자세히 알아보겠습니다 .

기존 주석을 사용하는 방법, 사용자 지정 주석을 만드는 방법, 마지막으로 주석을 비활성화하는 방법을 살펴보겠습니다.

2. 잭슨 직렬화 주석

먼저 직렬화 주석을 살펴보겠습니다.

2.1. @JsonAnyGetter

@JsonAnyGetter 주석을 사용하면 Map 필드를 표준 속성으로 유연하게 사용할 수 있습니다.

예를 들어, ExtendableBean 엔터티는 이름 속성과 키/값 쌍의 형태로 확장 가능한 속성 세트를 가지고 있습니다.

public class ExtendableBean {
    public String name;
    private Map<String, String> properties;

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

이 엔터티의 인스턴스를 직렬화할 때 Map 의 모든 키-값 을 표준 일반 속성으로 가져옵니다.

{
    "name":"My bean",
    "attr2":"val2",
    "attr1":"val1"
}

이 엔티티의 직렬화가 실제로 어떻게 보이는지 다음과 같습니다.

@Test
public void whenSerializingUsingJsonAnyGetter_thenCorrect()
  throws JsonProcessingException {
 
    ExtendableBean bean = new ExtendableBean("My bean");
    bean.add("attr1", "val1");
    bean.add("attr2", "val2");

    String result = new ObjectMapper().writeValueAsString(bean);
 
    assertThat(result, containsString("attr1"));
    assertThat(result, containsString("val1"));
}

false 로 활성화 된 선택적 인수를 사용하여 @JsonAnyGetter() 를 비활성화 할 수도 있습니다. 이 경우 Map 은 JSON으로 변환되어 직렬화 후 속성 변수 아래에 나타납니다.

2.2. @JsonGetter

@JsonGetter 주석은 메소드를 getter 메소드로 표시하는 @JsonProperty 주석 의 대안 입니다 .

다음 예제에서는 getTheName() 메서드를 MyBean 엔터티 의 name 속성에 대한 getter 메서드로 지정합니다.

public class MyBean {
    public int id;
    private String name;

    @JsonGetter("name")
    public String getTheName() {
        return name;
    }
}

이것이 실제로 작동하는 방식은 다음과 같습니다.

@Test
public void whenSerializingUsingJsonGetter_thenCorrect()
  throws JsonProcessingException {
 
    MyBean bean = new MyBean(1, "My bean");

    String result = new ObjectMapper().writeValueAsString(bean);
 
    assertThat(result, containsString("My bean"));
    assertThat(result, containsString("1"));
}

2.3. @JsonPropertyOrder

@JsonPropertyOrder 주석을 사용 하여 직렬화 시 속성의 순서 를 지정할 수 있습니다 .

MyBean 엔터티 의 속성에 대한 사용자 지정 순서를 설정해 보겠습니다 .

@JsonPropertyOrder({ "name", "id" })
public class MyBean {
    public int id;
    public String name;
}

직렬화의 출력은 다음과 같습니다.

{
    "name":"My bean",
    "id":1
}

그런 다음 간단한 테스트를 수행할 수 있습니다.

@Test
public void whenSerializingUsingJsonPropertyOrder_thenCorrect()
  throws JsonProcessingException {
 
    MyBean bean = new MyBean(1, "My bean");

    String result = new ObjectMapper().writeValueAsString(bean);
    assertThat(result, containsString("My bean"));
    assertThat(result, containsString("1"));
}

@JsonPropertyOrder(alphabetic=true) 를 사용하여 속성을 알파벳순으로 정렬 할 수도 있습니다 . 이 경우 직렬화의 출력은 다음과 같습니다.

{
    "id":1,
    "name":"My bean"
}

2.4. @JsonRawValue

@JsonRawValue 주석은 Jackson에게 속성을 있는 그대로 직렬화하도록 지시 할 수 있습니다 .

다음 예제에서는 @JsonRawValue 를 사용하여 일부 사용자 지정 JSON을 엔터티 값으로 포함합니다.

public class RawBean {
    public String name;

    @JsonRawValue
    public String json;
}

엔터티 직렬화의 출력은 다음과 같습니다.

{
    "name":"My bean",
    "json":{
        "attr":false
    }
}

다음은 간단한 테스트입니다.

@Test
public void whenSerializingUsingJsonRawValue_thenCorrect()
  throws JsonProcessingException {
 
    RawBean bean = new RawBean("My bean", "{\"attr\":false}");

    String result = new ObjectMapper().writeValueAsString(bean);
    assertThat(result, containsString("My bean"));
    assertThat(result, containsString("{\"attr\":false}"));
}

이 주석이 활성 상태인지 여부를 정의 하는 선택적 부울 인수 값 을 사용할 수도 있습니다 .

2.5. @JsonValue

@JsonValue 는 라이브러리가 전체 인스턴스를 직렬화하는 데 사용할 단일 메서드를 나타냅니다.

예를 들어 열거형에서 getName 에 @JsonValue 를 주석으로 추가하여 이러한 엔터티가 이름을 통해 직렬화되도록 합니다.

public enum TypeEnumWithValue {
    TYPE1(1, "Type A"), TYPE2(2, "Type 2");

    private Integer id;
    private String name;

    // standard constructors

    @JsonValue
    public String getName() {
        return name;
    }
}

이제 테스트가 있습니다.

@Test
public void whenSerializingUsingJsonValue_thenCorrect()
  throws JsonParseException, IOException {
 
    String enumAsString = new ObjectMapper()
      .writeValueAsString(TypeEnumWithValue.TYPE1);

    assertThat(enumAsString, is(""Type A""));
}

2.6. @JsonRootName

래핑 이 활성화된 경우 @JsonRootName 주석을 사용하여 사용할 루트 래퍼의 이름을 지정합니다.

래핑은 사용자 를 다음과 같이 직렬화하는 대신에 의미합니다 .

{
    "id": 1,
    "name": "John"
}

다음과 같이 포장됩니다.

{
    "User": {
        "id": 1,
        "name": "John"
    }
}

그럼 예를 하나 보겠습니다. 이 잠재적 래퍼 엔터티의 이름을 나타내기 위해 @JsonRootName 주석 을 사용할 것 입니다 .

@JsonRootName(value = "user")
public class UserWithRoot {
    public int id;
    public String name;
}

기본적으로 래퍼의 이름은 클래스 이름인 UserWithRoot 입니다. 주석을 사용하여 더 깔끔한 사용자를 얻습니다.

@Test
public void whenSerializingUsingJsonRootName_thenCorrect()
  throws JsonProcessingException {
 
    UserWithRoot user = new User(1, "John");

    ObjectMapper mapper = new ObjectMapper();
    mapper.enable(SerializationFeature.WRAP_ROOT_VALUE);
    String result = mapper.writeValueAsString(user);

    assertThat(result, containsString("John"));
    assertThat(result, containsString("user"));
}

직렬화의 출력은 다음과 같습니다.

{
    "user":{
        "id":1,
        "name":"John"
    }
}

Jackson 2.4 이후 로 XML과 같은 데이터 형식과 함께 사용할 수 있는 새로운 선택적 인수 네임스페이스 가 제공됩니다. 추가하면 정규화된 이름의 일부가 됩니다.

@JsonRootName(value = "user", namespace="users")
public class UserWithRootNamespace {
    public int id;
    public String name;

    // ...
}

XmlMapper로 직렬화 하면 출력은 다음과 같습니다.

<user xmlns="users">
    <id xmlns="">1</id>
    <name xmlns="">John</name>
    <items xmlns=""/>
</user>

2.7. @JsonSerialize

@JsonSerialize 는 엔터티 를 마샬링 할 때 사용할 사용자 지정 직렬 변환기를 나타냅니다 .

간단한 예를 살펴보겠습니다. @JsonSerialize 를 사용 하여 CustomDateSerializer 로 eventDate 속성 을 직렬화할 것입니다 .

public class EventWithSerializer {
    public String name;

    @JsonSerialize(using = CustomDateSerializer.class)
    public Date eventDate;
}

다음은 간단한 사용자 지정 Jackson 직렬 변환기입니다.

public class CustomDateSerializer extends StdSerializer<Date> {

    private static SimpleDateFormat formatter 
      = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");

    public CustomDateSerializer() { 
        this(null); 
    } 

    public CustomDateSerializer(Class<Date> t) {
        super(t); 
    }

    @Override
    public void serialize(
      Date value, JsonGenerator gen, SerializerProvider arg2) 
      throws IOException, JsonProcessingException {
        gen.writeString(formatter.format(value));
    }
}

이제 테스트에서 다음을 사용해 보겠습니다.

@Test
public void whenSerializingUsingJsonSerialize_thenCorrect()
  throws JsonProcessingException, ParseException {
 
    SimpleDateFormat df
      = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");

    String toParse = "20-12-2014 02:30:00";
    Date date = df.parse(toParse);
    EventWithSerializer event = new EventWithSerializer("party", date);

    String result = new ObjectMapper().writeValueAsString(event);
    assertThat(result, containsString(toParse));
}

3. Jackson 역직렬화 주석

다음으로 Jackson 역직렬화 주석을 살펴보겠습니다.

3.1. @JsonCreator

@JsonCreator 주석을 사용하여 역직렬화에 사용되는 생성자/팩토리를 조정할 수 있습니다 .

가져와야 하는 대상 엔터티와 정확히 일치하지 않는 일부 JSON을 역직렬화해야 할 때 매우 유용합니다.

예를 들어 보겠습니다. 다음 JSON을 역직렬화해야 한다고 가정해 보겠습니다.

{
    "id":1,
    "theName":"My bean"
}

그러나 대상 엔터티에는 이름 필드 가 없고 이름 필드만 있습니다. 이제 우리는 엔티티 자체를 변경하고 싶지 않습니다. @JsonCreator로 생성자에 주석을 달고 @JsonProperty 주석도 사용하여 비정렬화 프로세스를 좀 더 제어해야 합니다.

public class BeanWithCreator {
    public int id;
    public String name;

    @JsonCreator
    public BeanWithCreator(
      @JsonProperty("id") int id, 
      @JsonProperty("theName") String name) {
        this.id = id;
        this.name = name;
    }
}

이것을 실제로 봅시다:

@Test
public void whenDeserializingUsingJsonCreator_thenCorrect()
  throws IOException {
 
    String json = "{\"id\":1,\"theName\":\"My bean\"}";

    BeanWithCreator bean = new ObjectMapper()
      .readerFor(BeanWithCreator.class)
      .readValue(json);
    assertEquals("My bean", bean.name);
}

3.2. @JacksonInject

@JacksonInject 는 속성이 JSON 데이터가 아닌 주입에서 값을 가져옴을 나타냅니다.

다음 예제에서는 @JacksonInject 를 사용하여 속성 id 를 삽입합니다 .

public class BeanWithInject {
    @JacksonInject
    public int id;
    
    public String name;
}

작동 방식은 다음과 같습니다.

@Test
public void whenDeserializingUsingJsonInject_thenCorrect()
  throws IOException {
 
    String json = "{\"name\":\"My bean\"}";
    
    InjectableValues inject = new InjectableValues.Std()
      .addValue(int.class, 1);
    BeanWithInject bean = new ObjectMapper().reader(inject)
      .forType(BeanWithInject.class)
      .readValue(json);
    
    assertEquals("My bean", bean.name);
    assertEquals(1, bean.id);
}

3.3. @JsonAnySetter

@JsonAnySetter 를 사용하면 Map 을 표준 속성으로 유연하게 사용할 수 있습니다. 역직렬화에서 JSON의 속성은 단순히 맵에 추가됩니다.

먼저 @JsonAnySetter 를 사용하여 엔터티 ExtendableBean 을 역직렬화합니다 .

public class ExtendableBean {
    public String name;
    private Map<String, String> properties;

    @JsonAnySetter
    public void add(String key, String value) {
        properties.put(key, value);
    }
}

다음은 역직렬화해야 하는 JSON입니다.

{
    "name":"My bean",
    "attr2":"val2",
    "attr1":"val1"
}

그런 다음 모든 것이 함께 연결되는 방법은 다음과 같습니다.

@Test
public void whenDeserializingUsingJsonAnySetter_thenCorrect()
  throws IOException {
    String json
      = "{\"name\":\"My bean\",\"attr2\":\"val2\",\"attr1\":\"val1\"}";

    ExtendableBean bean = new ObjectMapper()
      .readerFor(ExtendableBean.class)
      .readValue(json);
    
    assertEquals("My bean", bean.name);
    assertEquals("val2", bean.getProperties().get("attr2"));
}

3.4. @JsonSetter

@JsonSetter 는 메서드를 setter 메서드로 표시하는 @JsonProperty 의 대안 입니다.

이것은 일부 JSON 데이터를 읽어야 할 때 매우 유용하지만 대상 엔터티 클래스가 해당 데이터와 정확히 일치하지 않으므로 적합하도록 프로세스를 조정해야 합니다.

다음 예제에서 우리는 MyBean 엔티티 에서 name 속성 의 setter로 etTheName() 메소드를 지정할 것입니다:

public class MyBean {
    public int id;
    private String name;

    @JsonSetter("name")
    public void setTheName(String name) {
        this.name = name;
    }
}

이제 일부 JSON 데이터를 비정렬화해야 할 때 완벽하게 작동합니다.

@Test
public void whenDeserializingUsingJsonSetter_thenCorrect()
  throws IOException {
 
    String json = "{\"id\":1,\"name\":\"My bean\"}";

    MyBean bean = new ObjectMapper()
      .readerFor(MyBean.class)
      .readValue(json);
    assertEquals("My bean", bean.getTheName());
}

3.5. @JsonDeserialize

@JsonDeserialize 는 커스텀 디시리얼라이저의 사용을 나타냅니다.

먼저 @JsonDeserialize 를 사용하여 CustomDateDeserializer 로 eventDate 속성 을 역직렬화합니다 .

public class EventWithSerializer {
    public String name;

    @JsonDeserialize(using = CustomDateDeserializer.class)
    public Date eventDate;
}

다음은 사용자 지정 디시리얼라이저입니다.

public class CustomDateDeserializer
  extends StdDeserializer<Date> {

    private static SimpleDateFormat formatter
      = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");

    public CustomDateDeserializer() { 
        this(null); 
    } 

    public CustomDateDeserializer(Class<?> vc) { 
        super(vc); 
    }

    @Override
    public Date deserialize(
      JsonParser jsonparser, DeserializationContext context) 
      throws IOException {
        
        String date = jsonparser.getText();
        try {
            return formatter.parse(date);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }
}

다음은 연속 테스트입니다.

@Test
public void whenDeserializingUsingJsonDeserialize_thenCorrect()
  throws IOException {
 
    String json
      = "{"name":"party","eventDate":"20-12-2014 02:30:00"}";

    SimpleDateFormat df
      = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");
    EventWithSerializer event = new ObjectMapper()
      .readerFor(EventWithSerializer.class)
      .readValue(json);
    
    assertEquals(
      "20-12-2014 02:30:00", df.format(event.eventDate));
}

3.6. @JsonAlias

@JsonAlias 는 역직렬화 동안 속성에 대한 하나 이상의 대체 이름을 정의합니다 .

빠른 예를 통해 이 주석이 어떻게 작동하는지 살펴보겠습니다.

public class AliasBean {
    @JsonAlias({ "fName", "f_name" })
    private String firstName;   
    private String lastName;
}

여기에 POJO가 있고 fName , f_name 및 firstName 과 같은 값을 사용하여 JSON을 POJO 의 firstName 변수로 역직렬화하려고 합니다.

다음은 이 주석이 예상대로 작동하는지 확인하는 테스트입니다.

@Test
public void whenDeserializingUsingJsonAlias_thenCorrect() throws IOException {
    String json = "{\"fName\": \"John\", \"lastName\": \"Green\"}";
    AliasBean aliasBean = new ObjectMapper().readerFor(AliasBean.class).readValue(json);
    assertEquals("John", aliasBean.getFirstName());
}

4. 잭슨 속성 포함 주석

4.1. @JsonIgnoreProperties

@JsonIgnoreProperties 는 Jackson이 무시할 속성 또는 속성 목록을 표시하는 클래스 수준 주석입니다.

직렬화 에서 속성 ID 를 무시하는 빠른 예를 살펴보겠습니다 .

@JsonIgnoreProperties({ "id" })
public class BeanWithIgnore {
    public int id;
    public String name;
}

이제 무시가 발생하는지 확인하는 테스트가 있습니다.

@Test
public void whenSerializingUsingJsonIgnoreProperties_thenCorrect()
  throws JsonProcessingException {
 
    BeanWithIgnore bean = new BeanWithIgnore(1, "My bean");

    String result = new ObjectMapper()
      .writeValueAsString(bean);
    
    assertThat(result, containsString("My bean"));
    assertThat(result, not(containsString("id")));
}

예외 없이 JSON 입력의 알 수 없는 속성을 무시하려면 @JsonIgnoreProperties 주석 의 ignoreUnknown=true 를 설정할 수 있습니다.

4.2. @Json무시

대조적으로 @JsonIgnore 주석은 필드 수준에서 속성을 무시하도록 표시하는 데 사용됩니다.

@JsonIgnore 를 사용 하여 직렬화 에서 속성 ID 를 무시해 보겠습니다.

public class BeanWithIgnore {
    @JsonIgnore
    public int id;

    public String name;
}

그런 다음 id 가 성공적으로 무시 되었는지 테스트합니다 .

@Test
public void whenSerializingUsingJsonIgnore_thenCorrect()
  throws JsonProcessingException {
 
    BeanWithIgnore bean = new BeanWithIgnore(1, "My bean");

    String result = new ObjectMapper()
      .writeValueAsString(bean);
    
    assertThat(result, containsString("My bean"));
    assertThat(result, not(containsString("id")));
}

4.3. @JsonIgnoreType

@JsonIgnoreType 은 주석이 달린 유형의 모든 속성을 무시하도록 표시합니다.

주석을 사용하여 Name 유형의 모든 속성을 무시하도록 표시할 수 있습니다.

public class User {
    public int id;
    public Name name;

    @JsonIgnoreType
    public static class Name {
        public String firstName;
        public String lastName;
    }
}

무시가 올바르게 작동하는지 테스트할 수도 있습니다.

@Test
public void whenSerializingUsingJsonIgnoreType_thenCorrect()
  throws JsonProcessingException, ParseException {
 
    User.Name name = new User.Name("John", "Doe");
    User user = new User(1, name);

    String result = new ObjectMapper()
      .writeValueAsString(user);

    assertThat(result, containsString("1"));
    assertThat(result, not(containsString("name")));
    assertThat(result, not(containsString("John")));
}

4.4. @Json인클루드

@JsonInclude 를 사용 하여 비어 있는/null/기본값이 있는 속성을 제외할 수 있습니다.

직렬화에서 null을 제외하는 예를 살펴보겠습니다.

@JsonInclude(Include.NON_NULL)
public class MyBean {
    public int id;
    public String name;
}

전체 테스트는 다음과 같습니다.

public void whenSerializingUsingJsonInclude_thenCorrect()
  throws JsonProcessingException {
 
    MyBean bean = new MyBean(1, null);

    String result = new ObjectMapper()
      .writeValueAsString(bean);
    
    assertThat(result, containsString("1"));
    assertThat(result, not(containsString("name")));
}

4.5. @JsonAutoDetect

@JsonAutoDetect 는 속성이 표시되고 표시되지 않는 기본 의미를 재정의할 수 있습니다 .

먼저 간단한 예에서 주석이 어떻게 매우 도움이 될 수 있는지 살펴보겠습니다. 개인 속성 직렬화를 활성화합시다:

@JsonAutoDetect(fieldVisibility = Visibility.ANY)
public class PrivateBean {
    private int id;
    private String name;
}

그런 다음 테스트:

@Test
public void whenSerializingUsingJsonAutoDetect_thenCorrect()
  throws JsonProcessingException {
 
    PrivateBean bean = new PrivateBean(1, "My bean");

    String result = new ObjectMapper()
      .writeValueAsString(bean);
    
    assertThat(result, containsString("1"));
    assertThat(result, containsString("My bean"));
}

5. Jackson 다형성 유형 처리 주석

다음으로 Jackson 다형성 유형 처리 주석을 살펴보겠습니다.

@JsonTypeInfo – 직렬화에 포함할 유형 정보의 세부 정보를 나타냅니다.
@JsonSubTypes – 주석이 달린 유형의 하위 유형을 나타냅니다.
@JsonTypeName – 주석이 달린 클래스에 사용할 논리적 유형 이름을 정의합니다.

좀 더 복잡한 예를 살펴 보고 @JsonTypeInfo , @JsonSubTypes 및 @JsonTypeName 의 세 가지 모두를 사용하여 Zoo 엔터티를 직렬화/역직렬화해 보겠습니다 .

public class Zoo {
    public Animal animal;

    @JsonTypeInfo(
      use = JsonTypeInfo.Id.NAME, 
      include = As.PROPERTY, 
      property = "type")
    @JsonSubTypes({
        @JsonSubTypes.Type(value = Dog.class, name = "dog"),
        @JsonSubTypes.Type(value = Cat.class, name = "cat")
    })
    public static class Animal {
        public String name;
    }

    @JsonTypeName("dog")
    public static class Dog extends Animal {
        public double barkVolume;
    }

    @JsonTypeName("cat")
    public static class Cat extends Animal {
        boolean likesCream;
        public int lives;
    }
}

직렬화를 수행할 때:

@Test
public void whenSerializingPolymorphic_thenCorrect()
  throws JsonProcessingException {
    Zoo.Dog dog = new Zoo.Dog("lacy");
    Zoo zoo = new Zoo(dog);

    String result = new ObjectMapper()
      .writeValueAsString(zoo);

    assertThat(result, containsString("type"));
    assertThat(result, containsString("dog"));
}

Zoo 인스턴스를 Dog 로 직렬화하면 다음 과 같은 결과가 나타납니다.

{
    "animal": {
        "type": "dog",
        "name": "lacy",
        "barkVolume": 0
    }
}

이제 역 직렬화를 위해. 다음 JSON 입력으로 시작하겠습니다.

{
    "animal":{
        "name":"lacy",
        "type":"cat"
    }
}

그런 다음 Zoo 인스턴스 로 비정렬화되는 방법을 살펴보겠습니다 .

@Test
public void whenDeserializingPolymorphic_thenCorrect()
throws IOException {
    String json = "{\"animal\":{\"name\":\"lacy\",\"type\":\"cat\"}}";

    Zoo zoo = new ObjectMapper()
      .readerFor(Zoo.class)
      .readValue(json);

    assertEquals("lacy", zoo.animal.name);
    assertEquals(Zoo.Cat.class, zoo.animal.getClass());
}

6. 잭슨 일반 주석

다음으로 Jackson의 좀 더 일반적인 주석에 대해 논의해 보겠습니다.

6.1. @JsonProperty

@JsonProperty 주석을 추가 하여 JSON에서 속성 이름을 나타낼 수 있습니다 .

비표준 getter 및 setter를 처리할 때 @JsonProperty 를 사용 하여 속성 이름 을 직렬화/역직렬화해 보겠습니다.

public class MyBean {
    public int id;
    private String name;

    @JsonProperty("name")
    public void setTheName(String name) {
        this.name = name;
    }

    @JsonProperty("name")
    public String getTheName() {
        return name;
    }
}

다음은 테스트입니다.

@Test
public void whenUsingJsonProperty_thenCorrect()
  throws IOException {
    MyBean bean = new MyBean(1, "My bean");

    String result = new ObjectMapper().writeValueAsString(bean);
    
    assertThat(result, containsString("My bean"));
    assertThat(result, containsString("1"));

    MyBean resultBean = new ObjectMapper()
      .readerFor(MyBean.class)
      .readValue(result);
    assertEquals("My bean", resultBean.getTheName());
}

6.2. @JsonFormat

@JsonFormat 주석은 날짜/시간 값을 직렬화할 때 형식을 지정합니다.

다음 예제에서는 @JsonFormat 을 사용하여 eventDate 속성의 형식을 제어합니다 .

public class EventWithFormat {
    public String name;

    @JsonFormat(
      shape = JsonFormat.Shape.STRING,
      pattern = "dd-MM-yyyy hh:mm:ss")
    public Date eventDate;
}

다음은 테스트입니다.

@Test
public void whenSerializingUsingJsonFormat_thenCorrect()
  throws JsonProcessingException, ParseException {
    SimpleDateFormat df = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");
    df.setTimeZone(TimeZone.getTimeZone("UTC"));

    String toParse = "20-12-2014 02:30:00";
    Date date = df.parse(toParse);
    EventWithFormat event = new EventWithFormat("party", date);
    
    String result = new ObjectMapper().writeValueAsString(event);
    
    assertThat(result, containsString(toParse));
}

6.3. @JsonUnwrapped

@JsonUnwrapped 는 직렬화/역직렬화 시 unwrapped/flatten되어야 하는 값을 정의합니다.

이것이 어떻게 작동하는지 봅시다. 속성 이름 을 풀기 위해 주석을 사용할 것입니다 .

public class UnwrappedUser {
    public int id;

    @JsonUnwrapped
    public Name name;

    public static class Name {
        public String firstName;
        public String lastName;
    }
}

이제 이 클래스의 인스턴스를 직렬화해 보겠습니다.

@Test
public void whenSerializingUsingJsonUnwrapped_thenCorrect()
  throws JsonProcessingException, ParseException {
    UnwrappedUser.Name name = new UnwrappedUser.Name("John", "Doe");
    UnwrappedUser user = new UnwrappedUser(1, name);

    String result = new ObjectMapper().writeValueAsString(user);
    
    assertThat(result, containsString("John"));
    assertThat(result, not(containsString("name")));
}

마지막으로 출력은 다음과 같습니다. 다른 필드와 함께 래핑되지 않은 정적 중첩 클래스의 필드입니다.

{
    "id":1,
    "firstName":"John",
    "lastName":"Doe"
}

6.4. @JsonView

@JsonView 는 직렬화/역직렬화를 위해 속성이 포함될 View를 나타냅니다.

예를 들어 @JsonView 를 사용하여 Item 엔터티 의 인스턴스를 직렬화합니다 .

먼저 보기부터 시작하겠습니다.

public class Views {
    public static class Public {}
    public static class Internal extends Public {}
}

다음은 보기를 사용하는 항목 엔터티입니다.

public class Item {
    @JsonView(Views.Public.class)
    public int id;

    @JsonView(Views.Public.class)
    public String itemName;

    @JsonView(Views.Internal.class)
    public String ownerName;
}

마지막으로 전체 테스트:

@Test
public void whenSerializingUsingJsonView_thenCorrect()
  throws JsonProcessingException {
    Item item = new Item(2, "book", "John");

    String result = new ObjectMapper()
      .writerWithView(Views.Public.class)
      .writeValueAsString(item);

    assertThat(result, containsString("book"));
    assertThat(result, containsString("2"));
    assertThat(result, not(containsString("John")));
}

6.5. @JsonManagedReference, @JsonBackReference

@JsonManagedReference 및 @JsonBackReference 주석은 부모/자식 관계를 처리 하고 루프를 해결할 수 있습니다 .

다음 예제에서는 @JsonManagedReference 및 @JsonBackReference 를 사용하여 ItemWithRef 엔터티 를 직렬화합니다 .

public class ItemWithRef {
    public int id;
    public String itemName;

    @JsonManagedReference
    public UserWithRef owner;
}

우리의 UserWithRef 엔터티:

public class UserWithRef {
    public int id;
    public String name;

    @JsonBackReference
    public List<ItemWithRef> userItems;
}

그런 다음 테스트:

@Test
public void whenSerializingUsingJacksonReferenceAnnotation_thenCorrect()
  throws JsonProcessingException {
    UserWithRef user = new UserWithRef(1, "John");
    ItemWithRef item = new ItemWithRef(2, "book", user);
    user.addItem(item);

    String result = new ObjectMapper().writeValueAsString(item);

    assertThat(result, containsString("book"));
    assertThat(result, containsString("John"));
    assertThat(result, not(containsString("userItems")));
}

6.6. @JsonIdentityInfo

@JsonIdentityInfo 는 예를 들어 무한 재귀 유형의 문제를 처리할 때와 같이 값을 직렬화/역직렬화할 때 개체 ID를 사용해야 함을 나타냅니다.

다음 예에는 UserWithIdentity 엔터티와 양방향 관계가 있는 ItemWithIdentity 엔터티가 있습니다.

@JsonIdentityInfo(
  generator = ObjectIdGenerators.PropertyGenerator.class,
  property = "id")
public class ItemWithIdentity {
    public int id;
    public String itemName;
    public UserWithIdentity owner;
}

UserWithIdentity 엔터티 :

@JsonIdentityInfo(
  generator = ObjectIdGenerators.PropertyGenerator.class,
  property = "id")
public class UserWithIdentity {
    public int id;
    public String name;
    public List<ItemWithIdentity> userItems;
}

이제 무한 재귀 문제가 어떻게 처리되는지 봅시다 .

@Test
public void whenSerializingUsingJsonIdentityInfo_thenCorrect()
  throws JsonProcessingException {
    UserWithIdentity user = new UserWithIdentity(1, "John");
    ItemWithIdentity item = new ItemWithIdentity(2, "book", user);
    user.addItem(item);

    String result = new ObjectMapper().writeValueAsString(item);

    assertThat(result, containsString("book"));
    assertThat(result, containsString("John"));
    assertThat(result, containsString("userItems"));
}

다음은 직렬화된 항목 및 사용자의 전체 출력입니다.

{
    "id": 2,
    "itemName": "book",
    "owner": {
        "id": 1,
        "name": "John",
        "userItems": [
            2
        ]
    }
}

6.7. @JsonFilter

@JsonFilter 주석은 직렬화 중에 사용할 필터를 지정합니다.

먼저 엔티티를 정의하고 필터를 가리킵니다.

@JsonFilter("myFilter")
public class BeanWithFilter {
    public int id;
    public String name;
}

이제 전체 테스트 에서 직렬화에서 이름 을 제외한 다른 모든 속성을 제외하는 필터를 정의합니다 .

@Test
public void whenSerializingUsingJsonFilter_thenCorrect()
  throws JsonProcessingException {
    BeanWithFilter bean = new BeanWithFilter(1, "My bean");

    FilterProvider filters 
      = new SimpleFilterProvider().addFilter(
        "myFilter", 
        SimpleBeanPropertyFilter.filterOutAllExcept("name"));

    String result = new ObjectMapper()
      .writer(filters)
      .writeValueAsString(bean);

    assertThat(result, containsString("My bean"));
    assertThat(result, not(containsString("id")));
}

7. 커스텀 잭슨 주석

다음으로 사용자 지정 Jackson 주석을 만드는 방법을 살펴보겠습니다. @JacksonAnnotationsInside 주석 을 사용할 수 있습니다 .

@Retention(RetentionPolicy.RUNTIME)
    @JacksonAnnotationsInside
    @JsonInclude(Include.NON_NULL)
    @JsonPropertyOrder({ "name", "id", "dateCreated" })
    public @interface CustomAnnotation {}

이제 엔티티에서 새 주석을 사용하는 경우:

@CustomAnnotation
public class BeanWithCustomAnnotation {
    public int id;
    public String name;
    public Date dateCreated;
}

기존 주석을 약어로 사용할 수 있는 간단한 사용자 정의 주석으로 결합하는 방법을 볼 수 있습니다.

@Test
public void whenSerializingUsingCustomAnnotation_thenCorrect()
  throws JsonProcessingException {
    BeanWithCustomAnnotation bean 
      = new BeanWithCustomAnnotation(1, "My bean", null);

    String result = new ObjectMapper().writeValueAsString(bean);

    assertThat(result, containsString("My bean"));
    assertThat(result, containsString("1"));
    assertThat(result, not(containsString("dateCreated")));
}

직렬화 프로세스의 출력:

{
    "name":"My bean",
    "id":1
}

8. 잭슨 믹스인 주석

다음으로 Jackson MixIn 주석을 사용하는 방법을 살펴보겠습니다.

예를 들어, MixIn 주석을 사용하여 User 유형의 속성을 무시해 보겠습니다 .

public class Item {
    public int id;
    public String itemName;
    public User owner;
}

@JsonIgnoreType
public class MyMixInForIgnoreType {}

그러면 다음과 같이 작동하는 것을 보겠습니다.

@Test
public void whenSerializingUsingMixInAnnotation_thenCorrect() 
  throws JsonProcessingException {
    Item item = new Item(1, "book", null);

    String result = new ObjectMapper().writeValueAsString(item);
    assertThat(result, containsString("owner"));

    ObjectMapper mapper = new ObjectMapper();
    mapper.addMixIn(User.class, MyMixInForIgnoreType.class);

    result = mapper.writeValueAsString(item);
    assertThat(result, not(containsString("owner")));
}

9. Jackson 주석 비활성화

마지막으로 모든 Jackson 주석을 비활성화 하는 방법을 살펴보겠습니다 . MapperFeature 를 비활성화하여 이를 수행할 수 있습니다 . 다음 예와 같이 USE_ANNOTATIONS:

@JsonInclude(Include.NON_NULL)
@JsonPropertyOrder({ "name", "id" })
public class MyBean {
    public int id;
    public String name;
}

이제 주석을 비활성화한 후에는 효과가 없고 라이브러리의 기본값이 적용되어야 합니다.

@Test
public void whenDisablingAllAnnotations_thenAllDisabled()
  throws IOException {
    MyBean bean = new MyBean(1, null);

    ObjectMapper mapper = new ObjectMapper();
    mapper.disable(MapperFeature.USE_ANNOTATIONS);
    String result = mapper.writeValueAsString(bean);
    
    assertThat(result, containsString("1"));
    assertThat(result, containsString("name"));
}

주석을 비활성화하기 전 직렬화 결과:

{"id":1}

주석 비활성화 후 직렬화 결과:

{
    "id":1,
    "name":null
}

10. 결론

이 기사에서는 Jackson 주석을 올바르게 사용하여 얻을 수 있는 유연성의 표면을 긁어 조사했습니다.
이러한 모든 예제와 코드 스니펫의 구현은 GitHub 에서 찾을 수 있습니다 .

[Java & Spring] 제이슨 관리 잭슨 json manage jackson-annotations