Spring Data 여러 기능

오늘은 Spring Data의 몇가지 기능들을 살펴 볼 예정이다. 예전에 작성했던 Spring data common 기타 기능과는 별개로 유용하게 사용할 수 있는 것들을 정리해 보도록 하자. 물론 어떤 특정한 버전, 프로젝트들은 따로 명시를 해놓도록 하겠다.

query method

Spring data 프로젝트의 특징인 query method는 아주 유용한 기능이다. 물론 복잡한 쿼리에는 사용할 수 없지만 간단한 쿼리를 작성하는데는 더할 나위 없이 유용한 기능이다.
필자도 간단한 쿼리를 작성할 때는 자주 이용하고 있다. 잘 모르고 있을 수도 있는 기능들을 좀 더 살펴보자.

public interface PersonRepository extends CrudRepository<Person, String> {

    List<Person> findByName(String name);

}

만약 이름으로 select을 하고 있다면 대부분 위와 같이 작성을 할 것이다. find란 키워드와 by라는 키워드 spring data에서 정의한 키워드이다. 만약 두개의 키워드가 존재하지 않다면 쿼리메서드는 제대로 동작하지 않을 수 있다.

하지만 select 할때는 find 라는 키워드 말고도 여러 키워드들이 존재한다. 굳이 find 키워드를 사용할 필요 없이 다른 키워드를 사용해도 된다.

public interface PersonRepository extends CrudRepository<Person, String> {

    List<Person> findByName(String name);

    List<Person> queryByName(String name);

    List<Person> streamByName(String name);

    List<Person> getByName(String name);

    List<Person> readByName(String name);

}

find 라는 키워드 말고도 query, stream, get, read 등으로 대체 할 수 있다.
이외에도 카운터를 세는 count 존재 여부를 알려주는 exists 등이 있다.

또한 삭제쿼리 메서드도 존재하는데 remove, delete 두가지 키워드를 사용해서 삭제할 수 있다.

public interface PersonRepository extends CrudRepositor<Person, String> {

    void deleteByName(String name);

    void removeByName(String name);

}

위와 같이 사용해도 동일한 결과를 얻을 수 있다.

find 라는 키워드 말고도 여러 키워드가 있으니 다른 키워드도 사용해도 좋다.

사실 위와 같이 delete method 에는 @Modifying 어노테이션이 필요 없다. @Modifying 어노테이션은 @Query(update or delete) 어노테이션을 사용할 때만 작성하면 된다.

또한 한글, 중국어, 일어 등도 가능하다. 사실 그럴일은 거의거의 없지만 그냥 가능하다고 만 알고 있자.

//@Entity, //Document ...
public class Person {

  // ...

  private String 이름;

  //... getter setter

}

public interface PersonRepository extends CrudRepositor<Person, String> {

  List<Book> findBy이름(String name);

}

entityName (Data-JPA)

이것은 Jpa에 특화된 기능이다. 다른 data 하위 프로젝트엔 동작하지 않는다. @Query 어노테이션을 사용할 때 유용하게 사용될 수 있는 기능이다.

entityName 이라는 키워드를 통해 해당 엔티티를 조회, 저장, 삭제등을 할 수 있다.

@MappedSuperclass
public class Product {

    @Id
    @GeneratedValue
    private Long id;

    private String name;

    ....
}

// book, disc 

@NoRepositoryBean
public interface ProductRepository<T extends Product> extends JpaRepository<T, Long> {

    @Query("select p from #{#entityName} p where p.name = :name")
    List<T> findName(String name);
}


public interface BookRepository extends ProductRepository<Book> {

}

public interface DiscRepository extends ProductRepository<Disc> {

}

주로 사용하고 있는 곳으로는 위와 같이 공통적인 상위 인터페이스를 정의 한 후 공통된 쿼리들을 entityName을 이용하여 처리 할 수 있다.
@Query 어노테이션을 자주 사용하는 분들은 아주 유용한 기능인 듯 싶다.

Mongo (Data-Mongo)

Spring data mongo를 사용할 때 몇가지 유용한 기능이다.

Document(model) 를 작성할 때 굳이 @Document 어노테이션과 @Id를 선언하지 않아도 된다.

@Value
public class Person {

    ObjectId id;

    String name;

    int age;

}

public interface PersonRepository extends MongoRepository<Person, ObjectId> {

}

위와 같이 Person 모델에 @Document 를 붙이지 않아도 자동으로 Spring data가 만들어서 넣어 준다. 만약 @Document 없다면 클래스명(첫글자는 소문자)으로 collection이 만들어 진다.

@Id도 마찬가지로 id, _id 라는 필드가 존재하면 그것을 키로 잡아 저장을 한다.

만약 어노테이션이 많아 보기가 힘들다면 작성하지 않아도 되며 명시적인 어노테이션을 선호한다면 작성해도 무방하다.

단, 아래코드는 동작하지 않는다.


@Value public class Person { ObjectId id; String name; int age; } public interface PersonRepository extends CrudRepository<Person, String> { }

그 이유는 해당 엔티티가 어느 스토어를 사용하지는 알수 없어 빈으로 등록하지 못한다. 위의 경우엔 명시적으로 @Document 어노테이션을 사용하거나 직접적인 MongoRepository를 사용해야 한다.

다른 spring data 하위 프로젝트(JPA는 해당사항 없다.) 들은 어떻게 되어 있는지 확인해보지 않았다. 만약 다른 프로젝트도 이런 기능이 있을 수도, 없을 수도 있으니 잘 보고 적용해야 된다.

Spring data 쪽에는 엔티티를 위와 같이 불변으로 만들어도 된다. (사실.. 확인은 mongo, redis 만 했다. 이것 또한 JPA는 해당사항 없다.)

JPA는 명시된 스펙으로 작성을 해야 되기 때문에 @Entity, @Id, 기본생성자, 정의된 스펙에 맞게 작성해야 한다.

public class Person {

    private final ObjectId id;

    private final String name;

    private final int age;

    public Person(ObjectId id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
   // getter
}

or

@Value
public class Person {

    ObjectId id;

    String name;

    int age;

}

or

@Value(staticConstructor = "of")
public class Person {

    ObjectId id;

    String name;

    int age;

}

@Value 는 롬복에 있는 어노테이션이며 여기를 참고하며 되겠다. 또한 팩토리 메서드를 만들어 사용해도 된다. 다른 더 많은 기능이 있으나 주로 사용될만한 기능은 이정도 일듯 싶다.

Streamable

Spring data 2.0 에서 추가된 Streamable 인터페이스를 query method 를 사용할 때 리턴타입으로 사용할 수 있다.

public interface PersonRepository extends MongoRepository<Person, String> {

    Streamable<Person> findByName(String name);

}

해당 인터페이스를 사용하면 바로 map, filter를 사용할 수 있다.

 List<String> names = people.map(Person::getName)
                    .stream()
                    .collect(Collectors.toList());

사실 사용 Api를 보면 List를 사용하는 것과 동일하다. 어차피 Stream으로 다시 만들어 하기에 굳이 사용할 필요가 있나 싶기도 하다.

하지만 spring data 2.2 부터는 (현재기준으로 아직 릴리즈는 되지 않았다) 조금 더 간편하게 사용할 수 있다.

List<String> names = people.map(Person::getName)
                    .toList()

Set<String> names = people.map(Person::getName)
                    .toSet()

내부적인 코드는 동일하지만 사용하는 Api는 간단하게 사용할 수 있다.

또한 spring data 2.2 부터는 좀 더 커스텀한 Wrapper Type의 Streamable 만들어 사용할 수 있다.

//@RequiredArgsConstructor(staticName = "of")
@RequiredArgsConstructor
public class Persons implements Streamable<Person> {

    private final Streamable<Person> people;

    public int getAge() {
        return people.stream()
                .mapToInt(Person::getAge)
                .sum();
    }

    @Override
    public Iterator<Person> iterator() {
        return people.iterator();
    }
}


public interface PersonRepository extends MongoRepository<Person, String> {

    Persons readByName(String name);

}

Persons people = personRepository.readByName("wonwoo");
int totalAge = people.getTotalAge();

이렇게 Wrapper Type을 만들어 내부적으로 기능들을 추가할 수 있어 유용한 기능인 것 같다.

오늘은 이렇게 Spring data 쪽에 사용되는 유용한 기능들을 살펴봤다. 조금이라도 도움이 되었으면 좋겠다.

오랜만에 포스팅을 했다. 이런저런 일도 있고 사실 귀찮았던게 더 컷다. 일주일에 한번(적어도 이주일엔)은 꼭 쓰도록 노력해야겠다.

Spring 5.2 그리고 Spring boot 2.2

몇일전에 Spring 5.2.M1버전 과 Spring boot2.2.M2 버전이 릴리즈 되었다. 아직 해당 프로젝트들의 GA 버전이 나오기엔 시간이 많이 남아있지만 (대략 7월) 많이 변경되지 않을 것들만 모아서 살펴보도록 하자. (사실 필자가 아는 부분만이겠지만)

일단 Spring Framework 5.2 부터 알아보자.

Spring Framework 5.2

@Configuration

@Configuration 어노테이션의 속성이 추가 되었다. proxyBeanMethods 라는 속성이며 예전에 필자가 포스팅한 글중 Lite Mode라는 주제가 있었던 그 내용이 Spring 쪽에 들어갔다.
사용법은 아주 간단하다.

@Configuration(proxyBeanMethods = false)
public class TestConfiguration  {
  //... 
}

위와 같이 lite mode를 적용하고 싶으면 proxyBeanMethods 속성을 false로 설정하면 된다. 기본값은 true이다. 그럼 cglib을 사용하지 않는 상태에서 설정이 진행된다.
해당 설명은 위의 포스팅이 있기에 생략.

참고로 Spring boot 2.2의 AutoConfiguration들은 모두 @Configuration(proxyBeanMethods = false) 로 변경하였다.
또한 @SpringBootApplication 어노테이션에도 proxyBeanMethods 속성이 추가 되었다.

vavr의 Try와 @Transactional

io.vavr(구 javaslang) 의 Try를 @Transactional 어노테이션을 지원한다.

@Transactional
public Try<?> hello() {
    return Try.of(() -> accountRepository.save(new Account(1L, "test")))
        .filter(Account::isActive)
        .andThenTry((account) -> accountRepository.save(new Account(account.getId()))); // 예외
}

해당 라인에서 예외가 발생하면 롤백이 진행된다. 필자가 vavr를 잘 사용하지 못하는 관계로..
만약 vavr 프로젝트를 잘 사용한다면 유용하게 쓰일듯 싶다. Spring data 쪽에서는 vavr 프로젝트도 지원해주니 함께 사용하면 더 많은 지원을 받을 수 있을 듯 싶다.

import io.vavr.control.Try;
import org.springframework.data.jpa.repository.JpaRepository;

public interface AccountRepository extends JpaRepository<Account, Long> {

    Try<Account> findByName(String name);

}

MergedAnnotations

Annotation을 처리하기 위해 새로운 API가 등장했다. 기존의 있던 AnnotationUtilsAnnotatedElementUtils 대신에 사용할 수 있는 API이다.
위의 AnnotationUtils, AnnotatedElementUtils API들도 내부적으로 MergedAnnotations 으로 변경하였다.
조금 더 살펴보고 해야겠지만 일단은 기본사용법만 알아두자. 언제 바뀔지 모르니..

MergedAnnotation<SpringBootApplication> springBootApplication = MergedAnnotations.from(Application.class)
    .get(SpringBootApplication.class);
Class<?>[] scanBasePackageClasses = springBootApplication.getClassArray("scanBasePackageClasses");
String[] scanBasePackages = springBootApplication.getStringArray("scanBasePackages");
boolean proxyBeanMethods = springBootApplication.getBoolean("proxyBeanMethods");

위와 같이 쉽게 사용할 수 있다. 더 많은 API 들과 속성들이 있긴 하지만 지금 당장은 살펴볼 필요가 없어서 이정도만 알아봤다. 릴리즈 되면 그때 다시 알아보도록 하자.
근데 사용할 일이 많이 없어서..

Spring boot 2.2

지금 부터는 Spring boot 쪽의 변화이다.

lazyInitialization

Spring boot 2.2 부터는 lazyInitialization를 모든 빈의 적용할 수 있게 되었다. 기존에는 @Lazy 어노테이션을 선언하여 게으른 빈은 설정하였다.

@Bean
@Lazy
public AccountService accountService() {
    return new AccountService();
}

위와 같이 설정하면 실제 사용될 시점에 빈이 생성된다.
조금 빠른 로딩을 하기 위해서 모든 빈에 게으르게 빈을 설정 할 수 있게 되었다.

spring.main.lazy-initialization=true

application.properties에 위와 같이 spring.main.lazy-initialization 속성을 true로 주면 모든 빈들이 Lazy 빈으로 생성 된다.
Spring boot 로딩 시간이 길다면 해당 속성을 이용해서 빠르게 로딩할 수 있다.

하지만 여기서 주의할점은 web 기준으로 http 첫 요청이 조금 길다는점. 첫 요청시 사용하는 빈들이 그 순간 만들어져 요청이 조금 느릴 수 있다.
두 번쨰로는 일반적으로는 빈을 찾을 수 없을 때 에러가 나지만 lazyInitialization을 설정하면 서버가 기동될때 에러를 찾을 수 없다. 빈을 사용할 때 그 때 빈을 찾으므로 런타임시 에러가 발생할 수 있으므로 조심해야 된다.

개발할 때만 설정하고 운영할 때는 설정 하지 않는것이 좋아 보인다.

만약 위의 설정을 해놓고 특정빈은 Lazy 로딩을 하고 싶지 않다면 다음과 같이 설정하면 된다.

@Bean
@Lazy(false)
public AccountService accountService() {
    return new AccountService();
}

이 기술(@Lazy)은 오래된 기술이다. 실제로는 대략 11년전에 개발된 기술이다. 그래서 우리도 간단한 구현만으로도 위와 비슷한 모든 빈에 Lazy 초기화를 할 수 있다.

@Bean
static BeanFactoryPostProcessor beanPostProcessor() {
    return beanFactory -> {
        String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
        for(String beanName : beanDefinitionNames) {
            beanFactory.getBeanDefinition(beanName).setLazyInit(true);
        }
    };
}

Spring boot 2.2를 사용하지 않더라도 그 이하버전에서도 위와 같이 구현하면 게으른 초기화를 진행 할 수 있다.

@ConfigurationPropertiesScan

@ConfigurationPropertiesScan 어노테이션이 추가 되었다. 애노테이션명 그대로 ConfigurationProperties를 스캔하는 용도이다.

@ConfigurationProperties("foo")
public class FooProperties {

    private String name;

    public String getName() {
        return name;
    }

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

위와 같은 Properties가 존재한다면 우리는 아래와 같이 설정하였다.

@Configuration
@EnableConfigurationProperties(FooProperties.class)
public class Application {

}

이제는 EnableConfigurationProperties을 사용하지 않고 @ConfigurationPropertiesScan 어노테이션을 사용하여 scan 할 수 있다.

@Configuration
@ConfigurationPropertiesScan("ml.wonwoo")
public class Application {

}

위와 같이 적용하면 ml.wonwoo 패키지 아래의 모든 프로퍼티들이 자동으로 등록이 된다.
Spring boot 2.2에서는 @SpringBootApplication 애노테이션에 메타 애노테이션으로 @ConfigurationPropertiesScan 애노테이션이 추가 되었으므로 추가적인 설정은 할필요 없다.

scan할 패지키를 지정하지 않는다면 선언된 애노테이션 이하의 패지키를 검색한다.

이제 @EnableConfigurationProperties의 사용처는 자동설정을 커스텀하게 만들때 사용하면 된다.

Immutable @ConfigurationProperties

불변의 Properties 를 지원한다. 기존에는 기본생성자와 setter가 존재 했어야 했지만 이제는 그럴 필요 없다.

@ConfigurationProperties("foo")
public class FooProperties {

    private String name;

    public String getName() {
        return name;
    }

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

기존에는 위와 같이 javaBeans 스펙에 따라야 했지만 이제는 setter 또한 필요 없고 기본생성자 또한 필요 없다.

@ConfigurationProperties("foo")
public class FooProperties {

    private final String name;

    public FooProperties(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

}

만약 해당 프로퍼티에 디폴트값을 원한다면 @DefaultValue 어노테이션을 이용해서 기본값을 설정 할 수 있다.

@ConfigurationProperties("foo")
public class FooProperties {

    private final String name;

    public FooProperties(@DefaultValue("wonwoo") String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

이렇게 하면 프로퍼티의 값이 존재 하지 않아도 기본값으로 wonwoo가 설정이 된다.

오늘은 이렇게 Spring과 Spring boot에 변화에 대해서 알아봤다. 이 보다 많은 변화가 있었지만 개발자들이 직접적으로 사용하기에는 위의 내용으로도 충분해 보여 몇가지만 준비했다.
더 많은 내용은 해당 문서를 통해 알아보도록 하고, 위의 내용 또한 언제 바뀔지 모르니 현재는 그냥 참고만 하면 되겠다.
나중에 릴리즈 될때 다시 보자!

Spring Web immutable Parameter

오늘은 Web immutable Parameter Object에 대해서 알아보도록 하자.
요즘에는 immutable Object를 많이 사용하는 듯 하다. 아마도 가장 좋은점은 스레드 세이프하다는 장점이 있어야 일 것이다.
그래서 오늘 Spring web과 관련해서 immutable 한 Parameter에 대해서 알아보도록 하자.

요즘은 코틀린으로 Spring 개발을 많이 하고 있고 Spring 에서도 코틀린을 거의 완벽히 지원해주고 있다.
또한 java에서는 lombok도 많이 사용하고 있으니 괜찮다면 한번 살펴보는 것도 나쁘지 않다.

@ModelAttribute

Spring5 부터는 @ModelAttribute도 불변의 Object도 사용가능하다. 아마도 코틀린을 지원하면서 고려가 많이 된 것 같다.

@RestController
public class PersonController {

    @PostMapping("/")
    Person person(@ModelAttribute Person person) {
        return person;
    }
}


public class Person {
    private final String name;
    private final String email;

    public Person(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }

}

만약 위의 코드처럼 작성하고 해당 컨트롤러를 호출해보자.

http POST :8080 name==wonwoo email==wonwoo@test.com

만약 버전이 Spring5 이전버전이라면 아래와 같이 에러가 발생할 것이다.

java.lang.NoSuchMethodException: xxx.xxxxx.xxxxxxx.Person.<init>()
 ...
 ...

기본 생성자가 없다는 뜻으로 Spring5 이전버전에서는 무조건 default 생성자가 존재했어야 했다. 하지만 spring5 부터는 기본생성자 없이도 에러가 발생하지 않는다.
Spring5에서 테스트를 해보자.

http POST :8080 name==wonwoo email==wonwoo@test.com
HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Date: Sun, 27 Jan 2019 10:58:49 GMT
Transfer-Encoding: chunked

{
    "email": "wonwoo@test.com",
    "name": "wonwoo"
}

그럼 에러가 발생하지 않고 우리가 원하던 데이터가 출력이 된다. 아주 괜찮다. lombok을 대부분 많이, 잘 사용하니 lombok을 사용한다면 좀 더 코드가 간결해 질 수 있다.

@Value
public class Person {
    String name;
    String email;
}

lombok 의 @Value
lombok @Value가 하는 역할은 위의 링크를 참고 하자.

만약 해당 모델의 파라미터명과 전달하는 파라미터가 다르다면 어떻게 할까? 이것 역시 Spring 에서 지원해주고 있다.
@ConstructorProperties 어노테이션을 통해 해당 파라미터명을 변경할 수 있다. @ConstructorProperties 어노테이션은 Spring이 제공해주는 것 아니지만 지원은 해주는 java bean 스펙이다.

어쨌든 @ConstructorProperties 어노테이션을 이용해서 파라미터를 변경할 수 있으니 한번 해보자.

public class Person {
    private final String name;
    private final String email;

    @ConstructorProperties({"user_name", "user_email"})
    public Person(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }

}

위와 같이 생성자에 @ConstructorProperties 어노테이션을 작성하고 해당 컬럼의 명을 순서대로 작성해주면 된다.

http POST :8080 user_name==wonwoo user_email==wonwoo@test.com
HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Date: Sun, 27 Jan 2019 11:03:29 GMT
Transfer-Encoding: chunked

{
    "email": "wonwoo@test.com",
    "name": "wonwoo"
}

아주 간단하다.

만약 lombok을 사용한다면 아래와 같이 작성하면 된다.

@Value
@RequiredArgsConstructor(onConstructor_ = @ConstructorProperties({"user_name", "user_email"}))
//@RequiredArgsConstructor(onConstructor = @__(@ConstructorProperties({"user_name", "user_email"})))
class Person {
    String name;
    String email;
}

onConstructor 문법은 java 버전과 관련이 있다.

@RequestBody (Jackson)

jackson 기준이기 때문에 다른 라이브러리를 사용한다면 다를 수 있으니 참고하길 바란다.

@RequestBody 어노테이션 또 한 불변의 Object로 만들 수 있다. Spring 지원한다기 보다는 사용하는 해당 라이브러리가 지원하고 있으니 사용하는 라이브러리의 문서를 살펴보면 좋다.

일단 기본적으로는 아무 설정하지 않았다면 jackson의 경우에는 기본생성자가 있어야 한다. 하지만 여러 방법으로 기본생성자 없이 사용할 수 있으니 한번 살펴보도록 하자.

@JsonProperty

@JsonProperty 어노테이션으로 해당 필드를 지정해주면 된다.

public class Person {

    private final String name;
    private final String email;

    public Person(@JsonProperty("name") String name, @JsonProperty("email") String email) {
        this.name = name;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }
}

위와 같이 작성한다면 기본생성자 없이도 deserialize가 가능하다. 만약 모델의 필드와 요청파라미터가 다르다면 @JsonProperty의 value를 변경하기만 하면 된다.

lombok을 사용한다면 다음과 같다.

@Value
class Person {
    String name;
    String email;

    public Person(@JsonProperty("name") String name, @JsonProperty("email") String email) {
        this.name = name;
        this.email = email;
    }
}

lombok일 경우에는 조금 귀찮다. 생성자 필드에는 어떻게 넣지..?

@ConstructorProperties

jackson 도 @ConstructorProperties 어노테이션을 지원하다. 아마도 jackson2.7 부터 지원한다고 했는데 그 이하버전은 테스트는 해보지 않았다.

public class Person {

    private final String name;
    private final String email;

    @ConstructorProperties({"name", "email"})
    public Person(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }
}

마찬가지로 해당 필드를 변경하고 싶다면 @ConstructorProperties의 속성을 순서대로 변경하면 된다.

lombok을 사용할 경우는 다음과 같다.

@Value
@RequiredArgsConstructor(onConstructor_ = @ConstructorProperties({"name", "email"}))
class Person {
    String name;
    String email;
}

jackson-module-parameter-names

jackson 해당 모듈을 사용해서도 가능하다. 하지만 ObjectMapper를 조금 설정해줘야 한다.

@Bean
public ObjectMapper objectMapper() {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.registerModule(new ParameterNamesModule());
    return objectMapper;
}

위와 같이 설정한 후에 사용하면 바로 사용할 수 있다. 하지만 위의 모듈은 java8부터 가능하다. 만약 그 이하 버전을 사용한다면 위의 모듈을 사용할 수 없다.

public class Person {

    private final String name;
    private final String email;

    public Person(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }
}

해당 모듈을 사용한다면 어노테이션을 사용하지 않아도 기본적으로 동작을 한다.

lombok을 사용할 경우는 다음과 같다.

@Value
class Person {
    String name;
    String email;
}

참고로 Spring boot 2.0 부터는 spring-boot-starter-json 에 jackson-module-parameter-names 모듈이 포함되어 있다. 그래서 spring-boot-starter-web을 디펜더시 받는 다면 기본적으로 spring-boot-starter-json가 포함 되어 있으니 jackson-module-parameter-names를 추가 하지 않아도 된다. 만약 그 이전 버전을 사용한다면 해당 모듈만 디펜더시만 받으면 자동설정이 동작한다.
또 한 jackson-module-parameter-names 과 @ConstructorProperties 어노테이션은 함께 동작하지 않는 것 같다. jackson-module-parameter-names 을 사용한다면 @JsonProperty 어노테이션을 사용해야 한다.

@Value
//@RequiredArgsConstructor(onConstructor_ = @ConstructorProperties({"user_name", "user_email"})) // not working
class Person {
    String name;
    String email;

    public Person(@JsonProperty("user_name") String name, @JsonProperty("user_email") String email) {
        this.name = name;
        this.email = email;
    }
}

위처럼 jackson-module-parameter-names 을 사용하는 경우엔 @JsonProperty 어노테이션을 사용해서 해당 필드를 변경해야 한다.

오늘은 이렇게 Spring Web immutable Parameter 에 대해서 알아봤다.
꼭 Object를 불변으로 만들 필요는 없지만 사용할일이 있다면 참고하면 되겠다. 또 한 프로퍼티들을 변경해야 하는 일이 있다면 사용해도 괜찮을 듯 하다.