Jackson 라이브러리 기본기능 정리 - json 직렬화와 역직렬화
Jackson Annotation 예제
본 글은 다음 원문을 번역 및 수정한 글입니다.
https://www.baeldung.com/jackson-annotations
전체 코드는 다음 레파지토리에 있습니다. 필요하다면 클론 받으셔서 test 패키지에 있는 JacksonTest.class 를 보시면 한 눈에 볼 수 있습니다.
https://github.com/JunHoPark93/jackson-practice
JunHoPark93/jackson-practice
Practice for jackson library. Contribute to JunHoPark93/jackson-practice development by creating an account on GitHub.
github.com
Jackson Serialization Annotation
이번 내용은 Baeldung 기술 블로그의 Jackson 관련 내용을 정리하려고 합니다. 정리하게 된 계기는 사내에서도 주로 쓰는 라이브러리이고 제대로 모르고 지나친다면 문제가 될 수 있는 부분들이 존재하기 때문입니다.
참고로 예시에서 접근제한자가 public 인 것들이 있는 이유는 (직렬화, 역직렬화 할때 필요하기도 하고) getter setter 넣을 시 코드가 길어지고, Lombok을 쓰자니 Jackson 애노테이션과 자칫 혼동할 수 있기 때문에 그렇게 하였습니다.
여기서 말하는 직렬화란 객체를 전송가능한 형태로 말아주는걸 의미하고 역직렬화란 그 데이터들을 다시 자바 객체로 변환해주는 것으로 이해하시면 됩니다.
@JsonAnyGetter
JsonAnyGetter 는 Map 필드를 다루는데 유연성을 제공합니다.
Member 클래스가 Map으로 속성을 가지고 있다고 가정 해보겠습니다.
public class Member {
public String name;
private Map<String, String> properties;
public Member(String name) {
this.name = name;
}
@JsonAnyGetter
public Map<String, String> getProperties() {
return properties;
}
public void add(String attr, String val) {
this.properties.put(attr, val);
}
}getProperties 메서드에 @JsonAnyGetter 가 붙어있습니다. 이 속성은 ObjectMapper를 이용해서 json String 으로 변환해보겠습니다.
@Test
public void json_any_getter() throws JsonProcessingException {
Member member = new Member("Jay");
member.add("favorite", "chicken");
member.add("hobby", "tennis");
String result = new ObjectMapper().writeValueAsString(member);
assertThat(result, containsString("favorite"));
assertThat(result, containsString("hobby"));
}테스트는 통과합니다. 결과가 어떻게 나오는지 살펴보면,
{"name":"Jay","favorite":"chicken","hobby":"tennis"}모든 속성이 동일한 depth로 있는것을 볼 수 있습니다. 즉 Map 타입이 전부 key-value 형식으로 json에 들어있는 것을 볼 수 있습니다. 그렇다면 @JsonAnyGetter 애노테이션을 제거하고 실행해볼까요?
{"name":"Jay","properties":{"favorite":"chicken","hobby":"tennis"}}그러면 Map 필드는 다음과 같이 properties 로 한 번 감싸진 형태의 json으로 나오게 됩니다. 자바단에서 Map을 쓴다면 @JsonAnyGetter를 이용해서 필요에 맞게 커스텀 할 수 있겠죠.
@JsonGetter
@JsonGetter는 메서드 이름을 getter 메서드로 표현하기 위해 @JsonProperty 애노테이션의 대안으로 쓸 수 있습니다.
public class Member2 {
public int id;
private String name;
public Member2(int id, String name) {
this.id = id;
this.name = name;
}
@JsonGetter("name")
public String getTheName() {
return name;
}
}@JsonGetter 의 이름으로 name을 썼는데요. 저 name 필드를 get 하는 것으로 쉽게 이해할 수 있습니다.
@Test
public void json_getter() throws JsonProcessingException {
Member2 member = new Member2(1, "Jay");
String result = new ObjectMapper().writeValueAsString(member);
assertThat(result, containsString("Jay"));
assertThat(result, containsString("1"));
}매우 직관적으로 알 수 있겠네요.
@JsonPropertyOrder
@JsonPropertyOrder 를 통해서 직렬화 하는 속성의 순서를 정할 수 있습니다.
@JsonPropertyOrder({ "name", "id" })
public class Member3 {
public int id;
public String name;
public Member3(int id, String name) {
this.id = id;
this.name = name;
}
}다음과 같이 순서를 지정하면 직렬화 시 필드의 순서를 결정할 수 있게 됩니다.
{"name":"My bean","id":1}저 애노테이션이 없다면 id name 순으로 나오게 되겠죠.
@JsonValue
@JsonValue 는 전체 인스턴스를 직렬화할 때 사용하는 단일 메서드를 나타냅니다. 예를들어, enum에서 getName 메서드에 @JsonValue를 넣어주어 이름을 통해 직렬화하게 합니다.
말이 조금 어려울 수 있는데 예시를 볼까요.
public enum TypeEnumWithValue {
TYPE1(1, "치킨"), TYPE2(2, "피자");
private Integer id;
private String name;
TypeEnumWithValue(Integer id, String name) {
this.id = id;
this.name = name;
}
@JsonValue
public String getName() {
return name;
}
}이 enum 은 TYPE1 과 TYPE2가 있습니다. 하단의 getName에 @JsonValue 애노테이션이 붙어있죠. 저 애노테이션이 없다면, 이 enum을 json 으로 직렬화를 할 때 enum 이름으로 직렬화가 됩니다.
new ObjectMapper().writeValueAsString(TypeEnumWithValue.TYPE1);즉 이 결과가 다음과 같이 나오게 됩니다 (애노테이션 없을 시)
TYPE1enum의 name 필드로 직렬화를 하고 싶다면 (치킨, 피자..) 저렇게 enum의 name이 나오면 원하는 결과를 얻을 수 없습니다. @JsonValue 애노테이션을 붙여준다면 직렬화 시 나오는 필드의 이름을 결정합니다. 결과적으로 다음과 같은 내용을 얻을 수 있습니다.
@JsonValue
public String getName() {
return name;
}
치킨@JsonRootName
@JsonRootName 애노테이션은 root wrapper의 이름을 설정할 수 있습니다. 아래와 같은 json을,
{
"id": 1,
"name":"Jay"
}
{
"Member": {
"id": 1,
"name": "Jay"
}
}위와 같이 Root 이름을 지정할 수 있습니다.
@JsonRootName(value = "member")
public class Member4 {
public int id;
public String name;
public Member4(int id, String name) {
this.id = id;
this.name = name;
}
}위와 같이 JsonRootName 을 member로 지정해 놓고 결과를 출력한다면 wrapping 된 결과를 얻을 수 있습니다.
@Test
public void json_root_name() throws JsonProcessingException {
Member4 user = new Member4(1, "Jay");
ObjectMapper mapper = new ObjectMapper();
mapper.enable(SerializationFeature.WRAP_ROOT_VALUE);
String result = mapper.writeValueAsString(user);
System.out.println(result);
assertThat(result, containsString("Jay"));
assertThat(result, containsString("member"));
}한 가지 주의 점이 있다면 ObjectMapper 설정을 변경 해주어야 합니다.
mapper.enable(SerializationFeature.WRAP_ROOT_VALUE);@JsonSerialize
@JsonSerialize 는 엔티티를 marshalling 할 때 사용자가 지정한 커스텀 serializer를 쓸 수 있게 해줍니다. 무슨 말인지 하나씩 살펴봅시다. 직렬화를 어떻게 할지 사용자가 커스텀을 한다고 했을 때는 StdSerializer를 이용해서 구현할 수 있습니다.
StdSerializer를 상속받아서 커스텀한 클래스를 만듭니다.
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 {
gen.writeString(formatter.format(value));
}
}커스텀할 부분을 serialize 라는 메서드를 재정의해서 만듭니다. 예시에는 날짜 데이터를 포매팅하고 있습니다.
@Test
public void json_serialize() throws ParseException, JsonProcessingException {
SimpleDateFormat df = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");
String toParse = "20-12-2014 02:30:00";
Date date = df.parse(toParse);
Event event = new Event("party", date);
String result = new ObjectMapper().writeValueAsString(event);
assertThat(result, containsString(toParse));
}다음과 같이 객체 필드의 포맷은 변경하지 않고 직렬화 시 변경해주고 싶은 필드만 커스텀하게 변경할 수 있습니다.
Jackson Deserialization Annotations
이제는 역직렬화에 대해서 알아보겠습니다.
@JsonCreator
@JsonCreator를 이용해서 역직렬화 할 때 생성자나 팩토리를 수정할 수 있습니다.
{
"id":1,
"theName":"Jay"
}이런 json이 있다고 할 때 역직렬화 할 객체에는 (이 json을 객체로 매핑하는 과정을 의미합니다) theName이라는 필드를 쓰기 싫습니다. 그냥 name이라는 필드를 쓰고 싶다고 가정한다면 다음과 같이 할 수 있습니다.
unmarshalling 과정의 조금의 절차를 넣어주면 됩니다. @JsonCreator 와 @JsonProperty를 사용함으로써 해결할 수 있습니다.
public class Member5 {
public int id;
public String name;
@JsonCreator
public Member5(@JsonProperty("id") int id, @JsonProperty("theName") String name) {
this.id = id;
this.name = name;
}
}@JsonCreator를 생성자 위에 달아주고 프로퍼티르 이름을 json key 에 해당하는 값을 넣어줍니다. 그리고 원하는 변수명에 넣어주면 됩니다.
@Test
public void json_creator() throws JsonProcessingException {
String json = "{\n" +
" \"id\":1,\n" +
" \"theName\":\"Jay\"\n" +
"}";
Member5 member = new ObjectMapper().readerFor(Member5.class).readValue(json);
assertThat(member.name, is(member.name));
}다음과 같이 objectmapper의 readFor과 readValue의 조합으로 원하는 객체로 역직렬화를 할 수 있습니다.
혹은 @JsonSetter 로 다음과 같이 만들 수 있습니다.
// 중략...
private String name;
@JsonSetter("name")
public void setTheName(String name) {
this.name = name;
}@JacksonInject
@JacksonInject 는 json 데이터가 아닌 곳에서 값을 주입할 때 쓰입니다.
public class Member6 {
@JacksonInject
public int id;
public String name;
}
@Test
public void json_inject() throws JsonProcessingException {
String json = "{\"name\":\"Jay\"}";
InjectableValues injectableValues = new InjectableValues.Std().addValue(int.class, 5);
Member6 member = new ObjectMapper().reader(injectableValues).forType(Member6.class).readValue(json);
assertThat(member.id, is(5));
}@JsonAnySetter
@JsonAnySetter 는 Map 을 다룰 때 유용합니다. 역직렬화 과정에서 json 프로퍼티의 값들을 map 에 손쉽게 담을 수 있습니다.
public class Member7 {
public String name;
public Map<String, String> properties = new HashMap<>();
@JsonAnySetter
public void add(String key, String value) {
properties.put(key, value);
}
}
@Test
public void json_any_setter() throws IOException {
String json = "{\"name\":\"Jay\",\"favorite\":\"chicken\",\"hobby\":\"tennis\"}";
Member7 member = new ObjectMapper().readerFor(Member7.class).readValue(json);
assertThat(member.properties.get("favorite"), is("chicken"));
}그러면 위와 같은 프로퍼티들이 map 에 하나씩 담기게 됩니다.
@JsonDeserialize
@JsonDeserialize는 커스텀 역직렬화를 만들 수 있습니다.
public class Event2 {
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 parser, DeserializationContext ctxt) throws IOException {
String date = parser.getText();
try {
return formatter.parse(date);
} catch (ParseException e) {
throw new RuntimeException(e);
}
}
}StdDeserializer를 상속받은 직렬화기를 만들었는데 StdDeserializer의 상위 클래스인 JsonDeserializer를 상속받아서 만들어도 됩니다.
@Test
public void json_deserializer() throws JsonProcessingException {
String json = "{\"name\":\"Jay event\",\"eventDate\":\"20-12-2020 01:01:00\"}";
SimpleDateFormat df = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss");
Event2 event = new ObjectMapper()
.readerFor(Event2.class)
.readValue(json);
assertThat(df.format(event.eventDate), is("20-12-2020 01:01:00"));
}@JsonAlias
@JsonAlias는 역직렬화를 할 때 한 개 이상의 이름을 한 객체 필드에 매핑되게 설정할 수 있습니다.
public class Member8 {
@JsonAlias({"name", "his_name", "her_name"})
public String name;
public String hobby;
}Member8 클래스는 name, his_name, her_name 중 어떤 것으로 들어오든 name에 매핑 시킬 수 있습니다.
@Test
public void json_alias() throws JsonProcessingException {
String json1 = "{\"name\":\"Jay\",\"hobby\":\"tennis\"}";
String json2 = "{\"his_name\":\"Jay\",\"hobby\":\"tennis\"}";
String json3 = "{\"her_name\":\"Jay\",\"hobby\":\"tennis\"}";
Member8 member1 = new ObjectMapper().readerFor(Member8.class).readValue(json1);
Member8 member2 = new ObjectMapper().readerFor(Member8.class).readValue(json2);
Member8 member3 = new ObjectMapper().readerFor(Member8.class).readValue(json3);
assertThat(member1.name, is("Jay"));
assertThat(member2.name, is("Jay"));
assertThat(member3.name, is("Jay"));
}Jackson Property Inclusion Annotations
@JsonIgnoreProperties
@JsonIgnoreProperties 애노테이션은 클래스 레벨에 붙일 수 애노테이션이며 Jackson이 무시할 필드를 설정할 수 있습니다.
@JsonIgnoreProperties({"id"})
public class Member9 {
public int id;
public String name;
public Member9(int id, String name) {
this.id = id;
this.name = name;
}
}
@Test
public void json_ignore_properties() throws JsonProcessingException {
Member9 member = new Member9(1, "Jay");
String result = new ObjectMapper().writeValueAsString(member);
assertThat(result, containsString("Jay"));
assertThat(result, not(containsString("1")));
}위와 같이 객체의 id 필드는 직렬화시 제외 시킨 결과가 나옵니다.
혹은 클래스레벨에서 쓰기 싫다면 필드에 붙이는 애노테이션도 존재합니다.
@JsonIgnore
@JsonIgnore
public int id;
public String name;@JsonIgnoreProperties와 같이 id 가 직렬화시 제외됩니다.
혹은 이너 클래스 전부를 제외시키고 싶다면 @JsonIgnoreType을 쓰면 됩니다.
// 클래스 내부
@JsonIgnoreType
public static class Name {
public String firstName;
public String lastName;
}@JsonInclude
@JsonInclude NON_NULL 은 null을 직렬화시 제외시킵니다.
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Member10 {
public int id;
public String name;
public Member10(int id, String name) {
this.id = id;
this.name = name;
}
}
@Test
public void json_include() throws JsonProcessingException {
Member10 member = new Member10(1, null);
String result = new ObjectMapper().writeValueAsString(member);
assertThat(result, containsString("1"));
assertThat(result, not(containsString("name")));
}@JsonAutoDetect
@JsonAutoDetect를 이용하여 필드의 직렬화 대상을 정할 수 있습니다. 서두에 필드 접근제한자에 대해서 신경쓰지 말라고 했는데 요번 파트는 잘 보셔야 합니다.
@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY)
public class Member11 {
private int id;
private String name;
public Member11(int id, String name) {
this.id = id;
this.name = name;
}
}id 와 name은 private 입니다. 접근할 수 있는 경로가 없습니다. 물론 getter 메서드를 만들면 해결되는 문제이긴 하지만, 없다고 가정하겠습니다.
그래서 @JsonAutoDetect의 가시성 범위를 설정합니다. ANY로 준다면 private 필드까지 모두 직렬화시 접근 가능합니다.
@Test
public void json_auto_detect_visibility_any() throws JsonProcessingException {
Member11 member = new Member11(1, "Jay");
String result = new ObjectMapper().writeValueAsString(member);
assertThat(result, containsString("1"));
assertThat(result, containsString("Jay"));
}JsonAutoDetect의 가시성 범위는 ANY, NON_PRIVATE, PROTECTED_AND_PUBLIC 등등 여러 속성이 있으니 필요한 것들을 골라 쓰면 될 것 같습니다.
@JsonProperty
직렬화시 설정할 수 있는 이름을 지정하는 애노테이션 입니다.
private String name;
@JsonProperty("name")
public void setTheName(String name) {
this.name = name;
}
@JsonProperty("name")
public String getTheName() {
return name;
}Jackson Annotation 비활성화
모든 애노테이션을 비활성화하려면 다음과 같은 옵션을 준 ObjectMapper를 이용하면 됩니다.
@Test
public void disable_jackson_annotation() {
ObjectMapper mapper = new ObjectMapper();
mapper.disable(MapperFeature.USE_ANNOTATIONS);
// 중략
// 이 mapper를 사용하면, 애노테이션이 전부 비활성화 됩니다
}제가 실제로 겪었던 문제
한 모듈에서 json 데이터를 가져올 때 어떤 DTO를 사용하고 있었습니다. 그 DTO 에서 @JsonDeserialize로 한 필드를 Hash 하면서 가져오고 있었죠. 당연히 중요하고 민감한 값이었습니다. 문제는 다른 모듈로 데이터를 전송하고 같은 DTO로 또 역직렬화를 한게 문제였습니다. 다른 필드들은 값이 같았지만 Hash 한 필드는 한 번 더 Hash가 진행되는 참사가 일어났습니다. DTO를 다른 것을 쓰면 되었지만 클래스가 너무 많아져서 하나의 DTO로 통신했던 것이 문제였습니다.
결국 한쪽에서 역직렬화할 때 사용하는 ObjectMapper를
mapper.disable(MapperFeature.USE_ANNOTATIONS);설정을 통해 @JsonDeserialize를 비활성화 시켜서 해결을 하였지만 더 좋은 방법이 있는지 고민중입니다.
지금 까지 Jackson Annotation의 기본 사용방법을 알아봤는데요. 고급기능들은 업무나 사이드에서 맞닥뜨리게 될 때 정리를 하려고 합니다.