深入:SpringBoot是如何操作Redis的

男娘i 2023-09-27 19:09 68阅读 0赞

## 最简单的配置使用 ##

引入

<dependencies>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-pool2</artifactId>
            </dependency>
        </dependencies>

配置yml

spring:
      redis:
        host: 192.168.0.101
        port: 6379
        database: 0

使用

@RunWith(SpringRunner.class)
    @SpringBootTest(classes = RedisApplication.class)
    public class RedisTest {
        @Autowired
        private RedisTemplate redisTemplate;
        @Test
        public void test(){
            redisTemplate.opsForValue().set("test","hello redis");
        }
    }

可以看出只需3步就能轻松操作`redis`，那么其背后是如何实现的呢？

## `redis`的自动装配 ##

![b019e3caaf1f9ee5835bb9feb27cb0d6.png][]

自动配置初始化流程相关类

`SpringBoot`启动类需要声明`@SpringBootApplication`注解，`@SpringBootApplication`注解里面还有个`@EnableAutoConfiguration`注解，该注解表示激活自动配置

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import(AutoConfigurationImportSelector.class)
    public @interface EnableAutoConfiguration {
    
      String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    
      Class<?>[] exclude() default {};
    
      String[] excludeName() default {};
    
    }

`EnableAutoConfiguration`有`exclude`和`excludeName`属性，如果启动的时候不想加载某个自动配置类，可以用该属性，例如`@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})`

`EnableAutoConfiguration`还导入了一个`AutoConfigurationImportSelector`自动配置导入选择器类，该类最后会调用`SpringFactoriesLoader`的`loadSpringFactories`方法

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
            MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
            if (result != null) {
                return result;
            } else {
                try {
                    Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                    LinkedMultiValueMap result = new LinkedMultiValueMap();
                    ...
                } catch (IOException var13) {
                    throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
                }
            }
        }

关键来了，该方法加载了一个`META-INFO/spring.factories`文件，定位文件位置

![c34edc4ad6a42225de232af9ff2f0d75.png][]

其中就有个`RedisAutoConfiguration`配置，进入`RedisAutoConfiguration`配置类，就可以看到`ReidsTemplate`和`StringRedisTemplate`

![3cba0b70a6141073c77f35eee61c84e5.png][]

总结：`SpringBoot`启动的时候会加载`autoconfigure`\->`META-INF`下的`spring.factories`文件，`RedisAutoConfiguration`就是其中之一，`RedisAutoConfiguration`为我们注入了`RedisTemplate`和`StringRedisTemplate`组件

## 如何连接到redis ##

这里分两步，管理和连接

管理：用哪个客户端？用不用连接池？是主从还是哨兵？

连接：拿到对应的客户端，进行连接操作

### 管理 ###

在`RedisAutoConfiguration`类中可以看出该类导入了`LettuceConnectionConfiguration`和`JedisConnectionConfiguration`两个类，这就是连接`Redis`的两个客户端

`Jedis`是通过`socket`实现的，是传统的`BIO`模型。每个连接需要独立的进程/线程单独处理，当并发请求量大时为了维护程序，内存、线程切换开销较大，这种模型在实际生产中很少使用

`Lettuce`是通过`netty`实现的，是`NIO`模型。可以基于一个阻塞对象，同时在多个描述符上等待就绪，而不是使用多个线程(每个文件描述符一个线程)，这样可以大大节省系统资源。

`SpringBoot`默认用的是`Lettuce`客户端,这里就通过`Lettuce`来看是如何连接`Redis`

![095f9219f35d477440293bcbb620d488.png][]

Redis配置流程相关类

首先`LettuceConnectionConfiguration`会判断是`sentinel`还是`cluster`还是`默认`模式，然后进行初始化`LettuceConnectionFactory`

@Bean
     @ConditionalOnMissingBean(RedisConnectionFactory.class)
     public LettuceConnectionFactory redisConnectionFactory(ClientResources clientResources)
       throws UnknownHostException {
      LettuceClientConfiguration clientConfig = getLettuceClientConfiguration(clientResources,
        this.properties.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);
     }

`LettuceConnectionFactory`然后会初始化`LettuceConnectionProvider`，这个类用来提供连接

private @Nullable LettuceConnectionProvider connectionProvider;
     private @Nullable LettuceConnectionProvider reactiveConnectionProvider;
    /*
      * (non-Javadoc)
      * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
      */
     public void afterPropertiesSet() {
    
      this.client = createClient();
    
      this.connectionProvider = createConnectionProvider(client, LettuceConnection.CODEC);
      this.reactiveConnectionProvider = createConnectionProvider(client, LettuceReactiveRedisConnection.CODEC);
    
      if (isClusterAware()) {
       this.clusterCommandExecutor = new ClusterCommandExecutor(
         new LettuceClusterTopologyProvider((RedisClusterClient) client),
         new LettuceClusterConnection.LettuceClusterNodeResourceProvider(this.connectionProvider),
         EXCEPTION_TRANSLATION);
      }
     }

默认情况`LettuceConnectionProvider`的实现类是`StandaloneConnectionProvider`

protected LettuceConnectionProvider doCreateConnectionProvider(AbstractRedisClient client, RedisCodec<?, ?> codec) {
    
      ReadFrom readFrom = getClientConfiguration().getReadFrom().orElse(null);
    
      if (isStaticMasterReplicaAware()) {
    
       List<RedisURI> nodes = ((RedisStaticMasterReplicaConfiguration) configuration).getNodes().stream() //
         .map(it -> createRedisURIAndApplySettings(it.getHostName(), it.getPort())) //
         .peek(it -> it.setDatabase(getDatabase())) //
         .collect(Collectors.toList());
    
       return new StaticMasterReplicaConnectionProvider((RedisClient) client, codec, nodes, readFrom);
      }
    
      if (isClusterAware()) {
       return new ClusterConnectionProvider((RedisClusterClient) client, codec, readFrom);
      }
    
      return new StandaloneConnectionProvider((RedisClient) client, codec, readFrom);
     }

获取回来的`LettuceConnectionProvider`会放在`LettucePoolingConnectionProvider`中

private LettuceConnectionProvider createConnectionProvider(AbstractRedisClient client, RedisCodec<?, ?> codec) {
    
      LettuceConnectionProvider connectionProvider = doCreateConnectionProvider(client, codec);
    
      if (this.clientConfiguration instanceof LettucePoolingClientConfiguration) {
       return new LettucePoolingConnectionProvider(connectionProvider,
         (LettucePoolingClientConfiguration) this.clientConfiguration);
      }
    
      return connectionProvider;
     }

### 连接 ###

当`RedisTemplate`执行时，会调用`execute`方法，然后获取`RedisConnectionFactory`，最后用`RedisConnectionUtils`来获取`RedisConnection`

@Nullable
     public <T> T execute(RedisCallback<T> action, boolean exposeConnection, boolean pipeline) {
    
      Assert.isTrue(initialized, "template not initialized; call afterPropertiesSet() before using it");
      Assert.notNull(action, "Callback object must not be null");
    
      RedisConnectionFactory factory = getRequiredConnectionFactory();
      RedisConnection conn = null;
      try {
    
       if (enableTransactionSupport) {
        // only bind resources in case of potential transaction synchronization
        conn = RedisConnectionUtils.bindConnection(factory, enableTransactionSupport);
       } else {
        conn = RedisConnectionUtils.getConnection(factory);
       }
    
       ....
      } finally {
       RedisConnectionUtils.releaseConnection(conn, factory, enableTransactionSupport);
      }
     }

`RedisConnectionUtils`的`getConnection`

@Override
     public <T extends StatefulConnection<?, ?>> T getConnection(Class<T> connectionType) {
    
      if (connectionType.equals(StatefulRedisSentinelConnection.class)) {
       return connectionType.cast(client.connectSentinel());
      }
    
      if (connectionType.equals(StatefulRedisPubSubConnection.class)) {
       return connectionType.cast(client.connectPubSub(codec));
      }
    
      if (StatefulConnection.class.isAssignableFrom(connectionType)) {
    
       return connectionType.cast(readFrom.map(it -> this.masterReplicaConnection(redisURISupplier.get(), it))
         .orElseGet(() -> client.connect(codec)));
      }
    
      throw new UnsupportedOperationException("Connection type " + connectionType + " not supported!");
     }

`client.connect`最后的调用

private void initializeChannelAsync0(ConnectionBuilder connectionBuilder, CompletableFuture<Channel> channelReadyFuture,
                SocketAddress redisAddress) {
     
            logger.debug("Connecting to Redis at {}", redisAddress);
     
            Bootstrap redisBootstrap = connectionBuilder.bootstrap();
     
            RedisChannelInitializer initializer = connectionBuilder.build();
            redisBootstrap.handler(initializer);
     
            clientResources.nettyCustomizer().afterBootstrapInitialized(redisBootstrap);
            CompletableFuture<Boolean> initFuture = initializer.channelInitialized();
            ChannelFuture connectFuture = redisBootstrap.connect(redisAddress);  
        }

可以看出最后是通过`netty`连接到`redis`的

附加`jedis`连接`redis`的方式

@Override
      public Socket createSocket() throws JedisConnectionException {
        Socket socket = null;
        try {
          socket = new Socket();
          ...
          HostAndPort hostAndPort = getSocketHostAndPort();
          socket.connect(new InetSocketAddress(hostAndPort.getHost(), hostAndPort.getPort()), getConnectionTimeout());
          socket.setSoTimeout(getSoTimeout()); 
          ...
          return socket;
    
        } catch (IOException ex) {
    
          IOUtils.closeQuietly(socket);
    
          throw new JedisConnectionException("Failed to create socket.", ex);
        }
      }

`lettuce`和`redis`功能比较

<table> 
 <thead> 
  <tr> 
   <th>功能</th> 
   <th>lettuce</th> 
   <th>redis</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>独立连接</td> 
   <td>X</td> 
   <td>X</td> 
  </tr> 
  <tr> 
   <td>主/副本连接</td> 
   <td>X</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>Redis前哨</td> 
   <td>主查询，前哨身份验证，副本读取</td> 
   <td>主查询</td> 
  </tr> 
  <tr> 
   <td>Redis集群</td> 
   <td>群集连接，群集节点连接，副本读取</td> 
   <td>群集连接，群集节点连接</td> 
  </tr> 
  <tr> 
   <td>运输渠道</td> 
   <td>TCP，OS原生TCP（epoll，kqueue），Unix域套接字</td> 
   <td>TCP协议</td> 
  </tr> 
  <tr> 
   <td>连接池</td> 
   <td>X（使用commons-pool2）</td> 
   <td>X（使用commons-pool2）</td> 
  </tr> 
  <tr> 
   <td>其他连接功能</td> 
   <td>非阻塞命令的单例连接共享</td> 
   <td>JedisShardInfo支持</td> 
  </tr> 
  <tr> 
   <td>SSL支持</td> 
   <td>X</td> 
   <td>X</td> 
  </tr> 
  <tr> 
   <td>发布/订阅</td> 
   <td>X</td> 
   <td>X</td> 
  </tr> 
  <tr> 
   <td>流水线</td> 
   <td>X</td> 
   <td>X</td> 
  </tr> 
  <tr> 
   <td>交易次数</td> 
   <td>X</td> 
   <td>X</td> 
  </tr> 
  <tr> 
   <td>数据类型支持</td> 
   <td>Key, String, List, Set, Sorted Set, Hash, Server, Stream, Scripting, Geo, HyperLogLog</td> 
   <td>Key, String, List, Set, Sorted Set, Hash, Server, Scripting, Geo, HyperLogLog</td> 
  </tr> 
  <tr> 
   <td>响应式（非阻塞）API</td> 
   <td>X</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

`SpringBoot`关于`redis`的相关配置

# REDIS (RedisProperties)
    spring.redis.cluster.max-redirects= # Maximum number of redirects to follow when executing commands across the cluster.
    spring.redis.cluster.nodes= # Comma-separated list of "host:port" pairs to bootstrap from.
    spring.redis.database=0 # Database index used by the connection factory.
    spring.redis.url= # Connection URL. Overrides host, port, and password. User is ignored. Example: redis://user:password@example.com:6379
    spring.redis.host=localhost # Redis server host.
    spring.redis.jedis.pool.max-active=8 # Maximum number of connections that can be allocated by the pool at a given time. Use a negative value for no limit.
    spring.redis.jedis.pool.max-idle=8 # Maximum number of "idle" connections in the pool. Use a negative value to indicate an unlimited number of idle connections.
    spring.redis.jedis.pool.max-wait=-1ms # 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.
    spring.redis.jedis.pool.min-idle=0 # Target for the minimum number of idle connections to maintain in the pool. This setting only has an effect if it is positive.
    spring.redis.lettuce.pool.max-active=8 # Maximum number of connections that can be allocated by the pool at a given time. Use a negative value for no limit.
    spring.redis.lettuce.pool.max-idle=8 # Maximum number of "idle" connections in the pool. Use a negative value to indicate an unlimited number of idle connections.
    spring.redis.lettuce.pool.max-wait=-1ms # 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.
    spring.redis.lettuce.pool.min-idle=0 # Target for the minimum number of idle connections to maintain in the pool. This setting only has an effect if it is positive.
    spring.redis.lettuce.shutdown-timeout=100ms # Shutdown timeout.
    spring.redis.password= # Login password of the redis server.
    spring.redis.port=6379 # Redis server port.
    spring.redis.sentinel.master= # Name of the Redis server.
    spring.redis.sentinel.nodes= # Comma-separated list of "host:port" pairs.
    spring.redis.ssl=false # Whether to enable SSL support.
    spring.redis.timeout= # Connection timeout.

[b019e3caaf1f9ee5835bb9feb27cb0d6.png]: https://img-blog.csdnimg.cn/img_convert/b019e3caaf1f9ee5835bb9feb27cb0d6.png
[c34edc4ad6a42225de232af9ff2f0d75.png]: https://img-blog.csdnimg.cn/img_convert/c34edc4ad6a42225de232af9ff2f0d75.png
[3cba0b70a6141073c77f35eee61c84e5.png]: https://img-blog.csdnimg.cn/img_convert/3cba0b70a6141073c77f35eee61c84e5.png
[095f9219f35d477440293bcbb620d488.png]: https://img-blog.csdnimg.cn/img_convert/095f9219f35d477440293bcbb620d488.png