springboot 使用redis和lettuce原理

springboot使用redis

简介

在Spring Boot中，要访问Redis，可以直接引入spring-boot-starter-data-redis依赖，它实际上是Spring Data的一个子项目——Spring Data Redis，主要用到了这几个组件：

Lettuce：一个基于Netty的高性能Redis客户端；
RedisTemplate：一个类似于JdbcTemplate的接口，用于简化Redis的操作

客户端配置

首要任务便是，连接客户端，获取连接句柄。spring提供了RedisConnection来标识一个连接，使用RedisConnectionFactory来创建连接。

方法一： yml配置，默认为Lettuce

 1 spring:
 2       redis:
 3         # Redis数据库索引（默认为0）
 4         database: 0
 5         # Redis服务器地址
 6         host: 127.0.0.1
 7         # Redis服务器连接端口
 8         port: 6379
 9         # 连接超时时间（毫秒）
10         timeout: 5000

View Code

方法二：bean注入

1 @Bean
2 public LettuceConnectionFactory redisConnectionFactory() {
3     return new LettuceConnectionFactory(new RedisStandaloneConfiguration("127.0.0.1", 6379));
4 }
5  
6 @Bean
7 public JedisConnectionFactory redisConnectionFactory() {
8     return new JedisConnectionFactory(new RedisStandaloneConfiguration("127.0.0.1", 6379));
9 }

View Code

工具类

RedisTemplate属于org.springframework.data.redis.core，是redis模块的核心，支持多种特性并对redis操作进行了高度抽象。

操作

Interface	Description
Interface	Description
Key Type Operations
`GeoOperations`	Redis geospatial operations, such as `GEOADD`, `GEORADIUS`,…
`HashOperations`	Redis hash operations
`HyperLogLogOperations`	Redis HyperLogLog operations, such as `PFADD`, `PFCOUNT`,…
`ListOperations`	Redis list operations
`SetOperations`	Redis set operations
`ValueOperations`	Redis string (or value) operations
`ZSetOperations`	Redis zset (or sorted set) operations
Key Bound Operations
`BoundGeoOperations`	Redis key bound geospatial operations
`BoundHashOperations`	Redis hash key bound operations
`BoundKeyOperations`	Redis key bound operations
`BoundListOperations`	Redis list key bound operations
`BoundSetOperations`	Redis set key bound operations
`BoundValueOperations`	Redis string (or value) key bound operations
`BoundZSetOperations`	Redis zset (or sorted set) key bound operations

使用无太大区别：

 1  // 地理缓存
 2   public void testGeoSpatial(){//reids 3.2版本之后支持
 3      String citys = "citys";
 4      String chengdu = "chengdu";
 5      String beijing = "beijing";
 6      String chongqing = "beijing";
 7      String luzhou = "beijing";
 8      GeoOperations<String, String> geoOperations = redisTemplate.opsForGeo();
 9      geoOperations.add(citys,new RedisGeoCommands.GeoLocation<String>(chengdu,new Point(104,30)));
10      geoOperations.add(citys,new Point(116,40),beijing);
11      geoOperations.add(citys,new Point(106,29),chongqing);
12      geoOperations.add(citys,new Point(105,25),luzhou);
13  
14      System.out.println(geoOperations.position(citys, "chengdu"));//获取成都经纬度
15      System.out.println(geoOperations.distance(citys, chengdu, beijing));//获取两地距离
16  
17      Point center = new Point(104,30);//定义中心点
18      Distance radius = new Distance(800, Metrics.KILOMETERS);//定义范围
19      Circle within = new Circle(center, radius);
20      //返回范围内的城市
21      System.out.println(geoOperations.radius(citys, within));
22      //根据距离排序,返回最近的两个
23      RedisGeoCommands.GeoRadiusCommandArgs args = RedisGeoCommands.GeoRadiusCommandArgs.
24              newGeoRadiusArgs().includeDistance().limit(2).sortAscending();
25      System.out.println(geoOperations.radius(citys, within, args));
26  
27  }
28  
29   // 计数缓存
30   void hyperLogLogTest() {
31     HyperLogLogOperations hyperLogLogOperations = redisTemplate.opsForHyperLogLog();
32     // 添加元素
33     Long add = hyperLogLogOperations.add("20220628:uv", "ip1", "ip2", "ip3");
34     System.out.println("add : " + add);
35  
36     hyperLogLogOperations.add("20220629:uv", "ip1", "ip2", "ip3", "ip4", "ip5");
37     hyperLogLogOperations.add("20220630:uv", "ip2", "ip4", "ip5", "ip6", "ip7", "ip8");
38  
39     // 获取元素基数
40     Long size = hyperLogLogOperations.size("20220628:uv", "20220629:uv");
41     System.out.println("size : " + size);
42  
43     // 合并多个元素
44     Long result = hyperLogLogOperations.union("unionResult", "20220628:uv", "20220629:uv", "20220630:uv");
45     System.out.println("result : " + result);
46     Long unionResult = hyperLogLogOperations.size("unionResult");
47     System.out.println("unionResult : " + unionResult);
48 }

额外提供了地理类型和计数类型操作

序列化

RedisTemplate是基于java的序列化器进行操作。

序列化器

RedisTemplate与StringRedisTemplate的区别

两者的关系是StringRedisTemplate继承RedisTemplate。

RedisTemplate默认使用JDK序列化策略，StringRedisTemplate默认使用String序列化策略。建议使用key为string，value为json。

 1 @Bean
 2 public RedisTemplate<String, Object> template(RedisConnectionFactory factory) {
 3     // 创建RedisTemplate<String, Object>对象
 4     RedisTemplate<String, Object> template = new RedisTemplate<>();
 5     // 配置连接工厂
 6     template.setConnectionFactory(factory);
 7     // 定义Jackson2JsonRedisSerializer序列化对象
 8     Jackson2JsonRedisSerializer<Object> jacksonSeial = new Jackson2JsonRedisSerializer<>(Object.class);
 9     ObjectMapper                        om           = new ObjectMapper();
10     // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
11     om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
12     // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会报异常
13     om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
14     jacksonSeial.setObjectMapper(om);
15     StringRedisSerializer stringSerial = new StringRedisSerializer();
16     // redis key 序列化方式使用stringSerial
17     template.setKeySerializer(stringSerial);
18     // redis value 序列化方式使用jackson
19     template.setValueSerializer(jacksonSeial);
20     // redis hash key 序列化方式使用stringSerial
21     template.setHashKeySerializer(stringSerial);
22     // redis hash value 序列化方式使用jackson
23     template.setHashValueSerializer(jacksonSeial);
24     // 默认序列化器 , 给cache用
25     template.setDefaultSerializer(stringSerial);
26     // tmplate实现了InitializingBean.afterPropertiesSet接口，注入bean需要手动调用
27     template.afterPropertiesSet();
28     return template;
29 }
30  
31 // 设置默认值
32 public void afterPropertiesSet() {
33     super.afterPropertiesSet();
34     boolean defaultUsed = false;
35     // 默认使用jdk序列化
36     if (this.defaultSerializer == null) {
37         this.defaultSerializer = new JdkSerializationRedisSerializer(this.classLoader != null ? this.classLoader : this.getClass().getClassLoader());
38     }
39  
40     if (this.enableDefaultSerializer) {
41         if (this.keySerializer == null) {
42             this.keySerializer = this.defaultSerializer;
43             defaultUsed = true;
44         }
45  
46         if (this.valueSerializer == null) {
47             this.valueSerializer = this.defaultSerializer;
48             defaultUsed = true;
49         }
50  
51         if (this.hashKeySerializer == null) {
52             this.hashKeySerializer = this.defaultSerializer;
53             defaultUsed = true;
54         }
55  
56         if (this.hashValueSerializer == null) {
57             this.hashValueSerializer = this.defaultSerializer;
58             defaultUsed = true;
59         }
60     }
61  
62     if (this.enableDefaultSerializer && defaultUsed) {
63         Assert.notNull(this.defaultSerializer, "default serializer null and not all serializers initialized");
64     }
65  
66     if (this.scriptExecutor == null) {
67         this.scriptExecutor = new DefaultScriptExecutor(this);
68     }
69  
70     this.initialized = true;
71 }

通过bean注入生成redistemplate

lettuce 原理及参数说明调优

　　概念

　 Lettuce是一个高性能redis客户端，底层基于netty框架来管理连接，天然是非阻塞和线程安全的。

　netty框架

Netty是一个异步的，事件驱动的网络应用程序框架。

特点

IO 线程模型：Netty的io线程模型采取了reactor主从模型，拥有很好的处理高并发的能力。
内存零拷贝：尽量减少不必要的内存拷贝，实现了更高效率的传输。
内存池设计：申请的内存可以重用，主要指直接内存。内部实现是用一颗二叉查找树管理内存分配情况。
串形化处理读写：避免使用锁带来的性能开销。
高性能序列化协议：支持 protobuf 等高性能序列化协议

reactor模型

其实就是对io多路复用(select/epoll)的一种应用。

特点

基于 I/O 复用模型：多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象等待，无需阻塞等待所有连接。当某个连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理。Reactor 对应的叫法: 1. 反应器模式 2. 分发者模式(Dispatcher) 3. 通知者模式(notifier)，我更倾向于叫分发者模式。
基于线程池复用线程资源：不必再为每个连接创建线程，将连接完成后的业务处理任务分配给线程进行处理，一个线程可以处理多个连接的业务。

netty模型

模型说明：

Netty将Selector以及Selector相关的事件及任务封装了NioEventLoop，这样BossGroup就可以通过管理NioEventLoop去管理各个Selector。
同时，Netty模型中主要存在两个大的线程池组BossGroup和WorkerGroup，用于管理主Reactor线程和从Reactor线程。
Netty抽象出两组线程池，BossGroup专门负责接收客户端的连接，WorkerGroup专门负责网络的读写
BossGroup和WorkerGroup类型的本质都是NioEventLoopGroup类型。
NioEventLoopGroup相当于一个线程管理器（类似于ExecutorServevice），它下面维护很多个NioEventLoop线程。
1. 在初始化这两个Group线程组时，默认会在每个Group中生成CPU*2个NioEventLoop线程
2. 当n个连接来了，Group默认会按照连接请求的顺序分别将这些连接分给各个NioEventLoop去处理。
3. 同时Group还负责管理EventLoop的生命周期。
NioEventLoop表示一个不断循环的执行处理任务的线程
1. 它维护了一个线程和任务队列。
2. 每个NioEventLoop都包含一个Selector，用于监听绑定在它上面的socket通讯。
3. 每个NioEventLoop相当于Selector，负责处理多个Channel上的事件
4. 每增加一个请求连接，NioEventLoopGroup就将这个请求依次分发给它下面的NioEventLoop处理。
每个Boss NioEventLoop循环执行的步骤有3步：
1. 轮询accept事件
2. 处理accept事件，与client建立连接，生成NioSocketChannel，并将其注册到某个Worker NioEventLoop的selector上。
3. 处理任务队列到任务，即runAllTasks
每个Worker NioEventLoop循环执行的步骤：
1. 轮询read，write事件
2. 处理I/O事件，即read，write事件，在对应的NioSocketChannel中进行处理
3. 处理任务队列的任务，即runAllTasks
每个 Worker NioEventLoop处理业务时，会使用pipeline（管道）<数据结构为双向链表>，pipeline中维护了一个ChannelHandlerContext链表，而ChannelHandlerContext则保存了Channel相关的所有上下文信息，同时关联一个ChannelHandler对象。如图所示，Channel和pipeline一一对应，ChannelHandler和ChannelHandlerContext一一对应 由此可见每个worker上面通过pipeline管理多个socket的io操作。

ChannelHandler 是一个接口，负责处理或拦截I/O操作，并将其转发到Pipeline中的下一个处理Handler进行处理。

异步ChannelFuture，表示 Channel 中异步 I/O 操作的结果，在 Netty 中所有的 I/O 操作都是异步的，I/O 的调用会直接返回，调用者并不能立刻获得结果，但是可以通过 ChannelFuture 来获取 I/O 操作的处理状态。

redis:
    lettuce:
        pool:
            #最大连接数
            max-active: 50
            #最大阻塞等待时间
            max-wait: 5000
            #连接池中最大空闲连接
            max-idle: 10
            #连接池中最小空闲连接
            min-idle: 5
            #eviction线程调度时间间隔
            time-between-eviction-runs: 1

连接池配置

// springboot实例化bean入口
@Bean
@ConditionalOnMissingBean({RedisConnectionFactory.class})
LettuceConnectionFactory redisConnectionFactory(ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers, ClientResources clientResources) throws UnknownHostException {
    // 获取LettuceClientConfiguration配置
    LettuceClientConfiguration clientConfig = this.getLettuceClientConfiguration(builderCustomizers, clientResources, this.getProperties().getLettuce().getPool());
    // 构造LettuceConnectionFactory
    return this.createLettuceConnectionFactory(clientConfig);
}
//  初始化的过程会判断是单点模式/集群模式/哨兵模式，来初始化连接工厂
private LettuceConnectionFactory createLettuceConnectionFactory(LettuceClientConfiguration clientConfiguration) {
    if (this.getSentinelConfig() != null) {
        return new LettuceConnectionFactory(this.getSentinelConfig(), clientConfiguration);
    } else {
        return this.getClusterConfiguration() != nul l ? new LettuceConnectionFactory(this.getClusterConfiguration(), clientConfiguration) : new LettuceConnectionFactory(this.getStandaloneConfig(), clientConfiguration);
    }
}
 
 
 
//  LettuceConnectionFactory构造
public LettuceConnectionFactory(RedisStandaloneConfiguration standaloneConfig, LettuceClientConfiguration clientConfig) {
    this(clientConfig);
    Assert.notNull(standaloneConfig, "RedisStandaloneConfiguration must not be null!");
    this.standaloneConfig = standaloneConfig;
    this.configuration = this.standaloneConfig;
}
 
 
// InitializingBean.afterPropertiesSet
public void afterPropertiesSet() {
    this.client = this.createClient();
    // lettuce默认提供了两种实现：有pool配置为LettucePoolingConnectionProvider 没有则为StandaloneConnectionProvider
    this.connectionProvider = this.createConnectionProvider(this.client, LettuceConnection.CODEC);     
    this.reactiveConnectionProvider = this.createConnectionProvider(this.client, LettuceReactiveRedisConnection.CODEC);
    // ...
}

构造过程

  1 /**
  2  * 从调用链看实现: redisTemplate.opsForValue().get(key)
  3  */
  4 1.RedisTemplate.execute()
  5 public <T> T execute(RedisCallback<T> action, boolean exposeConnection, boolean pipeline) {
  6     // ..
  7     RedisConnection conn = RedisConnectionUtils.getConnection(factory);
  8     // ..
  9     T result = action.doInRedis(connToExpose);
 10     // ..
 11     finally {
 12     RedisConnectionUtils.releaseConnection(conn, factory, this.enableTransactionSupport);
 13     }
 14      
 15 }
 16  
 17 2.获取连接类
 18 LettuceConnectionFactory.getConnection()
 19 // 工厂生成连接类
 20 public RedisConnection getConnection() {
 21         // getSharedConnection() 实例化了一个连接
 22         LettuceConnection connection = this.doCreateLettuceConnection(this.getSharedConnection(), this.connectionProvider, this.getTimeout(), this.getDatabase());
 23         connection.setConvertPipelineAndTxResults(this.convertPipelineAndTxResults);
 24         return connection;
 25 }
 26  
 27 3.连接类执行
 28 3.1 DefaultedRedisConnection.get() // RedisConnection爷爷类
 29 3.2 LettuceStringCommands.get()
 30     public byte[] get(byte[] key) {
 31     // ... 最终执行命令类调用，会触发dispatcher的转发,将请求转为为命令类发送给服务器，服务器解析命令调用对应的命令处理参数,最后服务器最后会写会到命令输出区。
 32     return (byte[])this.getConnection().get(key);
 33     }
 34 3.3 获取连接
 35 LettuceConnection.getConnection()
 36 protected RedisClusterCommands<byte[], byte[]> getConnection() {
 37     if (this.isQueueing()) {
 38         return this.getDedicatedConnection();
 39     } else {
 40         // 获取共享连接
 41         if (this.asyncSharedConn != null) {
 42             if (this.asyncSharedConn instanceof StatefulRedisConnection) {
 43                 return ((StatefulRedisConnection)this.asyncSharedConn).sync();
 44             }
 45  
 46             if (this.asyncSharedConn instanceof StatefulRedisClusterConnection) {
 47                 return ((StatefulRedisClusterConnection)this.asyncSharedConn).sync();
 48             }
 49         }
 50         // 从客户端获取, 并设置共享连接
 51         return this.getDedicatedConnection();
 52     }
 53 }
 54 // 获取Command类，提供api调用redis操作
 55 RedisClusterCommands<byte[], byte[]> getDedicatedConnection() {
 56     StatefulConnection<byte[], byte[]> connection = this.getOrCreateDedicatedConnection(); // 根据支持器获取StatefulRedisConnection
 57     if (connection instanceof StatefulRedisConnection) {
 58         return ((StatefulRedisConnection)connection).sync();  // StatefulRedisConnection提供Command类来执行命令
 59     } else if (connection instanceof StatefulRedisClusterConnection) {
 60         return ((StatefulRedisClusterConnection)connection).sync();
 61     } else {
 62         throw new IllegalStateException(String.format("%s is not a supported connection type.", connection.getClass().getName()));
 63     }
 64 }
 65 3.4 根据支持器获取真正的连接
 66 // StandaloneConnectionProvider
 67 Lpublic <T extends StatefulConnection<?, ?>> T getConnection(Class<T> connectionType) {
 68     // ..
 69     return this.client.connect(this.codec);
 70     // ..
 71 }
 72 // 最底层就是基于netty的接口调用了
 73 RedisClient.connect()
 74 private void initializeChannelAsync0(ConnectionBuilder connectionBuilder, CompletableFuture<Channel> channelReadyFuture,
 75             SocketAddress redisAddress) {
 76   
 77         logger.debug("Connecting to Redis at {}", redisAddress);
 78          
 79         
 80         Bootstrap redisBootstrap = connectionBuilder.bootstrap();
 81   
 82         RedisChannelInitializer initializer = connectionBuilder.build();
 83         redisBootstrap.handler(initializer);
 84   
 85         clientResources.nettyCustomizer().afterBootstrapInitialized(redisBootstrap);
 86         CompletableFuture<Boolean> initFuture = initializer.channelInitialized();
 87         ChannelFuture connectFuture = redisBootstrap.connect(redisAddress);
 88 //省略部分代码   
 89 }
 90 // LettucePoolingConnectionProvider
 91 public <T extends StatefulConnection<?, ?>> T getConnection(Class<T> connectionType) {
 92     // 初次调用会创建线程池
 93     GenericObjectPool pool = (GenericObjectPool)this.pools.computeIfAbsent(connectionType, (poolType) -> {
 94         return ConnectionPoolSupport.createGenericObjectPool(() -> {
 95             return this.connectionProvider.getConnection(connectionType); //创建连接的回调函数, 其实就是调用上方StandaloneConnectionProvider.getConnection
 96         }, this.poolConfig, false);
 97     });
 98  
 99     try {
100         // 从池子里获取一个连接
101         StatefulConnection<?, ?> connection = (StatefulConnection)pool.borrowObject();
102         this.poolRef.put(connection, pool);
103         return (StatefulConnection)connectionType.cast(connection);
104     } catch (Exception var4) {
105         throw new PoolException("Could not get a resource from the pool", var4);
106     }
107 }
108 3.5 获取一个连接
109 public T borrowObject(long borrowMaxWaitMillis) throws Exception {
110     // ...
111  
112     PooledObject<T> p = null;
113     boolean blockWhenExhausted = this.getBlockWhenExhausted();
114     long waitTime = System.currentTimeMillis();
115  
116     while(p == null) {
117         boolean create = false;
118         // 从闲置获取连接
119         p = (PooledObject)this.idleObjects.pollFirst();
120         if (p == null) {
121             // 获取不到则创建，调用的是传入的回调函数
122             p = this.create();
123             if (p != null) {
124                 create = true;
125             }
126         }
127     }   
128     // ..       
129     return p.getObject();
130 }
131 3.6 释放连接
132 public void returnObject(T obj) {
133     //...
134     int maxIdleSave = this.getMaxIdle();
135     if (this.isClosed() || maxIdleSave > -1 && maxIdleSave <= this.idleObjects.size()) {
136         try {
137             this.destroy(p);
138         } catch (Exception var12) {
139             this.swallowException(var12);
140         }
141      
142         try {
143             this.ensureIdle(1, false);
144         } catch (Exception var11) {
145             this.swallowException(var11);
146         }
147     } else {
148         if (this.getLifo()) {
149             this.idleObjects.addFirst(p);
150         } else {
151             this.idleObjects.addLast(p);
152         }
153      
154         if (this.isClosed()) {
155             this.clear();
156         }
157     }
158 }

调用链流程：

posted @ 2022-12-25 17:03 Duikerdd 阅读(2513) 评论(0) 编辑收藏举报

刷新页面返回顶部

Duikerdd

springboot 使用redis和lettuce原理

springboot使用redis

简介

客户端配置

工具类

操作

序列化

序列化器

RedisTemplate与StringRedisTemplate的区别

lettuce 原理及参数说明调优

概念

netty框架

特点

reactor模型

特点

netty模型

模型说明：

公告

　　概念

　netty框架