Spring Data Redis Autoconfiguration 분석

고성능 인메모리 데이터베이스 스토어인 Redis는 탁월한 데이터 캐싱 및 검색 속도를 제공하며 많은 프로덕션 환경에서 활용되고 있다.
이에 발맞추어 Spring Data 프로젝트는 Redis 상호 작용에 대한 높은 수준의 추상화를 제공하여 개발자에게 최소한의 노력으로 Redis의 성능 이점을 활용하면서 기능이 풍부한 애플리케이션을 구축하는데 집중할 수 있도록 한다.
이번 포스팅에서는 Spring에서 제공하는 Redis 관련 Auto Configuration에 대해서 다뤄보고자 한다. (Lettuce 위주로 살펴봄)

• 샘플 코드 작성은 spring boot 3.2.3과 JDK 21 버전에서 작성하였다.
• 샘플 코드 확인을 위한 Redis 서버 환경 구성은 spring boot docker compose를 활용하였다.
  • spring boot docker compose support 포스팅을 참고

Dependency

우선 Spring Data Redis를 사용하기 위해서는 다음과 같은 dependency가 필요하다.
build.gradle

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.2.3'
    id 'io.spring.dependency-management' version '1.1.4'
}
...
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
    implementation 'org.apache.commons:commons-pool2:2.12.0'
    developmentOnly 'org.springframework.boot:spring-boot-docker-compose'
    testAndDevelopmentOnly 'org.springframework.boot:spring-boot-docker-compose'
    ...
}

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.2.3'
    id 'io.spring.dependency-management' version '1.1.4'
}
...
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-redis'
    implementation 'org.apache.commons:commons-pool2:2.12.0'
    developmentOnly 'org.springframework.boot:spring-boot-docker-compose'
    testAndDevelopmentOnly 'org.springframework.boot:spring-boot-docker-compose'
    ...
}

• spring boot 에서 지원하는 docker compose 기능을 사용하기 위해서 추가로 spring-boot-docker-compose 아티팩트를 dependency로 추가하였다.
• 테스트 코드에서도 spring boot docker compose를 사용하고자 한다면
  • testAndDevelopmentOnly ‘org.springframework.boot:spring-boot-docker-compose’ 디펜던시를 추가한다.
• 단일 서버 환경의 Redis인 경우 connection pool을 사용하기 위해서는 commons-pool2 디펜던시를 추가해야 한다.
  • 단일 서버 환경의 경우 애플리케이션이 commons-pool2 라이브러리를 사용할 수 있다면 pool은 자동 활성화 된다.

Spring Redis Auto Configuration

Spring Boot에서 Redis를 위한 auto configuration의 시작은 org.springframework.boot:spring-boot-autoconfigure 아티팩트의 org.springframework.boot.autoconfigure.data.redis 패키지에 있는 RedisAutoConfiguration 클래스다.
RedisAutoConfiguration 클래스에 지정된 어노테이션을 살펴보면 다음과 같다.

@AutoConfiguration
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})

@AutoConfiguration
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})

• application.yml(. properties)의 Redis 관련 설정은 RedisProperties 클래스에 맵핑된다.
• LettuceConnectoinConfiguration, JedisConnectionConfiguration 이 우선 동작한다.

Spring Data Redis Properties

RedisProperties 클래스는 spring data redis 설정 항목에 대한 맵핑 클래스다.
RedisProperties 클래스의 어노테이션은 다음과 같이 지정되어 있다.

@ConfigurationProperties(
    prefix = "spring.data.redis"
)

@ConfigurationProperties(
    prefix = "spring.data.redis"
)

속성 이름에 spring.data.redis prefix가 정의됨을 알 수 있다.
서버 연결을 위한 기본 설정 항목은 다음과 같다.

Connection Pool 관련 설정은 다음과 같다.

• {jedis | lettuce} 표시된 부분은 jedis 혹은 lettuce 가 지정됨을 의미한다.
  spring data properties에 대한 전반적인 내용은
  https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#appendix.application-properties.data
  링크를 참고하면 도움이 될 것이다.

기본 설정 예시

spring:
  data:
    redis:
      # redis 접속 호스트 (default: localhost)
      # redis 접속 호스트 (default: localhost)
      # - redis를 spring boot docker compose로 생성한 경우 spring에서 생성한 docker 컨테이너로부터 정보를 얻어 접속 정보를 자동 셋팅한다.
      # - redis를 spring boot docker compose로 생성하지 않은 경우 redis 접속 호스트 정보를 셋팅한다.
      host: localhost
      # redis 접속 포트 (default: 6379)
      # - redis를 spring boot docker compose로 생성한 경우 spring에서 생성한 docker 컨테이너로부터 정보를 얻어 접속 정보를 자동 셋팅한다.
      # - redis를 spring boot docker compose로 생성하지 않은 경우 redis 접속 포트 정보를 셋팅한다.
      port: 6379
      # connection timeout
      connect-timeout: 30s
      # read timeout
      timeout: 10s

spring:
  data:
    redis:
      # redis 접속 호스트 (default: localhost)
      # redis 접속 호스트 (default: localhost)
      # - redis를 spring boot docker compose로 생성한 경우 spring에서 생성한 docker 컨테이너로부터 정보를 얻어 접속 정보를 자동 셋팅한다.
      # - redis를 spring boot docker compose로 생성하지 않은 경우 redis 접속 호스트 정보를 셋팅한다.
      host: localhost
      # redis 접속 포트 (default: 6379)
      # - redis를 spring boot docker compose로 생성한 경우 spring에서 생성한 docker 컨테이너로부터 정보를 얻어 접속 정보를 자동 셋팅한다.
      # - redis를 spring boot docker compose로 생성하지 않은 경우 redis 접속 포트 정보를 셋팅한다.
      port: 6379
      # connection timeout
      connect-timeout: 30s
      # read timeout
      timeout: 10s

ConnectionDetails 추상화

Spring Boot 3.1부터 도입된 ConnectionDetails 추상화는 여러 원격 서비스에 대한 연결 설정을 자동 구성을 통해 모델링할 수 있게 되었다.
Redis 서비스의 경우 ConnectionDetails 인터페이스를 확장한 RedisConnectionDetails 인터페이스를 사용하며 이에 대한 구현체는 다음과 같다.

• RedisDockerComposeConnectionDetails
  • Spring Boot Docker Compose에 의해서 구성된 redis 서비스에 대해서 사용된다.
  • Spring Boot Docker Compose는 개발 및 테스트용이라서 그런지 standalone만 지원한다.
  • Spring Boot Docker Compose로 자동 생성된 redis 서버 docker container에 대한 호스트 포트를 자동으로 감지한다.
• PropertiesRedisConnectionDetails
  • application.yml (. properties)의 spring.data.redis 설정에 의해서 연결 정보에 대한 ConnectionDetails 추상화가 구현된다.
  • RedisDockerComposeConnectionDetails와 달리 standalone, sentinel, cluster 구성 설정을 모두 처리한다.
    ConnectionDetails를 통해서 standalone, sentinel, cluster 연결 설정에 대한 클래스가 구성이 되는데 각각 다음과 같다.
• standalone – RedisStandaloneConfiguration – 단일 서버 환경에 대한 접속 정보 설정
• sentinel – RedisSentinelConfiguration – Sentinel 구성 환경에 대한 접속 정보 설정
• cluster – RedisClusterConfiguration – Cluster 구성 환경에 대한 접속 정보 설정

위 클래스 모두 ConnectionDetails 구현체 클래스를 통해서 알맞게 설정된다.
Spring Boot Docker Compose를 통해서 Redis 서비스를 구성한 경우 Auto Configuration 과정에서 다음에 설명할 LettuceConnectionConfiguration 클래스에 주입되는 ConnectionDetails 클래스에 대한 정보를 디버거를 통해서 보면 다음과 같다.

참고로 앞서 언급했듯이 RedisDockerComposeConnectionDetails 에는 도커 컨테이너의 Redis 서버 포트와 연결된 연결된 호스트 포트를 자동으로 감지함을 알 수 있다.

LettuceConnectionConfiguration, JedisConnectionConfiguration 클래스

RedisAutoConfiguration 클래스에서 Import 하고 있는 두 RedisConnectionConfiguration 클래스다.
각각의 클래스에 지정된 어노테이션을 살펴보자.

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({RedisClient.class})
@ConditionalOnProperty(
    name = {"spring.data.redis.client-type"},
    havingValue = "lettuce",
    matchIfMissing = true
)
class LettuceConnectionConfiguration extends RedisConnectionConfiguration {...}

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({RedisClient.class})
@ConditionalOnProperty(
    name = {"spring.data.redis.client-type"},
    havingValue = "lettuce",
    matchIfMissing = true
)
class LettuceConnectionConfiguration extends RedisConnectionConfiguration {...}

LettuceConnectionConfiguration 클래스는 Lettuce 라이브러리를 통해서 연결을 위한 자동 구성 설정을 한다.
spring.data.redis.client-type 설정이 ‘lettuce’로 설정되거나 설정되지 않은 경우(matchIfMissing = true) 자동 구성이 동작하며 해당 클래스에서 LettuceConnectionFactory 빈을 생성(현재 RedisConnectionFactory 빈이 생성되지 않은 경우) 한다.
JedisConnectionConfiguration 클래스에 지정된 어노테이션은 다음과 같다.

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({GenericObjectPool.class, JedisConnection.class, Jedis.class})
@ConditionalOnMissingBean({RedisConnectionFactory.class})
@ConditionalOnProperty(
    name = {"spring.data.redis.client-type"},
    havingValue = "jedis",
    matchIfMissing = true
)
class JedisConnectionConfiguration extends RedisConnectionConfiguration {...}

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({GenericObjectPool.class, JedisConnection.class, Jedis.class})
@ConditionalOnMissingBean({RedisConnectionFactory.class})
@ConditionalOnProperty(
    name = {"spring.data.redis.client-type"},
    havingValue = "jedis",
    matchIfMissing = true
)
class JedisConnectionConfiguration extends RedisConnectionConfiguration {...}

LettuceConnectionConfiguration에 지정된 어노테이션과 유사하지만
@ConditionalOnClass({GenericObjectPool.class, JedisConnection.class, Jedis.class})
@ConditionalOnMissingBean({RedisConnectionFactory.class})
차이가 있다.
Jedis를 사용하려면 추가적으로 Jedis 디펜던시가 추가되어야 한다.

implementation 'redis.clients:jedis:<version>'

implementation 'redis.clients:jedis:<version>'

또한 LettuceConnectionConfiguration에서 LettuceConnectionFactory(RedisConnectionFactory)를 생성하였다면 JedisConnectionConfiguration 클래스의 자동 구성은 수행되지 않는다.
즉 명시적으로 spring.data.redis.client-type=jedis로 설정된 경우에만 JedisConnectionConfiguration 자동 구성이 수행된다.

CientResources Custom (Lettuce 만 해당)

ClientResource는 Lettuce에서 Redis 클라이언트 연결에 필요한 이벤트 루프 그룹, 스레드 풀 및 기타 인프라 구성 요소와 같은 공유 리소스를 관리하는 Lettuce의 인터페이스다.
이러한 리소스는 생성하는데 비용이 많이 들기 때문에 RedisConnectionFactory 빈을 생성할 때 자동으로 DefaultClientResources 인스턴스를 생성하여 LettuceConnectionFactory에 등록하여 사용한다.
LettuceConnectionConfiguration 클래스는 다음과 같이 ClientResources 인스턴스를 생성한다.

@Bean(
    destroyMethod = "shutdown"
)
@ConditionalOnMissingBean({ClientResources.class})
DefaultClientResources lettuceClientResources(ObjectProvider<ClientResourcesBuilderCustomizer> customizers) {
    DefaultClientResources.Builder builder = DefaultClientResources.builder();
    customizers.orderedStream().forEach((customizer) -> {
        customizer.customize(builder);
    });
    return builder.build();
}

@Bean(
    destroyMethod = "shutdown"
)
@ConditionalOnMissingBean({ClientResources.class})
DefaultClientResources lettuceClientResources(ObjectProvider<ClientResourcesBuilderCustomizer> customizers) {
    DefaultClientResources.Builder builder = DefaultClientResources.builder();
    customizers.orderedStream().forEach((customizer) -> {
        customizer.customize(builder);
    });
    return builder.build();
}

• ClientResources 인스턴스를 직접 생성하지 않았다면 Auto Configuration에 의해서 자동으로 인스턴스가 생성되는데 이때 ClientResourcesBuilderCustomizer를 빈으로 등록하여 변경하고자 하는 Resource 항목만을 변경할 수 있다.
• ClientResources의 일부 항목을 변경하도록 ClientResourcesBuilderCustomizer 빈을 생성하는 샘플 코드는 다음과 같다.

@Configuration
public class RedisConfiguration {
    @Bean
    public ClientResourcesBuilderCustomizer clientResourceCustomize() {
        return builder -> {
            builder.reconnectDelay( Delay.constant( Duration.ofSeconds(50) ) );
            builder.ioThreadPoolSize( 4 );
            builder.commandLatencyRecorder( CommandLatencyRecorder.disabled() );
            builder.commandLatencyPublisherOptions( DefaultEventPublisherOptions.disabled() );
        };
    }
}

@Configuration
public class RedisConfiguration {
    @Bean
    public ClientResourcesBuilderCustomizer clientResourceCustomize() {
        return builder -> {
            builder.reconnectDelay( Delay.constant( Duration.ofSeconds(50) ) );
            builder.ioThreadPoolSize( 4 );
            builder.commandLatencyRecorder( CommandLatencyRecorder.disabled() );
            builder.commandLatencyPublisherOptions( DefaultEventPublisherOptions.disabled() );
        };
    }
}

위 clientResourceCustomize 코드는 다음과 같은 설정을 변경한다.

• ClientResources에서 reconnect delay 정책을 ConstantDelay 인스턴스로 설정한다. (디폴트는 ExponentialDelay 다)
  • 재접속을 위해서 대기하는 시간을 고정 시간으로 변경한다.
  • ExponentialDelay는 재접속 시도 횟수가 증가할수록 Delay 시간이 그에 비례하여 증가하는 방식이다.
• io thread pool size를 4개로 고정한다. (디폴트는 processors 수다)
• 지연 시간에 대한 메트릭 수집을 disable 한다.
• 지연 시간에 대해서 수집된 메트릭 이벤트 발행을 disable 한다.

ClinetResources 클래스에 정의된 각 멤버 변수들에 대한 설명은 다음과 같다.

Configuration 클래스에서 ConnectionFactory의 Client Configuration 변경하기

ClientResources의 항목을 Configuration 클래스에서 ClientResourcesBuilderCustomizer를 이용하여 변경할 수 있는 것처럼 LettuceClientConfigurationBuilderCustomizer를 이용하여 ConnectionFactory의 Client 설정 정보를 변경할 수 있다.
Lettuce를 기반으로 설정을 변경하는 샘플 코드는 다음과 같다.

@Bean
public LettuceClientConfigurationBuilderCustomizer lettuceClientConfigCustomize() {
    return builder -> {
        if ( builder instanceof
                LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder poolingBuilder ) {
            // Pool configuration
            GenericObjectPoolConfig<?> poolConfig = new GenericObjectPoolConfig<>();
            poolConfig.setMaxIdle(10);
            poolConfig.setMinIdle(5);
            poolConfig.setMaxTotal(20);
            poolConfig.setMaxWait(Duration.ofSeconds( 30 ));
            poolingBuilder.poolConfig( poolConfig );
        }
        builder.shutdownTimeout( Duration.ofMillis( 1000L ) );
    };
}

@Bean
public LettuceClientConfigurationBuilderCustomizer lettuceClientConfigCustomize() {
    return builder -> {
        if ( builder instanceof
                LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder poolingBuilder ) {
            // Pool configuration
            GenericObjectPoolConfig<?> poolConfig = new GenericObjectPoolConfig<>();
            poolConfig.setMaxIdle(10);
            poolConfig.setMinIdle(5);
            poolConfig.setMaxTotal(20);
            poolConfig.setMaxWait(Duration.ofSeconds( 30 ));
            poolingBuilder.poolConfig( poolConfig );
        }

        builder.shutdownTimeout( Duration.ofMillis( 1000L ) );
    };
}

위 코드는

• pool 설정이 있는 경우에는 LettucePoolingClientConfigurationBuilder 인스턴스가 생성되는데 max-idle, min-idle, max-total, max-wait 설정을 각각 10개, 5개, 20개, 30초로 다시 재설정을 한다.
• lettuce shutdown timeout 설정을 1000ms로 설정한다. (default: 100ms)
  • spring.data.redis.lettuce.shutdown-timeout 설정이 지정되어 있다면 override 한다.

lettuceClientConfigCustomize 빈이 어떻게 호출되는지 LettuceConnectionConfiguration 클래스를 통해 살펴보자.
LettuceConnectionFactory 빈을 생성하는 코드는 다음과 같다.

@Bean
@ConditionalOnMissingBean(RedisConnectionFactory.class)
@ConditionalOnThreading(Threading.PLATFORM)
LettuceConnectionFactory redisConnectionFactory(
		ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers,
		ClientResources clientResources) {
	return createConnectionFactory(builderCustomizers, clientResources);
}

@Bean
@ConditionalOnMissingBean(RedisConnectionFactory.class)
@ConditionalOnThreading(Threading.PLATFORM)
LettuceConnectionFactory redisConnectionFactory(
		ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers,
		ClientResources clientResources) {
	return createConnectionFactory(builderCustomizers, clientResources);
}

위 코드에서 ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers 파라미터에 직접 작성한 lettuceClientConfigCustomize 빈이 주입되게 된다.
createConnectionFactory(builderCustomizers, clientResources) 메서드 구현은 다음과 같다.

private LettuceConnectionFactory createConnectionFactory(
		ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers,
		ClientResources clientResources) {
	LettuceClientConfiguration clientConfig = getLettuceClientConfiguration(builderCustomizers, clientResources,
			getProperties().getLettuce().getPool());
	return createLettuceConnectionFactory(clientConfig);
}

private LettuceConnectionFactory createConnectionFactory(
		ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers,
		ClientResources clientResources) {
	LettuceClientConfiguration clientConfig = getLettuceClientConfiguration(builderCustomizers, clientResources,
			getProperties().getLettuce().getPool());
	return createLettuceConnectionFactory(clientConfig);
}

getLettuceClientConfiguration(builderCustomizers, clientResources, getProperties().getLettuce().getPool()); 메서드가 Lettuce Client 설정을 생성하는 부분이다.
따라가 보자.

private LettuceClientConfiguration getLettuceClientConfiguration(
		ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers,
		ClientResources clientResources, Pool pool) {
	LettuceClientConfigurationBuilder builder = createBuilder(pool);
	applyProperties(builder);
	if (StringUtils.hasText(getProperties().getUrl())) {
		customizeConfigurationFromUrl(builder);
	}
	builder.clientOptions(createClientOptions());
	builder.clientResources(clientResources);
	builderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(builder));
	return builder.build();
}

private LettuceClientConfiguration getLettuceClientConfiguration(
		ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers,
		ClientResources clientResources, Pool pool) {
	LettuceClientConfigurationBuilder builder = createBuilder(pool);
	applyProperties(builder);
	if (StringUtils.hasText(getProperties().getUrl())) {
		customizeConfigurationFromUrl(builder);
	}
	builder.clientOptions(createClientOptions());
	builder.clientResources(clientResources);
	builderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(builder));
	return builder.build();
}

직접 작성한 lettuceClientConfigCustomize 빈이 여기까지 흘러 들어왔다.
각 메서드 호출의 동작을 살펴보면

• createBuilder(pool) : pool 설정이 enabled인 경우 LettucePoolingClientConfigurationBuilder를 아닌 경우 LettuceClientConfigurationBuilder를 리턴한다.
• applyProperties(builder) : builder에 application 프로퍼티 설정내용을 적용한다. (spring.data.redis.~~~)
  • ssl enabled 여부 설정 적용 (spring.data.redis.ssl.enabled)
  • timeout 설정 적용 (spring.data.redis.timeout)
  • lettuce의 shutdown timeout 설정 적용 (spring.data.redis.lettuce.shutdown-timeout)
  • client name 설정 적용 (spring.data.redis.client-name)
• customizeConfigurationFromUrl(builder) : spring.data.redis.url 설정이 적용된 경우 url 내용을 파싱 하여 scheme가 rediss인 경우 use ssl을 true로 설정한다.
• builder.clientOptions(createClientOptions()) : ClientOptions 인스턴스를 생성하여 적용한다. ClientOptions에 적용되는 설정은 다음과 같다.
  • application.yml (.properties) 설정에 cluster refresh 관련 설정을 적용한다. (spring.data.redis.lettuce.cluster.refresh)
  • connection timeout 설정을 적용한다. (spring.data.redis.connect-timeout)
  • SSL bundle이 지정된 경우 bundle에 지정된 SSL 설정을 적용한다. (spring.data.redis.ssl.bundle)
• builder.clientResources : ClientResources 인스턴스를 적용한다.
• builderCustomizers.orderedStream().forEach( ( customizer ) → customizer.customize( builder ) )
  • 직접 작성한 lettuceClientConfigCustomize 인스턴스가 적용된다.
  • customizer.customize(builder) 호출은 결국 아래 코드와 같게 된다.

void customize(LettuceClientConfigurationBuilder builder) {
	if ( builder instanceof
        LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder poolingBuilder ) {
    // Pool configuration
	    GenericObjectPoolConfig<?> poolConfig = new GenericObjectPoolConfig<>();
	    poolConfig.setMaxIdle(10);
	    poolConfig.setMinIdle(5);
	    poolConfig.setMaxTotal(20);
	    poolConfig.setMaxWait(Duration.ofSeconds( 30 ));
	    poolingBuilder.poolConfig( poolConfig );
	}
	builder.shutdownTimeout( Duration.ofMillis( 1000L ) );
}

void customize(LettuceClientConfigurationBuilder builder) {
	if ( builder instanceof
        LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder poolingBuilder ) {
    // Pool configuration
	    GenericObjectPoolConfig<?> poolConfig = new GenericObjectPoolConfig<>();
	    poolConfig.setMaxIdle(10);
	    poolConfig.setMinIdle(5);
	    poolConfig.setMaxTotal(20);
	    poolConfig.setMaxWait(Duration.ofSeconds( 30 ));
	    poolingBuilder.poolConfig( poolConfig );
	}

	builder.shutdownTimeout( Duration.ofMillis( 1000L ) );
}

ClientOptions (Lettuce만 해당)

LettuceClientConfiguration를 생성시에 ClientOptions 인스턴스를 생성하여 LettuceClientConfiguration 인스턴스에 적용한다.
ClientOptions 클래스는 Spring 애플리케이션 내에서 사용되는 Redis 클라이언트의 동작을 구성하는 핵심 부분이다.
클라이언트가 Redis 서버와 상호 작용하는 방식에서 중요한 역할을 하며 연결 처리, 명령 실행, 보안 및 성능 최적화에 영향을 미친다.
다음은 ClientOptions 클래스의 각 필드에 대한 설명이다.

decodeBufferPolicy 
1. ratio 정책
   – 집계 버퍼의 용량과 사용량을 고려한 비율 기반의 정책이다. 사용 비율을 고려하여 CPU 사용량과 메모리 사용량을 최적화 한다. 값이 높을 수록 메모리 사용량이 늘어난다. parameter로 전달되는 bufferUsageRatio는 버퍼 사용 비율이다.
값이 1이면 50%, 값이 2이면 66%, 값이 3이면 75% 와 같이 계산된다. 0에서 2^31 – 1 사이의 값이어야 하며 일반적으로 50%에서 90%를 나타내는 1에서 10사이의 값을 설정한다.

2. always 정책
    – 각 디코딩 단계 후에 읽은 바이트를 삭제하는 정책이다. 메모리 효율성이 가장 높은 전략이지만 CPU 부담도 함께 커진다.

3. alwaysSome 정책
    – 각 디코딩 단계 후에 일부 읽기 바이트를 삭제하는 정책이다. 내부 구현에 따라 읽기 바이트의 일부 또는 전부를 삭제하거나 전혀 삭제하지 않고 잠재적으로 추가 메모리 소비를 감수하면서 전체 메모리 대역폭 소비를 줄일 수 있다.

disconnectBehavior
1. DEFAULT
    – autoReconnect 옵션이 true인 경우 명령을 수락하고, autoReconnect 옵션이 false인 경우 명령을 거부한다.

2. ACCEPT_COMMANDS
     – 연결이 끊긴 상태에서도 명령을 수락한다.

3. REJECT_COMMANDS
     – 연결이 끊기 상태에서는 명령을 거부한다.

RedisConnectionFactory 생성 (LettuceConnectionFactory)

지금까지 위에서 살펴본 ClientResources, LettuceClientConfiguration, ConnectionDetails 인스턴스를 통해서 RedisConnectionFactory가 생성된다.
최종적으로 LettuceConnectionFactory에는 LettuceClientConfiguration과 RedisConfiguration 인스턴스가 적용이 된다.
RedisConfiguration 인스턴스는 application.yml (.properties) 설정의 다음 항목에 따라서 인스턴스가 결정된다.

spring.data.redis.sentinel, spring.data.redis.cluster가 모두 설정된 경우에는 spring.data.redis.sentinel 설정이 적용된다.
정리하자면 RedisConnectionFactory(LettuceConnectionFactory) 인스턴스가 생성되는 과정은 다음과 같다.

RedisTemplate Serializers

Spring Data Redis에서 사용자 정의 타입과 raw 데이터 간의 변환은 org.springframework.data.redis.serializer 패키지에서 처리한다. 이 패키지에는 직렬화 프로세스를 처리하는 두 가지 유형의 직렬화기가 포함되어 있다.

• RedisSerializer를 기반으로 한 양방향 직렬화기
• Element를 읽고 쓰기 위해서 사용하는 RedisElementReader 및 RedisElementWriter
  두 직렬화기의 차이점은 RedisSerializer는 byte[]로 직렬화하는 반면, Reader와 Writer는 ByteBuffer를 사용한다.

위 두 가지 유형 이외에도 여러 직렬화기를 사용할 수 있다.

• RedisCache와 RedisTemplate에 기본적으로 사용되는 JdkSerializationRedisSerializer
• StringRedisSerializer
• Spring OXM 지원을 통해 객체/XML 매핑을 위한 OxmSerializer
• JSON 형식으로 데이터를 저장하기 위해 Jacson2JsonRedisSerializer 또는 GenericJackson2JsonRedisSerializer

저장 형식은 값으로만 제한되지 않고 키, 값 또는 해시에 제한 없이 사용할 수 있다.
기본적으로 RedisCache 및 RedisTemplate은 Java 네이티브 직렬화를 사용하도록 구성된다. Java 네이티브 직렬화는 확인되지 않은 바이트코드를 삽입하는 취약한 라이브러리 및 클래스를 악용하는 페이로드로 인해 원격 코드가 실행될 수 있는 것으로 알려져 있다. 조작된 입력으로 인해 역직렬화 단계에서 애플리케이션에 원하지 않는 코드가 실행될 수 있다. 따라서 신뢰할 수 없는 환경에서는 직렬화를 사용하지 않는 것이 좋다. 일반적으로 다른 메시지 형식(JSON과 같은)을 대신 사용할 것을 강력히 권장한다고 Spring 문서에서는 말한다.
다음 샘플 코드는 Redis의 키와 값에 대한 직렬화기를 설정하는 방법을 보여준다.

// lettuceConnectionFactory 인스턴스는 spring data redis auto configuration에 의해서 자동 생성됨
@Bean
public RedisTemplate<String, Object> redisTemplate( LettuceConnectionFactory lettuceConnectionFactory ) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory( lettuceConnectionFactory );
    // set key serializer
    // template.setKeySerializer( new StringRedisSerializer(StandardCharsets.UTF_8) ); 와 동일함
    template.setKeySerializer( RedisSerializer.string() );
    template.setHashKeySerializer( RedisSerializer.string() );
    // set value serializer
    // template.setDefaultSerializer( new GenericJackson2JsonRedisSerializer() ); 와 동일함
    template.setDefaultSerializer( RedisSerializer.json() );
    template.setValueSerializer( RedisSerializer.json() );
    template.setHashValueSerializer( RedisSerializer.json() );
    return template;
}

// lettuceConnectionFactory 인스턴스는 spring data redis auto configuration에 의해서 자동 생성됨
@Bean
public RedisTemplate<String, Object> redisTemplate( LettuceConnectionFactory lettuceConnectionFactory ) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory( lettuceConnectionFactory );

    // set key serializer
    // template.setKeySerializer( new StringRedisSerializer(StandardCharsets.UTF_8) ); 와 동일함
    template.setKeySerializer( RedisSerializer.string() );
    template.setHashKeySerializer( RedisSerializer.string() );

    // set value serializer
    // template.setDefaultSerializer( new GenericJackson2JsonRedisSerializer() ); 와 동일함
    template.setDefaultSerializer( RedisSerializer.json() );
    template.setValueSerializer( RedisSerializer.json() );
    template.setHashValueSerializer( RedisSerializer.json() );

    return template;
}

Serializer를 변경하려면 Auto Configuration으로 생성되는 RedisTemplate 대신에 직접 빈을 정의해야 한다.
위 코드는

• 키와 해시키에 대한 Serializer로 StringRedisSerializer를 사용하도록 한다.
• 값과 해시값에 대한 Serializer로 GenericJackson2JsonRedisSerializer를 사용하도록 한다.

RedisTemplate 사용 테스트 코드

지금까지 Spring Redis Auto Configuration 및 RedisTemplate에 Serializer를 적용한 설정을 토대로 간단한 테스트 코드를 작성해 보았다. UUID 형식의 키에 Person 객체를 저장하는 코드다.

package com.example.spring.redis.model;
import lombok.Builder;
import org.springframework.data.annotation.Id;
import java.util.UUID;
@Builder
public record Person(@Id UUID id,
                     String personName,
                     Integer personAge,
                     String personNation,
                     String comment) {
    public Person( UUID id, String personName, Integer personAge, String personNation, String comment ) {
        this.id = (id == null) ? UUID.randomUUID() : id;
        this.personName = personName;
        this.personAge = personAge;
        this.personNation = personNation;
        this.comment = comment;
    }
}

package com.example.spring.redis.model;

import lombok.Builder;
import org.springframework.data.annotation.Id;

import java.util.UUID;

@Builder
public record Person(@Id UUID id,
                     String personName,
                     Integer personAge,
                     String personNation,
                     String comment) {
    public Person( UUID id, String personName, Integer personAge, String personNation, String comment ) {
        this.id = (id == null) ? UUID.randomUUID() : id;
        this.personName = personName;
        this.personAge = personAge;
        this.personNation = personNation;
        this.comment = comment;
    }
}

Redis 연결을 위한 Configuration

@Configuration
@RequiredArgsConstructor
public class RedisConfiguration {
    @Bean
    public ClientResourcesBuilderCustomizer clientResourceCustomize() {
        return builder -> {
            builder.reconnectDelay( Delay.constant( Duration.ofSeconds(50) ) );
            builder.ioThreadPoolSize( 4 );
            builder.commandLatencyRecorder( CommandLatencyRecorder.disabled() );
            builder.commandLatencyPublisherOptions( DefaultEventPublisherOptions.disabled() );
        };
    }
    @Bean
    public LettuceClientConfigurationBuilderCustomizer lettucyClientConfigCustomize() {
        return builder -> {
            if ( builder instanceof
                    LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder poolingBuilder ) {
                // Pool configuration
                GenericObjectPoolConfig<?> poolConfig = new GenericObjectPoolConfig<>();
                poolConfig.setMaxIdle(10);
                poolConfig.setMinIdle(5);
                poolConfig.setMaxTotal(20);
                poolConfig.setMaxWait(Duration.ofSeconds( 30 ));
                poolingBuilder.poolConfig( poolConfig );
            }
            builder.shutdownTimeout( Duration.ofMillis( 1000L ) );
        };
    }
    // lettuceConnectionFactory 인스턴스는 spring data redis auto configuration에 의해서 자동 생성됨
    @Bean
    public RedisTemplate<String, Object> redisTemplate( LettuceConnectionFactory lettuceConnectionFactory ) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory( lettuceConnectionFactory );
        // set key serializer
        // template.setKeySerializer( new StringRedisSerializer(StandardCharsets.UTF_8) ); 와 동일함
        template.setKeySerializer( RedisSerializer.string() );
        template.setHashKeySerializer( RedisSerializer.string() );
        // set value serializer
        // template.setDefaultSerializer( new GenericJackson2JsonRedisSerializer() ); 와 동일함
        template.setDefaultSerializer( RedisSerializer.json() );
        template.setValueSerializer( RedisSerializer.json() );
        template.setHashValueSerializer( RedisSerializer.json() );
        return template;
    }
}

@Configuration
@RequiredArgsConstructor
public class RedisConfiguration {

    @Bean
    public ClientResourcesBuilderCustomizer clientResourceCustomize() {
        return builder -> {
            builder.reconnectDelay( Delay.constant( Duration.ofSeconds(50) ) );
            builder.ioThreadPoolSize( 4 );
            builder.commandLatencyRecorder( CommandLatencyRecorder.disabled() );
            builder.commandLatencyPublisherOptions( DefaultEventPublisherOptions.disabled() );
        };
    }

    @Bean
    public LettuceClientConfigurationBuilderCustomizer lettucyClientConfigCustomize() {
        return builder -> {
            if ( builder instanceof
                    LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder poolingBuilder ) {
                // Pool configuration
                GenericObjectPoolConfig<?> poolConfig = new GenericObjectPoolConfig<>();
                poolConfig.setMaxIdle(10);
                poolConfig.setMinIdle(5);
                poolConfig.setMaxTotal(20);
                poolConfig.setMaxWait(Duration.ofSeconds( 30 ));
                poolingBuilder.poolConfig( poolConfig );
            }

            builder.shutdownTimeout( Duration.ofMillis( 1000L ) );

        };
    }

    // lettuceConnectionFactory 인스턴스는 spring data redis auto configuration에 의해서 자동 생성됨
    @Bean
    public RedisTemplate<String, Object> redisTemplate( LettuceConnectionFactory lettuceConnectionFactory ) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory( lettuceConnectionFactory );

        // set key serializer
        // template.setKeySerializer( new StringRedisSerializer(StandardCharsets.UTF_8) ); 와 동일함
        template.setKeySerializer( RedisSerializer.string() );
        template.setHashKeySerializer( RedisSerializer.string() );

        // set value serializer
        // template.setDefaultSerializer( new GenericJackson2JsonRedisSerializer() ); 와 동일함
        template.setDefaultSerializer( RedisSerializer.json() );
        template.setValueSerializer( RedisSerializer.json() );
        template.setHashValueSerializer( RedisSerializer.json() );

        return template;
    }
}

테스트 코드

@ExtendWith( SpringExtension.class )
@ContextConfiguration( classes = { RedisConfiguration.class } )
@DataRedisTest
@EnableAutoConfiguration
public class RedisTest {
    @Autowired
    RedisTemplate<String, Object> redisTemplate;
    final UUID id = UUID.randomUUID();
    @Test
    @DisplayName( "redis insert test" )
    void insert_person_redis_test() {
        Person person = Person.builder()
                .id( id )
                .personName( "test-name" )
                .personAge( 100 )
                .personNation( "korea" )
                .comment( "first commit data" )
                .build();
        redisTemplate.opsForValue().set( id.toString(), person );
        // find data
        Object object = redisTemplate.opsForValue().get( id.toString() );
        Assertions.assertThat( object ).isInstanceOf( Person.class );
        Person find = ( Person ) object;
        Assertions.assertThat( find.id().toString() ).isEqualTo( id.toString() );
    }
}

@ExtendWith( SpringExtension.class )
@ContextConfiguration( classes = { RedisConfiguration.class } )
@DataRedisTest
@EnableAutoConfiguration
public class RedisTest {

    @Autowired
    RedisTemplate<String, Object> redisTemplate;

    final UUID id = UUID.randomUUID();

    @Test
    @DisplayName( "redis insert test" )
    void insert_person_redis_test() {
        Person person = Person.builder()
                .id( id )
                .personName( "test-name" )
                .personAge( 100 )
                .personNation( "korea" )
                .comment( "first commit data" )
                .build();

        redisTemplate.opsForValue().set( id.toString(), person );

        // find data
        Object object = redisTemplate.opsForValue().get( id.toString() );
        Assertions.assertThat( object ).isInstanceOf( Person.class );
        Person find = ( Person ) object;
        Assertions.assertThat( find.id().toString() ).isEqualTo( id.toString() );
    }
}

테스트 코드를 통해서 Redis에 저장된 데이터를 살펴보면 JSON 형식으로 저장된 것을 확인해 볼 수 있다.


Spring Data Redis를 사용하기 위한 연결 설정을 위해서 수행되는 Redis Auto Configuration에 대해서 살펴보았다.
application.yml (.properties)의 spring.data.redis 설정과 변경하고자 하는 ClientResources, ClientConfiguration에 대한 customize 빈과 RedisTemplate에 적용할 Serializer를 설정하는 것만으로 손쉽게 Redis를 활용할 수 있다.

끝.

샘플 코드는 GITLAB 링크 에서 확인할 수 있다.