聊聊spring-data-redis的连接池的校验

最新推荐文章于 2024-09-10 20:01:34 发布
最新推荐文章于 2024-09-10 20:01:34 发布
阅读量2.1k 收藏
点赞数
文章标签： 数据库 java 运维
原文链接：https://juejin.im/post/5b9b09d96fb9a05d212e8511
版权

序

本文主要研究一下spring-data-redis的连接池的校验

lettuce

LettucePoolingConnectionProvider

spring-data-redis/2.0.10.RELEASE/spring-data-redis-2.0.10.RELEASE-sources.jar!/org/springframework/data/redis/connection/lettuce/LettucePoolingConnectionProvider.java

class LettucePoolingConnectionProvider implements LettuceConnectionProvider, RedisClientProvider, DisposableBean {
    private static final Log log = LogFactory.getLog(LettucePoolingConnectionProvider.class);
    private final LettuceConnectionProvider connectionProvider;
    private final GenericObjectPoolConfig poolConfig;
    private final Map<StatefulConnection<?, ?>, GenericObjectPool<StatefulConnection<?, ?>>> poolRef = new ConcurrentHashMap(32);
    private final Map<Class<?>, GenericObjectPool<StatefulConnection<?, ?>>> pools = new ConcurrentHashMap(32);

    LettucePoolingConnectionProvider(LettuceConnectionProvider connectionProvider, LettucePoolingClientConfiguration clientConfiguration) {
        Assert.notNull(connectionProvider, "ConnectionProvider must not be null!");
        Assert.notNull(clientConfiguration, "ClientConfiguration must not be null!");
        this.connectionProvider = connectionProvider;
        this.poolConfig = clientConfiguration.getPoolConfig();
    }

    public <T extends StatefulConnection<?, ?>> T getConnection(Class<T> connectionType) {
        GenericObjectPool pool = (GenericObjectPool)this.pools.computeIfAbsent(connectionType, (poolType) -> {
            return ConnectionPoolSupport.createGenericObjectPool(() -> {
                return this.connectionProvider.getConnection(connectionType);
            }, this.poolConfig, false);
        });

        try {
            StatefulConnection<?, ?> connection = (StatefulConnection)pool.borrowObject();
            this.poolRef.put(connection, pool);
            return (StatefulConnection)connectionType.cast(connection);
        } catch (Exception var4) {
            throw new PoolException("Could not get a resource from the pool", var4);
        }
    }

    public AbstractRedisClient getRedisClient() {
        if (this.connectionProvider instanceof RedisClientProvider) {
            return ((RedisClientProvider)this.connectionProvider).getRedisClient();
        } else {
            throw new IllegalStateException(String.format("Underlying connection provider %s does not implement RedisClientProvider!", this.connectionProvider.getClass().getName()));
        }
    }

    public void release(StatefulConnection<?, ?> connection) {
        GenericObjectPool<StatefulConnection<?, ?>> pool = (GenericObjectPool)this.poolRef.remove(connection);
        if (pool == null) {
            throw new PoolException("Returned connection " + connection + " was either previously returned or does not belong to this connection provider");
        } else {
            pool.returnObject(connection);
        }
    }

    public void destroy() throws Exception {
        if (!this.poolRef.isEmpty()) {
            log.warn("LettucePoolingConnectionProvider contains unreleased connections");
            this.poolRef.forEach((connection, pool) -> {
                pool.returnObject(connection);
            });
            this.poolRef.clear();
        }

        this.pools.forEach((type, pool) -> {
            pool.close();
        });
        this.pools.clear();
    }
}
复制代码
  • 这里调用ConnectionPoolSupport.createGenericObjectPool来创建连接池

ConnectionPoolSupport.createGenericObjectPool

lettuce-core-5.0.5.RELEASE-sources.jar!/io/lettuce/core/support/ConnectionPoolSupport.java

    public static <T extends StatefulConnection<?, ?>> GenericObjectPool<T> createGenericObjectPool(
            Supplier<T> connectionSupplier, GenericObjectPoolConfig config, boolean wrapConnections) {

        LettuceAssert.notNull(connectionSupplier, "Connection supplier must not be null");
        LettuceAssert.notNull(config, "GenericObjectPoolConfig must not be null");

        AtomicReference<ObjectPool<T>> poolRef = new AtomicReference<>();

        GenericObjectPool<T> pool = new GenericObjectPool<T>(new RedisPooledObjectFactory<T>(connectionSupplier), config) {

            @Override
            public T borrowObject() throws Exception {
                return wrapConnections ? wrapConnection(super.borrowObject(), this) : super.borrowObject();
            }

            @Override
            public void returnObject(T obj) {

                if (wrapConnections && obj instanceof HasTargetConnection) {
                    super.returnObject((T) ((HasTargetConnection) obj).getTargetConnection());
                    return;
                }
                super.returnObject(obj);
            }
        };

        poolRef.set(pool);

        return pool;
    }
复制代码
  • 这里使用了RedisPooledObjectFactory

ConnectionPoolSupport.RedisPooledObjectFactory

lettuce-core-5.0.5.RELEASE-sources.jar!/io/lettuce/core/support/ConnectionPoolSupport.java

    private static class RedisPooledObjectFactory<T extends StatefulConnection<?, ?>> extends BasePooledObjectFactory<T> {

        private final Supplier<T> connectionSupplier;

        RedisPooledObjectFactory(Supplier<T> connectionSupplier) {
            this.connectionSupplier = connectionSupplier;
        }

        @Override
        public T create() throws Exception {
            return connectionSupplier.get();
        }

        @Override
        public void destroyObject(PooledObject<T> p) throws Exception {
            p.getObject().close();
        }

        @Override
        public PooledObject<T> wrap(T obj) {
            return new DefaultPooledObject<>(obj);
        }

        @Override
        public boolean validateObject(PooledObject<T> p) {
            return p.getObject().isOpen();
        }
    }
复制代码
  • 这里继承了BasePooledObjectFactory，重写了validate等方法，这里validate是通过isOpen来判断

RedisChannelHandler.isOpen

lettuce-core-5.0.5.RELEASE-sources.jar!/io/lettuce/core/RedisChannelHandler.java

public abstract class RedisChannelHandler<K, V> implements Closeable, ConnectionFacade {

    private static final InternalLogger logger = InternalLoggerFactory.getInstance(RedisChannelHandler.class);

    private Duration timeout;
    private CloseEvents closeEvents = new CloseEvents();

    private final RedisChannelWriter channelWriter;
    private final boolean debugEnabled = logger.isDebugEnabled();

    private volatile boolean closed;
    private volatile boolean active = true;
    private volatile ClientOptions clientOptions;

    //......

    /**
     * Notification when the connection becomes active (connected).
     */
    public void activated() {
        active = true;
        closed = false;
    }

    /**
     * Notification when the connection becomes inactive (disconnected).
     */
    public void deactivated() {
        active = false;
    }

    /**
     *
     * @return true if the connection is active and not closed.
     */
    public boolean isOpen() {
        return active;
    }

    @Override
    public synchronized void close() {

        if (debugEnabled) {
            logger.debug("close()");
        }

        if (closed) {
            logger.warn("Connection is already closed");
            return;
        }

        if (!closed) {
            active = false;
            closed = true;
            channelWriter.close();
            closeEvents.fireEventClosed(this);
            closeEvents = new CloseEvents();
        }
    }
}
复制代码
  • isOpen是通过active字段来判断的，而active在deactivated或者close的时候变为false，初始化以及在activated的时候变为true
  • 可以看到对于docker pause这种造成的timeout，active这种方式检测不出来

LettuceConnectionFactory.SharedConnection.validateConnection

spring-data-redis-2.0.10.RELEASE-sources.jar!/org/springframework/data/redis/connection/lettuce/LettuceConnectionFactory.java

		/**
		 * Validate the connection. Invalid connections will be closed and the connection state will be reset.
		 */
		void validateConnection() {

			synchronized (this.connectionMonitor) {

				boolean valid = false;

				if (connection != null && connection.isOpen()) {
					try {

						if (connection instanceof StatefulRedisConnection) {
							((StatefulRedisConnection) connection).sync().ping();
						}

						if (connection instanceof StatefulRedisClusterConnection) {
							((StatefulRedisConnection) connection).sync().ping();
						}
						valid = true;
					} catch (Exception e) {
						log.debug("Validation failed", e);
					}
				}

				if (!valid) {

					if (connection != null) {
						connectionProvider.release(connection);
					}

					log.warn("Validation of shared connection failed. Creating a new connection.");

					resetConnection();
					this.connection = getNativeConnection();
				}
			}
		}
复制代码
  • 这个是默认开启LettuceConnectionFactory的shareNativeConnection走的获取连接的方法
  • 如果LettuceConnectionFactory的validateConnection为true的话(默认为false)，则会自己在每次get的时候执行一下validateConnection

DefaultLettucePool.LettuceFactory

spring-data-redis-2.0.10.RELEASE-sources.jar!/org/springframework/data/redis/connection/lettuce/DefaultLettucePool.java

private static class LettuceFactory extends BasePooledObjectFactory<StatefulConnection<byte[], byte[]>> {
        private final RedisClient client;
        private int dbIndex;

        public LettuceFactory(RedisClient client, int dbIndex) {
            this.client = client;
            this.dbIndex = dbIndex;
        }

        public void activateObject(PooledObject<StatefulConnection<byte[], byte[]>> pooledObject) throws Exception {
            if (pooledObject.getObject() instanceof StatefulRedisConnection) {
                ((StatefulRedisConnection)pooledObject.getObject()).sync().select(this.dbIndex);
            }

        }

        public void destroyObject(PooledObject<StatefulConnection<byte[], byte[]>> obj) throws Exception {
            try {
                ((StatefulConnection)obj.getObject()).close();
            } catch (Exception var3) {
                ;
            }

        }

        public boolean validateObject(PooledObject<StatefulConnection<byte[], byte[]>> obj) {
            try {
                if (obj.getObject() instanceof StatefulRedisConnection) {
                    ((StatefulRedisConnection)obj.getObject()).sync().ping();
                }

                return true;
            } catch (Exception var3) {
                return false;
            }
        }

        public StatefulConnection<byte[], byte[]> create() throws Exception {
            return this.client.connect(LettuceConnection.CODEC);
        }

        public PooledObject<StatefulConnection<byte[], byte[]>> wrap(StatefulConnection<byte[], byte[]> obj) {
            return new DefaultPooledObject(obj);
        }
    }
复制代码
  • 被废弃的DefaultLettucePool里头有个LettuceFactory，其validate是通过ping来判断的，因而更为准确

jedis

JedisConnectionFactory

spring-data-redis-2.0.10.RELEASE-sources.jar!/org/springframework/data/redis/connection/jedis/JedisConnectionFactory.java

public class JedisConnectionFactory implements InitializingBean, DisposableBean, RedisConnectionFactory {
	//......
	private Pool<Jedis> createPool() {

		if (isRedisSentinelAware()) {
			return createRedisSentinelPool(this.sentinelConfig);
		}
		return createRedisPool();
	}

	/**
	 * Creates {@link JedisSentinelPool}.
	 *
	 * @param config the actual {@link RedisSentinelConfiguration}. Never {@literal null}.
	 * @return the {@link Pool} to use. Never {@literal null}.
	 * @since 1.4
	 */
	protected Pool<Jedis> createRedisSentinelPool(RedisSentinelConfiguration config) {

		GenericObjectPoolConfig poolConfig = getPoolConfig() != null ? getPoolConfig() : new JedisPoolConfig();
		return new JedisSentinelPool(config.getMaster().getName(), convertToJedisSentinelSet(config.getSentinels()),
				poolConfig, getConnectTimeout(), getReadTimeout(), getPassword(), getDatabase(), getClientName());
	}

	/**
	 * Creates {@link JedisPool}.
	 *
	 * @return the {@link Pool} to use. Never {@literal null}.
	 * @since 1.4
	 */
	protected Pool<Jedis> createRedisPool() {

		return new JedisPool(getPoolConfig(), getHostName(), getPort(), getConnectTimeout(), getReadTimeout(),
				getPassword(), getDatabase(), getClientName(), isUseSsl(),
				clientConfiguration.getSslSocketFactory().orElse(null), //
				clientConfiguration.getSslParameters().orElse(null), //
				clientConfiguration.getHostnameVerifier().orElse(null));
	}
	//......
}
复制代码
  • 不管是JedisPool还是JedisSentinelPool，里头使用的是JedisFactory

JedisFactory.validateObject

jedis-2.9.0-sources.jar!/redis/clients/jedis/JedisFactory.java

class JedisFactory implements PooledObjectFactory<Jedis> {
  private final AtomicReference<HostAndPort> hostAndPort = new AtomicReference<HostAndPort>();
  private final int connectionTimeout;
  private final int soTimeout;
  private final String password;
  private final int database;
  private final String clientName;
  private final boolean ssl;
  private final SSLSocketFactory sslSocketFactory;
  private SSLParameters sslParameters;
  private HostnameVerifier hostnameVerifier;

  //......

  @Override
  public boolean validateObject(PooledObject<Jedis> pooledJedis) {
    final BinaryJedis jedis = pooledJedis.getObject();
    try {
      HostAndPort hostAndPort = this.hostAndPort.get();

      String connectionHost = jedis.getClient().getHost();
      int connectionPort = jedis.getClient().getPort();

      return hostAndPort.getHost().equals(connectionHost)
          && hostAndPort.getPort() == connectionPort && jedis.isConnected()
          && jedis.ping().equals("PONG");
    } catch (final Exception e) {
      return false;
    }
  }
}
复制代码
  • JedisFactory实现了PooledObjectFactory接口，其validateObject方法不仅校验isConnected，而且也校验了ping方法
  • ping方法只要超时就会抛出异常，从而校验失败，因而可以感知到docker pause带来的timeout，从而将连接从连接池剔除

小结

  • spring-date-redis的2.0及以上版本废弃了原来的LettucePool，改为使用LettucePoolingClientConfiguration
  • 这里有一个问题，就是旧版连接池校验是采用ping的方式，而新版连接池校验则是使用active字段来标识，对于docker pause识别不出来
  • 对于lettuce其shareNativeConnection参数默认为true，且validateConnection为false，第一次从连接池borrow到连接之后，就一直复用底层的连接，也没有归还。如果要每次获取连接都走连接池获取然后归还，需要设置shareNativeConnection为false
  • jedis的连接池实现，其validateObject方法不仅校验isConnected，而且也校验了ping方法，因而能够感知到docker pause带来的timeout，从而将连接从连接池剔除
  • 对于lettuce来说，如果要识别docker pause的异常，有两个方案，一个是修复ConnectionPoolSupport中RedisPooledObjectFactory的validateObject方法，不仅判断isOpen，还需要ping一下；另外一个是不开启连接池，并且将LettuceConnectionFactory的validateConnection参数设置为true

doc

weixin_34037515
关注
redis的五种数据类型
学Java，找哪吒
05-15 5万+
（1）Redis（Remote Dictionary Server 远程字段服务）是一个开源的使用ANSI C语言编写、支持网络、科技与内存亦可持久化的日志型、key-value数据库，并提供多种语言的API。（2）Redis是一个key-value存储系统，它支持存储的value类型相对更多，包括string、list、set、zset（sorted set --有序集合）和hash。这些数据结构都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。
在springboot starter中使用Redis及选择redis序列化方案问题
BigSTR的博客
08-19 637
在springboot starter中使用Redis及选择redis序列化方案问题 场景介绍 将redis介入springboot starter redis序列化问题 场景介绍 ​ 笔者做了一套token校验（单点登录），统一参数校验，统一日志，统一返回包装和统一异常返回的springboot基础框架，在处理关于 单点登录验证时，由于需要用redis来存储用户token，故需要在springboot starter中使用redis并与其交互，我们选用的是RedisTemplate， 在写的过程中，先
聊聊LettucePoolingConnectionProvider
weixin_33725722的博客
09-17 1124
序 本文主要研究一下LettucePoolingConnectionProvider LettucePoolingConnectionProvider spring-data-redis-2.0.10.RELEASE-sources.jar!/org/springframework/data/redis/connection/lettuc...
无法连接redis
m0_68068256的博客
05-10 597
原因：因为我的redis没有设置密码，配置的时候却加了密码，在配置的时候删掉就行了。
Lettuce中RedisCommandTimeoutException异常分析
最新发布
gb4215287的博客
09-10 243
Lettuce中RedisCommandTimeoutException异常分析
springboot研究九：lettuce连接池很香，撸撸它的源代码
zjj2006的专栏
06-20 1万+
lettuce连接池源码解读
聊聊lettuce的shareNativeConnection参数
weixin_33805992的博客
09-16 3680
序 本文主要研究一下lettuce的shareNativeConnection参数 LettuceConnectionFactory spring-data-redis-2.0.10.RELEASE-sources.jar!/org/springframework/data/redis/connection/lettuce/LettuceConnectionFactory.java public ...
SpringDataRedis整合Lettuce学习整理
爱软件-从懂得生活开始。
08-09 4181
import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.spri...
Spring Boot 完整讲解
可乐的博客
02-28 2万+
SpringBoot学习笔记 文章写得比较详细，所以很长（105336 字数），可以参考目录 文章目录SpringBoot学习笔记@[toc]一、 Spring Boot 入门预：必须掌握的技术：1. Spring Boot 简介背景解决的问题优点缺点2.微服务What are Microservices?单体应用微服务3.环境准备Maven设置：Idea设置4.Spring Boot Hel...
【狂神说】Redis
weixin_46703850的博客
01-27 4942
​ Redis等关系型数据库作缓存去缓存使用频率高的数据，减轻Mysql等关系型数据库的压力
Redis（基于狂神说Java-Redis）
weixin_46468474的博客
11-19 4472
最近在进行Redis二刷，看了B站狂神的视频，纯手写的方式做了一个总结，如果这篇文章有帮到你，也希望能够多多支持，也支持一下狂神狂宝宝的视频，一起加油，继续努力！ 什么是NoSQL？ 为什么要用NoSQL？ 先从历史开始讲吧 1、单机数据库时代 90年代，一个基本的网站访问量较小，单个数据库可以顶住当时的访问量 在那个时候，都会去使用静态网页html，因为服务器压力不会太大 缺点： 数据量太大，一台机子放不下了 当数据量达到300万以上，就需要建立索引，MySQL索引，B+树。数据量一大，电脑内存.
Redis使用之--基于Lettuce实现Spring和Redis的集成（一）
田sir的博客
03-08 4000
主要从Redis的应用出发，介绍在java项目中，基于lettuce实现spring和redis的集成过程。 集成方案：spring4.x + spring-data-redis1.8.x + lettuce4.2.x 在集成中，不再使用xml配置方式，全部使用spring注解的方式，完成redis的集成。集成后支持redis单机、redis主从哨兵两种部署模式的redis的连接使用。
SpringBoot整合redis+lettuce
热门推荐
Venus's Blog
08-22 2万+
Spring Boot提供了与Redis的集成框架，可以使用Lettuce作为Redis客户端来进行整合。
Redis的Java客户端——SpringDataRedis、RedisTemplate、StringRedisTemplate
weixin_51351637的博客
10-25 3824
!-- 引入Jackson依赖-->@Bean //RedisConnectionFactory不需要我们创建Spring会帮助我们创建// 1.创建RedisTemplate对象// 2.设置连接工厂// 3.创建JSON序列化工具// 4.设置Key的序列化// 5.设置Value的序列化 jsonRedisSerializer使我们第三步new出来的// 6.返回}}@Test。
Springboot + redis操作多种实现（以及Jedis,Redisson,Lettuce的区别比较）
诗和远方，任重道远
10-16 1万+
Springboot + redis 操作多种实现一、Jedis,Redisson,Lettuce三者的区别二、Jedis三、RedisTemplate3.1、使用配置3.2、使用示例3.3、扩展3.3.1、spring-boot-starter-data-redis的依赖包3.3.2、stringRedisTemplate API（部分展示）3.3.3 StringRedisTemplate默认...
Java整合Redis高性能框架Lettuce单机版实例
qq_39004108的博客
02-15 2558
Lettuce配置： /** * Lettuce客户端配置 */ @Configuration public class LettuceRedisConfig { @Value("${spring.redis.database}") private int database; @Value("${spring.redis.host}") private String host; @Value("${spring.redis.password}") .
spring-data-redis 集成lettuce
u012693823的博客
07-23 612
背景 一、使用方法 二、客户端 1、java sample 2、配置文件 三、参数说明 四、其它的一些问题 背景 经过大量的性能测试以及综合评估之后，我们决定推出lettuce作为redis的客户端，本文将详细说明lettuce的接入、使用，并给出"合理"的配置推荐 一、使用方法 使用spring-boot-starter全家桶 注2.4.1.RELEASE 使用的是最新的Lettuce6.0.1.RELEASE (注： redis 6.x 使用了 resp3.0，可使用...
Springdata redis与jedis关系
DONGHONGBAI的专栏
03-02 2598
注：本文转自https://www.jianshu.com/p/c7b4cd47ad65 对于刚接触Spring boot data-redis 的同学，与jedis的关系很容易搞混，这里对data-redis于jedis做一个简单的说明，并提供整合方式 1. 区别与关系 jedis jedis是redis的java客户端，通过它可以对redis进行操作。与之功能相似的还包括：Lettuce...
基于SpringBoot2.0默认使用Redis连接池的配置操作
yonghutwo的专栏
05-08 2080
https://www.jb51.net/article/201224.htm SpringBoot2.0默认采用Lettuce客户端来连接Redis服务端的 默认是不使用连接池的，只有配置 redis.lettuce.pool下的属性的时候才可以使用到redis连接池 1 2 3 4 5 6 7 8 9 10 11 redis: cluster: nodes: ${re...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值