redisson luttuce 对比 redisson lettuce混用，集成redission starter

1. Redis整合Lettuce池配置多个实例

Redis 是目前业界使用最广泛的内存数据存储。相比 Memcached，Redis 支持更丰富的数据结构，例如 hashes, lists, sets ，sortedsets等。数据库有分库分表，当然redis也能实现mysql一样的分库逻辑。本文介绍 Redis 在 Spring Boot 中分库的应用场景。

2. 快速上手

1、引入依赖包

<!-- 引入 redis 依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 引入 Lettuce池 依赖 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>
<!-- 引入 fastjson 依赖，序列化使用的是fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.44</version> 
</dependency>
 
 

　　

SpringBoot 提供了对 Redis 集成的组件包：spring-boot-starter-data-redis，spring-boot-starter-data-redis依赖于spring-data-redis 和 lettuce 。lettuce使用netty NIO来管理连接对象的，十分高效且线程安全，多个线程可共享一个connection对象。

SpringBoot2.0升级了redis池，从jedis升级到了lettuce，而且用户可无感知的切换到lettuce。

2.添加配置文件

两种添加配置文件的方式，一种是application.properties，另一种是application.yml。读者选择一种即可。

application.properties

#redis db1
spring.redis.redis-onedb.database=1
spring.redis.redis-onedb.hostName=localhost
spring.redis.redis-onedb.port=6379
spring.redis.redis-onedb.timeout=5000
#redis db2
spring.redis.redis-twodb.database=2
spring.redis.redis-twodb.hostName=localhost
spring.redis.redis-twodb.port=6379
spring.redis.redis-twodb.timeout=5000


spring.redis.lettuce.pool.MaxTotal=50
spring.redis.lettuce.pool.minIdle=1
spring.redis.lettuce.pool.maxWaitMillis=5000
spring.redis.lettuce.pool.maxIdle=5
spring.redis.lettuce.pool.testOnBorrow=true
spring.redis.lettuce.pool.testOnReturn=true
spring.redis.lettuce.pool.testWhileIdle=true
 
 

　　

application.yml

spring:
  redis:
    lettuce:
      pool:
        MaxTotal: 50
        minIdle: 1
        maxWaitMillis: 5000
        maxIdle: 5
        testOnBorrow: true
        testOnReturn: true
        testWhileIdle: true
    redis-twodb:
      database: 1
      hostName: localhost
      port: 6379
      timeout: 5000
    redis-onedb:
      database: 2
      hostName: localhost
      port: 6379
      timeout: 5000
 
 

　　

3.配置类RedisConfig

@Configuration
public class RedisConfig {
	
	
@Bean
@ConfigurationProperties(prefix = "spring.redis.lettuce.pool")
@Scope(value = "prototype")
public GenericObjectPoolConfig redisPool(){
    return new GenericObjectPoolConfig();
}

@Bean
@ConfigurationProperties(prefix = "spring.redis.redis-onedb")
public RedisStandaloneConfiguration redisConfigA(){
    return new RedisStandaloneConfiguration();
}


@Primary
@Bean
public LettuceConnectionFactory factoryA(GenericObjectPoolConfig config, RedisStandaloneConfiguration redisConfigA){
    LettuceClientConfiguration clientConfiguration = LettucePoolingClientConfiguration.builder()
            .poolConfig(config).commandTimeout(Duration.ofMillis(config.getMaxWaitMillis())).build();
    return new LettuceConnectionFactory(redisConfigA, clientConfiguration);
}


@Bean(name = "oneRedis")
public StringRedisTemplate redisBusTemplate(@Qualifier("factoryA") LettuceConnectionFactory factoryA){
    StringRedisTemplate template = getRedisTemplate();
    template.setConnectionFactory(factoryA);
    return template;
}



@Bean
@ConfigurationProperties(prefix = "spring.redis.redis-twodb")
public RedisStandaloneConfiguration redisConfigB(){
    return new RedisStandaloneConfiguration();
}

@Bean
public LettuceConnectionFactory factoryB(GenericObjectPoolConfig config, RedisStandaloneConfiguration redisConfigB){
    LettuceClientConfiguration clientConfiguration = LettucePoolingClientConfiguration.builder()
            .poolConfig(config).commandTimeout(Duration.ofMillis(config.getMaxWaitMillis())).build();
    return new LettuceConnectionFactory(redisConfigB, clientConfiguration);
}


@Bean(name = "twoRedis")
public StringRedisTemplate redisLoginTemplate(@Qualifier("factoryB")LettuceConnectionFactory factoryB){
    StringRedisTemplate template = getRedisTemplate();
    template.setConnectionFactory(factoryB);
    return template;
}

private StringRedisTemplate getRedisTemplate(){
    StringRedisTemplate template = new StringRedisTemplate();
    template.setValueSerializer(new GenericFastJsonRedisSerializer());
    template.setValueSerializer(new StringRedisSerializer());
    return template;
}
}
 
 

　　

RedisConfig类中配置的Lettuce多例模式池对象。

@Bean
@ConfigurationProperties(prefix = "spring.redis.lettuce.pool")
@Scope(value = "prototype")
public GenericObjectPoolConfig redisPool(){
    return new GenericObjectPoolConfig();
}
 
 

　　

我们来梳理一下：

  1. RedisTemplate对象 依赖 LettuceConnectionFactory对象；
  2. LettuceConnectionFactory对象 依赖 RedisStandaloneConfiguration池配置对象以及Redis配置对象。
  3. oneRedis->factoryA->redisConfigA + redisPool , twoRedis->factoryB->redisConfigB + redisPool

3. 测试效果

编写测试代码RedisTestor类的run方法。

System.out.println("在db1中设置key的值为：hello db1");
oneRedis.opsForValue().set("key", "hello db1");
System.out.println("在db2中设置key的值为：hello db1");
twoRedis.opsForValue().set("key", "hello db1");

System.out.println("db1中key："+oneRedis.opsForValue().get("key"));
System.out.println("db2中key："+twoRedis.opsForValue().get("key"));
 
 

　　

查看db1、db2的数据

redisson luttuce 对比 redisson lettuce混用_redisson luttuce 对比

redisson luttuce 对比 redisson lettuce混用_mob6454cc714ea1的技术博客_51CTO博客

springboot 集成redission starter_mob64ca12edea6e的技术博客_51CTO博客

Spring Boot 集成 Redisson Starter 教程

在现代的微服务架构中，Redis 作为一个高性能的内存数据库，常常被用来进行数据缓存、消息队列等功能。但在 Spring Boot 项目中直接使用 Redis 客户端可能会增加许多复杂性。为此，Redisson 的出现提供了一个高层次的封装，让我们可以更轻松地与 Redis 进行交互。本文将详细讲解如何在 Spring Boot 项目中集成 Redisson Starter。

整体流程

在开始之前，我们先看一下实现过程的总体步骤：

步骤 描述
1 创建 Spring Boot 项目
2 添加 Redisson Starter 依赖
3 配置 Redisson 连接信息
4 创建一个 Redis 操作服务
5 在控制器中使用该服务
6 运行和测试项目

步骤详细说明

1. 创建 Spring Boot 项目

首先，你需要创建一个 Spring Boot 项目。你可以使用 [Spring Initializr]( 快速生成一个基础项目。在这个项目中，可以选择添加 Web 依赖。

2. 添加 Redisson Starter 依赖

接下来，在 pom.xml 文件中添加 Redisson Starter 依赖。示例如下：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.5</version> <!-- 请确认使用最新版本 -->
</dependency>
 
 

这段代码是在 Maven 中引入 Redisson Starter 的方式，方便我们使用 Redisson 提供的功能。

3. 配置 Redisson 连接信息

在 application.yml 或 application.properties 文件中，添加 Redis 连接配置信息。示例如下：

redisson:
  address: "redis://127.0.0.1:6379"  # Redis 服务器地址
  password: "your_password"           # 如果没有设置密码，可以去掉这一行
 
 

这段代码是用来配置与 Redis 服务的连接信息，确保你的 Redis 服务正在运行，地址、密码填写正确。

4. 创建一个 Redis 操作服务

现在，我们可以创建一个 Redis 操作服务，以便在其他地方使用 Redisson。下面是一个简单的示例：

import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class RedisService {

    @Autowired
    private RedissonClient redissonClient;

    // 保存数据到 Redis
    public void saveData(String key, String value) {
        RBucket<String> bucket = redissonClient.getBucket(key); // 获取 Redis 中的键
        bucket.set(value); // 设置值
    }

    // 从 Redis 中获取数据
    public String getData(String key) {
        RBucket<String> bucket = redissonClient.getBucket(key);
        return bucket.get(); // 获取值
    }
}
 
 

在这一段代码中，我们定义了一个 RedisService 类，它提供了方法用于存储和获取数据。

5. 在控制器中使用该服务

接下来，我们创建一个控制器，并在其中使用 RedisService ：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/redis")
public class RedisController {

    @Autowired
    private RedisService redisService;

    @PostMapping("/save")
    public String save(@RequestParam String key, @RequestParam String value) {
        redisService.saveData(key, value);
        return "Data saved successfully!";
    }

    @GetMapping("/get")
    public String get(@RequestParam String key) {
        return redisService.getData(key);
    }
}
 
 

这个控制器为我们提供了两个 API，一个用于保存数据，另一个用于通过键获取数据。

6. 运行和测试项目

最后，运行你的 Spring Boot 项目，然后在 Postman 或浏览器中进行测试。

# 保存数据
POST http://localhost:8080/redis/save?key=testKey&value=HelloRedisson

# 获取数据
GET http://localhost:8080/redis/get?key=testKey
 
 

序列图

以下是整个流程的序列图，帮助你更直观理解各组件之间的交互：

RedissonClientRedisServiceRedisControllerClientRedissonClientRedisServiceRedisControllerClientsave(key, value)saveData(key, value)getBucket(key)RBucketset(value)successsuccess"Data saved successfully!"get(key)getData(key)getBucket(key)RBucketget()valuevaluevalue

结尾

通过上面的步骤，我们成功地在 Spring Boot 项目中集成了 Redisson Starter，并使用它提供的 API 来操作 Redis 数据。Redisson 的强大功能可以让我们以更简洁的方式与 Redis 互动，非常适合在微服务架构中使用。希望本文对你理解和使用 Redisson Starter 有所帮助！如果有什么问题，欢迎讨论。

与 Spring 集成 - Redisson 参考指南

Element - 网站快速成型工具

ElasticJob - Distributed scheduled job solution

posted @ 2025-02-05 16:29  CharyGao  阅读(314)  评论(0)    收藏  举报