[Spring] Jackson annotation - Serialization 알아보기

문득 직렬화 관련해서 궁금해하다가, Jackson 라이브러리에 대해서도 한 번 공부해보면 좋을 것 같아서 작성하는 글!

정말 간단하고 얕게 정리할 예정이라, 나중에 깊게 공부하게 된다면 한 번 더 작성해보지 않을까 싶다 🫠

---

 

✔️ Serialization

Serialization is taking the properties of an object, and converting them into json string representation.

직렬화란 무엇일까? 객체의 속성을 가져와서 Json 문자열 표현으로 변환하는 것을 의미한다.

정확하게는, 객체를 바이트 스트림으로 변환하는 것이며, 직렬화된 객체는 나중에 다시 복원이 가능하다.

 

public class Crew {
    private String name;
    private int age;
    private String course;
}

 

이러한 객체가 존재한다고 가정했을 때, 다음과 같은 형태로 변경하는 것이다.

{
    "Crew": {
        "name": "져니",
        "age": 23,
        "course": "Backend"
    }
}

 

직렬화를 사용하면 바이트 단위로 변환하기 때문에 파일이나 네트워크를 통해 주고받을 수 있게 된다.

https://hazelcast.com/glossary/serialization/

 

위 그림을 보면 이해하기가 쉬울 것이다.

객체를 저장하거나 외부로 전송하기 위해, 객체를 바이트 스트림으로 변환하는 것을 직렬화라고 한다.

직렬화는 언제 사용할 수 있을까? 다음과 같은 상황에서 사용이 가능하다.

 

1. 메시징 시나리오에서 객체를 전송하기 위하여

2. REST API 같은 웹 서비스에서 애플리케이션끼리 통신할 때

3. 방화벽을 통해 전송할 때

4. 다른 데이터 저장소로 저장할 때

5. 데이터의 변경 사항을 식별할 때 (이전 상태와 비교하여 객체의 변경 판단)

...

 

등등에서 사용할 수 있다.

 

자바에서 모든 클래스를 직렬화할 수는 없다. java.io.Serializable 인터페이스를 구현한 클래스의 객체만 직렬화할 수 있다.

public interface Serializable {
}

Serializable 인터페이스를 살펴보자.

내부적으로 아무 메서드도 존재하지 않지만, '직렬화가 가능한 객체'라는 것을 나타내기 위한 마커용 인터페이스이다.

 

---

 

✔️ Jackson

Jackson 라이브러리는 Java에서 Json으로 직렬화할 때 사용하는 대표적인 라이브러리이다.

(물론 Json뿐만 아니라 XML, YAML, CSV 등, 다양한 형식의 데이터를 지원하는 데이터 전처리 툴이다)

implementation 'com.fasterxml.jackson.core:jackson-databind:2.14.2'

실습을 위해, build.gradle에 다음과 같은 의존성을 추가해두도록 하자.

 

---

🌱 Jackson의 기본 직렬화 전략

일단 Jackson이 어떤 식으로 직렬화를 진행하는지 대략적으로 살펴보자.

기본적으로 어떠한 객체가 있을 때, getter가 없다면 public 필드에 대해서만 직렬화를 진행한다.

public class Crew {

   public final String publicName;
   protected final String protectedName;
   final String defaultName;
   private final String privateName;

    public Crew(final String publicName, final String protectedName, final String defaultName, final String privateName) {
        this.publicName = publicName;
        this.protectedName = protectedName;
        this.defaultName = defaultName;
        this.privateName = privateName;
    }
}

위와 같이 public 필드인 publicName만 출력되는 것을 볼 수 있다.

 

만약, public이 아닌 필드를 직렬화 하고 싶다면 getter를 열어줘야 한다.

public String getPrivateName() {
    return privateName;
}

privateName으로 getter를 열어두었더니 직렬화 대상에 포함된 것을 확인할 수 있다.

 

만약, 소스 코드를 수정할 수 없는 상황이라면 직렬화 시 옵션으로 줄 수도 있다.

final ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY);
String result = objectMapper.writeValueAsString(crew);

이런 식으로 모든 필드에 대해서 Visibility를 Any로 설정한다면 다음과 같이 직렬화가 가능하다.

(하지만 보통 이렇게는 잘 사용하지 않을 것 같다. 비용적인 문제도 있고 + 관리 포인트의 증가도 있고 + 보통 ObjectMapper는 빈으로 1번만 등록해서 사용할 텐데 모든 객체들에 대해 이 옵션을 지정할 수는 없으니까...)

 

---

 

🌱 @JsonGetter

Marker annotation that can be used to define a non-static, no-argument value-returning (non-void) method to be used as a "getter" for a logical property. It can be used as an alternative to more general 
JsonProperty annotation (which is the recommended choice in general case).

Getter means that when serializing Object instance of class that has this method (possibly inherited from a super class), a call is made through the method, and return value will be serialized as value of the property.

논리적 프로퍼티의 "getter"로 사용할 non-static하거나 파라미터가 없으면서 void 형이 아닌 메서드를 정의하는 데 사용할 수 있는 마커 어노테이션이다. @JsonProperty의 대안으로 사용될 수 있다. 또한, 해당 메서드를 가진 클래스의 객체 인스턴스를 직렬화 할 때 이 메서드를 통해 호출하고, 반환값을 Json 프로퍼티 값으로 직렬화한다는 의미를 가진다.

 

메서드의 반환 값을 직렬화 하기 위해서 Jackson의 @JsonGetter 어노테이션을 활용할 수 있다.

이 메서드는 직렬화 중에 호출되며, 호출된 이후 반환값은 직렬화가 된다.

또한, @JsonGetter 어노테이션을 사용하기 위해서 해당 메서드는 static하지 않아야 한다.

json의 결과에 대한 name의 메서드 이름에서 따오지만, 별도로 지정도 가능하다.

 

예시를 들어보자. 크루들의 정보를 저장하는 클래스가 있고, 해당 클래스는 크루들이 지금까지 먹은 점심 메뉴 정보를 담는 리스트를 가지고 있다. (예시를 위해서 말도 안 되는 객체를 생성하였다... ^_^)

public class Menu {
    private final String name;
    private final int price;

    public Menu(final String name, final int price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public int getPrice() {
        return price;
    }
}

직렬화를 위해서는 getter가 필요하기 때문에 Menu의 필드들에 대한 getter는 열어두도록 하자.

public class Crew {
    private final String name;
    private final int age;
    private final List<Menu> menus;

    public Crew(final String name, final int age, final List<Menu> menus) {
        this.name = name;
        this.age = age;
        this.menus = menus;
    }

    @JsonGetter
    public List<Menu> getMenus() {
        return menus;
    }
}

그리고, 이를 반환하기 위한 getMenus 메서드에 @JsonGetter를 붙여주었다.

이러면 Crew 클래스를 직렬화 되고, 반환값으로 Json을 가질 수 있도록 해준다. 

기본적으로 해당 Json 배열의 속성 이름은 메서드 네임을 기반으로 하며, getXXX 메서드에서 get이 제거된다.

 

위의 경우, getMenus라는 메서드이기 때문에 get이라는 네이밍이 제거되고, 그 뒤에 붙은 'Menus'가 카멜 케이스로 형식이 지정된 다음 프로퍼티 이름으로 사용된다. 

 

직렬화가 잘 되는지 한 번 확인해보자.

@Test
public void jsonGetter() throws JsonProcessingException {
    // given
    final List<Menu> menus = List.of(new Menu("마라탕", 10000), new Menu("제육", 10000));
    final Crew crew = new Crew("져니", 23, menus);

    // when
    String result = new ObjectMapper().writeValueAsString(crew);
    System.out.println(result);

    // then
    assertThat(JsonPath.from(result).getList("menus"))
            .isNotNull();
}

테스트 결과, 성공이 되었다.

출력했을 때도 menu에 대해 값들이 굉장히 잘 담긴 것을 볼 수 있다.

(참고로, getter를 통해 열어준 값에 대해서만 직렬화가 된다. 위에서는 menus에 대한 getter만 존재하기 때문에 메뉴 정보만 나왔다.)

사실 getter만 있어도 직렬화는 잘 되기 때문에 @JsonGetter를 이런 식으로 사용하는 것은 의미가 없다.

 

public class Crew {
    private final String name;
    private final int age;
    private final List<Menu> menus;

    public Crew(final String name, final int age, final List<Menu> menus) {
        this.name = name;
        this.age = age;
        this.menus = menus;
    }

    @JsonGetter(value = "lunch")
    public List<Menu> getMenus() {
        return menus;
    }
}

 

위와 같이 JsonGetter의 value 값으로, json의 이름을 정해줄 수 있다.

@Test
public void jsonGetter() throws JsonProcessingException {
    // given
    final List<Menu> menus = List.of(new Menu("마라탕", 10000), new Menu("제육", 10000));
    final Crew crew = new Crew("져니", 23, menus);

    // when
    String result = new ObjectMapper().writeValueAsString(crew);
    System.out.println(result);

    // then
    assertThat(JsonPath.from(result).getList("lunch"))
            .isNotNull();
}

다시 테스트 코드를 돌려보자. 이번에는 lunch라는 이름으로 나온 것을 볼 수 있다.

하지만, 사실 이것도 잘 쓰지는 않는다.

getter의 네이밍 자체를 getLunch라고 한다면 'lunch'라는 필드로 값이 나오기 때문이다.

 

---

🌱 @JsonPropertyOrder

Annotation that can be used to define ordering (possibly partial) to use when serializing object properties. Properties included in annotation declaration will be serialized first (in defined order), followed by any properties not included in the definition. Annotation definition will override any implicit orderings (such as guarantee that Creator-properties are serialized before non-creator properties)

This annotation may or may not have effect on deserialization: for basic JSON handling there is no effect, but for other supported data types (or structural conventions) there may be.

객체 프로퍼티를 직렬화할 때 사용할 순서(부분적일 수 있음)를 정의하는 데 사용할 수 있는 어노테이션이다. 
어노테이션 선언에 포함된 프로퍼티가 정의된 순서대로 먼저 직렬화되고, 그 다음 포함되지 않은 프로퍼티가 진행된다.

역직렬화에 영향을 미칠 수도 있고, 아닐 수도 있다.
기본 JSON 처리의 경우 영향을 미치지 않지만 지원되는 다른 데이터 유형(또는 구조적 규칙)의 경우 영향을 미칠 수 있다.

 

@JsonPropertyOrder를 사용하면 json property의 순서를 지정해줄 수 있다.

주로 클래스 레벨에 붙이며, 우리가 원하는 순서대로 직렬화될 이름을 지정해주면 된다.

@JsonPropertyOrder(value = "{age}", alphabetic = true)
public class Crew {
    private final String name;
    private final int age;
    private final List<Menu> menus;

    public Crew(final String name, final int age, final List<Menu> menus) {
        this.name = name;
        this.age = age;
        this.menus = menus;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public List<Menu> getMenus() {
        return menus;
    }
}

이때, 모든 필드에 대해서 지정해주지 않았다면 남은 필드에 대해서 알파벳순으로 정렬시킬 수 있다. (alphabetic = true)

우리는 이제 age -> menus -> name 순으로 뜨기를 원할 것이다.

결과를 보면, 우리가 원하는대로 순서가 잘 지정된 것을 볼 수 있다.

 

문득 궁금해서 value에 들어가야 하는 값이 필드명이 아니라, 직렬화 시 나와야 하는 필드명인가 싶어서 실험을 해보았다.

@JsonGetter(value = "zebra")
public int getAge() {
    return age;
}

그래서 getAge에 JsonGetter를 통해서 알파벳 맨 뒤로 갈 수 있도록 zebra라는 이름을 부여했다.

확인 결과, 가장 뒤로 갔다.

이로 인해서 value 내부에 들어가는 값은 필드가 아니라, 직렬화 시 나오는 값을 기준으로 한다는 것을 알게 되었다.

 

---

🌱 JsonRawValue

Marker annotation that indicates that the annotated method or field should be serialized by including literal String value of the property as is, without quoting of characters. This can be useful for injecting values already serialized in JSON or passing javascript function definitions from server to a javascript client.

어노테이션이 달린 메서드나 필드가 문자를 따옴표로 묶지 않고, 프로퍼티의 리터럴 문자열 값을 그대로 포함해서 직렬화하는 것을 나타내는 마커 어노테이션이다. 이미 Json으로 직렬화된 값을 삽입하거나, 서버에서 자바스크립트 함수 정의를 자바스크립트 클라이언트로 전달해야 할 때 유용하게 사용할 수 있다.

 

이미 직렬화된 Json 값을 문자열로 표현하고 싶을 때 사용한다.

public class Crew {

    @JsonRawValue
    private String info;

    public String getInfo() {
        return info;
    }

    public void setInfo(final String info) {
        this.info = info;
    }
}

@Test
void jsonRawValue() throws JsonProcessingException {
    // given
    Crew crew = new Crew();
    crew.setInfo("{\"name\":\"져니\", \"age\":23}");

    // when
    String result = new ObjectMapper().writeValueAsString(crew);

    // then
    System.out.println(result);
}

테스트의 결과값을 보면, info라는 필드로 json 값이 예쁘게 들어간 것을 볼 수 있다.

만약 @JsonRawValue 어노테이션이 없다면 리터럴까지 출력되어서 예쁘지가 않다.

 

---

🌱 JsonRootName

Annotation similar to XmlRootElement, used to indicate name to use for root-level wrapping, if wrapping is enabled. Annotation itself does not indicate that wrapping should be used; but if it is, name used for serialization should be name specified here, and deserializer will expect the name as well.

루트 레벨의 래핑에 사용할 이름을 나타내는데 사용되는 어노테이션이다.
어노테이션 자체는 래핑을 사용하는 것을 나타내지 않지만, 래핑을 사용하는 경우 직렬화에 사용되는 이름을 지정할 수 있으며, 마찬가지로 역직렬화에 대해서도 여기서 지정된 이름을 사용할 수 있다.

 

여러 개의 Json 값에 대한 루트 이름을 지정해줄 수 있다. 클래스 레벨에 붙이는 어노테이션이다.

@JsonRootName("lunchMenu")
public class Crew {

    private final List<Menu> menus;

    public Crew(final List<Menu> menus) {
        this.menus = menus;
    }

    public List<Menu> getMenus() {
        return menus;
    }
}

@Test
void jsonRootName() throws JsonProcessingException {
    // given
    final List<Menu> menus = List.of(new Menu("마라탕", 10000), new Menu("제육", 10000));
    final Crew crew = new Crew(menus);

    // when
    final ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.enable(SerializationFeature.WRAP_ROOT_VALUE);
    String result = objectMapper.writeValueAsString(crew);

    // then
    System.out.println(result);
}

참고로, objectMapper.enable(SerializationFeature.WRAP_ROOT_VALUE); 이 코드를 지정해줘야 wrapping 된다.

이런 식으로 lunchMenu라는 최상위 값으로 감싸져 있는 것을 볼 수 있다.

만약 WRAP_ROOT_VALUE 옵션을 지정했지만 @JsonRootName을 지정하지 않았다면 어떻게 될까?

이렇게 클래스 이름인 Crew로 감싸지게 된다.

---

 

🌱 @JsonValue

Marker annotation similar to XmlValue that indicates that results of the annotated "getter" method (which means signature must be that of getters; non-void return type, no args) is to be used as the single value to serialize for the instance. Usually value will be of a simple scalar type (String or Number), but it can be any serializable type (Collection, Map or Bean).

어노테이션으로 지정된 "getter" 메서드의 결과 (getXXX, void가 아닌 반환 값, 인자가 없는 경우)의 인스턴스에 대해 직렬화할 값을 나타내는 어노테이션이다. 일반적으로 값은 단순한 문자열이나 숫자지만, 직렬화 가능한 모든 타입 (컬렉션, 맵, 빈)이 될 수 있다.

At most one method of a Class can be annotated with this annotation; if more than one is found, an exception may be thrown. Also, if method signature is not compatible with Getters, an exception may be thrown (whether exception is thrown or not is an implementation detail (due to filtering during introspection, some annotations may be skipped) and applications should not rely on specific behavior).

클래스의 메서드에는 이 어노테이션을 최대 1개만 사용할 수 있으며, 2개 이상 사용 시 예외가 발생한다.
또한, 메서드 이름이 getXXX의 형태가 아니라면 예외가 발생할 수도 있다.

 

인스턴스의 JSON 값을 반환하는 역할을 한다.

객체 전체를 직렬화하는 것이 아닌, annotating method를 호출하라는 의미로 쓰인다.

하나의 메서드에만 달 수 있으며, 둘 이상의 메서드에 이 어노테이션이 달려있으면 예외가 발생한다.

full JSON string을 반환할 수 없으며, 하고 싶다면 map 같은 직렬화 가능한 객체를 반환하도록 해야 한다.

 

말로 설명하면 어렵기 때문에, 코드로 보는 것이 좋다.

public class Crew {

    private final String name;
    private final Course course;

    public Crew(final String name, final Course course) {
        this.name = name;
        this.course = course;
    }

    public String getName() {
        return name;
    }
    
    public Course getCourse() {
        return course;
    }

    public enum Course {
        FRONTEND("프론트", 50), BACKEND("백엔드", 100), ANDROID("안드로이드", 25);

        private final String name;
        private final int count;

        Course(final String name, final int count) {
            this.name = name;
            this.count = count;
        }

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

        public int getCount() {
            return count;
        }
    }
}

이번에는 크루들의 과정 정보를 담은 클래스를 생성하였다.

그리고, 과정의 이름을 반환하는 getter 메서드에 @JsonValue를 달아주었다.

Crew에 대한 직렬화 결과를 보면 다음과 같이 course에서는 name에 대한 정보만 나오는 것을 볼 수 있다.

 

만약, @JsonValue를 붙이지 않았다면 어떻게 나올까?

enum에는 2개의 getter가 있음에도 enum의 name 값이 디폴트로 나오게 된다.

(이 부분은 이팩티브자바에서 싱글턴 - enum을 사용하라는 포스팅에서 코드 레벨로 다루었다.)

 

만약 name과 course 두 가지 모두에다가 @JsonValue를 붙이면 어떻게 될까?

이런 식으로 여러 개의 value에 붙어있다고 안 된다고 나온다.

 

하지만, 나는 enum의 2가지 값 모두를 보고 싶을 수도 있다.

public class Crew {

    ...

    public enum Course {
        FRONTEND("프론트", 50), BACKEND("백엔드", 100), ANDROID("안드로이드", 25);

        private final String name;
        private final int count;

        Course(final String name, final int count) {
            this.name = name;
            this.count = count;
        }

        @JsonValue
        public Map<String, Object> toJson() {
            final Map<String, Object> values = new HashMap<>();
            values.put("name", name);
            values.put("count", count);
            return values;
        }

        ...
    }
}

그렇다면 이런 식으로 Map을 반환해주면 된다.

그러면 이렇게 name과 course의 모든 정보에 대해서 잘 나오는 것을 확인할 수 있다.

 

---

 

🌱 @JsonAnyGetter

Marker annotation that can be used to define a non-static, no-argument method or member field as something of a reverse of JsonAnySetter method; basically being used like a getter but such that contents of the returned Map (type must be Map) are serialized as if they were actual properties of the bean that contains method/field with this annotations. As with JsonAnySetter, only one property should be annotated with this annotation.

static이 아니면서, 인자가 없는 메서드나 멤버 필드를 정의하는데 사용하는 마커 어노테이션이다.
일반적으로 getter처럼 사용되지만, 이 어노테이션을 사용하면 메서드, 필드를 포함하는 빈의 실제 프로퍼티처럼 반환된 Map의 내용이 직렬화하도록 한다. 또한, JsonAnySetter처럼 하나의 프로퍼티에만 적용해야 한다.

 

반환 값이 Map인 메서드를 표현하는데 사용한다.

Map을 키와 값의 쌍으로 평면화를 하며, root level처럼 값이 나오도록 만들어준다. (해당 클래스에 존재하는 필드처럼)

클래스당 하나의 Json getter만 가능하다.

public class Crew {

    private final String name;
    private final Map<String, String> pair;

    public Crew(final String name, final Map<String, String> pair) {
        this.name = name;
        this.pair = pair;
    }

    public String getName() {
        return name;
    }

    @JsonAnyGetter
    public Map<String, String> getPair() {
        return pair;
    }
}

결과를 보면, pair로 들어간 map의 정보가 crew에 존재하는 필드인 것처럼 직렬화되는 것을 볼 수 있다.

만약 @JsonAnyGetter를 제거하였다면 다음과 같이 나타났을 것이다.

 

위에서는 예제를 이렇게 했지만, 보통 실제로 쓰인다면 다음과 같이 쓰일 것 같다.

약간 이런 식으로... map의 키 값으로 실제 필드값의 이름을 넣어서 평면화를 할 것 같다.

(외부 api 전송 시 규격을 맞추기 위해서 사용할 수도 있을 것 같고... 사용 예시 의외로 다양할 것 같다.)

 

---

🌱 JsonNaming

Annotation that can be used to indicate a PropertyNamingStrategy to use for annotated class. Overrides the global (default) strategy. Note that if the value() property is omitted, its default value means "use default naming" (that is, no alternate naming method is used.

클래스에 대해 PropertyNamingStrategy을 나타내는데 사용할 수 있는 어노테이션이다.
기본 전략을 재정의할 때 사용하며, value() 속성을 생략하면 기본 네이밍 전략을 사용하는 것을 의미한다.

 

직렬화 시 네이밍 전략을 무엇으로 할지 결정할 수 있다. Jackson은 현재 다음과 같은 네이밍 전략을 제공하고 있다.

name	example
LOWER_CAMEL_CASE	nameStrategy, numberValue
UPPER_CAMEL_CASE	NameStrategy, NumberValue
SNAKE_CASE	name_strategy, number_value
UPPER_SNAKE_CASE	Name_Strategy, Number_Value
LOWER_CASE	namestrategy, numbervalue
KEBAB_CASE	name-strategy, number-value
LOWER_DOT_CASE	number.strategy, number.value

그래서, 보통 camel Case를 사용하는 자바와 요청 API 사이의 간극을 맞추기 위해서 많이 사용한다.

@JsonNaming(PropertyNamingStrategies.SnakeCaseStrategy.class)
public class Crew {

   private final String crewName;
   private final int crewAge;

    public Crew(final String crewName, final int crewAge) {
        this.crewName = crewName;
        this.crewAge = crewAge;
    }

    public String getCrewName() {
        return crewName;
    }

    public int getCrewAge() {
        return crewAge;
    }
}

이런 식으로 편리하게 snake case로 변환이 가능하다.

---

🌱 JsonIgnore / JsonInclude

- JsonIgnore

Marker annotation that indicates that the annotated method or field is to be ignored by introspection-based serialization and deserialization functionality. That is, it should not be consider a "getter", "setter" or "creator".

In addition, starting with Jackson 1.9, if this is the only annotation associated with a property, it will also cause cause the whole property to be ignored: that is, if setter has this annotation and getter has no annotations, getter is also effectively ignored. It is still possible for different accessors to use different annotations; so if only "getter" is to be ignored, other accessors (setter or field) would need explicit annotation to prevent ignoral (usually JsonProperty).

직렬화나 역직렬화 시 무시되는 것을 나타내는 마커 어노테이션이다.
해당 어노테이션을 지정한 것이 json 프로퍼티와 연관된 유일한 어노테이션일 경우 전체 프로퍼티가 무시된다. (1.9 버전부터)
ex. setter에는 어노테이션이 있지만, getter에는 없는 경우 무시
-> 만약 getter만 무시하고 싶다면 @JsonProperty 같은 명시적인 어노테이션을 사용해야 한다.

- jsonInclude

Annotation used to indicate when value of the annotated property (when used for a field, method or constructor parameter), or all properties of the annotated class, is to be serialized. Without annotation property values are always included, but by using this annotation one can specify simple exclusion rules to reduce amount of properties to write out.

어노테이션이 지정된 클래스의 모든 프로퍼티 값을 직렬화할 조건을 나타낼 때 사용한다. (간단한 제외 규칙 지정 가능)

 

getter로 열린 모든 필드가 아닌, 일부 필드에 대해서만 직렬화를 하고 싶다면 @JsonIgnore를 통해 직렬화를 하고 싶지 않은 필드를 지정해줄 수 있다.

public class Crew {

    private final String crewName;
    private final int crewAge;

    public Crew(final String crewName, final int crewAge) {
        this.crewName = crewName;
        this.crewAge = crewAge;
    }

    public String getCrewName() {
        return crewName;
    }

    @JsonIgnore
    public int getCrewAge() {
        return crewAge;
    }
}

age에 대해 ignore를 했기 때문에 name에 대해서만 직렬화가 된다.

 

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

    private final String crewName;
    private final int crewAge;

    public Crew(final String crewName, final int crewAge) {
        this.crewName = crewName;
        this.crewAge = crewAge;
    }

    public String getCrewName() {
        return crewName;
    }

    public int getCrewAge() {
        return crewAge;
    }
}

혹은, 조금 더 응용해서 이런 식으로도 작성해줄 수 있다. 

비어있지 않은 필드에 대해서만 직렬화가 되도록 만드는 것이며, 보통 응답값으로 보내줄 때 많이 사용하는 편이다. (개인적 취향)

// given
final Crew crew = new Crew("", 23);

// when
final ObjectMapper objectMapper = new ObjectMapper();
String result = objectMapper.writeValueAsString(crew);
System.out.println(result);

그럼 이런 식으로 이름 필드가 비어있다면 나이만 나오게 된다.

어떤 값이 지정되는지에 따라서 달라지기 때문에 활용하기가 좋다.

 

---

생각보다 내용이 길어졌다...

사실 내부 동작 코드를 볼까 하다가, 직렬화는 응용이 중요하지 내부 동작 원리가 중요하지는 않을 것 같아서 그냥 뒀다. (복잡하기도 하고...) 다음 포스팅으로는 역직렬화에 대해서 다루어볼까 한다.