[Spring] WebFlux 초기 설정

1. Webflux 프로젝트 생성

 

* 프로젝트 구조

 

2. application.properties 설정

# Spring 애플리케이션 이름 설정
spring.application.name=webFlux

# MySQL 데이터베이스 연결 설정 (R2DBC 사용)
spring.r2dbc.url=r2dbc:mysql://localhost:/capston2024
spring.r2dbc.username=
spring.r2dbc.password=

# R2DBC 리포지토리 활성화 (리액티브 리포지토리 사용)
spring.data.r2dbc.repositories.enabled=true

# R2DBC MySQL 연결 풀 설정
## 커넥션 풀 사용 여부
spring.r2dbc.pool.enabled=true
## 초기 커넥션 풀 크기
spring.r2dbc.pool.initial-size=5
## 최대 커넥션 풀 크기
spring.r2dbc.pool.max-size=20

# 로깅 설정 (디버그 로그 활성화) - R2DBC 코어 로깅 디버그 레벨
logging.level.org.springframework.r2dbc.core=DEBUG

# NoSQL 리소스 - Redis 설정
spring.data.redis.host=localhost
spring.data.redis.port=6379

# Redis 자동 설정 제외 (Redis 관련 자동 구성 비활성화)
spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration

 

3. build.gradle

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.3.5'
    id 'io.spring.dependency-management' version '1.1.6'
    id 'org.cyclonedx.bom' version '1.10.0'
}

group = 'com.obj'
version = '0.0.1-SNAPSHOT'

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-r2dbc'
    implementation 'org.springframework.boot:spring-boot-starter-data-redis-reactive'
    implementation 'org.springframework.boot:spring-boot-starter-webflux'
    implementation 'io.netty:netty-resolver-dns-native-macos:4.1.97.Final'
    compileOnly 'org.projectlombok:lombok'
    runtimeOnly 'com.mysql:mysql-connector-j'
    runtimeOnly 'io.asyncer:r2dbc-mysql'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'io.projectreactor:reactor-test'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}

tasks.named('test') {
    useJUnitPlatform()
}

 

4. Redis 사용을 위한 기본 Configuration

package com.obj.webflux.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.*;
import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.ReactiveRedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RedisConfig {

    // Redis 서버의 호스트 주소를 환경 변수에서 가져와 설정
    @Value("${spring.data.redis.host}")
    private String host;

    // Redis 서버의 포트 번호를 환경 변수에서 가져와 설정
    @Value("${spring.data.redis.port}")
    private int port;

    // ReactiveRedisConnectionFactory Bean 생성
    // Redis 서버와의 비동기 연결을 관리하는 Factory를 생성
    @Bean
    @Primary
    public ReactiveRedisConnectionFactory reactiveRedisConnectionFactory() {
        return new LettuceConnectionFactory(host, port); // Lettuce 클라이언트를 사용하여 Redis 연결
    }

    // ReactiveRedisTemplate Bean 생성
    // Redis에 데이터를 비동기적으로 저장하고 읽기 위한 템플릿 객체를 생성
    @Bean
    public ReactiveRedisTemplate<String, String> reactiveRedisTemplate(
            ReactiveRedisConnectionFactory factory) {

        // RedisSerializationContext 생성
        // Redis 키와 값을 String 타입으로 직렬화하는 설정
        RedisSerializationContext<String, String> serializationContext = RedisSerializationContext
                .<String, String>newSerializationContext(new StringRedisSerializer()) // 기본 직렬화 설정
                .key(new StringRedisSerializer()) // 키를 String 타입으로 직렬화
                .value(new StringRedisSerializer()) // 값을 String 타입으로 직렬화
                .hashKey(new StringRedisSerializer()) // 해시 키를 String 타입으로 직렬화
                .hashValue(new StringRedisSerializer()) // 해시 값을 String 타입으로 직렬화
                .build();

        // ReactiveRedisTemplate 생성
        return new ReactiveRedisTemplate<>(factory, serializationContext);
    }
}

 

5. User 엔티티 클래스

: 데이터베이스에 저장될 사용자 정보 테이블을 정의

package com.obj.webflux.user.entity;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Table;

import java.time.LocalDateTime;

@Builder // 빌더 패턴을 사용해 객체를 쉽게 생성할 수 있도록 하는 Lombok 어노테이션
@NoArgsConstructor // 기본 생성자를 자동 생성
@AllArgsConstructor // 모든 필드를 매개변수로 받는 생성자를 자동 생성
@Table(name = "users") // 이 클래스가 "users" 테이블과 매핑되도록 설정
public class User {

    @Id // 이 필드가 Primary Key임을 나타냄
    private Long id; // 사용자 고유 ID

    private String name; // 사용자 이름

    private String email; // 사용자 이메일

    private LocalDateTime createdAt; // 사용자가 생성된 날짜 및 시간

    private LocalDateTime updatedAt; // 사용자가 마지막으로 수정된 날짜 및 시간
}

 

6. UserRepository 클래스

- `User` 엔티티에 대해 CRUD 작업을 수행하기 위한 저장소
: Reactive 프로그래밍 환경에서 동작하며, `ReactiveCrudRepository`를 확장하여 비동기 방식으로 데이터베이스와 상호작용할 수 있는 메서드를 제공

package com.obj.webflux.user.repository;

import com.obj.webflux.user.entity.User;
import org.springframework.data.repository.reactive.ReactiveCrudRepository;

public interface UserRepository extends ReactiveCrudRepository<User, Long> {
}

 

7. WebFluxApplication 클래스

: 애플리케이션의 진입점으로 WebFlux와 Spring Boot 애플리케이션을 실행

package com.obj.webflux;

import com.obj.webflux.user.entity.User;
import com.obj.webflux.user.repository.UserRepository;
import lombok.*;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.redis.core.ReactiveRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;

import java.util.Map;

// 애플리케이션의 진입점으로 WebFlux와 Spring Boot 애플리케이션을 실행
@SpringBootApplication // Spring Boot 애플리케이션 구성 및 컴포넌트 스캔을 활성화
@RestController // REST API 엔드포인트를 제공하는 컨트롤러로 설정
@RequiredArgsConstructor // final로 선언된 필드를 자동으로 생성자 주입하도록 설정
public class WebFluxApplication {

    // Reactive Redis 연산을 처리하기 위한 템플릿
    private final ReactiveRedisTemplate<String, String> reactiveRedisTemplate;

    // 데이터베이스 작업을 처리하기 위한 ReactiveCrudRepository 구현체
    private final UserRepository userRepository;

    public static void main(String[] args) {
        // Spring Boot 애플리케이션 실행
        SpringApplication.run(WebFluxApplication.class, args);
    }

    // 애플리케이션 상태를 확인하기 위한 간단한 헬스 체크 API
    @GetMapping("/health") // HTTP GET 요청을 "/health" 경로로 매핑
    public Mono<Map<String, String>> health() {
        // "health: ok"라는 응답을 반환
        return Mono.just(Map.of("health", "ok"));
    }

    // Redis에서 특정 사용자 데이터를 캐시에서 가져오는 API
    @GetMapping("/users/1/cache") // HTTP GET 요청을 "/users/1/cache" 경로로 매핑
    public Mono<Map<String, String>> getCachedUser() {
        // Redis에서 "users:1:name" 키의 값을 가져옴
        var name = reactiveRedisTemplate.opsForValue().get("users:1:name");
        // Redis에서 "users:1:email" 키의 값을 가져옴
        var email = reactiveRedisTemplate.opsForValue().get("users:1:email");

        // 두 값(name과 email)을 병합한 후 Map 형태로 반환
        return Mono.zip(name, email)
                .map(i -> Map.of("name", i.getT1(), "email", i.getT2()));
    }

    // 사용자 ID로 데이터베이스에서 사용자 정보를 가져오는 API
    @GetMapping("/users/{id}") // HTTP GET 요청을 "/users/{id}" 경로로 매핑
    public Mono<User> getUser(@PathVariable Long id) {
        // 주어진 ID로 사용자 정보를 조회하고, 없으면 기본값(User 객체)을 반환
        return userRepository.findById(id).defaultIfEmpty(new User());
    }
}