• Springboot 中 Redis 自动配置源码分析

    spring.factories

    org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\

    RedisAutoConfiguration

    1. package org.springframework.boot.autoconfigure.data.redis;
    2.  
    3.  
    4. @Configuration(
    5.     proxyBeanMethods = false
    6. )
    7. @ConditionalOnClass({RedisOperations.class})
    8. @EnableConfigurationProperties({RedisProperties.class})  //自动配置properties 文件
    9. @Import({LettuceConnectionConfiguration.class,  JedisConnectionConfiguration.class}) 
    10. public class RedisAutoConfiguration {
    11.     public RedisAutoConfiguration() {
    12.     }
    13.  
    14.     @Bean
    15.     @ConditionalOnMissingBean(
    16.         name = {"redisTemplate"}
    17.     )
    18.     @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    19.     public RedisTemplate  redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    20.         RedisTemplate template = new RedisTemplate();
    21.         template.setConnectionFactory(redisConnectionFactory);
    22.         return template;
    23.     }
    24.  
    25.     @Bean
    26.     @ConditionalOnMissingBean
    27.     @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    28.     public StringRedisTemplate  stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
    29.         return new StringRedisTemplate(redisConnectionFactory);
    30.     }
    31. }

     LettuceConnectionConfiguration

    1. package org.springframework.boot.autoconfigure.data.redis;
    2.  
    3. @Configuration(
    4.     proxyBeanMethods = false
    5. )
    6. @ConditionalOnClass({RedisClient.class})
    7. @ConditionalOnProperty(
    8.     name = {"spring.redis.client-type"},
    9.     havingValue = "lettuce",
    10.     matchIfMissing = true
    11. )
    12. class LettuceConnectionConfiguration extends  RedisConnectionConfiguration {
    13.     LettuceConnectionConfiguration(RedisProperties properties,  ObjectProvider  standaloneConfigurationProvider,  ObjectProvider  sentinelConfigurationProvider, ObjectProvider  clusterConfigurationProvider) {
    14.         super(properties, standaloneConfigurationProvider,  sentinelConfigurationProvider, clusterConfigurationProvider);
    15.     }
    16.     
    17.        //使用ObjectProvider进行构造器注入,将ioc 中的对象注入到这里
    18.     @Bean(
    19.         destroyMethod = "shutdown"
    20.     )
    21.     @ConditionalOnMissingBean({ClientResources.class})
    22.     DefaultClientResources  lettuceClientResources(ObjectProvider  customizers) {
    23.         Builder builder = DefaultClientResources.builder();
    24.         customizers.orderedStream().forEach((customizer) -> {
    25.             customizer.customize(builder);
    26.         });
    27.         return builder.build();
    28.     }
    29.     
    30.     // 创建RedisConnectionFactory并注入到容器
    31.     @Bean
    32.     @ConditionalOnMissingBean({RedisConnectionFactory.class})
    33.     LettuceConnectionFactory  redisConnectionFactory(ObjectProvider builderCustomizers, ClientResources clientResources) {
    34.          // 获取lettuce客户端配置（获取配置逻辑在下面）
    35.         LettuceClientConfiguration clientConfig =  this.getLettuceClientConfiguration(builderCustomizers, clientResources,  this.getProperties().getLettuce().getPool());
    36.         
    37.         return this.createLettuceConnectionFactory(clientConfig);  //创建lettuce 
    38.     }
    39.  
    40.     //根据配置文件不同，创建不同的连接工厂，如果配置是哨兵则创建哨兵模式的连接工厂，如果是集群则创建集群的连接工厂，如果是单点则创建单点的连接工厂
    41.     private LettuceConnectionFactory  createLettuceConnectionFactory(LettuceClientConfiguration  clientConfiguration) {
    42.         if (this.getSentinelConfig() != null) {
    43.             //创建哨兵模式的连接工厂
    44.             return new LettuceConnectionFactory(this.getSentinelConfig(),  clientConfiguration);
    45.         } else {
    46.             
    47.             return this.getClusterConfiguration() != null ? new  LettuceConnectionFactory(this.getClusterConfiguration(),  clientConfiguration) : new  LettuceConnectionFactory(this.getStandaloneConfig(),  clientConfiguration);
    48.         }
    49.     }
    50.     
    51.     // 构建lettuce客户端连接配置
    52.     private LettuceClientConfiguration  getLettuceClientConfiguration(ObjectProvider builderCustomizers, ClientResources clientResources,  Pool pool) {
    53.         // lettuce客户端配置建造者，通过建造者去解析url、连接主机、端口等信息，然后构建成一个lettuce客户端配置
    54.         LettuceClientConfigurationBuilder builder =  this.createBuilder(pool);
    55.         this.applyProperties(builder);
    56.         if (StringUtils.hasText(this.getProperties().getUrl())) {
    57.             this.customizeConfigurationFromUrl(builder);
    58.         }
    59.  
    60.         builder.clientOptions(this.createClientOptions());
    61.         builder.clientResources(clientResources);
    62.         builderCustomizers.orderedStream().forEach((customizer) -> {
    63.             customizer.customize(builder);
    64.         });
    65.         return builder.build();
    66.     }
    67.  
    68.     private LettuceClientConfigurationBuilder createBuilder(Pool pool) {
    69.         return this.isPoolEnabled(pool) ? (new  LettuceConnectionConfiguration.PoolBuilderFactory()).createBuilder(pool)  : LettuceClientConfiguration.builder();
    70.     }
    71.  
    72.     private LettuceClientConfigurationBuilder  applyProperties(LettuceClientConfigurationBuilder builder) {
    73.         if (this.getProperties().isSsl()) {
    74.             builder.useSsl();
    75.         }
    76.  
    77.         if (this.getProperties().getTimeout() != null) {
    78.             builder.commandTimeout(this.getProperties().getTimeout());
    79.         }
    80.  
    81.         if (this.getProperties().getLettuce() != null) {
    82.             Lettuce lettuce = this.getProperties().getLettuce();
    83.             if (lettuce.getShutdownTimeout() != null &&  !lettuce.getShutdownTimeout().isZero()) {
    84.                  builder.shutdownTimeout(this.getProperties().getLettuce().getShutdownTimeout());
    85.             }
    86.         }
    87.  
    88.         if (StringUtils.hasText(this.getProperties().getClientName())) {
    89.             builder.clientName(this.getProperties().getClientName());
    90.         }
    91.  
    92.         return builder;
    93.     }
    94.  
    95.     private ClientOptions createClientOptions() {
    96.         io.lettuce.core.ClientOptions.Builder builder =  this.initializeClientOptionsBuilder();
    97.         Duration connectTimeout =  this.getProperties().getConnectTimeout();
    98.         if (connectTimeout != null) {
    99.              builder.socketOptions(SocketOptions.builder().connectTimeout(connectTimeout).build());
    100.         }
    101.         return builder.timeoutOptions(TimeoutOptions.enabled()).build();
    102.     }
    103.  
    104.     private io.lettuce.core.ClientOptions.Builder  initializeClientOptionsBuilder() {
    105.         if (this.getProperties().getCluster() != null) {
    106.             io.lettuce.core.cluster.ClusterClientOptions.Builder builder  = ClusterClientOptions.builder();
    107.             Refresh refreshProperties =  this.getProperties().getLettuce().getCluster().getRefresh();
    108.             io.lettuce.core.cluster.ClusterTopologyRefreshOptions.Builder  refreshBuilder =  ClusterTopologyRefreshOptions.builder().dynamicRefreshSources(refreshProperties.isDynamicRefreshSources());
    109.             if (refreshProperties.getPeriod() != null) {
    110.                  refreshBuilder.enablePeriodicRefresh(refreshProperties.getPeriod());
    111.             }
    112.  
    113.             if (refreshProperties.isAdaptive()) {
    114.                 refreshBuilder.enableAllAdaptiveRefreshTriggers();
    115.             }
    116.  
    117.             return  builder.topologyRefreshOptions(refreshBuilder.build());
    118.         } else {
    119.             return ClientOptions.builder();
    120.         }
    121.     }
    122.  
    123.     private void  customizeConfigurationFromUrl(LettuceClientConfigurationBuilder builder)  {
    124.         ConnectionInfo connectionInfo =  this.parseUrl(this.getProperties().getUrl());
    125.         if (connectionInfo.isUseSsl()) {
    126.             builder.useSsl();
    127.         }
    128.     }
    129.  
    130.     private static class PoolBuilderFactory {
    131.         private PoolBuilderFactory() {
    132.         }
    133.  
    134.         LettuceClientConfigurationBuilder createBuilder(Pool properties)  {
    135.             return  LettucePoolingClientConfiguration.builder().poolConfig(this.getPoolConfig(properties));
    136.         }
    137.  
    138.         private GenericObjectPoolConfig getPoolConfig(Pool properties)  {
    139.             GenericObjectPoolConfig config = new  GenericObjectPoolConfig();
    140.             config.setMaxTotal(properties.getMaxActive());
    141.             config.setMaxIdle(properties.getMaxIdle());
    142.             config.setMinIdle(properties.getMinIdle());
    143.             if (properties.getTimeBetweenEvictionRuns() != null) {
    144.                  config.setTimeBetweenEvictionRuns(properties.getTimeBetweenEvictionRuns());
    145.             }
    146.  
    147.             if (properties.getMaxWait() != null) {
    148.                 config.setMaxWait(properties.getMaxWait());
    149.             }
    150.  
    151.             return config;
    152.         }
    153.     }
    154. }

    RedisProperties

    1. package org.springframework.boot.autoconfigure.data.redis;
    2.  
    3. @ConfigurationProperties(
    4.     prefix = "spring.redis"
    5. )  //加载前缀为spring.redis 的配置信息
    6. public class RedisProperties {
    7.     private int database = 0;
    8.     private String url;
    9.     private String host = "localhost";
    10.     private String username;
    11.     private String password;
    12.     private int port = 6379;
    13.     private boolean ssl;
    14.     private Duration timeout;
    15.     private Duration connectTimeout;
    16.     private String clientName;
    17.     private RedisProperties.ClientType clientType;
    18.     private RedisProperties.Sentinel sentinel;
    19.     private RedisProperties.Cluster cluster;
    20.     private final RedisProperties.Jedis jedis = new  RedisProperties.Jedis();
    21.     private final RedisProperties.Lettuce lettuce = new  RedisProperties.Lettuce();
    22.  
    23.     public RedisProperties() {
    24.     }
    25.  
    26.     public static class Lettuce {
    27.         private Duration shutdownTimeout = Duration.ofMillis(100L);
    28.         private final RedisProperties.Pool pool = new  RedisProperties.Pool();
    29.         private final RedisProperties.Lettuce.Cluster cluster = new  RedisProperties.Lettuce.Cluster();
    30.  
    31.         public Lettuce() {
    32.         }
    33.  
    34.         public Duration getShutdownTimeout() {
    35.             return this.shutdownTimeout;
    36.         }
    37.  
    38.         public void setShutdownTimeout(Duration shutdownTimeout) {
    39.             this.shutdownTimeout = shutdownTimeout;
    40.         }
    41.  
    42.         public RedisProperties.Pool getPool() {
    43.             return this.pool;
    44.         }
    45.  
    46.         public RedisProperties.Lettuce.Cluster getCluster() {
    47.             return this.cluster;
    48.         }
    49.  
    50.         public static class Cluster {
    51.             private final RedisProperties.Lettuce.Cluster.Refresh refresh  = new RedisProperties.Lettuce.Cluster.Refresh();
    52.  
    53.             public Cluster() {
    54.             }
    55.  
    56.             public RedisProperties.Lettuce.Cluster.Refresh getRefresh() {
    57.                 return this.refresh;
    58.             }
    59.  
    60.             public static class Refresh {
    61.                 private boolean dynamicRefreshSources = true;
    62.                 private Duration period;
    63.                 private boolean adaptive;
    64.                 public Refresh() {
    65.                 }
    66.  
    67.                 public boolean isDynamicRefreshSources() {
    68.                     return this.dynamicRefreshSources;
    69.                 }
    70.  
    71.                 public void setDynamicRefreshSources(boolean  dynamicRefreshSources) {
    72.                     this.dynamicRefreshSources = dynamicRefreshSources;
    73.                 }
    74.  
    75.                 public Duration getPeriod() {
    76.                     return this.period;
    77.                 }
    78.  
    79.                 public void setPeriod(Duration period) {
    80.                     this.period = period;
    81.                 }
    82.  
    83.                 public boolean isAdaptive() {
    84.                     return this.adaptive;
    85.                 }
    86.  
    87.                 public void setAdaptive(boolean adaptive) {
    88.                     this.adaptive = adaptive;
    89.                 }
    90.             }
    91.         }
    92.     }
    93.  
    94.     public static class Jedis {
    95.         private final RedisProperties.Pool pool = new  RedisProperties.Pool();
    96.         public Jedis() {
    97.         }
    98.  
    99.         public RedisProperties.Pool getPool() {
    100.             return this.pool;
    101.         }
    102.     }
    103.  
    104.     public static class Sentinel {
    105.         private String master;
    106.         private List nodes;
    107.         private String password;
    108.  
    109.         public Sentinel() {
    110.         }
    111.  
    112.         public String getMaster() {
    113.             return this.master;
    114.         }
    115.  
    116.         public void setMaster(String master) {
    117.             this.master = master;
    118.         }
    119.  
    120.         public List getNodes() {
    121.             return this.nodes;
    122.         }
    123.  
    124.         public void setNodes(List nodes) {
    125.             this.nodes = nodes;
    126.         }
    127.  
    128.         public String getPassword() {
    129.             return this.password;
    130.         }
    131.  
    132.         public void setPassword(String password) {
    133.             this.password = password;
    134.         }
    135.     }
    136.  
    137.     public static class Cluster {
    138.         private List nodes;
    139.         private Integer maxRedirects;
    140.  
    141.         public Cluster() {
    142.         }
    143.  
    144.         public List getNodes() {
    145.             return this.nodes;
    146.         }
    147.  
    148.         public void setNodes(List nodes) {
    149.             this.nodes = nodes;
    150.         }
    151.  
    152.         public Integer getMaxRedirects() {
    153.             return this.maxRedirects;
    154.         }
    155.  
    156.         public void setMaxRedirects(Integer maxRedirects) {
    157.             this.maxRedirects = maxRedirects;
    158.         }
    159.     }
    160.  
    161.     public static class Pool {
    162.         private Boolean enabled;
    163.         private int maxIdle = 8;
    164.         private int minIdle = 0;
    165.         private int maxActive = 8;
    166.         private Duration maxWait = Duration.ofMillis(-1L);
    167.         private Duration timeBetweenEvictionRuns;
    168.  
    169.         public Pool() {
    170.         }
    171.  
    172.         public Boolean getEnabled() {
    173.             return this.enabled;
    174.         }
    175.  
    176.         public void setEnabled(Boolean enabled) {
    177.             this.enabled = enabled;
    178.         }
    179.  
    180.         public int getMaxIdle() {
    181.             return this.maxIdle;
    182.         }
    183.  
    184.         public void setMaxIdle(int maxIdle) {
    185.             this.maxIdle = maxIdle;
    186.         }
    187.  
    188.         public int getMinIdle() {
    189.             return this.minIdle;
    190.         }
    191.  
    192.         public void setMinIdle(int minIdle) {
    193.             this.minIdle = minIdle;
    194.         }
    195.  
    196.         public int getMaxActive() {
    197.             return this.maxActive;
    198.         }
    199.  
    200.         public void setMaxActive(int maxActive) {
    201.             this.maxActive = maxActive;
    202.         }
    203.  
    204.         public Duration getMaxWait() {
    205.             return this.maxWait;
    206.         }
    207.  
    208.         public void setMaxWait(Duration maxWait) {
    209.             this.maxWait = maxWait;
    210.         }
    211.  
    212.         public Duration getTimeBetweenEvictionRuns() {
    213.             return this.timeBetweenEvictionRuns;
    214.         }
    215.  
    216.         public void setTimeBetweenEvictionRuns(Duration  timeBetweenEvictionRuns) {
    217.             this.timeBetweenEvictionRuns = timeBetweenEvictionRuns;
    218.         }
    219.     }
    220.  
    221.     public static enum ClientType {
    222.         LETTUCE,
    223.         JEDIS;
    224.  
    225.  
    226.         private ClientType() {
    227.         }
    228.     }
    229. }

    类图解析：

    类名

    类信息说明

    RedisStandaloneConfiguration

    redis单点配置

    RedisSentinelConfiguration

    redis 哨兵配置

    RedisClusterConfiguration

    redis集群配置

    RedisProperties

    redis属性文件文件配置类，从配置文件中读取属性文件，写入配置类中

    RedisConnectionConfiguration

    redis连接配置，是lettuce连接和jedis连接配置的抽象父类，封装了redis的各种配置方式

    LettuceConnectionConfiguration

    lettuce 客户端配置

    JedisConnectionConfiguration

    jedis客户端配置

    RedisAutoConfiguration

    springboot 中 redis的自动配置类 

     redis自动配置类加载时序图：

     

    流程图解析：

    ②RedisConnectionConfiguration 构造方法调用

    1.  //为redis配置赋值
    2.     protected RedisConnectionConfiguration(RedisProperties properties,  ObjectProvider  standaloneConfigurationProvider,  ObjectProvider  sentinelConfigurationProvider, ObjectProvider  clusterConfigurationProvider) {
    3.         this.properties = properties;
    4.         this.standaloneConfiguration =  (RedisStandaloneConfiguration)standaloneConfigurationProvider.getIfAvailable();
    5.         this.sentinelConfiguration =  (RedisSentinelConfiguration)sentinelConfigurationProvider.getIfAvailable();
    6.         this.clusterConfiguration =  (RedisClusterConfiguration)clusterConfigurationProvider.getIfAvailable();
    7.     }

    解析，当RedisConnectionConfiguration的构造方法被子类LettuceConnectionConfiguration调用时，会为RedisProperties、RedisClusterConfiguration、RedisSentinelConfiguration、RedisStandaloneConfiguration这几个配置属性赋值。

    ⑤LettuceConnectionConfiguration 创建连接工厂

    1.  //根据配置文件不同，创建不同的连接工厂，如果配置是哨兵则创建哨兵模式的连接工厂，如果是集群则创建集群的连接工厂，如果是单点则创建单点的连接工厂
    2.    private LettuceConnectionFactory  createLettuceConnectionFactory(LettuceClientConfiguration  clientConfiguration) {
    3.         if (this.getSentinelConfig() != null) {
    4.             //创建哨兵模式的连接工厂
    5.             return new LettuceConnectionFactory(this.getSentinelConfig(),  clientConfiguration);
    6.         } else {
    7.             
    8.             return this.getClusterConfiguration() != null ? new  LettuceConnectionFactory(this.getClusterConfiguration(),  clientConfiguration) : new  LettuceConnectionFactory(this.getStandaloneConfig(),  clientConfiguration);
    9.         }
    10.     }

     解析：当createLettuceConnectionFactory（）方法被调用时，会根据RedisConnectionConfiguration构造方法中对redis的配置初始化情况，选择配置对象不为空的配置对象创建连接工厂

    项目连接集群配置示例：

    1. #redis 配置
    2. redis:
    3.   database: 1
    4.   lettuce:
    5.     pool:
    6.       max-active: 3000   #最大连接数据库连接数,设 -1 为没有限制
    7.       max-idle: 3000     #最大等待连接中的数量,设 0 为没有限制
    8.       max-wait: -1ms  #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
    9.       min-idle: 0     #最小等待连接中的数量,设 0 为没有限制
    10.     shutdown-timeout: 100ms
    11.   password: xxxxxx
    12.   #standalone 使用此配置
    13.   #host: 10.1.x.xxx
    14.   #port: 6379
    15.   #cluster 使用此配置
    16.   cluster:
    17.     timeout: 5000
    18.     max-redirects: 3
    19.     nodes:
    20.       - 10.2.6.xx:6379
    21.       - 10.2.6.xx:6380
    22.       - 10.2.6.xx:6381
    23.       - 10.2.6.xx:6382
    24.       - 10.2.6.xx:6383
    25.       - 10.2.6.xx:6384

  • 相关阅读:
    力扣(LeetCode)1333. 餐厅过滤器(C++)
    JavaScript - 手写call、apply和bind函数
    Linux进程控制
    软件安全性测试包含哪些类型?2023年专业软件安全测试报告获取
    Golang Context 的使用指南
    [PostgreSql]生产级别数据库安装要考虑哪些问题？
    【通信】基于增广矩阵束的L型阵列的二维DOA估计附matlab完整代码
    基于Spring AOP和CGLIB代理实现引介增强（Introduction Advice）示例
    代码随想录训练营二刷第二十三天 | 669. 修剪二叉搜索树 108.将有序数组转换为二叉搜索树 538.把二叉搜索树转换为累加树
    docker部署frp穿透内网
  • 原文地址：https://blog.csdn.net/donkeyboy001/article/details/128018679