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文件


    org.springframework.boot
    spring-boot-starter-data-redis


    org.apache.commons
    commons-pool2
    2.6.0

 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 {
    @Bean
    RedisTemplate redisTemplate(LettuceConnectionFactory factory){
        factory.setShareNativeConnection(false);
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }
}

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

lettuce初始化 

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

 springboot研究九:lettuce连接池很香,撸撸它的源代码_第1张图片

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 getConnection(Class 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 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 initFuture = initializer.channelInitialized();
        ChannelFuture connectFuture = redisBootstrap.connect(redisAddress);
		//省略部分代码    
    }

管理连接 

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

                                springboot研究九:lettuce连接池很香,撸撸它的源代码_第2张图片

 关键代码

LettucePoolingConnectionProvider中getConnection

public > T getConnection(Class connectionType) {
	GenericObjectPool> 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 p = null;
        // Get local copy of current config so it is consistent for entire
        // method execution
        final 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();
    }

 释放连接的流程图入下:

                                                springboot研究九:lettuce连接池很香,撸撸它的源代码_第3张图片

看下关键代码

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 closeAsync() {
		//省略部分代码
        if (CLOSED.compareAndSet(this, ST_OPEN, ST_CLOSED)) {
            active = false;
            CompletableFuture future = channelWriter.closeAsync();
			//省略部分代码
        }
        return closeFuture;
    }

DefaultEndpoint类的closeAsync

public CompletableFuture 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类图如下:

springboot研究九:lettuce连接池很香,撸撸它的源代码_第4张图片

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

protected Mono 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 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 connectionType) {

			Assert.notNull(connectionProvider, "LettuceConnectionProvider must not be null!");

			this.connectionProvider = connectionProvider;
			//回到了之前讲的使用connectionProvider创建连接
			Mono defer = Mono.defer(() -> Mono. 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个连接池

                                    springboot研究九:lettuce连接池很香,撸撸它的源代码_第5张图片 

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

private void ensureIdle(final int idleCount, final boolean always) throws Exception {
       //省略部分代码
        while (idleObjects.size() < idleCount) {
            final PooledObject 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 doHealthCheck(Health.Builder builder) {
	return getConnection().flatMap((connection) -> doHealthCheck(builder, connection));
}

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

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

3.调用了ConnectionPoolSupport.createGenericObjectPool

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

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

public GenericObjectPool(final PooledObjectFactory factory,
            final GenericObjectPoolConfig 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 

 

 

 

 

 

 

 

 

你可能感兴趣的:(spring-boot)