[Spring] Jackson annotation - Deserialization 알아보기

지난 번에 직렬화 관련해서 글을 작성했었어서, 이번에는 Jackson에서 제공하는 역직렬화 기능에 대해서 공부해보고자 한다.

---

✔️ Deserialization

Deserialization is the process of reconstructing a data structure or object from a series of bytes or a string in order to instantiate the object for consumption.

역직렬화는 data structure나 객체를 일련의 바이트나 문자열로 재구성하여 사용할 수 있도록 인스턴스화하는 프로세스이다.

직렬화의 반대라고 볼 수 있으며, 변환된 데이터를 장치간의 저장이나 전송하는 것이다.

https://hazelcast.com/glossary/deserialization/

 

Jackson에서는 어떤 어노테이션을 통해 역직렬화를 지원하는지 확인해보자.

 

---

🌱 Jackson의 기본 역직렬화 전략

지난 포스팅에서, 직렬화 시 getter가 없을 경우 public 필드에 대해 직렬화를 하는 것을 볼 수 있었다.

그 외의 필드에 대해서는 getter가 열려 있어야 했는데, 역직렬화 시에도 마찬가지로 getter가 열려있으면 된다.

추가적으로 역직렬화의 경우 setter를 통해서도 진행할 수 있는데, 여러 가지 케이스를 테스트 해보자.

 

도메인 구조

public class Crew {

   public String publicName;
   protected String protectedName;
   String defaultName;
   private String privateName;
   
   ...
}

 

확인 코드

Crew crew = new Crew("져니", "져니", "져니", "져니");
String result = new ObjectMapper().writeValueAsString(crew);
System.out.println(result);

String json = "{\"publicName\":\"져니\", \"protectedName\":\"져니\", \"defaultName\":\"져니\", \"privateName\":\"져니\"}";
Crew crew2 = new ObjectMapper().readerFor(Crew.class).readValue(json);
System.out.println(crew2);

 

1) Getter : 직렬화 O, 역직렬화 X

 

2) Getter + 기본 생성자 : 직렬화 O, 역직렬화 O

 

3) Setter : public 필드만 직렬화 O, 역직렬화 X

 

4) Setter + 기본 생성자 : public 필드만 직렬화 O, 역직렬화 O

 

결과를 보면 getter는 직렬화 전용, 기본 생성자 + setter는 역직렬화 느낌이다.

기본 생성자를 선언하고 리플렉션을 통해서 객체의 값을 채워주는 것이라고 추정된다.

 

정말 간략하게 코드를 확인해봤는데, 아래와 같이 기본 생성자를 생성해주는 코드가 있다.

기본 생성자를 생성하기.

call()이라는 메서드를 호출한다.

그리고 여기서 newInstance를 통해서 새로운 객체를 생성해준다.

아까 위의 코드(vanillaDeserialize)에서 beanProperties.find()라는 메서드가 있었는데, 거기서 deserializeAndSet()이라는 메서드를 호출한다. 그리고 valueDeserializer.deserialize() 메서드를 호출하는데, 아마 저기서... 리플렉션을 쓰는 것 같다 ㅎㅎ 

 

아무튼! 정리하자면 아래와 같이 나타낼 수 있다.

타입	직렬화 가능 여부	역직렬화 가능 여부
Getter	O	X
Getter + 기본 생성자	O	O
Setter	public 필드만	X
Setter + 기본 생성자	public 필드만	O

 

---

🌱 @JsonSetter

Annotation that can be used to define a non-static, single-argument method to be used as a "setter" for a logical property as an alternative to recommended JsonProperty annotation; or (as of 2.9 and later), specify additional aspects of the assigning property a value during serialization.

JsonProperty 어노테이션을 대체하여 사용할 수 있다.
non-static이며 1개의 인자를 가진 메서드에 대해서 역직렬화 시 사용할 수 있다.

 

바인딩할 객체와 json의 필드 이름이 일치하지 않을 때 유용하게 사용한다.

@JsonGetter와 마찬가지로 non-static 해야 하며, 오직 1개의 argument만 받는다.

{ 
	"name": "져니", 
	"age": 23,
        "menus": [
            {"name":"마라탕", "price": 10000},
            {"name":"찜닭", "price": 15000}
        ]
}

위와 같은 Json을 객체로 변경해본다고 생각해보자.

이때 실제 객체에서는 menus에 관한 필드가 없고, lunchMenus라는 필드가 있어서 그쪽으로 매핑을 시키려고 한다.

 

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

    public Menu() {
    }

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

    public void setPrice(final int price) {
        this.price = price;
    }
    
    @Override
    public String toString() {
        return "Menu{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

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

    public Crew() {
    }

    @JsonSetter("menus")
    public void setLunchMenus(final List<Menu> lunchMenus) {
        this.lunchMenus = lunchMenus;
    }

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

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

    @Override
    public String toString() {
        return "Crew{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", lunchMenus=" + lunchMenus +
                '}';
    }
}

위와 같이 @JsonSetter를 통해 어떤 필드의 값이 주입될지 선택할 수 있다.

실제로 출력을 해서 확인을 해보았다.

String json = "{\"name\": \"져니\", " +
            "\"age\": 23, " +
            "\"menus\": [" +
            "{\"name\":\"마라탕\", \"price\": 10000}, " +
            "{\"name\":\"찜닭\", \"price\": 15000}]} ";

Crew crew = new ObjectMapper().readerFor(Crew.class).readValue(json);

실제로 출력을 해보면 위와 같이 모두 lunchMenu라는 필드에 잘 들어간 것을 볼 수 있다.

 

---

🌱 @JsonAnySetter

Marker annotation that can be used to define a logical "any setter" mutator -- either using non-static two-argument method (first argument name of property, second value to set) or a field (of type Map or POJO) - to be used as a "fallback" handler for all otherwise unrecognized properties found from JSON content. It is similar to XmlAnyElement in behavior; and can only be used to denote a single property per type.
If used, all otherwise unmapped key-value pairs from JSON Object values are added using mutator.

non-static, 2개의 인자를 가진 메서드나 (첫 번째는 프로퍼티 이름, 두 번째는 설정한 값) 혹은 Map을 인자로 가지고 있는 메서드에 대해 역직렬화를 하는 방법이다.
Json 객체 값에서 매핑되지 않은 모든 키-값 쌍이 mutator를 사용하여 추가될 수 있도록 한다.

 

Map을 이용해 역직렬화를 하는 방법이다.

마찬가지로 non-static한 메서드여야 하며, 첫 번째 인자는 키, 두 번째 인자로 value를 받는다.

public class Wootecho {
    private Map<String, String> crews = new HashMap<>();

    public Map<String, String> getCrews() {
        return crews;
    }

    @JsonAnySetter
    public void addCrew(final String name, final String course) {
        crews.put(name, course);
    }
}

크루들의 리스트를 담는 우테코 클래스가 있다고 생각해보자.

addCrew를 통해 이름과 해당 크루의 과정 정보를 받아서 map에 추가해주는 코드이다.

그리고, 여기에 @JsonAnySetter를 활용하면 역직렬화 과정에서 json 프로퍼티의 값을 쉽게 map에 담을 수 있다.

 

String json = "{" +
            "\"크루1\":\"백엔드\"," +
            "\"크루2\":\"프론트엔드\"," +
            "\"크루3\":\"안드로이드\"" +
            "}";

Wootecho wootecho = new ObjectMapper().readerFor(Wootecho.class).readValue(json);
Map<String, String> crews = wootecho.getCrews();
System.out.println(crews);

다음과 같은 코드를 작성하고 실행해보자.

그럼 위처럼 맵에 크루들의 정보가 잘 담긴 것을 확인할 수 있다.

 

---

 

🌱 @JsonCreator

Marker annotation that can be used to define constructors and factory methods as one to use for instantiating new instances of the associated class.

생성자나 정적 팩터리 메서드를 연관된 클래스의 새로운 인스턴스를 인스턴스화할 때 사용하는 마커 어노테이션이다.

NOTE: when annotating creator methods (constructors, factory methods), method must either be:
- Single-argument constructor/factory method without JsonProperty annotation for the argument: if so, this is so-called "delegate creator", in which case Jackson first binds JSON into type of the argument, and then calls creator. This is often used in conjunction with JsonValue (used for serialization).
- Constructor/factory method where every argument is annotated with either JsonProperty or JacksonInject, to indicate name of property to bind to

참고로, 생성자 메서드에 어노테이션을 달기 위해서는 해당 메서드가 다음과 같은 사항 중 하나여야 한다.
- 인자에 대해 @JsonProperty가 없는 단일 인자 생성자, 혹은 팩터리 메서드 (델리게이트 생성자라고 한다)
: 이때 Jackson은 Json을 먼저 argument의 타입에 바인딩하고 생성자를 호출하며, jsonValue와 자주 사용한다.
- 바인딩할 프로퍼티 이름을 나타내기 위해, 모든 argument는 jsonProperty 또는 JacksonInject로 지정된 생성자나 팩터리 메서드여야 한다.

Also note that all JsonProperty annotations must specify actual name (NOT empty String for "default") unless you use one of extension modules that can detect parameter name; this because default JDK versions before 8 have not been able to store and/or retrieve parameter names from bytecode. 

One common use case is to use a delegating Creator to construct instances from scalar values (like java.lang.String) during deserialization, and serialize values using JsonValue.

또한, 매개변수 이름을 감지할 수 있는 확장 모듈을 사용하지 않는 한, 모든 @JsonProperty 어노테이션은 실제 이름 (빈 문자열이 아닌)을 지정해야 하는데, JDK 1.8 이전에는 바이트코드에서 매개변수 이름을 저장 및 검색이 되지 않았었다. (하지만 그 이후부터는 가능하게 되면서 이름 지정이 선택 사항이 되었다고 한다.)
일반적으로는 역직렬화 중에 delegating Creator를 사용하여 String 같은 스칼라 값으로 인스턴스를 구성하고, jsonValue를 사용하여 값을 직렬화할 때 많이 사용한다.

 

생성자나 정적 팩터리 메서드에서 주로 사용하며, 생성자의 필드 이름이 json의 필드값과 다를 때 주로 사용한다.

보통 @JsonProperty와 조합하여 많이 사용한다.

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

    @JsonCreator
    public Crew(
            @JsonProperty("crewName") final String name,
            @JsonProperty("crewAge") final int age) {
        this.name = name;
        this.age = age;
    }

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

위와 같은 크루 클래스가 있다고 했을 때, 해당 크루 클래스의 생성자에 @JsonCreator를 붙여주고, 생성자의 인자에 @JsonProperty를 붙여준다. 이러면 생성자의 인자로 역직렬화 시 json 값이 매핑된다.

@Test
void test() throws JsonProcessingException {
    // given
    String json = "{\"crewName\": \"져니\", " +
            "\"crewAge\": 23} ";

    // when
    Crew crew = new ObjectMapper().readerFor(Crew.class).readValue(json);
    System.out.println(crew);
}

실제로 코드를 돌려보면 굉장히 잘 매핑되는 것을 볼 수 있다.

 

내부의 인자가 리스트일 때도 잘 매핑되는지 궁금해서 해봤다.

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

    @JsonCreator
    public Crew(@JsonProperty("crewName") final String name,
                @JsonProperty("crewAge") final int age,
                @JsonProperty("menus") final List<Menu> lunchMenus) {
        this.name = name;
        this.age = age;
        this.lunchMenus = lunchMenus;
    }
    ...
}

굉장히 매핑이 잘 되는 모습을 볼 수 있다.

---

🌱 @JacksonInject

Jackson-specific annotation used for indicating that value of annotated property will be "injected", i.e. set based on value configured by ObjectMapper (usually on per-call basis). Usually property is not deserialized from JSON, although it possible to have injected value as default and still allow optional override from JSON.

어노테이션이 지정된 프로퍼티의 값이 주입될 것이라고 사용되는 Jackson 전용 어노테이션이다.
ObjectMapper가 구성한 값에 따라서 설정되며, 일반적으로 프로퍼티는 Json으로부터 역직렬화되지 않지만, 기본값으로 inject된 값을 사용하여 Json에서 선택적으로 재정의가 가능하다.

 

@JacksonInject를 사용하면 Json 데이터의 필드값이 아닌 값에 대해서도 inject를 시킬 수 있다. 

이건 코드로 보는 게 더 이해하기 쉽기 때문에 코드를 확인해보자.

public class Crew {
    @JacksonInject
    private Long id;
    private String name;
    private int age;

    public Crew() {
    }

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

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

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

위와 같이 id라는 필드를 추가해주었다. 이 값은 json으로 들어오지 않을 값이다.

String json = "{\"name\": \"져니\", " +
                "\"age\": 23} ";

InjectableValues inject = new InjectableValues.Std()
        .addValue(Long.class, 1L);

Crew crew = new ObjectMapper().reader(inject)
        .forType(Crew.class)
        .readValue(json);
System.out.println(crew);

그리고, 위와 같이 InjectableValues를 활용하여서 값을 주입해주었다.

그럼 이런 식으로 1이 들어간다! (신기하다)

어떤 상황에서 응용할 수 있을지 생각해봤는데, 요청이 들어온 시간에 대해 필드에 저장할 때 사용할 수도 있을 것 같고 (물론 그냥 LocalDateTime을 쓸 수도 있겠지만?) DB 필드의 마지막 업데이트 시간 등으로 활용할 수 있을 것 같다. (물론 이것도 JpaAuditing 사용하면 되긴 하겠지만...)

 

아무튼 역직렬화에 대해서 알아보았다. 다음에는 ObjectMapper의 동작원리도 좀 확인해볼 예정이다.