脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → SpringBoot集成Lettuce连接Redis

关于SpringBoot集成Lettuce连接Redis的方法和案例

 更新时间：2023年04月22日 09:09:55   作者：帅气的梧桐述  
这篇文章主要介绍了关于SpringBoot集成Lettuce连接Redis的方法和案例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

首先使用maven在pom.xml添加如下依赖

说明：

  • SpringBoot从2.0起默认使用lettuce客户端进行连接。
  • 此次使用的版本：springboot：2.6.6，lettuce：6.1.8。
<dependency> 
  <groupId>org.springframework.boot</groupId>  
  <artifactId>spring-boot-starter-web</artifactId>  
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>  
  <artifactId>spring-boot-starter-data-redis</artifactId>  
</dependency>

 使用SpringBoot集成Lettuce连接实例

Springboot+Lettuce单连方式连接Redis单机/主备/Proxy集群示例。

1、在application.properties配置文件中加上redis相关配置。 

spring.redis.host=host  
spring.redis.database=0  
spring.redis.password=pwd 
spring.redis.port=port

2、Redis配置类RedisConfiguration。

@Bean  
public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {   
    RedisTemplate<String, Object> template = new RedisTemplate<>();  
    template.setConnectionFactory(lettuceConnectionFactory);  
    //使用Jackson2JsonRedisSerializer替换默认的JdkSerializationRedisSerializer来序列化和反序列化redis的value值  
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);  
    ObjectMapper mapper = new ObjectMapper();  
    mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
    mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,  
        ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);  
    jackson2JsonRedisSerializer.setObjectMapper(mapper);  
    StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();  
    //key采用String的序列化方式  
    template.setKeySerializer(stringRedisSerializer);  
    // hash的key也采用String的序列化方式  
    template.setHashKeySerializer(stringRedisSerializer);  
    // value序列化方式采用jackson  
    template.setValueSerializer(jackson2JsonRedisSerializer);  
    // hash的value序列化方式采用jackson  
    template.setHashValueSerializer(jackson2JsonRedisSerializer);  
    template.afterPropertiesSet();  
    return template;  
}

3、Redis操作类RedisUtil。

 /** 
  * 普通缓存获取 
  * @param key 键 
  * @return 值 
  */  
 public Object get(String key){  
     return key==null?null:redisTemplate.opsForValue().get(key);  
 }  
 
 /** 
  * 普通缓存放入 
  * @param key 键 
  * @param value 值 
  * @return true成功 false失败 
  */  
 public boolean set(String key,Object value) {  
     try {  
         redisTemplate.opsForValue().set(key, value);  
         return true;  
     } catch (Exception e) {  
         e.printStackTrace();  
         return false;  
     }  
 }

4、编写controller类进行测试。

@RestController  
public class HelloRedis {  
    @Autowired  
    RedisUtil redisUtil;  
 
 
    @RequestMapping("/setParams")  
    @ResponseBody  
    public String setParams(String name) {  
	    redisUtil.set("name", name);  
	    return "success";  
	}  
	
    @RequestMapping("/getParams")  
    @ResponseBody  
    public String getParams(String name) {  
	   System.out.println("--------------" + name + "-------------");  
	   String retName = redisUtil.get(name) + "";  
	   return retName;  
	}  
	
}

SpringBoot+Lettuce连接池方式连接Redis单机/主备/Proxy集群示例。

 1、在上边maven依赖的基础上添加以下依赖。

<dependency>  
  <groupId>org.apache.commons</groupId>  
  <artifactId>commons-pool2</artifactId>  
</dependency>

2、在application.properties配置文件中加上redis相关配置。

spring.redis.host=host  
spring.redis.database=0  
spring.redis.password=pwd  
spring.redis.port=port  
# 连接超时时间  
spring.redis.timeout=1000  
# 连接池最大连接数（使用负值表示没有限制）  
spring.redis.lettuce.pool.max-active=50  
# 连接池中的最小空闲连接  
spring.redis.lettuce.pool.min-idle=5  
# 连接池中的最大空闲连接  
spring.redis.lettuce.pool.max-idle=50  
# 连接池最大阻塞等待时间（使用负值表示没有限制）  
spring.redis.lettuce.pool.max-wait=5000  
#eviction线程调度时间间隔  
spring.redis.pool.time-between-eviction-runs-millis=2000

 这里最后的这个配置：spring.redis.pool.time-between-eviction-runs-millis=2000 在某些版本中会不生效，需要自己DEBUG看一下

LettuceConnectionFactory

实例里边有没设置成功，如果没有则调整成如下配置：

spring.redis.lettuce.pool.time-between-eviction-runs=2000

3、Redis连接配置类RedisConfiguration。

@Bean  
public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {  
    lettuceConnectionFactory.setShareNativeConnection(false);  
    RedisTemplate<String, Object> template = new RedisTemplate<>();  
    template.setConnectionFactory(lettuceConnectionFactory);  
    //使用Jackson2JsonRedisSerializer替换默认的JdkSerializationRedisSerializer来序列化和反序列化redis的value值  
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);  
    ObjectMapper mapper = new ObjectMapper();  
    mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
    mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,  
        ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);  
    jackson2JsonRedisSerializer.setObjectMapper(mapper);  
    StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();  
    //key采用String的序列化方式  
    template.setKeySerializer(stringRedisSerializer);  
    // hash的key也采用String的序列化方式  
    template.setHashKeySerializer(stringRedisSerializer);  
    // value序列化方式采用jackson  
    template.setValueSerializer(jackson2JsonRedisSerializer);  
    // hash的value序列化方式采用jackson  
    template.setHashValueSerializer(jackson2JsonRedisSerializer);  
    template.afterPropertiesSet();  
    return template;  
}

SpringBoot+Lettuce单连接方式连接Redis Cluster集群代码示例。

1、在application.properties配置文件中加上redis相关配置。

spring.redis.cluster.nodes=host:port  
spring.redis.cluster.max-redirects=3  
spring.redis.password= pwd 
# 自动刷新时间 
spring.redis.lettuce.cluster.refresh.period=60
# 开启自适应刷新  
spring.redis.lettuce.cluster.refresh.adaptive=true  
spring.redis.timeout=60

2、Redis配置类RedisConfiguration，请务必开启集群自动刷新拓扑配置。

@Bean  
public LettuceConnectionFactory lettuceConnectionFactory() {  
     String[] nodes = clusterNodes.split(",");  
     List<RedisNode> listNodes = new ArrayList();  
     for (String node : nodes) {  
         String[] ipAndPort = node.split(":");  
         RedisNode redisNode = new RedisNode(ipAndPort[0], Integer.parseInt(ipAndPort[1]));  
         listNodes.add(redisNode);  
     }  
     RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();  
     redisClusterConfiguration.setClusterNodes(listNodes);  
     redisClusterConfiguration.setPassword(password);  
     redisClusterConfiguration.setMaxRedirects(maxRedirects);  
      // 配置集群自动刷新拓扑 
     ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()  
         .enablePeriodicRefresh(Duration.ofSeconds(period)) //按照周期刷新拓扑  
         .enableAllAdaptiveRefreshTriggers() //根据事件刷新拓扑  
         .build();  
 
     ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()  
         //redis命令超时时间,超时后才会使用新的拓扑信息重新建立连接  
         .timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(period)))  
         .topologyRefreshOptions(topologyRefreshOptions)  
         .build();  
     LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()  
             .commandTimeout(Duration.ofSeconds(timeout))   
             .readFrom(ReadFrom.REPLICA_PREFERRED) // 优先从副本读取  
             .clientOptions(clusterClientOptions)  
             .build();  
     LettuceConnectionFactory factory = new LettuceConnectionFactory(redisClusterConfiguration, clientConfig);  
     return factory;  
}  
 
@Bean  
public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {  
    RedisTemplate<String, Object> template = new RedisTemplate<>();  
    template.setConnectionFactory(lettuceConnectionFactory);  
    //使用Jackson2JsonRedisSerializer替换默认的JdkSerializationRedisSerializer来序列化和反序列化redis的value值  
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);  
    ObjectMapper mapper = new ObjectMapper();  
    mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
    mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,  
        ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);  
    jackson2JsonRedisSerializer.setObjectMapper(mapper);  
    StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();  
    //key采用String的序列化方式  
    template.setKeySerializer(stringRedisSerializer);  
    // hash的key也采用String的序列化方式  
    template.setHashKeySerializer(stringRedisSerializer);  
    // value序列化方式采用jackson  
    template.setValueSerializer(jackson2JsonRedisSerializer);  
    // hash的value序列化方式采用jackson  
    template.setHashValueSerializer(jackson2JsonRedisSerializer);  
    template.afterPropertiesSet();  
    return template;  
}

springboot+lettuce连接池方式连接Redis Cluster集群代码示例。

1、在application.properties配置文件中加上Redis相关配置。

spring.redis.cluster.nodes=host:port  
spring.redis.cluster.max-redirects=3  
spring.redis.password=pwd 
spring.redis.lettuce.cluster.refresh.period=60  
spring.redis.lettuce.cluster.refresh.adaptive=true  
# 连接超时时间 
spring.redis.timeout=60s   
# 连接池最大连接数（使用负值表示没有限制）  
spring.redis.lettuce.pool.max-active=50  
# 连接池中的最小空闲连接  
spring.redis.lettuce.pool.min-idle=5  
# 连接池中的最大空闲连接  
spring.redis.lettuce.pool.max-idle=50  
# 连接池最大阻塞等待时间（使用负值表示没有限制）  
spring.redis.lettuce.pool.max-wait=5000  
#eviction线程调度时间间隔  
spring.redis.lettuce.pool.time-between-eviction-runs=2000

2、redis配置类RedisConfiguration，请务必开启集群自动刷新拓扑配置。

@Bean  
 public LettuceConnectionFactory lettuceConnectionFactory() {  
     GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();  
     genericObjectPoolConfig.setMaxIdle(maxIdle);  
     genericObjectPoolConfig.setMinIdle(minIdle);  
     genericObjectPoolConfig.setMaxTotal(maxActive);  
     genericObjectPoolConfig.setMaxWait(Duration.ofMillis(maxWait));  
     genericObjectPoolConfig.setTimeBetweenEvictionRuns(Duration.ofMillis(timeBetweenEvictionRunsMillis));  
     String[] nodes = clusterNodes.split(",");  
     List<RedisNode> listNodes = new ArrayList();  
     for (String node : nodes) {  
         String[] ipAndPort = node.split(":");  
         RedisNode redisNode = new RedisNode(ipAndPort[0], Integer.parseInt(ipAndPort[1]));  
         listNodes.add(redisNode);  
     }  
     RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();  
     redisClusterConfiguration.setClusterNodes(listNodes);  
     redisClusterConfiguration.setPassword(password);  
     redisClusterConfiguration.setMaxRedirects(maxRedirects);  
      // 配置集群自动刷新拓扑 
     ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()  
         .enablePeriodicRefresh(Duration.ofSeconds(period)) //按照周期刷新拓扑  
         .enableAllAdaptiveRefreshTriggers() //根据事件刷新拓扑  
         .build();  
 
     ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()  
         //redis命令超时时间,超时后才会使用新的拓扑信息重新建立连接  
         .timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(period)))  
         .topologyRefreshOptions(topologyRefreshOptions)  
         .build();  
     LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()  
             .commandTimeout(Duration.ofSeconds(timeout))  
             .poolConfig(genericObjectPoolConfig)  
             .readFrom(ReadFrom.REPLICA_PREFERRED) // 优先从副本读取  
             .clientOptions(clusterClientOptions)  
             .build();  
     LettuceConnectionFactory factory = new LettuceConnectionFactory(redisClusterConfiguration, clientConfig);  
     return factory;  
 }  
 
@Bean  
public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {  
    lettuceConnectionFactory.setShareNativeConnection(false);  
    RedisTemplate<String, Object> template = new RedisTemplate<>();  
    template.setConnectionFactory(lettuceConnectionFactory);  
    //使用Jackson2JsonRedisSerializer替换默认的JdkSerializationRedisSerializer来序列化和反序列化redis的value值  
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);  
    ObjectMapper mapper = new ObjectMapper();  
    mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);  
    mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,  
        ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);  
    jackson2JsonRedisSerializer.setObjectMapper(mapper);  
    StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();  
    //key采用String的序列化方式  
    template.setKeySerializer(stringRedisSerializer);  
    // hash的key也采用String的序列化方式  
    template.setHashKeySerializer(stringRedisSerializer);  
    // value序列化方式采用jackson  
    template.setValueSerializer(jackson2JsonRedisSerializer);  
    // hash的value序列化方式采用jackson  
    template.setHashValueSerializer(jackson2JsonRedisSerializer);  
    template.afterPropertiesSet();  
    return template;  
}

推荐使用连接池方式。

到此这篇关于关于SpringBoot集成Lettuce连接Redis的方法和案例的文章就介绍到这了,更多相关SpringBoot集成Lettuce连接Redis内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • SpringBoot获取Request请求的三种方式小结

    SpringBoot获取Request请求的三种方式小结

    本文介绍了SpringBoot中获取Request对象的三种方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2024-12-12
  • Springboot中yml文件没有叶子图标的解决

    Springboot中yml文件没有叶子图标的解决

    这篇文章主要介绍了Springboot中yml文件没有叶子图标的解决方案,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2023-09-09
  • 如何测试Java类的线程安全性

    如何测试Java类的线程安全性

    这篇文章主要介绍了如何测试Java类的线程安全性,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2019-12-12
  • Java设计模式之抽象工厂模式浅析讲解

    Java设计模式之抽象工厂模式浅析讲解

    当系统所提供的工厂所需生产的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构中属于不同类型的具体产品时需要使用抽象工厂模式，抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态
    2022-08-08
  • IDEA解决springboot热部署失效问题(推荐)

    IDEA解决springboot热部署失效问题(推荐)

    热部署，就是在应用正在运行的时候升级软件，却不需要重新启动应用。这篇文章主要介绍了IDEA解决springboot热部署失效问题,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2020-09-09
  • Mybatis日志参数快速替换占位符工具的详细步骤

    Mybatis日志参数快速替换占位符工具的详细步骤

    这篇文章主要介绍了Mybatis日志参数快速替换占位符工具的详细步骤，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2020-08-08
  • 详解SpringCloud Ribbon 负载均衡通过服务器名无法连接的神坑

    详解SpringCloud Ribbon 负载均衡通过服务器名无法连接的神坑

    这篇文章主要介绍了详解SpringCloud Ribbon 负载均衡通过服务器名无法连接的神坑，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2019-06-06
  • JAVA SpringBoot jar程序 Systemctl生产环境部署方案

    JAVA SpringBoot jar程序 Systemctl生产环境部署方案

    这篇文章主要介绍了JAVA SpringBoot jar程序 Systemctl生产环境部署方案,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2025-03-03
  • SpringMvc中容器加载的过程源码详解

    SpringMvc中容器加载的过程源码详解

    这篇文章主要介绍了SpringMvc中容器加载的过程源码详解,springmvc是基于spring的一个web层框架,同样也是web层框架的有struts,struts2等等,但是struts因为漏洞等问题,被慢慢淘汰了,现在基本都在用springmvc,需要的朋友可以参考下
    2023-11-11
  • LeetCode 动态规划之矩阵区域和详情

    LeetCode 动态规划之矩阵区域和详情

    这篇文章主要介绍了LeetCode 动态规划之矩阵区域和详情，文章基于Java的相关资料展开对LeetCode 动态规划的详细介绍，需要的小伙伴可以参考一下
    2022-04-04

最新评论