一文詳解SpringBoot?Redis多數(shù)據(jù)源配置

更新時間：2024年11月17日 09:33:01 作者：Lvan

Spring?Boot默認只允許一種?Redis?連接池配置,且配置受限于?Lettuce?包,不夠靈活,所以本文將為大家介紹如何自定義Redis配置方案實現(xiàn)多數(shù)據(jù)源支持,需要的可以參考下

問題背景

在實際項目中，我們需要支持兩種 Redis 部署方式（集群和主從），但 Spring Boot 默認只允許一種 Redis 連接池配置，且配置受限于 Lettuce 包，不夠靈活。為了解決這個問題，我深入研究了 Spring Boot 的源碼，自定義了 Redis 配置方案，實現(xiàn)了多數(shù)據(jù)源支持。這一調(diào)整讓我們可以在同一項目中靈活適配不同的 Redis 部署方式，解決了配置的局限性，讓系統(tǒng)更具擴展性和靈活性。

源碼分析

LettuceConnectionConfiguration 的核心配置

LettuceConnectionConfiguration 位于 org.springframework.boot.autoconfigure.data.redis 包內(nèi)，使其作用域被限制，無法直接擴展。為支持集群和主從 Redis 部署，我們需要通過自定義配置，繞過該限制。

LettuceConnectionFactory 是 Redis 連接的核心工廠，依賴于 DefaultClientResources，并通過 LettuceClientConfiguration 設置諸如連接池、超時時間等基礎參數(shù)。配置如下：

class LettuceConnectionConfiguration extends RedisConnectionConfiguration {
	@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);
	}
}

lettuceClientResources 方法定義了 ClientResources，作為單例供所有 Redis 連接工廠復用。因此，自定義 LettuceConnectionFactory 時可以直接使用這個共享的 ClientResources。

客戶端配置與初始化解析

LettuceClientConfiguration 的獲取：getLettuceClientConfiguration 方法用以構(gòu)建 Lettuce 客戶端配置，應用基本參數(shù)并支持連接池：

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();
}

創(chuàng)建 LettuceClientConfigurationBuilder：createBuilder 方法生成 LettuceClientConfigurationBuilder，并判斷是否啟用連接池。若啟用，PoolBuilderFactory 會創(chuàng)建包含連接池的配置，該連接池通過 GenericObjectPoolConfig 構(gòu)建。

private static final boolean COMMONS_POOL2_AVAILABLE = ClassUtils.isPresent("org.apache.commons.pool2.ObjectPool", 
       RedisConnectionConfiguration.class.getClassLoader());
       
private LettuceClientConfigurationBuilder createBuilder(Pool pool) {  
    if (isPoolEnabled(pool)) {  
       return new PoolBuilderFactory().createBuilder(pool);  
    }  
    return LettuceClientConfiguration.builder();  
}

protected boolean isPoolEnabled(Pool pool) {  
    Boolean enabled = pool.getEnabled();  
    return (enabled != null) ? enabled : COMMONS_POOL2_AVAILABLE;  
}

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;  
    }   
}

參數(shù)應用與超時配置：applyProperties 方法用于配置 Redis 的基礎屬性，如 SSL、超時時間等。

private LettuceClientConfigurationBuilder applyProperties(
    LettuceClientConfiguration.LettuceClientConfigurationBuilder builder) {
    if (getProperties().isSsl()) {
        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());
    }
    return builder;
}

Redis 多模式支持

在創(chuàng)建 LettuceConnectionFactory 時，根據(jù)不同配置模式（哨兵、集群或單節(jié)點）構(gòu)建連接工廠：

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);
}

哨兵模式：getSentinelConfig() 返回哨兵配置實例，實現(xiàn)高可用 Redis。
集群模式：若啟用集群，getClusterConfiguration() 返回集群配置以支持分布式 Redis。
單節(jié)點模式：默認單節(jié)點配置，返回 StandaloneConfig。

getClusterConfiguration 的方法實現(xiàn)：

protected final RedisClusterConfiguration getClusterConfiguration() {
    if (this.clusterConfiguration != null) {
        return this.clusterConfiguration;
    }
    if (this.properties.getCluster() == null) {
        return null;
    }
    RedisProperties.Cluster clusterProperties = this.properties.getCluster();
    RedisClusterConfiguration config = new RedisClusterConfiguration(clusterProperties.getNodes());
    if (clusterProperties.getMaxRedirects() != null) {
        config.setMaxRedirects(clusterProperties.getMaxRedirects());
    }
    config.setUsername(this.properties.getUsername());
    if (this.properties.getPassword() != null) {
        config.setPassword(RedisPassword.of(this.properties.getPassword()));
    }
    return config;
}

集群節(jié)點與重定向：配置集群節(jié)點信息及最大重定向次數(shù)。
用戶名與密碼：集群連接的身份驗證配置。

Redis 多數(shù)據(jù)源配置思路

通過以上的源碼分析，我梳理出了 LettuceConnectionFactory 構(gòu)建的流程：

1.LettuceClientConfiguration 初始化：

連接池初始化
Redis 基礎屬性配置
設置 ClientResource

2.RedisConfiguration 初始化，官方支持以下配置：

RedisClusterConfiguration
RedisSentinelConfiguration
RedisStaticMasterReplicaConfiguration
RedisStandaloneConfiguration

Redis 多數(shù)據(jù)源配置實戰(zhàn)

復用 LettuceClientConfiguration 配置

/**
 * 這里與源碼有個不同的是返回了builder，因為后續(xù)實現(xiàn)的主從模式的lettuce客戶端仍有自定義的配置，返回了builder則相對靈活一點。
 */
private LettuceClientConfiguration.LettuceClientConfigurationBuilder getLettuceClientConfiguration(ClientResources clientResources, RedisProperties.Pool pool) {  
    LettuceClientConfiguration.LettuceClientConfigurationBuilder builder = createBuilder(pool);  
    applyProperties(builder);  
    builder.clientOptions(createClientOptions());  
    builder.clientResources(clientResources);  
    return builder;  
}  
  
/**  
 * 創(chuàng)建Lettuce客戶端配置構(gòu)建器  
 */  
private LettuceClientConfiguration.LettuceClientConfigurationBuilder createBuilder(RedisProperties.Pool pool) {  
    if (isPoolEnabled(pool)) {  
        return LettucePoolingClientConfiguration.builder().poolConfig(getPoolConfig(pool));  
    }  
    return LettuceClientConfiguration.builder();  
}  
  
/**  
 * 判斷Redis連接池是否啟用  
 */  
private boolean isPoolEnabled(RedisProperties.Pool pool) {  
    Boolean enabled = pool.getEnabled();  
    return (enabled != null) ? enabled : COMMONS_POOL2_AVAILABLE;  
}  
  
/**  
 * 根據(jù)Redis屬性配置創(chuàng)建并返回一個通用對象池配置  
 */  
private GenericObjectPoolConfig<?> getPoolConfig(RedisProperties.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;  
}  
  
/**  
 * 根據(jù)Redis屬性配置構(gòu)建Lettuce客戶端配置  
 *  
 * @param builder Lettuce客戶端配置的構(gòu)建器  
 * @return 返回配置完畢的Lettuce客戶端配置構(gòu)建器  
 */  
private LettuceClientConfiguration.LettuceClientConfigurationBuilder applyProperties(  
        LettuceClientConfiguration.LettuceClientConfigurationBuilder builder) {  
    if (redisProperties.isSsl()) {  
        builder.useSsl();  
    }  
    if (redisProperties.getTimeout() != null) {  
        builder.commandTimeout(redisProperties.getTimeout());  
    }  
    if (redisProperties.getLettuce() != null) {  
        RedisProperties.Lettuce lettuce = redisProperties.getLettuce();  
        if (lettuce.getShutdownTimeout() != null && !lettuce.getShutdownTimeout().isZero()) {  
            builder.shutdownTimeout(redisProperties.getLettuce().getShutdownTimeout());  
        }  
    }  
    if (StringUtils.hasText(redisProperties.getClientName())) {  
        builder.clientName(redisProperties.getClientName());  
    }  
    return builder;  
}  
  
/**  
 * 創(chuàng)建客戶端配置選項  
 */  
private ClientOptions createClientOptions() {  
    ClientOptions.Builder builder = initializeClientOptionsBuilder();  
    Duration connectTimeout = redisProperties.getConnectTimeout();  
    if (connectTimeout != null) {  
        builder.socketOptions(SocketOptions.builder().connectTimeout(connectTimeout).build());  
    }  
    return builder.timeoutOptions(TimeoutOptions.enabled()).build();  
}  
  
/**  
 * 初始化ClientOptions構(gòu)建器  
 */  
private ClientOptions.Builder initializeClientOptionsBuilder() {  
    if (redisProperties.getCluster() != null) {  
        ClusterClientOptions.Builder builder = ClusterClientOptions.builder();  
        RedisProperties.Lettuce.Cluster.Refresh refreshProperties = redisProperties.getLettuce().getCluster().getRefresh();  
        ClusterTopologyRefreshOptions.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();  
}

復用 Redis 集群初始化

/**  
 * 獲取Redis集群配置  
 */  
private RedisClusterConfiguration getClusterConfiguration() {  
    if (redisProperties.getCluster() == null) {  
        return null;  
    }  
    RedisProperties.Cluster clusterProperties = redisProperties.getCluster();  
    RedisClusterConfiguration config = new RedisClusterConfiguration(clusterProperties.getNodes());  
    if (clusterProperties.getMaxRedirects() != null) {  
        config.setMaxRedirects(clusterProperties.getMaxRedirects());  
    }  
    config.setUsername(redisProperties.getUsername());  
    if (redisProperties.getPassword() != null) {  
        config.setPassword(RedisPassword.of(redisProperties.getPassword()));  
    }  
    return config;  
}

自定義 Redis 主從配置

@Getter  
@Setter  
@ConfigurationProperties(prefix = "spring.redis")  
public class RedisPropertiesExtend {  
  
    private MasterReplica masterReplica;  
  
    @Getter  
    @Setter    public static class MasterReplica {  
  
        private String masterNodes;  
        private List<String> replicaNodes;  
    }  
}

/**  
 * 獲取主從配置  
 */  
private RedisStaticMasterReplicaConfiguration getStaticMasterReplicaConfiguration() {  
    if (redisPropertiesExtend.getMasterReplica() == null) {  
        return null;  
    }  
    RedisPropertiesExtend.MasterReplica masterReplica = redisPropertiesExtend.getMasterReplica();  
    List<String> masterNodes = CharSequenceUtil.split(masterReplica.getMasterNodes(), StrPool.COLON);  
    RedisStaticMasterReplicaConfiguration config = new RedisStaticMasterReplicaConfiguration(  
            masterNodes.get(0), Integer.parseInt(masterNodes.get(1)));  
    for (String replicaNode : masterReplica.getReplicaNodes()) {  
        List<String> replicaNodes = CharSequenceUtil.split(replicaNode, StrPool.COLON);  
        config.addNode(replicaNodes.get(0), Integer.parseInt(replicaNodes.get(1)));  
    }  
    config.setUsername(redisProperties.getUsername());  
    if (redisProperties.getPassword() != null) {  
        config.setPassword(RedisPassword.of(redisProperties.getPassword()));  
    }  
    return config;  
}

注冊 LettuceConnectionFactory

@Primary  
@Bean(name = "redisClusterConnectionFactory")  
@ConditionalOnMissingBean(name = "redisClusterConnectionFactory")  
public LettuceConnectionFactory redisClusterConnectionFactory(ClientResources clientResources) {  
    LettuceClientConfiguration clientConfig = getLettuceClientConfiguration(clientResources,  
            redisProperties.getLettuce().getPool())  
            .build();  
    return new LettuceConnectionFactory(getClusterConfiguration(), clientConfig);  
}  
  
@Bean(name = "redisMasterReplicaConnectionFactory")  
@ConditionalOnMissingBean(name = "redisMasterReplicaConnectionFactory")  
public LettuceConnectionFactory redisMasterReplicaConnectionFactory(ClientResources clientResources) {  
    LettuceClientConfiguration clientConfig = getLettuceClientConfiguration(clientResources,  
            redisProperties.getLettuce().getPool())  
            .readFrom(ReadFrom.REPLICA_PREFERRED)  
            .build();  
    return new LettuceConnectionFactory(getStaticMasterReplicaConfiguration(), clientConfig);  
}

應用

@Bean  
@ConditionalOnMissingBean(name = "redisTemplate")  
public RedisTemplate<Object, Object> redisTemplate(@Qualifier("redisClusterConnectionFactory") RedisConnectionFactory redisConnectionFactory) {  
    RedisTemplate<Object, Object> template = new RedisTemplate<>();  
    template.setConnectionFactory(redisConnectionFactory);  
    return template;  
}

@Bean  
@ConditionalOnMissingBean(name = "masterReplicaRedisTemplate")  
public RedisTemplate<Object, Object> masterReplicaRedisTemplate(@Qualifier("redisMasterReplicaConnectionFactory") RedisConnectionFactory redisConnectionFactory) {  
    RedisTemplate<Object, Object> template = new RedisTemplate<>();  
    template.setConnectionFactory(redisConnectionFactory);  
    return template;  
}

最后

深入理解 Spring Boot Redis 自動配置源碼是實現(xiàn)靈活多數(shù)據(jù)源支持的關鍵。通過源碼分析，我們能夠在保持框架兼容性的同時，精準定制和擴展功能，從而滿足復雜的業(yè)務需求。

以上就是一文詳解SpringBoot Redis多數(shù)據(jù)源配置的詳細內(nèi)容，更多關于SpringBoot Redis多數(shù)據(jù)源配置的資料請關注腳本之家其它相關文章！

您可能感興趣的文章:

JAVA工程中引用本地jar的3種常用簡單方式
Jar文件的全稱是Java Archive File即Java歸檔文件,主要是對class文件進行壓縮,是一種壓縮文件,和常見的zip壓縮文件兼容,下面這篇文章主要給大家介紹了關于JAVA工程中引用本地jar的3種常用簡單方式,需要的朋友可以參考下
2024-03-03
Java集合系列之HashMap源碼分析
這篇文章主要為大家詳細介紹了Java集合系列之HashMap源碼，具有一定的參考價值，感興趣的小伙伴們可以參考一下
2018-02-02
Java求余%操作引發(fā)的一連串故事
取模運算與取余運算兩個概念有重疊的部分但又不完全一致。主要的區(qū)別在于對負整數(shù)進行除法運算時操作不同。本文重點給大家介紹Java求余%操作引發(fā)的一連串故事，感興趣的朋友跟隨小編一起看看吧
2021-05-05
Java中System.currentTimeMillis()計算方式與時間單位轉(zhuǎn)換講解
本文詳細講解了Java中System.currentTimeMillis()計算方式與時間單位轉(zhuǎn)換，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下
2021-12-12
springBoot整合CXF并實現(xiàn)用戶名密碼校驗的方法
這篇文章主要介紹了springBoot整合CXF并實現(xiàn)用戶名密碼校驗的方法，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧
2018-08-08
Java實現(xiàn)讀取設置pdf屬性信息
這篇文章主要為大家詳細介紹了如何使用Java實現(xiàn)讀取設置pdf屬性信息,文中的示例代碼講解詳細,感興趣的小伙伴可以跟隨小編一起學習一下
2025-01-01
將Java程序打包成EXE文件的實現(xiàn)方式
這篇文章主要介紹了將Java程序打包成EXE文件的實現(xiàn)方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教
2025-04-04
一文詳解如何更改電腦使用的JDK版本
我們在日常學習或者工作中,難免會遇到需要使用不同的jdk版本進行開發(fā),這篇文章主要給大家介紹了關于如何更改電腦使用的JDK版本的相關資料,需要的朋友可以參考下
2024-01-01
JAVA最容易忽視的數(shù)據(jù)類型之枚舉詳解
這篇文章主要給大家介紹了關于JAVA最容易忽視的數(shù)據(jù)類型之枚舉的相關資料,Java中的枚舉類型是一種特殊的類型,它允許程序員定義一個固定的值集合,并為每個值分配一個名稱,枚舉類型提供了一種簡單、安全和可讀性強的方式來表示一組相關的常量,需要的朋友可以參考下
2023-10-10
Java語言中的內(nèi)存泄露代碼詳解
這篇文章主要介紹了Java語言中的內(nèi)存泄露代碼詳解，具有一定借鑒價值，需要的朋友可以參考下。
2017-12-12