springboot研究九：lettuce连接池很香，撸撸它的源代码

个人公众号:jinjunzhu

springboot中lettuce配置

lettuce初始化

使用netty创建连接

管理连接

actuator健康检查获取连接

释放不掉的连接

共享连接

总结

Lettuce是一个高性能的redis客户端，底层基于netty框架来管理连接，天然是非阻塞和线程安全的。比起jedis需要为每个实例创建物理连接来保证线程安全，lettuce确实很优秀。本文主要介绍springboot使用lettuce整合redis客户端。说明一下，本文的源代码是使用springboot2.1.6，对应lettuce版本是5.1.7.RELEASE。

springboot中lettuce配置

springboot中配置lettuce是非常容易的，代码如下：

pom.xml文件

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

application.properties配置

spring.redis.database=0
spring.redis.host=192.168.59.138
spring.redis.password=
spring.redis.port=6379
spring.redis.timeout=5000
#最大连接数
spring.redis.lettuce.pool.max-active=50
#最大阻塞等待时间
spring.redis.lettuce.pool.max-wait=5000
#连接池中最大空闲连接
spring.redis.lettuce.pool.max-idle=50
#连接池中最小空闲连接
spring.redis.lettuce.pool.min-idle=5
#eviction线程调度时间间隔
spring.redis.lettuce.pool.time-between-eviction-runs=1

redis配置类RedisConfig.java

@Configuration
public class RedisConfig {@BeanRedisTemplate redisTemplate(LettuceConnectionFactory factory){factory.setShareNativeConnection(false);RedisTemplate redisTemplate = new RedisTemplate();redisTemplate.setConnectionFactory(factory);return redisTemplate;}
}

上面3步就能完成springboot使用lettuce连接池整合redis的配置，之后我们就可以在业务类中注入RedisTemplate来使用了。

lettuce初始化

我们看一下整个初始化流程相关类的UML类图

LettuceConnectionConfiguration类是lettuce初始化的起始类，这个类是spring的管理的配置类，它初始化了lettuce连接工厂类，见如下代码

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

获取到工厂类以后，lettuce会用如下2个Provider来获取和释放连接，分别管理普通模式和交互模式的连接。本示例采用单机的redis模式，所以初始化后的Provider是StandaloneConnectionProvider。

private @Nullable LettuceConnectionProvider connectionProvider;
private @Nullable LettuceConnectionProvider reactiveConnectionProvider;
public void afterPropertiesSet() {this.client = createClient();this.connectionProvider = createConnectionProvider(client, LettuceConnection.CODEC);this.reactiveConnectionProvider = createConnectionProvider(client, LettuceReactiveRedisConnection.CODEC);//省略部分代码}

注意：上面创建的provider类型是LettucePoolingConnectionProvider，它是StandaloneConnectionProvider的装饰器类，每次获取和释放连接，工厂类都会通过LettucePoolingConnectionProvider类调用LettucePoolingConnectionProvider的获取和释放操作

使用netty创建连接

lettuce的连接是靠netty来管理的，这或许是它性能优秀的重要原因。我们看一下通过netty来创建连接的代码，看一下StandaloneConnectionProvider的下面方法：

public <T extends StatefulConnection<?, ?>> T getConnection(Class<T> connectionType) {//省略部分代码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(codec)是创建连接的代码，一直跟踪这个方法，

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);//省略部分代码    }

管理连接

执行请求命令的时候首先要获取连接，流程图入下

关键代码

LettucePoolingConnectionProvider中getConnection

public <T extends StatefulConnection<?, ?>> T getConnection(Class<T> connectionType) {GenericObjectPool<StatefulConnection<?, ?>> pool = pools.computeIfAbsent(connectionType, poolType -> {return ConnectionPoolSupport.createGenericObjectPool(() -> connectionProvider.getConnection(connectionType),poolConfig, false);});try {StatefulConnection<?, ?> connection = pool.borrowObject();poolRef.put(connection, pool);return connectionType.cast(connection);} catch (Exception e) {throw new PoolException("Could not get a resource from the pool", e);}
}

GenericObjectPool中borrowObject

public T borrowObject(final long borrowMaxWaitMillis) throws Exception {//省略部分代码PooledObject<T> p = null;// Get local copy of current config so it is consistent for entire// method executionfinal boolean blockWhenExhausted = getBlockWhenExhausted();boolean create;final long waitTime = System.currentTimeMillis();while (p == null) {create = false;p = idleObjects.pollFirst();if (p == null) {p = create();if (p != null) {create = true;}}//省略部分代码}updateStatsBorrow(p, System.currentTimeMillis() - waitTime);return p.getObject();}

释放连接的流程图入下：

看下关键代码

GenericObjectPool中释放连接代码

public void returnObject(final T obj) {//省略部分代码final int maxIdleSave = getMaxIdle();if (isClosed() || maxIdleSave > -1 && maxIdleSave <= idleObjects.size()) {try {destroy(p);} catch (final Exception e) {swallowException(e);}} else {if (getLifo()) {idleObjects.addFirst(p);} else {idleObjects.addLast(p);}if (isClosed()) {// Pool closed while object was being added to idle objects.// Make sure the returned object is destroyed rather than left// in the idle object pool (which would effectively be a leak)clear();}}updateStatsReturn(activeTime);}

RedisChannalHandler中的close方法

public void close() {//省略部分代码closeAsync().join();
}
public CompletableFuture<Void> closeAsync() {//省略部分代码if (CLOSED.compareAndSet(this, ST_OPEN, ST_CLOSED)) {active = false;CompletableFuture<Void> future = channelWriter.closeAsync();//省略部分代码}return closeFuture;}

DefaultEndpoint类的closeAsync

public CompletableFuture<Void> closeAsync() {//省略部分代码if (STATUS.compareAndSet(this, ST_OPEN, ST_CLOSED)) {Channel channel = getOpenChannel();if (channel != null) {Futures.adapt(channel.close(), closeFuture);} else {closeFuture.complete(null);}}return closeFuture;}

actuator健康检查获取连接

我们知道，springboot的actuator健康检查是实现了ReactiveHealthIndicator接口，如果springboot工程启用了actuator，在lettuce初始化时，会创建一个reactive的连接，UML类图如下：

RedisReactiveHealthIndicator类会调用RedisConnectionFactory来创建一个reactive连接，代码如下：

protected Mono<Health> doHealthCheck(Health.Builder builder) {//getConnection()创建一个连接return getConnection().flatMap((connection) -> doHealthCheck(builder, connection));
}public LettuceReactiveRedisConnection getReactiveConnection() {//下面的构造函数会创建交互式连接return getShareNativeConnection()? new LettuceReactiveRedisConnection(getSharedReactiveConnection(), reactiveConnectionProvider): new LettuceReactiveRedisConnection(reactiveConnectionProvider);
}
LettuceReactiveRedisConnection(StatefulConnection<ByteBuffer, ByteBuffer> sharedConnection,LettuceConnectionProvider connectionProvider) {Assert.notNull(sharedConnection, "Shared StatefulConnection must not be null!");Assert.notNull(connectionProvider, "LettuceConnectionProvider must not be null!");//调用AsyncConnect构造函数创建连接方法this.dedicatedConnection = new AsyncConnect(connectionProvider, StatefulConnection.class);this.pubSubConnection = new AsyncConnect(connectionProvider, StatefulRedisPubSubConnection.class);this.sharedConnection = Mono.just(sharedConnection);}
AsyncConnect(LettuceConnectionProvider connectionProvider, Class<? extends T> connectionType) {Assert.notNull(connectionProvider, "LettuceConnectionProvider must not be null!");this.connectionProvider = connectionProvider;//回到了之前讲的使用connectionProvider创建连接Mono<T> defer = Mono.defer(() -> Mono.<T> just(connectionProvider.getConnection(connectionType)));this.connectionPublisher = defer.subscribeOn(Schedulers.elastic());}

释放不掉的连接

有时候我们为了节省创建连接花费的时间，会设置min-idle，但其实lettuce初始化时并不会创建这个数量的连接，除非我们设置一个参数spring.redis.lettuce.pool.time-between-eviction-runs=1，
而这样lettuce在初始化的时候因为使用了actuator做健康检查而创建${min-idle} + 1个reactive连接，并不会创建普通连接，只有在第一次请求的时候才会创建${min-idle} + 1个普通连接。
如果没有交互式场景，这些交互式连接不会被释放，造成资源浪费。所以如果使用了actuator监控检查，而又想初始化时创建一定数量的连接，只能造成连接资源浪费了。
为什么要这么设计，有点不明白，可能是bug?没顾上看后面的版本有没有处理这个问题。看下UML类图，从这个流程图看到，time-between-eviction-runs这个参数决定了是否初始化的时候创建${min-idle} + 1个连接池

上面关键代码就是GenericObjectPool类中的ensureMinIdle方法，在释放连接的时候也会调用这个方法，代码如下：

private void ensureIdle(final int idleCount, final boolean always) throws Exception {//省略部分代码while (idleObjects.size() < idleCount) {final PooledObject<T> p = create();if (p == null) {// Can't create objects, no reason to think another call to// create will work. Give up.break;}if (getLifo()) {idleObjects.addFirst(p);} else {idleObjects.addLast(p);}}if (isClosed()) {// Pool closed while object was being added to idle objects.// Make sure the returned object is destroyed rather than left// in the idle object pool (which would effectively be a leak)clear();}}

那为什么会比min-idle多创建一个连接呢？问题还在于上面的一个方法。初始化的流程如下：
1.健康检查需要创建一个reactive连接

protected Mono<Health> doHealthCheck(Health.Builder builder) {return getConnection().flatMap((connection) -> doHealthCheck(builder, connection));
}

2.之前介绍过，创建连接实际是用LettucePoolConnectionProvider的getConnection方法

public <T extends StatefulConnection<?, ?>> T getConnection(Class<T> connectionType) {GenericObjectPool<StatefulConnection<?, ?>> pool = pools.computeIfAbsent(connectionType, poolType -> {return ConnectionPoolSupport.createGenericObjectPool(() -> connectionProvider.getConnection(connectionType),poolConfig, false);});//省略部分代码
}

3.调用了ConnectionPoolSupport.createGenericObjectPool

public static <T extends StatefulConnection<?, ?>> GenericObjectPool<T> createGenericObjectPool(Supplier<T> connectionSupplier, GenericObjectPoolConfig config, boolean wrapConnections) {//省略部分代码GenericObjectPool<T> pool = new GenericObjectPool<T>(new RedisPooledObjectFactory<T>(connectionSupplier), config) {//省略部分代码};poolRef.set(new ObjectPoolWrapper<>(pool));return pool;
}

4.ConnectionPoolSupport.createGenericObjectPool方法创建GenericObjectPool对象，构造函数里面用到了前面讲的setConfig

public GenericObjectPool(final PooledObjectFactory<T> factory,final GenericObjectPoolConfig<T> config) {//省略部分代码setConfig(config);}

5.setConfig最终调用了上面讲的ensureIdle，而健康检查的那个连接还没有返还给线程池，线程池的数量已经是min-idle了，最终多了一个

同理，普通连接也是一样，首次创建的时候会比min-idle多一个

共享连接

第一部分介绍springboot整合lettuce时讲到RedisConfig的配置，如下方法里面第一行代码就是设置时是否共享Native连接。

@Bean
RedisTemplate redisTemplate(LettuceConnectionFactory factory){factory.setShareNativeConnection(false);RedisTemplate redisTemplate = new RedisTemplate();redisTemplate.setConnectionFactory(factory);return redisTemplate;
}

这个主要用于获取集群中的连接或者是获取Reactive连接时，可以用LettuceConnectionFactory中直接获取。我对这个地方的设计并不是特别理解，只是为了省去了从连接池获取和释放的的时间？

总结

lettuce的确很香，不过从设计中也可以看出一些瑕疵
如果应用使用了springboot的actuator，建议min-idle设置为0

本专栏精彩文章：

《redis灵魂拷问：为什么响应变慢了》

《redis灵魂拷问：聊一聊主从复制缓冲区》

《redis灵魂拷问：AOF文件可以保存RDB格式吗》

《redis灵魂拷问：聊一聊AOF日志重写》

《redis灵魂拷问：聊一聊redis底层数据结构》

《redis灵魂拷问：怎么搭建一个哨兵主从集群》

欢迎关注个人公众号