Clients

Spring Redis Connection Auto Config

레디스 개발자 교육 신청	레디스 정기점검/기술지원 Redis Technical Support	레디스 엔터프라이즈 서버 Redis Enterprise Server

Spring Boot Redis Properties

이 문서는 Spring Boot에서 application.properties or yml을 이용해서 Redis Server에 연결하는 방법을 설명합니다.
레디스 접속 기본 클라이언트 라이브러리로 Spring Boot 1.x에서는 Jedis를 사용하였고, 2.x부터는 Lettuce를 사용합니다.
이 문서에서는 Lettuce를 기준으로 설명합니다.

Spring Redis Properties 관련 공식 문서는 아래 링크를 참고하세요.

Spring Boot 2.7.14 RedisProperties (docs.spring.io)
spring.redis @ConfigurationProperties(prefix="spring.redis")
Spring Boot 3.1.3 RedisProperties (docs.spring.io)
spring.data.redis @ConfigurationProperties(prefix="spring.data.redis")
Spring Boot 최신(current) RedisProperties (docs.spring.io)
Spring Boot RedisProperties.java (github.com java soruce)
Spring Boot RedisAutoConfiguration.java (github.com java soruce)
Spring Data Redis (3.1.3 docs.spring.io 설명)

Spring Boot 3.x

application.properties 설정

Spring Boot 2.x에서는 spring.redis로 시작
Spring Boot 3.x에서는 spring.data.redis로 시작

이 문서는 Spring Boot 3.x를 기준으로 작성합니다.

Auto Configuration 설정 방법

Auto Configuration은 application.properties에 설정만 해 놓으면 설정한 값으로 Redis Server에 연결은 Spring이 알아서 해줍니다.
Redis Auto Configuration에는 세 가지가 있다.

Standalone
Sentinel
Cluster

Standalone 설정

redis.host: 레디스 서버의 IP를 입력합니다. (필수)
redis.port: 레디스 서버의 port를 입력합니다. (필수)
password: redis server에 password(requirepass) 설정했을 경우 사용합니다. (선택)

application.properties
spring.data.redis.host: 192.168.56.102 spring.data.redis.port: 18500 spring.data.redis.password: redisgate
application.yml
spring: data: redis: host: 192.168.56.102 port: 18500 password: redisgate

Sentinel 설정

sentinel.nodes: 센티널 서버의 IP:Port를 입력합니다. (필수) 센티널 서버 3대 정보를 모두 입력합니다.
sentinel.master: sentinel.conf에 "sentinel monitor mymaster 192.168.56.102 18520 2" 이와 같이 입력했을 경우 'mymaster'를 입력합니다. (필수)
Lettuce는 위 정보로 센티널 서버에 접속해서 'sentinel master mymaster' 명령을 실행해서 레디스 마스터 서버 정보를 얻어오고, 'sentinel replicas mymaster' 명령을 실행해서 복제 서버 정보를 얻어옵니다. 그러므로 레디스 서버의 IP:Port는 입력할 필요없습니다.
sentinel.password: 센티널 서버에 password(requirepass) 설정했을 경우 사용합니다. (선택)
redis.password: 레디스 서버에 password(requirepass) 설정했을 경우 사용합니다. (선택)

application.properties
spring.data.redis.sentinel.nodes: 192.168.56.102:18525, 192.168.56.102:18526, 192.168.56.102:18527 spring.data.redis.sentinel.master: mymaster spring.data.redis.sentinel.password: redisgate spring.redis.password: redisgate
application.yml
spring: data: redis: sentinel: nodes: 192.168.56.102:18525, 192.168.56.102:18526, 192.168.56.102:18527 master: mymaster password: redisgate password: redisgate

Cluster 설정

cluster.nodes: 클러스터로 설정한 레디스 서버의 IP:Port를 입력합니다. (필수) 6대 정보를 모두 입력합니다.
redis.password: 레디스 서버에 password(requirepass) 설정했을 경우 사용합니다. (선택)

application.properties
spring.data.redis.cluster.nodes: 192.168.56.102:18530, 192.168.56.102:18531, 192.168.56.102:18532, 192.168.56.102:18533, 192.168.56.102:18534, 192.168.56.102:18535 spring.data.redis.password: redisgate application.yml
spring: data: redis: cluster: nodes: 192.168.56.102:18530, 192.168.56.102:18531, 192.168.56.102:18532, 192.168.56.102:18533, 192.168.56.102:18534, 192.168.56.102:18535 password: redisgate

프로젝트 생성

start.spring.io

Project: Gradle
Language: Java
Spring Boot 3.1.3
Group: com.redisgate
Artifact: redis2
Packaging: Jar
Java: 17
Dependencies
- Spring Web
- Lombok
- Spring Data Redis(Access+Driver)

Spring Boot 3.x -> Java 17 이상
Spring Boot 2.x -> Java 11 이하

개발 IDE: IntelliJ

Java 소스

Package 구성
package

Java 파일(클래스) 설명

Redis2Application.java: main program
StringEntity.java: Redis String data type용 entity
StringRepository.java: 저장(save), 조회(get)한다.
StringController.java: url 요청을 받아 실행한다.

Redis2Application.java
package com.redisgate.redis2; import lombok.extern.slf4j.Slf4j; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication @Slf4j public class Redis2Application { public static void main(String[] args) { SpringApplication.run(Redis2Application.class, args); log.info("Spring Boot 3.x application.properties Test"); } }

StringEntity.java
package com.redisgate.redis2.entity; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; @Data @NoArgsConstructor @AllArgsConstructor public class StringEntity { private String key; private String value; }

StringRepository.java
package com.redisgate.redis2.repository; import com.redisgate.redis2.entity.StringEntity; import lombok.extern.slf4j.Slf4j; import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.data.redis.core.ValueOperations; import org.springframework.stereotype.Repository; @Repository @Slf4j public class StringRepository { private StringRedisTemplate redisCmds; private ValueOperations redisString; public StringRepository(StringRedisTemplate stringRedisTemplate) { this.redisCmds = stringRedisTemplate; this.redisString = stringRedisTemplate.opsForValue(); } public void save(StringEntity stringEntity) { redisString.set(stringEntity.getKey(), stringEntity.getValue()); } public StringEntity get(String key) { String value = (String) redisString.get(key); if (value == null) { log.info("value is null"); return null; } return new StringEntity(key, value); } }

StringController.java
package com.redisgate.redis2.controller; import com.redisgate.redis2.entity.StringEntity; import com.redisgate.redis2.repository.StringRepository; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; @RestController @RequestMapping("/api/") public class StringController { @Autowired StringRepository stringRepository; @PostMapping("string") public StringEntity saveString(@RequestBody StringEntity stringEntity){ stringRepository.save(stringEntity); return stringEntity; } @GetMapping("string/{key}") public StringEntity get(@PathVariable("key") String key) { return stringRepository.get(key); } }

프로그램 테스트

프로그램 테스트는 Talend api Tester 확장 프로그램을 사용했습니다.

입력

METHOD: POST
URL: http://localhost:9090/api/string
BODY(입력 내용): { "key": "key01", "value": "value01" }

조회

METHOD: GET
URL: http://localhost:9090/api/string/key01
BODY(조회 결과): { "key": "key01", "value": "value01" }

class RedisProperties 설명

여기에 있는 항목(필드)를 application.properties에 설정하면 자동 적용된다.
application.properties: spring.data.redis로 시작한다.
예) spring.data.redis.host = localhost or 127.0.0.1
springboot 3.1.3 기준

Redis general Properties

No	Field	설명 Desc
1	String host = "localhost"	Redis server host(IP). redis.conf: bind
2	int port = 6379	Redis server port. redis.conf: port
3	int database = 0	Database index used by the connection factory. 기본으로 제공되는 16개(0~15번) DB를 접속시 선택한다. Spring Auto Config에서는 접속 후 DB를 변경할 수 없다. (select 명령이 제공되지 않는다) * 참고: Redis Cluster는 0번 DB만 사용된다.
4	String username	Login username of the redis server.
5	String password	Login password of the redis server. redis.conf: requirepass
6	Duration timeout	Read(command) timeout. Default 60초 io.lettuce.core.RedisURI DEFAULT_TIMEOUT = 60 (sec) Redis에 적절한 timeout: 3~5초 권장
7	String url	redis://[[username:]password@]host [: port][/database] [? [timeout=timeout[d\|h\|m\|s\|ms\|us\|ns]] [&database=database] [&clientName=clientName]] 예) redis://password@127.0.0.1:6379/0?timeout=10s 위와 같이 설정하면 password, host, port, database, timeout을 따로 설정하지 않아도 된다.
8	Duration connectTimeout	Connection timeout. Default 10초 io.lettuce.core.SocketOptions DEFAULT_CONNECT_TIMEOUT = 10 (sec)
9	String clientName	Client name to be set on connections with CLIENT SETNAME.
10	ClientType clientType	Type of client to use. By default, auto-detected according to the classpath. LETTUCE -> Use the Lettuce redis client. JEDIS -> Use the Jedis redis client.
11	Sentinel sentinel	센티널 노드, 마스터이름 등 설정, 아래 Sentinel properties 참조
12	Cluster cluster	클러스터 노드 등 설정, 아래 Cluster properties 참조
13	final Ssl ssl = new Ssl()	SSL: 보안 소켓 계층(Secure Sockets Layer) 사용 여부 설정 아래 SSL properties 참조
14	final Jedis jedis = new Jedis()	Jedis pool 설정, 아래 Jedis properties 참조
15	final Lettuce lettuce = new Lettuce()	Pool, Cluster topology refresh period 등 설정 아래 Lettuce properties 참조

Pool properties (static class)

Pool은 바로 지정할 수 없고 아래와 같이 lettuce, jedis 다음에 지정한다.
spring.data.redis.lettuce.pool.enabled = true
spring.data.redis.jedis.pool.enabled = true

No	Field	설명 Desc
1	Boolean enabled	Whether to enable the pool. Enabled automatically if "commons-pool2" is available. With Jedis, pooling is implicitly enabled in sentinel mode and this setting only applies to single node setup. Pool을 활성화할지 여부입니다. "commons-pool2"를 사용할 수 있는 경우 자동으로 활성화됩니다. Jedis를 사용하면 센티넬 모드에서 풀링이 암시적으로 활성화되며 이 설정은 단일 노드 설정에만 적용됩니다. spring.data.redis.lettuce.pool.enabled = true Lettuce: GenericObjectPoolConfig(), ClientResources
2	int maxIdle = 8	Maximum number of "idle" connections in the pool. Use a negative value to indicate an unlimited number of idle connections. Pool의 최대 "유휴(idle)" 연결 수입니다. 유휴 연결 수에 제한이 없음을 나타내려면 음수 값을 사용합니다.
3	int minIdle = 0	Target for the minimum number of idle connections to maintain in the pool. This setting only has an effect if both it and time between eviction runs are positive. Pool에서 유지 관리할 최소 유휴 연결 수의 목표입니다. 이 설정은 해당 설정과 제거 실행 사이의 시간이 모두 양수인 경우에만 효과가 있습니다.
4	int maxActive = 8	Maximum number of connections that can be allocated by the pool at a given time. Use a negative value for no limit. 주어진 시간에 pool에서 할당할 수 있는 최대 연결 수입니다. 제한이 없으면 음수 값을 사용합니다.
5	Duration maxWait = Duration.ofMillis(-1)	Maximum amount of time a connection allocation should block before throwing an exception when the pool is exhausted. Use a negative value to block indefinitely. Pool이 소진되었을 때 예외가 발생하기 전에 연결 할당이 차단되어야 하는 최대 시간입니다. 무기한 차단하려면 음수 값을 사용하세요.
6	Duration timeBetweenEvictionRuns	Time between runs of the idle object evictor thread. When positive, the idle object evictor thread starts, otherwise no idle object eviction is performed. 유휴(idle) 개체 축출기 스레드 실행 사이의 시간입니다. 양수이면 유휴 개체 제거 스레드가 시작되고, 그렇지 않으면 유휴 개체 제거가 수행되지 않습니다.

Cluster properties (static class)

No	Field	설명 Desc
1	List<String> nodes	Comma-separated list of "host:port" pairs to bootstrap from. This represents an "initial" list of cluster nodes and is required to have at least one entry. 부트스트랩할 "host:port" 쌍의 쉼표로 구분된 목록입니다. 이는 클러스터 노드의 초기(initial) 목록을 나타내며 하나 이상의 항목이 있어야 합니다. 마스터 노드 뿐만 아니라 복제 노드까지 모두 나열하세요. (마스터가 모두 다운되었을 경우를 대비해서)
2	Integer maxRedirects	Maximum number of redirects to follow when executing commands across the cluster. 클러스터 전체에서 명령을 실행할 때 따라야 할 최대 리디렉션 수입니다. 슬롯 이동(reshard)과 관련있습니다. 내부적으로 ClusterClientOptions class에서 int DEFAULT_MAX_REDIRECTS = 5 설정되어 있습니다. 특별한 사유가 없으면 기본값대로 사용하세요. (별도로 설정하지 마세요)

Sentinel properties (static class)

No	Field	설명 Desc
1	String master	Name of the Redis server. sentinel.conf: sentinel monitor mymaster 127.0.0.1 6379 2 application.properties: spring.data.redis.sentinel.master = mymaster
2	List<String> nodes	Comma-separated list of "host:port" pairs. application.properties: spring.data.redis.sentinel.nodes = 127.0.0.1:16379, 127.0.0.1:16380 List로 선언되어 있는데 구현에서 RedisSentinelConfiguration(String master, Set<String> sentinelHostAndPorts)는 Set으로 되어있으므로 Set으로 변경해야 한다. 예제) RedisSentinelConfiguration(redisInfo.getSentinel().getMaster(), new HashSet<>(redisInfo.getSentinel().getNodes()));
3	String username	Login username for authenticating with sentinel(s). 센티널에 username을 설정한 경우 sentinel.conf: sentinel sentinel-user <username>
4	String password	Password for authenticating with sentinel(s). 센티널에 password를 설정한 경우 sentinel.conf: requirepass <password> or sentinel sentinel-pass <password>

SSL properties (static class)

No	Field	설명 Desc
1	Boolean enabled	Whether to enable SSL support. Enabled automatically if "bundle" is provided unless specified otherwise. SSL 지원 활성화 여부. 별도로 지정하지 않는 한 "번들(bundle)"이 제공되면 자동으로 활성화됩니다.
2	String bundle	SSL bundle name.

Jedis properties (static class)

No	Field	설명 Desc
1	final Pool pool = new Pool()	Jedis pool configuration.

Lettuce properties (static class)

No	Field	설명 Desc
1	Duration shutdownTimeout = Duration.ofMillis(100)	Shutdown timeout.
2	final Pool pool = new Pool()	Lettuce pool configuration.
3	final Cluster cluster = new Cluster()	아래 Cluster properties 참조.

Lettuce.Cluster properties (static class)

No	Field	설명 Desc
1	final Refresh refresh = new Refresh()	ClusterTopologyRefreshOptions: 기간(여부 포함) 설정한다. 아래 Refresh properties 참조.

Lettuce.Cluster.Refresh properties (static class)

No	Field	설명 Desc
1	boolean dynamicRefreshSources = true	Whether to discover and query all cluster nodes for obtaining the cluster topology. When set to false, only the initial seed nodes are used as sources for topology discovery. 클러스터 토폴로지를 얻기 위해 모든 클러스터 노드를 검색하고 쿼리할지 여부입니다. false로 설정하면 초기 시드(seed) 노드만 토폴로지 검색의 소스로 사용됩니다. true: CLUSTER NODES 명령을 실행해서 얻은 모든 노드들에 CLUSTER NODES 명령을 실행한다. false: spring.data.redis.cluster.nodes 에 지정된 노드들에만 CLUSTER NODES 명령을 실행한다.
2	Duration period (중요)	Cluster topology refresh period. 클러스터 토폴로지 새로고침 기간(주기). spring.data.redis.lettuce.cluster.refresh.period: 60s ClusterTopologyRefreshOptions.enablePeriodicRefresh(Duration.ofSeconds(60)) 설정된 주기마다 레디스 서버에 HELLO, CLIENT SETNAME, CLUSTER NODES, INFO 4개 명령을 실행합니다. 3 마스터, 3 복제 구성에서 마스터1번이 다운되면 새로고침(refresh) 전까지는 마스터1번에 입력되는 명령은 에러가 발생합니다. 다른 마스터에 입력되는 명령과 복제에 조회 명령은 정상적으로 실행됩니다. 새로고침 후에는 복제1번이 새 마스터가 된것을 인지해서 입력 명령이 정상적으로 실행됩니다. 설정해야 합니다. 설정하지 않으면 새로고침을 하지 않습니다. 적정 값: 30초 ~ 60초 (일반적인 기준)
3	boolean adaptive	Whether adaptive topology refreshing using all available refresh triggers should be used. 사용 가능한 모든 새로 고침 트리거를 사용하여 적응형 토폴로지 새로 고침을 사용해야 하는지 여부입니다. true: ClusterTopologyRefreshOptions.enableAllAdaptiveRefreshTriggers()

Java Source

public class RedisProperties
public class RedisAutoConfiguration
public interface RedisConnectionDetails extends ConnectionDetails
abstract class RedisConnectionConfiguration
class LettuceConnectionConfiguration extends RedisConnectionConfiguration

springboot 3.1.3 기준

RedisProperties.java

--------------------------------------------------------------------------------------------------------- public class RedisProperties --------------------------------------------------------------------------------------------------------- package org.springframework.boot.autoconfigure.data.redis; import java.time.Duration; import java.util.List; import org.springframework.boot.context.properties.ConfigurationProperties; /** * Configuration properties for Redis. * * @author Dave Syer * @author Christoph Strobl * @author Eddú Meléndez * @author Marco Aust * @author Mark Paluch * @author Stephane Nicoll * @author Scott Frederick * @since 1.0.0 */ @ConfigurationProperties(prefix = "spring.data.redis") public class RedisProperties { /** * Database index used by the connection factory. */ private int database = 0; /** * Connection URL. Overrides host, port, username, and password. Example: * redis://user:password@example.com:6379 */ private String url; /** * Redis server host. */ private String host = "localhost"; /** * Login username of the redis server. */ private String username; /** * Login password of the redis server. */ private String password; /** * Redis server port. */ private int port = 6379; /** * Read timeout. */ private Duration timeout; /** * Connection timeout. */ private Duration connectTimeout; /** * Client name to be set on connections with CLIENT SETNAME. */ private String clientName; /** * Type of client to use. By default, auto-detected according to the classpath. */ private ClientType clientType; private Sentinel sentinel; private Cluster cluster; private final Ssl ssl = new Ssl(); private final Jedis jedis = new Jedis(); private final Lettuce lettuce = new Lettuce(); public int getDatabase() { return this.database; } public void setDatabase(int database) { this.database = database; } public String getUrl() { return this.url; } public void setUrl(String url) { this.url = url; } public String getHost() { return this.host; } public void setHost(String host) { this.host = host; } public String getUsername() { return this.username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return this.password; } public void setPassword(String password) { this.password = password; } public int getPort() { return this.port; } public void setPort(int port) { this.port = port; } public Ssl getSsl() { return this.ssl; } public void setTimeout(Duration timeout) { this.timeout = timeout; } public Duration getTimeout() { return this.timeout; } public Duration getConnectTimeout() { return this.connectTimeout; } public void setConnectTimeout(Duration connectTimeout) { this.connectTimeout = connectTimeout; } public String getClientName() { return this.clientName; } public void setClientName(String clientName) { this.clientName = clientName; } public ClientType getClientType() { return this.clientType; } public void setClientType(ClientType clientType) { this.clientType = clientType; } public Sentinel getSentinel() { return this.sentinel; } public void setSentinel(Sentinel sentinel) { this.sentinel = sentinel; } public Cluster getCluster() { return this.cluster; } public void setCluster(Cluster cluster) { this.cluster = cluster; } public Jedis getJedis() { return this.jedis; } public Lettuce getLettuce() { return this.lettuce; } /** * Type of Redis client to use. */ public enum ClientType { /** * Use the Lettuce redis client. */ LETTUCE, /** * Use the Jedis redis client. */ JEDIS } /** * Pool properties. */ public static class Pool { /** * Whether to enable the pool. Enabled automatically if "commons-pool2" is * available. With Jedis, pooling is implicitly enabled in sentinel mode and this * setting only applies to single node setup. */ private Boolean enabled; /** * Maximum number of "idle" connections in the pool. Use a negative value to * indicate an unlimited number of idle connections. */ private int maxIdle = 8; /** * Target for the minimum number of idle connections to maintain in the pool. This * setting only has an effect if both it and time between eviction runs are * positive. */ private int minIdle = 0; /** * Maximum number of connections that can be allocated by the pool at a given * time. Use a negative value for no limit. */ private int maxActive = 8; /** * Maximum amount of time a connection allocation should block before throwing an * exception when the pool is exhausted. Use a negative value to block * indefinitely. */ private Duration maxWait = Duration.ofMillis(-1); /** * Time between runs of the idle object evictor thread. When positive, the idle * object evictor thread starts, otherwise no idle object eviction is performed. */ private Duration timeBetweenEvictionRuns; public Boolean getEnabled() { return this.enabled; } public void setEnabled(Boolean enabled) { this.enabled = enabled; } public int getMaxIdle() { return this.maxIdle; } public void setMaxIdle(int maxIdle) { this.maxIdle = maxIdle; } public int getMinIdle() { return this.minIdle; } public void setMinIdle(int minIdle) { this.minIdle = minIdle; } public int getMaxActive() { return this.maxActive; } public void setMaxActive(int maxActive) { this.maxActive = maxActive; } public Duration getMaxWait() { return this.maxWait; } public void setMaxWait(Duration maxWait) { this.maxWait = maxWait; } public Duration getTimeBetweenEvictionRuns() { return this.timeBetweenEvictionRuns; } public void setTimeBetweenEvictionRuns(Duration timeBetweenEvictionRuns) { this.timeBetweenEvictionRuns = timeBetweenEvictionRuns; } } /** * Cluster properties. */ public static class Cluster { /** * Comma-separated list of "host:port" pairs to bootstrap from. This represents an * "initial" list of cluster nodes and is required to have at least one entry. */ private List<String> nodes; /** * Maximum number of redirects to follow when executing commands across the * cluster. */ private Integer maxRedirects; public List<String> getNodes() { return this.nodes; } public void setNodes(List<String> nodes) { this.nodes = nodes; } public Integer getMaxRedirects() { return this.maxRedirects; } public void setMaxRedirects(Integer maxRedirects) { this.maxRedirects = maxRedirects; } } /** * Redis sentinel properties. */ public static class Sentinel { /** * Name of the Redis server. */ private String master; /** * Comma-separated list of "host:port" pairs. */ private List<String> nodes; /** * Login username for authenticating with sentinel(s). */ private String username; /** * Password for authenticating with sentinel(s). */ private String password; public String getMaster() { return this.master; } public void setMaster(String master) { this.master = master; } public List<String> getNodes() { return this.nodes; } public void setNodes(List<String> nodes) { this.nodes = nodes; } public String getUsername() { return this.username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return this.password; } public void setPassword(String password) { this.password = password; } } public static class Ssl { /** * Whether to enable SSL support. Enabled automatically if "bundle" is provided * unless specified otherwise. */ private Boolean enabled; /** * SSL bundle name. */ private String bundle; public boolean isEnabled() { return (this.enabled != null) ? this.enabled : this.bundle != null; } public void setEnabled(boolean enabled) { this.enabled = enabled; } public String getBundle() { return this.bundle; } public void setBundle(String bundle) { this.bundle = bundle; } } /** * Jedis client properties. */ public static class Jedis { /** * Jedis pool configuration. */ private final Pool pool = new Pool(); public Pool getPool() { return this.pool; } } /** * Lettuce client properties. */ public static class Lettuce { /** * Shutdown timeout. */ private Duration shutdownTimeout = Duration.ofMillis(100); /** * Lettuce pool configuration. */ private final Pool pool = new Pool(); private final Cluster cluster = new Cluster(); public Duration getShutdownTimeout() { return this.shutdownTimeout; } public void setShutdownTimeout(Duration shutdownTimeout) { this.shutdownTimeout = shutdownTimeout; } public Pool getPool() { return this.pool; } public Cluster getCluster() { return this.cluster; } public static class Cluster { private final Refresh refresh = new Refresh(); public Refresh getRefresh() { return this.refresh; } public static class Refresh { /** * Whether to discover and query all cluster nodes for obtaining the * cluster topology. When set to false, only the initial seed nodes are * used as sources for topology discovery. * 클러스터 토폴로지를 얻기 위해 모든 클러스터 노드를 검색하고 쿼리할지 여부입니다. * false로 설정하면 초기 시드 노드만 토폴로지 검색의 소스로 사용됩니다. */ private boolean dynamicRefreshSources = true; /** * Cluster topology refresh period. */ private Duration period; /** * Whether adaptive topology refreshing using all available refresh * triggers should be used. */ private boolean adaptive; public boolean isDynamicRefreshSources() { return this.dynamicRefreshSources; } public void setDynamicRefreshSources(boolean dynamicRefreshSources) { this.dynamicRefreshSources = dynamicRefreshSources; } public Duration getPeriod() { return this.period; } public void setPeriod(Duration period) { this.period = period; } public boolean isAdaptive() { return this.adaptive; } public void setAdaptive(boolean adaptive) { this.adaptive = adaptive; } } } } }

RedisAutoConfiguration.java

--------------------------------------------------------------------------------------------------------- public class RedisAutoConfiguration --------------------------------------------------------------------------------------------------------- package org.springframework.boot.autoconfigure.data.redis; import java.net.URI; import java.net.URISyntaxException; import java.net.UnknownHostException; import java.util.ArrayList; import java.util.List; import org.apache.commons.pool2.impl.GenericObjectPool; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPoolConfig; import org.springframework.beans.factory.ObjectProvider; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.boot.autoconfigure.data.redis.RedisProperties.Cluster; import org.springframework.boot.autoconfigure.data.redis.RedisProperties.Sentinel; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.connection.RedisClusterConfiguration; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.connection.RedisNode; import org.springframework.data.redis.connection.RedisSentinelConfiguration; import org.springframework.data.redis.connection.jedis.JedisConnection; import org.springframework.data.redis.connection.jedis.JedisConnectionFactory; import org.springframework.data.redis.core.RedisOperations; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.util.Assert; import org.springframework.util.StringUtils; /** * {@link EnableAutoConfiguration Auto-configuration} for Spring Data's Redis support. * * @author Dave Syer * @author Andy Wilkinson * @author Christian Dupuis * @author Christoph Strobl * @author Phillip Webb * @author Eddú Meléndez * @author Stephane Nicoll * @author Marco Aust */ @Configuration @ConditionalOnClass({ JedisConnection.class, RedisOperations.class, Jedis.class }) @EnableConfigurationProperties(RedisProperties.class) public class RedisAutoConfiguration { /** * Redis connection configuration. */ @Configuration @ConditionalOnClass(GenericObjectPool.class) protected static class RedisConnectionConfiguration { private final RedisProperties properties; private final RedisSentinelConfiguration sentinelConfiguration; private final RedisClusterConfiguration clusterConfiguration; public RedisConnectionConfiguration(RedisProperties properties, ObjectProvider<RedisSentinelConfiguration> sentinelConfiguration, ObjectProvider<RedisClusterConfiguration> clusterConfiguration) { this.properties = properties; this.sentinelConfiguration = sentinelConfiguration.getIfAvailable(); this.clusterConfiguration = clusterConfiguration.getIfAvailable(); } @Bean @ConditionalOnMissingBean(RedisConnectionFactory.class) public JedisConnectionFactory redisConnectionFactory() throws UnknownHostException { return applyProperties(createJedisConnectionFactory()); } protected final JedisConnectionFactory applyProperties( JedisConnectionFactory factory) { configureConnection(factory); if (this.properties.isSsl()) { factory.setUseSsl(true); } factory.setDatabase(this.properties.getDatabase()); if (this.properties.getTimeout() > 0) { factory.setTimeout(this.properties.getTimeout()); } return factory; } private void configureConnection(JedisConnectionFactory factory) { if (StringUtils.hasText(this.properties.getUrl())) { configureConnectionFromUrl(factory); } else { factory.setHostName(this.properties.getHost()); factory.setPort(this.properties.getPort()); if (this.properties.getPassword() != null) { factory.setPassword(this.properties.getPassword()); } } } private void configureConnectionFromUrl(JedisConnectionFactory factory) { String url = this.properties.getUrl(); if (url.startsWith("rediss://")) { factory.setUseSsl(true); } try { URI uri = new URI(url); factory.setHostName(uri.getHost()); factory.setPort(uri.getPort()); if (uri.getUserInfo() != null) { String password = uri.getUserInfo(); int index = password.lastIndexOf(":"); if (index >= 0) { password = password.substring(index + 1); } factory.setPassword(password); } } catch (URISyntaxException ex) { throw new IllegalArgumentException("Malformed 'spring.redis.url' " + url, ex); } } protected final RedisSentinelConfiguration getSentinelConfig() { if (this.sentinelConfiguration != null) { return this.sentinelConfiguration; } Sentinel sentinelProperties = this.properties.getSentinel(); if (sentinelProperties != null) { RedisSentinelConfiguration config = new RedisSentinelConfiguration(); config.master(sentinelProperties.getMaster()); config.setSentinels(createSentinels(sentinelProperties)); return config; } return null; } /** * Create a {@link RedisClusterConfiguration} if necessary. * @return {@literal null} if no cluster settings are set. */ protected final RedisClusterConfiguration getClusterConfiguration() { if (this.clusterConfiguration != null) { return this.clusterConfiguration; } if (this.properties.getCluster() == null) { return null; } Cluster clusterProperties = this.properties.getCluster(); RedisClusterConfiguration config = new RedisClusterConfiguration( clusterProperties.getNodes()); if (clusterProperties.getMaxRedirects() != null) { config.setMaxRedirects(clusterProperties.getMaxRedirects()); } return config; } private List<RedisNode> createSentinels(Sentinel sentinel) { List<RedisNode> nodes = new ArrayList<RedisNode>(); for (String node : StringUtils .commaDelimitedListToStringArray(sentinel.getNodes())) { try { String[] parts = StringUtils.split(node, ":"); Assert.state(parts.length == 2, "Must be defined as 'host:port'"); nodes.add(new RedisNode(parts[0], Integer.valueOf(parts[1]))); } catch (RuntimeException ex) { throw new IllegalStateException( "Invalid redis sentinel " + "property '" + node + "'", ex); } } return nodes; } private JedisConnectionFactory createJedisConnectionFactory() { JedisPoolConfig poolConfig = this.properties.getPool() != null ? jedisPoolConfig() : new JedisPoolConfig(); if (getSentinelConfig() != null) { return new JedisConnectionFactory(getSentinelConfig(), poolConfig); } if (getClusterConfiguration() != null) { return new JedisConnectionFactory(getClusterConfiguration(), poolConfig); } return new JedisConnectionFactory(poolConfig); } private JedisPoolConfig jedisPoolConfig() { JedisPoolConfig config = new JedisPoolConfig(); RedisProperties.Pool props = this.properties.getPool(); config.setMaxTotal(props.getMaxActive()); config.setMaxIdle(props.getMaxIdle()); config.setMinIdle(props.getMinIdle()); config.setMaxWaitMillis(props.getMaxWait()); return config; } } /** * Standard Redis configuration. */ @Configuration protected static class RedisConfiguration { @Bean @ConditionalOnMissingBean(name = "redisTemplate") public RedisTemplate<Object, Object> redisTemplate( RedisConnectionFactory redisConnectionFactory) throws UnknownHostException { RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>(); template.setConnectionFactory(redisConnectionFactory); return template; } @Bean @ConditionalOnMissingBean(StringRedisTemplate.class) public StringRedisTemplate stringRedisTemplate( RedisConnectionFactory redisConnectionFactory) throws UnknownHostException { StringRedisTemplate template = new StringRedisTemplate(); template.setConnectionFactory(redisConnectionFactory); return template; } } }

RedisConnectionDetails.java

--------------------------------------------------------------------------------------------------------- public interface RedisConnectionDetails extends ConnectionDetails --------------------------------------------------------------------------------------------------------- package org.springframework.boot.autoconfigure.data.redis; import java.util.List; import org.springframework.boot.autoconfigure.service.connection.ConnectionDetails; import org.springframework.util.Assert; /** * Details required to establish a connection to a Redis service. * * @author Moritz Halbritter * @author Andy Wilkinson * @since 3.1.0 */ public interface RedisConnectionDetails extends ConnectionDetails { /** * Login username of the redis server. * @return the login username of the redis server */ default String getUsername() { return null; } /** * Login password of the redis server. * @return the login password of the redis server */ default String getPassword() { return null; } /** * Redis standalone configuration. Mutually exclusive with {@link #getSentinel()} and * {@link #getCluster()}. * @return the Redis standalone configuration */ default Standalone getStandalone() { return null; } /** * Redis sentinel configuration. Mutually exclusive with {@link #getStandalone()} and * {@link #getCluster()}. * @return the Redis sentinel configuration */ default Sentinel getSentinel() { return null; } /** * Redis cluster configuration. Mutually exclusive with {@link #getStandalone()} and * {@link #getSentinel()}. * @return the Redis cluster configuration */ default Cluster getCluster() { return null; } /** * Redis standalone configuration. */ interface Standalone { /** * Redis server host. * @return the redis server host */ String getHost(); /** * Redis server port. * @return the redis server port */ int getPort(); /** * Database index used by the connection factory. * @return the database index used by the connection factory */ default int getDatabase() { return 0; } static Standalone of(String host, int port) { return of(host, port, 0); } static Standalone of(String host, int port, int database) { Assert.hasLength(host, "Host must not be empty"); return new Standalone() { @Override public String getHost() { return host; } @Override public int getPort() { return port; } @Override public int getDatabase() { return database; } }; } } /** * Redis sentinel configuration. */ interface Sentinel { /** * Database index used by the connection factory. * @return the database index used by the connection factory */ int getDatabase(); /** * Name of the Redis server. * @return the name of the Redis server */ String getMaster(); /** * List of nodes. * @return the list of nodes */ List<Node> getNodes(); /** * Login username for authenticating with sentinel(s). * @return the login username for authenticating with sentinel(s) or {@code null} */ String getUsername(); /** * Password for authenticating with sentinel(s). * @return the password for authenticating with sentinel(s) or {@code null} */ String getPassword(); } /** * Redis cluster configuration. */ interface Cluster { /** * Nodes to bootstrap from. This represents an "initial" list of cluster nodes and * is required to have at least one entry. * @return nodes to bootstrap from */ List<Node> getNodes(); } /** * A node in a sentinel or cluster configuration. * * @param host the hostname of the node * @param port the port of the node */ record Node(String host, int port) { } }

RedisConnectionConfiguration.java

--------------------------------------------------------------------------------------------------------- abstract class RedisConnectionConfiguration --------------------------------------------------------------------------------------------------------- package org.springframework.boot.autoconfigure.data.redis; import java.net.URI; import java.net.URISyntaxException; import java.util.ArrayList; import java.util.List; import org.springframework.beans.factory.ObjectProvider; import org.springframework.boot.autoconfigure.data.redis.RedisConnectionDetails.Cluster; import org.springframework.boot.autoconfigure.data.redis.RedisConnectionDetails.Node; import org.springframework.boot.autoconfigure.data.redis.RedisConnectionDetails.Sentinel; import org.springframework.boot.autoconfigure.data.redis.RedisProperties.Pool; import org.springframework.boot.ssl.SslBundles; import org.springframework.data.redis.connection.RedisClusterConfiguration; import org.springframework.data.redis.connection.RedisNode; import org.springframework.data.redis.connection.RedisPassword; import org.springframework.data.redis.connection.RedisSentinelConfiguration; import org.springframework.data.redis.connection.RedisStandaloneConfiguration; import org.springframework.util.ClassUtils; /** * Base Redis connection configuration. * * @author Mark Paluch * @author Stephane Nicoll * @author Alen Turkovic * @author Scott Frederick * @author Eddú Meléndez * @author Moritz Halbritter * @author Andy Wilkinson * @author Phillip Webb */ abstract class RedisConnectionConfiguration { private static final boolean COMMONS_POOL2_AVAILABLE = ClassUtils.isPresent("org.apache.commons.pool2.ObjectPool", RedisConnectionConfiguration.class.getClassLoader()); private final RedisProperties properties; private final RedisStandaloneConfiguration standaloneConfiguration; private final RedisSentinelConfiguration sentinelConfiguration; private final RedisClusterConfiguration clusterConfiguration; private final RedisConnectionDetails connectionDetails; private final SslBundles sslBundles; protected RedisConnectionConfiguration(RedisProperties properties, RedisConnectionDetails connectionDetails, ObjectProvider<RedisStandaloneConfiguration> standaloneConfigurationProvider, ObjectProvider<RedisSentinelConfiguration> sentinelConfigurationProvider, ObjectProvider<RedisClusterConfiguration> clusterConfigurationProvider, ObjectProvider<SslBundles> sslBundles) { this.properties = properties; this.standaloneConfiguration = standaloneConfigurationProvider.getIfAvailable(); this.sentinelConfiguration = sentinelConfigurationProvider.getIfAvailable(); this.clusterConfiguration = clusterConfigurationProvider.getIfAvailable(); this.connectionDetails = connectionDetails; this.sslBundles = sslBundles.getIfAvailable(); } protected final RedisStandaloneConfiguration getStandaloneConfig() { if (this.standaloneConfiguration != null) { return this.standaloneConfiguration; } RedisStandaloneConfiguration config = new RedisStandaloneConfiguration(); config.setHostName(this.connectionDetails.getStandalone().getHost()); config.setPort(this.connectionDetails.getStandalone().getPort()); config.setUsername(this.connectionDetails.getUsername()); config.setPassword(RedisPassword.of(this.connectionDetails.getPassword())); config.setDatabase(this.connectionDetails.getStandalone().getDatabase()); return config; } protected final RedisSentinelConfiguration getSentinelConfig() { if (this.sentinelConfiguration != null) { return this.sentinelConfiguration; } if (this.connectionDetails.getSentinel() != null) { RedisSentinelConfiguration config = new RedisSentinelConfiguration(); config.master(this.connectionDetails.getSentinel().getMaster()); config.setSentinels(createSentinels(this.connectionDetails.getSentinel())); config.setUsername(this.connectionDetails.getUsername()); String password = this.connectionDetails.getPassword(); if (password != null) { config.setPassword(RedisPassword.of(password)); } config.setSentinelUsername(this.connectionDetails.getSentinel().getUsername()); String sentinelPassword = this.connectionDetails.getSentinel().getPassword(); if (sentinelPassword != null) { config.setSentinelPassword(RedisPassword.of(sentinelPassword)); } config.setDatabase(this.connectionDetails.getSentinel().getDatabase()); return config; } return null; } /** * Create a {@link RedisClusterConfiguration} if necessary. * @return {@literal null} if no cluster settings are set. */ protected final RedisClusterConfiguration getClusterConfiguration() { if (this.clusterConfiguration != null) { return this.clusterConfiguration; } RedisProperties.Cluster clusterProperties = this.properties.getCluster(); if (this.connectionDetails.getCluster() != null) { RedisClusterConfiguration config = new RedisClusterConfiguration( getNodes(this.connectionDetails.getCluster())); if (clusterProperties != null && clusterProperties.getMaxRedirects() != null) { config.setMaxRedirects(clusterProperties.getMaxRedirects()); } config.setUsername(this.connectionDetails.getUsername()); String password = this.connectionDetails.getPassword(); if (password != null) { config.setPassword(RedisPassword.of(password)); } return config; } return null; } private List<String> getNodes(Cluster cluster) { return cluster.getNodes().stream().map((node) -> "%s:%d".formatted(node.host(), node.port())).toList(); } protected final RedisProperties getProperties() { return this.properties; } protected SslBundles getSslBundles() { return this.sslBundles; } protected boolean isSslEnabled() { return getProperties().getSsl().isEnabled(); } protected boolean isPoolEnabled(Pool pool) { Boolean enabled = pool.getEnabled(); return (enabled != null) ? enabled : COMMONS_POOL2_AVAILABLE; } private List<RedisNode> createSentinels(Sentinel sentinel) { List<RedisNode> nodes = new ArrayList<>(); for (Node node : sentinel.getNodes()) { nodes.add(new RedisNode(node.host(), node.port())); } return nodes; } protected final boolean urlUsesSsl() { return parseUrl(this.properties.getUrl()).isUseSsl(); } protected final RedisConnectionDetails getConnectionDetails() { return this.connectionDetails; } static ConnectionInfo parseUrl(String url) { try { URI uri = new URI(url); String scheme = uri.getScheme(); if (!"redis".equals(scheme) && !"rediss".equals(scheme)) { throw new RedisUrlSyntaxException(url); } boolean useSsl = ("rediss".equals(scheme)); String username = null; String password = null; if (uri.getUserInfo() != null) { String candidate = uri.getUserInfo(); int index = candidate.indexOf(':'); if (index >= 0) { username = candidate.substring(0, index); password = candidate.substring(index + 1); } else { password = candidate; } } return new ConnectionInfo(uri, useSsl, username, password); } catch (URISyntaxException ex) { throw new RedisUrlSyntaxException(url, ex); } } static class ConnectionInfo { private final URI uri; private final boolean useSsl; private final String username; private final String password; ConnectionInfo(URI uri, boolean useSsl, String username, String password) { this.uri = uri; this.useSsl = useSsl; this.username = username; this.password = password; } URI getUri() { return this.uri; } boolean isUseSsl() { return this.useSsl; } String getUsername() { return this.username; } String getPassword() { return this.password; } } }

LettuceConnectionConfiguration.java

enablePeriodicRefresh(), GenericObjectPoolConfig(connection pool) 등이 있다. --------------------------------------------------------------------------------------------------------- class LettuceConnectionConfiguration extends RedisConnectionConfiguration --------------------------------------------------------------------------------------------------------- package org.springframework.boot.autoconfigure.data.redis; import java.time.Duration; import io.lettuce.core.ClientOptions; import io.lettuce.core.RedisClient; import io.lettuce.core.SocketOptions; import io.lettuce.core.TimeoutOptions; import io.lettuce.core.cluster.ClusterClientOptions; import io.lettuce.core.cluster.ClusterTopologyRefreshOptions; import io.lettuce.core.cluster.ClusterTopologyRefreshOptions.Builder; import io.lettuce.core.resource.ClientResources; import io.lettuce.core.resource.DefaultClientResources; import org.apache.commons.pool2.impl.GenericObjectPoolConfig; import org.springframework.beans.factory.ObjectProvider; import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.boot.autoconfigure.data.redis.RedisProperties.Lettuce.Cluster.Refresh; import org.springframework.boot.autoconfigure.data.redis.RedisProperties.Pool; import org.springframework.boot.ssl.SslBundle; import org.springframework.boot.ssl.SslBundles; import org.springframework.boot.ssl.SslOptions; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.connection.RedisClusterConfiguration; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.connection.RedisSentinelConfiguration; import org.springframework.data.redis.connection.RedisStandaloneConfiguration; import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration; import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration.LettuceClientConfigurationBuilder; import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration; import org.springframework.util.StringUtils; /** * Redis connection configuration using Lettuce. * * @author Mark Paluch * @author Andy Wilkinson * @author Moritz Halbritter * @author Phillip Webb * @author Scott Frederick */ @Configuration(proxyBeanMethods = false) @ConditionalOnClass(RedisClient.class) @ConditionalOnProperty(name = "spring.data.redis.client-type", havingValue = "lettuce", matchIfMissing = true) class LettuceConnectionConfiguration extends RedisConnectionConfiguration { LettuceConnectionConfiguration(RedisProperties properties, ObjectProvider<RedisStandaloneConfiguration> standaloneConfigurationProvider, ObjectProvider<RedisSentinelConfiguration> sentinelConfigurationProvider, ObjectProvider<RedisClusterConfiguration> clusterConfigurationProvider, RedisConnectionDetails connectionDetails, ObjectProvider<SslBundles> sslBundles) { super(properties, connectionDetails, standaloneConfigurationProvider, sentinelConfigurationProvider, clusterConfigurationProvider, sslBundles); } @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 @ConditionalOnMissingBean(RedisConnectionFactory.class) LettuceConnectionFactory redisConnectionFactory( ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers, ClientResources clientResources) { LettuceClientConfiguration clientConfig = getLettuceClientConfiguration(builderCustomizers, clientResources, getProperties().getLettuce().getPool()); return createLettuceConnectionFactory(clientConfig); } private LettuceConnectionFactory createLettuceConnectionFactory(LettuceClientConfiguration clientConfiguration) { if (getSentinelConfig() != null) { return new LettuceConnectionFactory(getSentinelConfig(), clientConfiguration); } if (getClusterConfiguration() != null) { return new LettuceConnectionFactory(getClusterConfiguration(), clientConfiguration); } return new LettuceConnectionFactory(getStandaloneConfig(), clientConfiguration); } 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 LettuceClientConfigurationBuilder createBuilder(Pool pool) { if (isPoolEnabled(pool)) { return new PoolBuilderFactory().createBuilder(pool); } return LettuceClientConfiguration.builder(); } private void applyProperties(LettuceClientConfiguration.LettuceClientConfigurationBuilder builder) { if (isSslEnabled()) { builder.useSsl(); } if (getProperties().getTimeout() != null) { builder.commandTimeout(getProperties().getTimeout()); } if (getProperties().getLettuce() != null) { RedisProperties.Lettuce lettuce = getProperties().getLettuce(); if (lettuce.getShutdownTimeout() != null && !lettuce.getShutdownTimeout().isZero()) { builder.shutdownTimeout(getProperties().getLettuce().getShutdownTimeout()); } } if (StringUtils.hasText(getProperties().getClientName())) { builder.clientName(getProperties().getClientName()); } } private ClientOptions createClientOptions() { ClientOptions.Builder builder = initializeClientOptionsBuilder(); Duration connectTimeout = getProperties().getConnectTimeout(); if (connectTimeout != null) { builder.socketOptions(SocketOptions.builder().connectTimeout(connectTimeout).build()); } if (isSslEnabled() && getProperties().getSsl().getBundle() != null) { SslBundle sslBundle = getSslBundles().getBundle(getProperties().getSsl().getBundle()); io.lettuce.core.SslOptions.Builder sslOptionsBuilder = io.lettuce.core.SslOptions.builder(); sslOptionsBuilder.keyManager(sslBundle.getManagers().getKeyManagerFactory()); sslOptionsBuilder.trustManager(sslBundle.getManagers().getTrustManagerFactory()); SslOptions sslOptions = sslBundle.getOptions(); if (sslOptions.getCiphers() != null) { sslOptionsBuilder.cipherSuites(sslOptions.getCiphers()); } if (sslOptions.getEnabledProtocols() != null) { sslOptionsBuilder.protocols(sslOptions.getEnabledProtocols()); } builder.sslOptions(sslOptionsBuilder.build()); } return builder.timeoutOptions(TimeoutOptions.enabled()).build(); } private ClientOptions.Builder initializeClientOptionsBuilder() { if (getProperties().getCluster() != null) { ClusterClientOptions.Builder builder = ClusterClientOptions.builder(); Refresh refreshProperties = getProperties().getLettuce().getCluster().getRefresh(); Builder refreshBuilder = ClusterTopologyRefreshOptions.builder() .dynamicRefreshSources(refreshProperties.isDynamicRefreshSources()); if (refreshProperties.getPeriod() != null) { refreshBuilder.enablePeriodicRefresh(refreshProperties.getPeriod()); } if (refreshProperties.isAdaptive()) { refreshBuilder.enableAllAdaptiveRefreshTriggers(); } return builder.topologyRefreshOptions(refreshBuilder.build()); } return ClientOptions.builder(); } private void customizeConfigurationFromUrl(LettuceClientConfiguration.LettuceClientConfigurationBuilder builder) { if (urlUsesSsl()) { builder.useSsl(); } } /** * Inner class to allow optional commons-pool2 dependency. */ private static class PoolBuilderFactory { LettuceClientConfigurationBuilder createBuilder(Pool properties) { return LettucePoolingClientConfiguration.builder().poolConfig(getPoolConfig(properties)); } private GenericObjectPoolConfig<?> getPoolConfig(Pool properties) { GenericObjectPoolConfig<?> config = new GenericObjectPoolConfig<>(); config.setMaxTotal(properties.getMaxActive()); config.setMaxIdle(properties.getMaxIdle()); config.setMinIdle(properties.getMinIdle()); if (properties.getTimeBetweenEvictionRuns() != null) { config.setTimeBetweenEvictionRuns(properties.getTimeBetweenEvictionRuns()); } if (properties.getMaxWait() != null) { config.setMaxWait(properties.getMaxWait()); } return config; } } }

PDF manual

	Spring Boot Auto Config	Manual Config >>

Email 답글이 올라오면 이메일로 알려드리겠습니다.