SpringBoot集成Lettuce

本文涉及的产品
云数据库 Redis 版,社区版 2GB
推荐场景:
搭建游戏排行榜
简介: SpringBoot集成Lettuce


SpringBoot从2.0起默认使用lettuce客户端进行连接

参考

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

  • pom
<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> 
spring.redis.host=host   
spring.redis.database=0   
spring.redis.password=pwd  
spring.redis.port=port 
  • Redis配置类
@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;   
}  
  • 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;   
     }   
 }
  • 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集群示例

  • 添加以下依赖
<dependency>   
  <groupId>org.apache.commons</groupId>   
  <artifactId>commons-pool2</artifactId>   
</dependency> 
  • 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 
  • Redis连接配置类
@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集群代码示例

  • 配置文件中加上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
  • Redis配置类,务必开启集群自动刷新拓扑配置
@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集群代码示例

  • 配置文件中加上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
  • redis配置类,务必开启集群自动刷新拓扑配置
@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;   
}  

说明:host为Redis实例的IP地址/域名,port为Redis实例的端口,请按实际情况修改后执行,pwd为创建Redis实例时自定义的密码,请按实际情况修改后执行。推荐使用连接池方式。超时时间(TimeOut),最大连接数(MaxTotal),最小空闲连接(MinIdle),最大空闲连接(MaxIdle),最大等待时间(MaxWait)等相关参数,请根据业务实际来调优


相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务,基于高可靠双机热备架构及可无缝扩展的集群架构,满足高读写性能场景及容量需弹性变配的业务需求。 产品详情:https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验:数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引,您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接,领取免费ECS&amp;RDS资源,30分钟完成数据库上云实战!https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
相关文章
|
1月前
|
前端开发 Java 应用服务中间件
从零手写实现 tomcat-08-tomcat 如何与 springboot 集成?
该文是一系列关于从零开始手写实现 Apache Tomcat 的教程概述。作者希望通过亲自动手实践理解 Tomcat 的核心机制。文章讨论了 Spring Boot 如何实现直接通过 `main` 方法启动,Spring 与 Tomcat 容器的集成方式,以及两者生命周期的同步原理。文中还提出了实现 Tomcat 的启发,强调在设计启动流程时确保资源的正确加载和初始化。最后提到了一个名为 mini-cat(嗅虎)的简易 Tomcat 实现项目,开源于 [GitHub](https://github.com/houbb/minicat)。
|
15天前
|
API Java 监控
SpringBoot基于OpenAPI3的接口文档管理快速集成和使用
本文主要简单介绍SpringCloud2023中进行接口文档管理,方便前后端开发和文档维护。文档管理工具基于开源的knife4j封装的openapi3。
47 3
|
1月前
|
前端开发 Java 应用服务中间件
从零手写实现 tomcat-08-tomcat 如何与 springboot 集成?
本文探讨了Spring Boot如何实现像普通Java程序一样通过main方法启动,关键在于Spring Boot的自动配置、内嵌Servlet容器(如Tomcat)以及`SpringApplication`类。Spring与Tomcat集成有两种方式:独立模式和嵌入式模式,两者通过Servlet规范、Spring MVC协同工作。Spring和Tomcat的生命周期同步涉及启动、运行和关闭阶段,通过事件和监听器实现。文章鼓励读者从实现Tomcat中学习资源管理和生命周期管理。此外,推荐了Netty权威指南系列文章,并提到了一个名为mini-cat的简易Tomcat实现项目。
|
4天前
|
Prometheus Cloud Native Java
springboot集成prometheus异常处理
springboot集成prometheus异常处理
11 2
|
7天前
|
移动开发 前端开发 JavaScript
|
7天前
|
网络协议 JavaScript Java
|
11天前
|
Java Spring
解决Springboot集成ElasticSearch 报错:A bean with that name has already been defined in null and overriding
解决Springboot集成ElasticSearch 报错:A bean with that name has already been defined in null and overriding
|
13天前
|
搜索推荐 前端开发 JavaScript
SpringBoot静态资源访问控制和封装集成方案
该文档描述了对基于SpringBoot的项目框架进行优化和整合的过程。原先采用前后端分离,后端兼做前端,但随着项目增多,升级维护变得复杂。因此,决定整合后台管理页面与后端代码,统一发布。设计上,框架包含后台管理资源,项目则配置具体业务页面,项目可通过覆盖框架资源实现个性化。关键步骤包括:自定义静态资源访问路径、解决图标与字体文件访问问题、设定自定义欢迎页面和页面图标,以及确保项目能正确访问框架静态资源。通过扫描jar包、解压和拷贝资源到项目目录,实现了框架静态资源的动态加载。此外,调整静态资源访问优先级,保证正确加载。最终实现支持jar和war包的项目结构优化。
49 4
|
20天前
|
消息中间件 JSON Java
SpringBoot集成和使用消息队列
SpringBoot集成和使用消息队列
|
1月前
|
Java 数据库连接 数据安全/隐私保护
springBoot集成token认证,最全Java面试知识点梳理
springBoot集成token认证,最全Java面试知识点梳理

热门文章

最新文章