조세영의 Kotlin World

[Kotlin Spring] WebMvcConfigurer 사용해 CORS 규칙 설정하기

Dev.Cho — Fri, 6 Dec 2024 07:56:49 +0900

문제 상황 및 원인

스프링 애플리케이션을 백엔드로 하고, React 애플리케이션을 프론트엔드로 하는 개발하던 중, 다음과 같은 오류를 발견했다.

확인해보니, 브라우저는 기본적으로 동일 출처 정책(Same Origin Policy, SOP)을 지키기 때문에 다른 출처의 리소스 접근을 금지해 생기는 문제로 확인됐다. 이를 해결하기 위해서는 스프링 애플리케이션의 CORS(Cross-Origin Resource Sharing) 설정에 특정 주소로부터의 Cross Origin Request를 허용해야 한다.

문제 해결

Cross Origin Request를 허용하기 위해서는 서버에서 Access-Control-Allow-Origin 헤더를 포함한 응답을 주는 것이 필요하다. 이 Access-Control-Allow-Origin의 값은 요청하는 위치의 주소이다. 예를 들어 http://localhost:8080 에서 실행 중인 스프링 애플리케이션이 http://localhost:3000 로부터의 요청을 허용하고 싶다면 다음과 같은 헤더를 추가하면 된다.

Access-Control-Allow-Origin: http://localhost:3000

그렇다면, 스프링 MVC에서는 위 헤더를 어떻게 추가할 수 있을까? 바로 WebMvcConfigurer을 사용하면 된다.

아래는 실제로 동작하는 WebMvcConfigurer에 대한 설정이다.

@Configuration
class WebConfig {
    @Bean
    fun webMvcConfigurer(): WebMvcConfigurer {
        return object : WebMvcConfigurer {
            override fun addCorsMappings(registry: CorsRegistry) {
                registry.addMapping("/**")
                    .allowedOrigins("http://localhost:3000")
            }
        }
    }
}

WebMvcConfigurer는 addCorsMapping 함수를 오버라이드 해 CORS 설정을 추가할 수 있으며, 이곳의 CorsRegistry의 addMapping 함수를 통해 특정 경로에 대해 Cross Origin Request를 허용 할 수 있다. 여기서는 addMapping("/**") 을 사용했는데, 이는 전체 경로에 대한 Cross Origin Request를 허용한다는 뜻이다.

만약 /hello 경로 하위에 대해서만 Cross Origin Request를 허용하고 싶다면 다음과 같이 설정하면 된다.

registry.addMapping("/student/**")

어떤 경로에 대해 Cross Origin Request를 허용할지 정했으면, 어떤 곳으로부터의 요청을 허용할지도 정해야 한다. React 애플리케이션은 로컬에서 일반적으로 3000번 포트를 사용하므로 http://localhost:3000 을 허용해주면 React 애플리케이션에서 Spring 애플리케이션에 HTTP 요청을 할 수 있게 된다.

이제 이렇게 설정한 후 리액트 애플리케이션에서 스프링 애플리케이션에 HTTP 요청을 실행해보면, 다음과 같은 헤더와 함께 성공 응답이 오는 것을 볼 수 있다.

[Spring JPA] 실행된 SQL문 로깅하고 포멧팅 하는 방법 한 번에 정리하기

Dev.Cho — Thu, 5 Dec 2024 07:43:09 +0900

실행된 SQL문의 확인이 필요한 이유

Spring Data JPA를 사용하면 JpaRepository를 상속해 기본적인 CRUD가 가능한 함수들을 사용할 수 있다. 하지만, 이 함수들을 사용하면, JPA에서 알아서 SQL문을 만들어서 쿼리하기 때문에 어떤 SQL문이 실행되는지 확인하기 어렵다. 대부분의 상황에서 이것은 문제가 되지 않지만, 만약 버그가 일어났다면 어떤 SQL문 때문에 문제가 생겼는지 확인해야 한다.

Spring Data JPA는 이를 위해 실행되는 SQL문을 로깅할 수 있는 기능을 제공한다. 지금부터 이 방법에 대해 알아보자.

실행된 SQL문 로깅하기

실행된 SQL문을 로깅하도록 설정하기 위해서는 application.properties 파일에 다음과 같은 설정을 추가해야 한다.

spring.jpa.show-sql=true

그런 후 이전 글에서 만든 다음 addVocabulary 함수를 호출해보자.

@RestController
class VocabularyController(
    private val vocabularyRepository: VocabularyRepository
) {
    ...

    @PostMapping("/vocabulary")
    fun addVocabulary(
        @RequestParam word: String,
        @RequestParam meaning: String
    ): Vocabulary {
        val vocabulary = Vocabulary(word = word, meaning = meaning)
        return vocabularyRepository.save(vocabulary)
    }

    ...
}

HTTP 요청은 다음과 같다.

POST http://localhost:8080/vocabulary
Content-Type: application/x-www-form-urlencoded

word=abc&meaning=xyz

그러면 Vocabulary를 입력하는 SQL문이 실행되고, 다음과 같이 성공 응답이 오는 것을 확인할 수 있다.

이제 로그를 확인해보자. 그러면 다음과 같이 어떤 쿼리가 실행됐는지에 대한 정보가 나오는 것을 볼 수 있다.

로깅 시 SQL문 포멧팅 될 수 있도록 하기

위에서는 어떤 SQL문이 실행됐는지 확인할 수 있지만 포멧팅이 되지 않아 가독성이 나쁘다. 이런 문제를 해결하기 위해 Spring Data JPA는 SQL문을 포멧팅 하는 기능도 제공한다. 포멧팅하는 방법은 간단하다. 단순히 application.properties 파일에 다음과 같은 설정을 추가하면 된다.

# SQL 포맷팅
spring.jpa.properties.hibernate.format_sql=true

이제 다시 애플리케이션을 실행해 POST 요청을 날려보자. 그러면 다음과 같이 실행된 SQL문이 포멧팅 되는 것을 확인할 수 있다.

[Kotlin Spring JPA] JpaRepository, @Query 사용해 데이터베이스에 쿼리 하는 방법 한 번에 정리하기

Dev.Cho — Wed, 4 Dec 2024 07:53:18 +0900

시작하며

이전 글에서 우리는 DB를 만들고 커넥션을 설정한 다음, 테이블을 만드는 작업을 했다.

이제 테이블을 만들었으니, 이번 글에서는 쿼리를 만들어 실행해보자.

일반적으로 쿼리를 실행하기 위해서는 쿼리문을 작성해야 하지만, Spring Data JPA를 사용하면 기본적인 쿼리문을 모두 기본으로 생성되게 만들 수 있는데 이런 역할을 하는 것이 바로 JpaRepository이다. 지금부터 JpaRepository를 사용해 쿼리를 만들어 실행해보자.

JpaRepository 상속 받는 객체 만들기

JpaRepository를 사용하는 방법은 간단하다. 예를 들어 다음과 같은 Vocabulary 엔티티가 있다고 해보자.

@Entity
data class Vocabulary(
    @Id
    val id: String = UUID.randomUUID().toString(),
    val word: String,
    val meaning: String
)

그러면 이 JpaRepository<Vocabulary, String> 을 상속하는 VocabularyRepository 인터페이스를 다음과 같이 만들면 이 VocabularyRepository는 자동으로 Bean으로 등록된다.

interface VocabularyRepository: JpaRepository<Vocabulary, String>

여기서 JpaRepository는 JpaRepository<t, id=""> 라는 제네릭 타입을 갖는데, ID는 바로 Vocabulary를 구분할 수 있는 단일 ID 값이 되며 일반적으로 Primary Key로 등록되는 타입을 사용하면 된다.

이제 JpaRepository가 만들어졌으니 이걸 사용해 데이터 베이스에 쿼리를 실행하는 컨트롤러를 만들어보자.

JpaRepository 사용해 쿼리 실행하기

JpaRepository를 사용해 쿼리를 실행하는 방법은 간단하다. JpaRepository를 상속 받은 인터페이스인 VocabularyRepository가 Bean으로 등록되었으므로, 이를 사용해 쿼리를 실행하면 된다.

이때 JpaRepository에는 CRUD를 위한 findById, findAll, save, deleteById 등의 메서드가 이미 정의되어 있기 때문에 다음과 같이 직접 쿼리를 작성할 필요 없이 코틀린 코드만 작성하면 되며, 그러면 원하는 쿼리가 실행된다.

@RestController
class VocabularyController(
    private val vocabularyRepository: VocabularyRepository
) {
    @GetMapping("/vocabulary")
    fun getVocabularyById(@RequestParam id: String): Vocabulary {
        return vocabularyRepository.findById(id).get()
    }

    @GetMapping("/vocabulary/all")
    fun getAllVocabulary(): List<Vocabulary> {
        return vocabularyRepository.findAll()
    }

    @PostMapping("/vocabulary")
    fun addVocabulary(
        @RequestParam word: String,
        @RequestParam meaning: String
    ): Vocabulary {
        val vocabulary = Vocabulary(word = word, meaning = meaning)
        return vocabularyRepository.save(vocabulary)
    }

    @DeleteMapping
    fun deleteVocabulary(@RequestParam id: String) {
        vocabularyRepository.deleteById(id)
    }
}

위의 코드의 findById 함수를 보면 인자로 id를 넘기고 있는데, 이 Id는 Vocabulary 객체에서 @Id 어노테이션이 붙은 필드인 id에 대응된다.

이처럼 쿼리를 직접 작성하지 않고도 손쉽게 쿼리를 실행할 수 있다.

@Query 사용해 커스텀 쿼리 만들기

JpaRepository는 기본적인 CRUD 쿼리만을 정의하고 있기 때문에 종종 JpaRepository에 정의된 쿼리 함수들 만으로 충분하지 않은 경우가 있다. 예를 들어 word를 사용해 검색 시스템을 만드는 경우를 생각해보자. 이런 경우는 검색을 위해 LIKE 문을 사용해야 하는데, JpaRepository에는 이런 쿼리 함수가 정의되어 있지 않다.

이런 경우에는 JpaRepository를 상속 받는 Repository 안에 @Query 어노테이션을 사용해 커스텀 쿼리를 직접 작성하면 된다. 만약 인자를 커스텀 쿼리 내부로 넘겨야 한다면 @Query에는 %:[인자명]% 을 적고, 함수의 인자에는 @Param("[인자명]") 과 함께 인자를 넘기면 된다.

예를 들어 word를 사용해 검색을 하는 함수는 다음과 같이 만들 수 있다.

interface VocabularyRepository: JpaRepository<Vocabulary, String> {
    @Query("SELECT v FROM Vocabulary v WHERE v.word LIKE %:word%")
    fun searchByWord(@Param("word") word: String): List<Vocabulary>
}

이곳에서는 @Param("word") word: String 를 받아 이를 LIKE 문 뒤에 %:word% 형태로 넣고 있다.

추가 자료

JpaRepository는 어떻게 Bean으로 등록되는가?

JpaRepository 내부를 보면 @NoRepositoryBean만 붙어 있을 뿐 @Component 어노테이션이 붙어있지 않다. @NoRepositoryBean은 레포지토리를 표시하는 메서드를 정의하는 인터페이스라는 것을 명시하고 해당 인터페이스를 실제 Bean객체로 등록되지 않게 하는 역할을 하기 때문에 Bean으로 등록되지 않는다.

@NoRepositoryBean
public interface JpaRepository<T, ID> extends ListCrudRepository<T, ID>, ListPagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T>

이를 처리하는 것은 @EnableJpaRepositories 이라는 어노테이션으로, @EnableJpaRepositories를 사용하면 특정 패키지 하위의 JpaRepository를 스캔해 Bean으로 별도로 등록해준다. 예를 들어 com.somepackage 하위의 모든 JpaRepository를 등록하려면 다음과 같이 작성 후 이를 애플리케이션 클래스 위에 붙여 주면 된다.

@EnableJpaRepositories(value = ["com.somepackage"])

다만 이것은 스프링 부트를 사용하면 @SpringBootApplication이 붙어 있는 패키지와 하위 패키지에 대해 생략이 가능하다고 한다.

[Kotlin Spring JPA] @Entity, @Table, @Id, @Column 사용해 Table 정보 설정하는 방법 한 번에 정리하기

Dev.Cho — Tue, 3 Dec 2024 07:55:27 +0900

@Entity와 @Id 어노테이션 사용해 테이블 정의하기

특정 클래스에 @Entity 어노테이션을 사용하면 테이블을 정의할 수 있다. 예를 들어 단어 정보를 저장하기 위한 Vocabulary 테이블을 정의한다고 해보자. 이런 테이블은 다음과 같이 정의될 수 있다.

@Entity
data class Vocabulary(
    @Id
    val id: String = UUID.randomUUID().toString(),
    val word: String,
    val meaning: String
)

이 테이블의 이름은 클래스의 이름과 같은 Vocabulary가 되며, 내부에는 아이디 id, 단어 word, 뜻 meaning 세가지 필드를 가진다. 테이블에는 꼭 Primary Key가 필요하기 때문에 id 변수 위에는 @Id 어노테이션을 붙여 이 필드가 Primary Key라는 것을 알려야 한다. 이렇게 만든 후 스프링 애플리케이션을 실행하면 다음과 같이 VOCABULARY 테이블과 내부에 선언된 ID, MEANING, WORD 컬럼을 확인할 수 있다.

여기서 중요한 것은 꼭 @Entity가 붙은 클래스가 있다면 테이블로 만들어지게 되기 때문에 @Id가 붙은 필드가 있어야 한다는 점이다. 만약 없다면 다음과 같이 Primary Key가 있어야 한다는 경고 문구가 나온다.

이처럼 테이블을 만드는 것은 매우 간단하다.

이어서 이 Entity에 다양한 옵션을 적용하는 방법을 알아보자.

@Entity의 name 프로퍼티 설정해 테이블 이름 설정하기

@Entity의 name 프로퍼티를 사용하면 테이블의 이름을 커스텀하게 설정할 수 있다. 예를 들어 테이블의 이름을 Vocabulary가 아닌, Voca로 설정하고 싶다면 다음과 같이 name 프로퍼티를 "Voca"로 설정하면 된다.

@Entity(name = "Voca") // Entity명 지정도 가능
data class Vocabulary(
    @Id
    val id: String = UUID.randomUUID().toString(),
    val word: String,
    val meaning: String
)

그러면 다음과 같이 테이블의 이름이 VOCA로 변경되는 것을 볼 수 있다.

이렇게 테이블의 이름을 설정할 수도 있지만 JPA은 테이블의 정보를 더욱 세밀하게 지정할 수 있는 @Table 어노테이션을 지원한다. 이어서 이에 대해 알아보자.

@Table 어노테이션 사용해 테이블 정보 설정하기

@Table 어노테이션을 사용하면 테이블의 이름과, 어떤 필드에 인덱싱을 할지를 설정할 수 있다. 예를 들어 단어를 저장하는 테이블의 이름은 VocaTable이라 지정하고, word 컬럼에 인덱싱을 하고 싶다고 해보자. 그러면 다음과 같이 @Table 어노테이션을 설정하면 된다.

@Entity
@Table(name = "VocaTable", indexes = [Index(name = "idx_word", columnList = "word")])
data class Vocabulary(
    @Id
    val id: String = UUID.randomUUID().toString(),
    val word: String,
    val meaning: String
)

그러면 다음과 같이 VOCA_TABLE이라는 이름을 가진 테이블이 생성되고, IDX_WORD라 불리는 WORD를 인덱싱한 인덱스가 생성되는 것을 볼 수 있다.

이 외에도 schema, catalog, uniqueConstraints 같은 프로퍼티를 이 @Table 어노테이션을 사용해 설정할 수 있다.

지금까지 우리는 테이블의 속성을 설정하는 방법을 아아봤다. 이번에는 @Column 어노테이션 사용해 컬럼의 속성을 설정하는 방법을 알아보자.

@Column 어노테이션 사용해 컬럼의 속성 설정하기

@Column 어노테이션을 사용하면 컬럼의 속성을 설정할 수 있다. @Column 어노테이션을 통해서는 다음 속성들을 설정할 수 있다.

name: 컬럼의 이름을 설정하는데 사용. 설정하지 않으면 필드의 이름이 컬럼의 이름으로 설정됨.
unique: 현재 필드에 UNIQUE 제약을 걸지 여부를 결정. 기본 값은 false.
nullable: 현재 필드가 NULL이 될 수 있는지 설정. 기본 값은 true.
insertable: 엔티티 저장 시 해당 필드도 함께 저장할지 여부를 결정. 기본값은 true로 설정됨.
updatable: 엔티티 수정 시 해당 필드도 함께 수정될지 여부를 결정. 기본값은 true로 설정됨.
columnDefinition: 컬럼 정보를 직접 설정할 때 사용.
table: 하나의 엔티티가 두 개 이상의 테이블에 매핑돼야 할 때 사용
length: 컬럼의 최대 길이 설정. 기본 값은 255.
precision: 소수점을 포함한 전체 자릿수 지정. 기본 값은 19.
scale: 소수점 이하의 자리수 지정. 기본 값은 2.

예를 들어 MEANING 컬럼의 이름을 MEAN으로 지정하고 싶다면 다음과 같이 name="mean"을 사용하면 된다.

@Entity
data class Vocabulary(
    @Id
    val id: String = UUID.randomUUID().toString(),
    val word: String,
    @Column(name = "mean") // Column명 지정도 가능
    val meaning: String
)

그러면 다음과 같이 meaning 필드의 컬럼명이 MEAN이 되는 것을 볼 수 있다.

[Kotlin Spring] Spring Data JPA 와 H2 Database 사용 설정하는 방법 알아보기

Dev.Cho — Mon, 2 Dec 2024 07:09:15 +0900

H2 Database란?

H2 Database는 가볍고 편리한 인 메모리 데이터 베이스로 프로그램 구동 시 메모리에 데이터를 저장하고, 애플리케이션이 종료되면 메모리가 삭제되는 데이터베이스이다. 이는 일반적으로 테스트 환경 혹은 Dev 환경 등 데이터에 대한 영속성이 요구되지 않는 환경에서 데이터를 저장하는데 사용한다. 브라우저 기반의 콘솔 프로그램 또한 제공해, 어떤 데이터가 저장되었고 삭제되었는지를 편하게 확인할 수 있다.

이번 시간에는 Spring Data JPA를 사용해 H2 Database를 사용 설정하는 방법을 알아볼 것이다.

코틀린 스프링 프로젝트에 Spring Data JPA, H2 Database 사용 설정하기

plugin.jpa 플러그인 사용 설정하기

일반적으로 스프링에서 JPA를 사용한다고 하면, 구현체인 Hibernate를 사용한다. 이 Hibernate는 ORM 라이브러리로써 특정 객체를 테이블에 매핑 시키기 위해 @Entity 라는 어노테이션을 사용하는데, Hibernate의 사용자 가이드에서는 이 @Entity라는 어노테이션이 붙은 클래스는 매개변수가 없으면서 가시성이 public 혹은 protected로 설정된 생성자가 있어야 한다고 명시한다.

하지만, 코틀린에서 프로퍼티가 정의된 클래스는 일반적으로 기본 생성자를 자신이 가진 프로퍼티를 매개변수로 갖는 생성자를 자동으로 생성한다. 이로 인해 Hibernate의 요구사항과 충돌이 발생할 수 있으며, 이를 해결하기 위해서는 다음과 같이 별도의 생성자를 정의하고 이 생성자를 호출할 때는 기본 값들을 사용해 객체가 생성될 수 있도록 해야 한다.

@Entity
class User(
    @Id val id: Long? = null,
    val name: String
) {
    constructor() : this(null, "")
}

하지만, 매번 Entity를 정의할 때마다 이런 매개변수가 없는 생성자를 만드는 것은 보일러 플레이트 코드가 되고, 코드의 가독성을 떨어트릴 수 있다. 이 문제를 해결하기 위해 코틀린에서는 plugin.jpa라는 플러그인을 제공한다. 이 플러그인을 사용하면, 클래스를 아래와 같이 같이 작성해도 컴파일 타임에 자동으로 매개변수가 없는 생성자를 만들어준다.

@Entity
class User(
    @Id val id: Long? = null,
    val name: String
)

plugin.jpa 플러그인을 적용하는 방법은 간단하다. 단순히 build.gradle.kts 파일에 다음과 같이 plugin.jpa 플러그인을 추가하면 된다.

plugins {
    // JPA 플러그인 설정
    kotlin("plugin.jpa") version "1.9.25"
}

이제 플러그인 설정이 마무리 됐으니, 의존성 설정을 진행해보자.

Spring Data JPA, H2 Database 의존성 설정하기

Spring Data JPA를 사용하기 위해서는 두가지 의존성을 설정해야 한다. 하나는 Spring Boot 프로젝트에서 JDBC(Java Database Connectivity)를 더 쉽고 효율적으로 사용할 수 있도록 도와주는 스타터 패키지인 spring-boot-starter-data-jdbc 라이브러리에 대한 의존성을 추가하는 것이고, 다른 하나는 Spring Boot 프로젝트에서 JPA(Java Persistence API)를 쉽고 효율적으로 사용할 수 있도록 도와주는 스타터 패키지인 spring-boot-starter-data-jpa에 대한 의존성을 추가하는 것이다. 이들 각각에 대한 의존성은 implementation 함수를 통해 설정한다.

dependencies {
    // Spring Data JDBC 의존성 설정 
    implementation("org.springframework.boot:spring-boot-starter-data-jdbc")
    
    // Spring Data JPA 의존성 설정
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    ...
}

이제 H2 Database에 대한 설정만 남았다. H2 Database는 런타임에 실행되는 인메모리 데이터 베이스 이므로, runtimeOnly 함수를 통해 com.h2database:h2 를 사용하도록 하면 된다.

dependencies {
    // Spring Data JDBC 의존성 설정 
    implementation("org.springframework.boot:spring-boot-starter-data-jdbc")
    
    // Spring Data JPA 의존성 설정
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    
    // H2 Database 사용 설정
    runtimeOnly("com.h2database:h2")
    ...
}

이렇게 설정하면 모든 의존성 설정이 마무리 된다.

이제 마지막 한 단계가 남았다. 나머지 한 단계도 마저 마무리 해보자.

@Entity, @Embeddable, @MappedSuperclass가 붙은 클래스들이 상속 가능하게 만들기

자바에서는 기본적으로 클래스가 상속 가능하게 설정되는 반면, 코틀린에서 클래스는 기본적으로 final로 선언돼 상속이 불가능하며, 상속 가능하게 만들기 위해서는 다음과 같이 open 이라는 키워드가 앞에 붙어야 한다.

@Entity
open class User(
    @Id val id: Long? = null,
    val name: String
)

하지만, Hibernate를 사용할 때는 @Entity, @Embeddable, @MappedSuperclass 가 붙은 클래스들은 상속 가능하도록 되어야 한다. 이를 위해 build.gradle.kts 파일에 다음과 같은 설정을 추가로 해주면 @Entity, @Embeddable, @MappedSuperclass 어노테이션이 붙은 클래스들이 상속 가능해진다.

allOpen {
    annotation("jakarta.persistence.Entity")
    annotation("jakarta.persistence.MappedSuperclass")
    annotation("jakarta.persistence.Embeddable")
}

이제 build.gradle.kts에서는 모든 준비가 마쳐졌다. 전체 코드는 다음 링크에서 확인할 수 있다.

다음으로는 H2 Database관련 설정을 application.properties에 추가해보자.

application.properties에 H2 Database 설정하기

H2 Database 연결 설정하기

H2 Database 연결을 설정하기 위해서는 다음 네가지를 설정해줘야 한다.

spring.datasource.url: 어떤 url을 통해 db에 접근이 가능한지
spring.datasource.driverClassName:어떤 드라이버를 사용할 것인지
spring.datasource.username: DB 유저 이름
spring.datasource.password: DB 유저 비밀번호

예를 들어 jdbc:h2:mem:testdb 를 통해 db에 접근하면서 org.h2.Driver 드라이버를 사용하고, 사용자 이름은 user 비밀번호는 password으로 설정하고 싶다면 다음과 같이 설정해주면 된다.

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=dummyuser
spring.datasource.password=password

그러면 연결과 관련된 설정이 마무리되었다.

H2 Database 콘솔 설정하기

이제 H2 Database 용 콘솔을 사용할 수 있도록 설정해보자. spring.h2.console.enabled의 값을 true로 두면 콘솔이 활성화되고, spring.h2.console.path를 /h2-console로 설정하면 /h2-console 경로를 통해 콘솔 창에 접근할 수 있게 된다.

spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

여기까지 모든 준비가 마무리됐다. 전체 코드는 다음 링크에서 확인할 수 있다.

이제 스프링 애플리케이션을 실행하고, 콘솔에 접근해보자.

H2 Database 콘솔 사용하기

http://localhost:8080/h2-console 로 접근하면 다음과 같은 화면이 나온다.

화면에 위의 application.properties에 설정한 데이터를 적은 후 Connect를 눌러주면 다음과 같이 콘솔 창이 나오는 것을 볼 수 있다.

여기까지 모든 설정이 마무리됐다.

이어서 H2 Database 내부에 테이블을 만드는 방법을 알아보자.

[Spring] WAR와 JAR 파일의 차이 한 번에 정리하기

Dev.Cho — Sun, 1 Dec 2024 07:40:49 +0900

WAR 파일을 통해 배포하기

WAR 파일을 배포하기 위해서는 다음 과정을 거쳐야 한다.

1. JDK 혹은 JRE 설치

2. Web Server 설치

3. WAR 파일 배포

WAR 파일을 배포하기 위해서는 JRE와 Web Server가 있어야 한다. 따라서 우선 JDK나 JRE을 설치 한 후 Web Server을 설치하고 해당 WebServer에 WAR파일을 배포하면 된다. 예를 들어 Tomcat을 사용하는 경우 WAR파일을 webapps 디렉토리에 복사하거나, Tomcat Manager을 사용해 WAR 파일을 직접 선택해 배포해야 할 수 있다.

익숙하다면 복잡하지 않을 수 있지만, 만약 이 Web Server을 배포를 위한 파일에 함께 내장할 수 있다면 배포 과정이 더욱 간단해질 수 있을 것이다. 이러한 역할을 하기 위해 JAR 파일이 등장한다.

JAR 파일을 통해 배포하기

JAR 파일에는 Web Server(Tomcat 등)가 내장되어 있다. 따라서 별도로 WebServer을 설치할 필요가 없으며, 배포를 위해 JRE만 필요하다. 따라서 JDK나 JRE를 설치한 후, 단순히 아래 명령어를 실행하면 배포가 완료된다.

java -jar 파일명.jar

즉 과정이 다음 그림과 같이 두 단계로 단순화된다.

이런 장점 때문에 최근에는 WAR 파일을 사용하지 않고 JAR 파일을 주로 사용한다.

[Spring Boot] Actuator 사용해 애플리케이션 모니터링하기

Dev.Cho — Sat, 30 Nov 2024 07:17:37 +0900

Actuator란 무엇인가?

Actuator란 Spring Boot에서 제공하는 애플리케이션 모니터링 및 관리 기능으로, Spring 애플리케이션의 Health를 체크하거나, Bean 목록을 확인하거나, 각 패키지의 로그 레벨이 어떻게 설정돼 있는지 확인하거나, Heap Dump를 제공하는 등 수십가지 기능을 제공하는 모니터링 툴이다.

Actuator 사용하기

Actuator을 사용하는 방법은 매우 간단하다. 단순히 build.gradle.kts 파일에 spring-boot-starter-actuator에 대한 의존성을 추가하면 된다. 그러면, Actuator 관련 기능이 활성화 된다.

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-actuator")
    ...
}

이것을 추가하고, 애플리케이션을 실행해보자. 이후 localhost:8080/actuator 에 접속하면 다음과 같은 화면이 나온다.

여기서 "health", "health-path"는 Actuator에서 제공하는 기능이며, href로 표현된 링크로 이동하면 해당 기능을 사용할 수 있다. 예를 들어 health를 확인하기 위해서는 http://localhost:8080/actuator/health로 이동하면 된다.

그러면 다음과 같이 "status": "UP" 이라는 문구가 나오고, 이는 서버가 살아있다 라는 뜻이다.

하지만, 서버가 살아있다 정도로는 정보가 충분하지 않으므로, 더 자세한 정보를 보는 방법을 알아보자.

Spring Actuator은 여러 지표를 수집할 수 있지만, 별도 옵션을 적용하지 않으면 기본적으로 최소한의 정보만을 수집한다. 더욱 많은 정보를 수집할 수록 애플리케이션에 부담이 가고, 심하게는 보안 문제가 생길 수 있기 때문이다. 따라서 필요한 경우 정보를 수집하기 위한 옵션을 application.properties 파일에 별도로 정의해줘야 한다.

health와 관련된 더 자세한 정보를 수집하기 위해서는 application.properties 파일에 다음과 같은 옵션을 추가하면 된다.

management.endpoint.health.show-details=always

그런 후 애플리케이션을 다시 실행하고 http://localhost:8080/actuator/health 를 확인하면 다음과 같이 더욱 자세한 정보가 나오는 것을 볼 수 있게 된다.

Actuator의 다른 기능들 살펴보기

앞서 Actuator에는 수십가지 기능이 있다고 했는데, 이곳에는 한 가지 기능밖에 없었다. Actuator의 다른 기능들을 살펴보기 위해서는 필요한 application.properties 파일에 보이도록 설정해야 한다.

예를 들어 생성된 bean 정보(beans), 패키지별 로그 레벨 정보(loggers), 지표 정보(metric) 를 확인하기 위해서는 다음과 같은 옵션을 application.properties에 추가하면 된다.

management.endpoints.web.exposure.include=beans,loggers,metrics

그러면 다시 /actuator 경로로 접근했을 때 다음과 같이 bean 정보(beans), 패키지별 로그 레벨 정보(loggers), 지표 정보(metric)이 추가로 나오게 된다.

여기서 http://localhost:8080/actuator/loggers로 들어가 보면 다음과 같이 각 패키지별로 로그 레벨이 어떻게 설정돼 있는지 볼 수 있다.

Actuator의 모든 기능 노출하는 방법과 주의점

Actuator의 모든 기능을 살펴보기 위해서는 application.properties 파일에 management.endpoints.web.exposure.include=* 옵션을 추가하면 된다.

management.endpoints.web.exposure.include=*

하지만, 위 옵션을 실제 서비스 되는 애플리케이션에 적용하는 것은 권장되지 않는다. 성능 상에도 문제가 있고 무엇보다 노출되면 안되는 Key가 노출돼 보안 문제가 생길 수 있기 때문이다.

즉, Actuator을 사용할 때는 모든 기능을 차단해두고 필요한 기능만을 추가하는 화이트리스트 방식으로 해야 한다.

[Spring Boot] @ConfigurationProperties 사용해 application.properties에 정의된 값을 Bean으로 주입 받기

Dev.Cho — Fri, 29 Nov 2024 07:38:12 +0900

@ConfigurationProperties 가 필요한 경우

application.properties 파일에는 애플리케이션을 위한 여러 설정이 들어간다. 이때 여러 설정 값들을 application.properties에 정의해 놓는데, 이 값들을 앱으로 가져와야 하는 경우가 생긴다. 예를 들어 서버의 이름, 서버에서 허용하는 클라이언트의 유형 등을 개발 환경 별로 다르게 설정해놓고 이 값을 통해 애플리케이션을 설정하는 경우 등이 있을 수 있다.

예를 들어 다음과 같은 application.properties 파일이 있다고 해보자.

spring.application.name=setting-configurationproperties

server.server-name=release
server.allowed-clients[0]=Android
server.allowed-clients[1]=iOS

이런 경우 server.server-name, server.allowed-client 를 코드에서 사용하고 싶다면 @ConfigurationProperties 를 사용하면 된다.

@ConfigurationProperties 사용해 값을 담는 Bean 만들기

@ConfigurationProperties를 사용하는 방법은 간단하다. 단순히 server.server-name와 server.allowed-client의 prefix가 server 이므로, @ConfigurationProperties의 prefix인자로 server를 넘긴 후, 그 다음에 나오는 server-name과 allowed-client는 camel case로 변경해 serverName, allowedClient로 만들어 프로퍼티로 넣으면 된다.

@ConfigurationProperties(prefix = "server")
data class ServerConfiguration(
    val serverName: String,
    val allowedClients: List<String>
)

이후 이 ConfigurationProperties를 만드는 것을 허용하기 위해 @EnableConfigurationProperties(ServerConfiguration::class) 어노테이션을 SpringBootApplication과 함께 붙여 넣으면 된다.

@SpringBootApplication
@EnableConfigurationProperties(ServerConfiguration::class)
class SettingConfigurationpropertiesApplication

그러면 ServerConfiguration은 Bean으로 등록되고, 어디에서든 사용할 수 있게 된다.

Bean이 제대로 만들어졌는지 확인하기 위해 다음과 같이 간단한 컨트롤러를 만들어보자.

@RestController
class ServerController(
    private val serverConfiguration: ServerConfiguration
) {
    @GetMapping("/server/config")
    fun getServerConfiguration(): ServerConfiguration {
        return serverConfiguration
    }
}

이 컨트롤러는 /server/config 경로로 요청이 들어올 시 ServerConfiguration 객체를 JSON 형태로 반환하는 컨트롤러이다.

이제 애플리케이션을 실행한 후 localhost:8080/server/config 로 접속하면 다음과 같은 결과가 나오는 것을 볼 수 있다.

[Spring Boot] DevTools로 개발 생산성 높이기 1편: Live Reload 완벽 가이드

Dev.Cho — Thu, 28 Nov 2024 07:46:28 +0900

Live Reload란?

스프링 부트로 스프링 애플리케이션을 개발하면서 코드에 변경 사항이 발생하면, 애플리케이션을 중지한 후 다시 실행해야 변경 사항을 확인할 수 있다. 하지만, 매번 이 과정을 거치는 것은 번거롭다. 이 문제를 해결하기 위해 Spring Boot는 DevTools 모듈을 통해 Live Reload라는 기능을 제공해 이 과정을 자동으로 할 수 있게 한다.

DevTools 의존성 추가하기

이런 기능을 사용하기 위해서는 DevTools 모듈을 추가해야 한다. build.gradle.kts 파일의 dependencies 블록에 다음과 같은 의존성을 설정한다.

dependencies {
    developmentOnly("org.springframework.boot:spring-boot-devtools")
    ...
}

developmentOnly는 개발 시에만 추가되는 의존성으로 이 DevTools 모듈은 개발 편의를 위한 것이기 때문에 의존성 설정 시 developmentOnly를 사용한다.

이 의존성이 추가되면 자동으로 Live Reload 기능이 활성화된다. 이것이 제대로 동작하는지 확인해보자.

Controller 만들기

먼저 Controller을 다음과 같이 만든 후 애플리케이션을 실행해보자.

@Controller
class Controller {
    @GetMapping("/hello")
    @ResponseBody
    fun hello(): String {
        return "Hello, Kotlin World!"
    }
}

그러면 /hello 경로에 대한 Get 호출 시 "Hello, Kotlin World" 문구가 반환된다.

이제 Live Reload 기능이 제대로 동작하는지 확인하기 위해 위 Controller을 다음과 같이 변경 후 저장해보자.

@Controller
class Controller {
    @GetMapping("/hello")
    @ResponseBody
    fun hello(): String {
        return "Hello, Spring Kotlin World!"
    }
}

그러면 로그를 보면 "[devtools][ restartedMain]" 이라는 문구가 나오면서 스프링 애플리케이션이 자동으로 재시작된다.

그리고 다시 /hello 경로로 접속해보면 변경된 코드가 바로 반영된 것을 볼 수 있다.

이처럼 Live Reload 기능을 사용하면, 코드에 변경사항이 생기면 스프링 애플리케이션이 자동으로 재시작된다.

[Spring Boot] 개발환경(Dev, Qa, Release) 별로 서로 다른 application.properties 파일 사용하도록 만들기

Dev.Cho — Wed, 27 Nov 2024 07:02:06 +0900

개발 환경 별로 서로 다른 application.properties 파일이 필요한 이유

application.properties는 스프링 부트 애플리케이션의 설정 파일 역할을 하며, 이곳에는 로그 레벨이나 DB 접속 정보 등 다양한 설정을 작성할 수 있다. 이 정보들은 개발 환경 별로 다르게 설정되어야 한다. 개발 환경은 대표적으로 다음 세가지가 있다.

Dev
Qa
Release(혹은 Prod)

Dev 환경에서는 개발을 편하게 만들기 위한 환경이 설정돼야 하기 때문에 로그 레벨이 DEBUG나 TRACE 정도가 되어야 하고, 개발만을 위한 DB가 따로 설정돼야 한다. 또한 Release 환경은 사용자가 직접적으로 접하는 환경이기 때문에 로그 레벨이 ERROR 정도로 설정되어야 하고 DB가 별도로 설정돼야 한다.

즉, application.properties 파일이 개발 환경 별로 다르게 설정돼야 한다. 그렇다면 어떻게 개발 환경 별로 application.properties를 다르게 설정할 수 있을까? 지금부터 이에 대해 알아보자.

개발 환경 별로 서로 다른 application.properties 파일 설정하기

Spring Boot의 프로파일 기반의 설정 파일을 지원하기 때문에 애플리케이션 실행 시 설정 파일을 지정할 수 있다. 즉, 애플리케이션 실행 시 application.properties에 우선하는 설정 파일을 지정하면 application.properties의 설정 값들을 기본으로 지정된 설정 파일에 설정된 값들이 덮어 씌워진다.

이러한 파일들은 기본적으로 application-[개발 환경].properties이라는 이름을 가지며, 만약 Dev, Qa, Release별로 다른 설정 파일을 만들어야 한다면 이들의 이름은 application-dev.properties, application-qa.properties, application-release.properties가 된다.

먼저 각 파일을 application.properties와 같은 디렉토리에 만들어보자. 만들어진 모양은 다음과 같다.

각 파일의 내부는 다음과 같은 모양을 가진다.

application-dev.properties:

logging.level.org.springframework=debug

application-qa.properties:

logging.level.org.springframework=warn

application-release.properties:

logging.level.org.springframework=error

각 파일 내부에서는 로그 레벨을 서로 다르게 설정하도록 했다. Dev에서는 DEBUG로, Qa에서는 WARN으로 RELEASE에서는 ERROR로 설정해 각 실행 환경 별로 필요한 로그만 출력되게 했다.

이제 모든 준비가 마쳐졌다. 이제 위에서 만든 application.properties을 사용하는 방법을 알아보자.

사용할 설정 파일 지정하기

특정 설정 파일을 사용하기 위해서는 application.properties의 spring.profiles.active 값을 지정해주면 된다. 만약 application-dev.properties를 사용하고 싶다면 값을 dev로 application-qa.properties를 사요하고 싶다면 값을 qa로 application-release.properties를 사용하고 싶다면 값을 release로 설정하면 된다.

다음과 dev를 사용하기 위해 spring.profiles.active=dev라고 설정해보자.

spring.application.name=settings

spring.profiles.active=dev

그런 후 애플리케이션을 실행하면 다음과 같이 DEBUG로그가 나오는 것을 볼 수 있다.

jar 파일 실행 시 설정 파일 지정하기

스프링 애플리케이션은 jar 로 패키징한 후 실행되는 것이 일반적이다. 이런 경우 특정 프로필을 사용하려면 다음과 같은 명령어를 사용하면 된다.

java -jar springapplication.jar --spring.profiles.active=release

이를 확인하기 위해 먼저 jar 파일을 빌드해보자. 다음 명령어를 통해 스프링부트 애플리케이션용 jar 파일을 빌드할 수 있다.

 ./gradlew bootJar

그러면 build/libs 디렉토리에 다음과 같은 jar파일이 생긴다.

이제 다음 명령어를 사용해 application-release.properties를 사용하도록 설정해 애플리케이션을 실행해보자.

java -jar build/libs/settings-0.0.1-SNAPSHOT.jar --spring.profiles.active=release

그러면 다음과 같이 INFO 수준의 로그만 나오는 것을 확인할 수 있다.