参考:SpringBoot集成Lettuce_分布式缓存服务 DCS_用户指南_连接Redis缓存实例_多语言连接_华为云
前提条件
- 已成功申请Redis实例,且状态为“运行中”。
- 已创建弹性云服务器,创建弹性云服务器的方法,请参见创建弹性云服务器。
- 如果弹性云服务器为Linux系统,该弹性云服务器必须已经安装java编译环境。
操作步骤
- 查看并获取待连接Redis实例的IP地址/域名和端口。
具体步骤请参见查看实例信息。
- 登录弹性云服务器。
- 首先使用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集群示例。
- 在application.properties配置文件中加上redis相关配置。
spring.redis.host=host spring.redis.database=0 spring.redis.password=pwd spring.redis.port=port
- 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; }
- 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; } }
- 在application.properties配置文件中加上redis相关配置。
- SpringBoot+Lettuce连接池方式连接Redis单机/主备/Proxy集群示例。
- 在以上maven依赖的基础上添加以下依赖。
<dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> </dependency>
- 在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
- 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; }
- 在以上maven依赖的基础上添加以下依赖。
- SpringBoot+Lettuce单连接方式连接Redis Cluster集群代码示例。
- 在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
- 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; }
- 在application.properties配置文件中加上redis相关配置。
- springboot+lettuce连接池方式连接Redis Cluster集群代码示例。
- 在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
- 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; }
- 在application.properties配置文件中加上Redis相关配置。
说明:host为Redis实例的IP地址/域名,port为Redis实例的端口,请按实际情况修改后执行,pwd为创建Redis实例时自定义的密码,请按实际情况修改后执行。推荐使用连接池方式。超时时间(TimeOut),最大连接数(MaxTotal),最小空闲连接(MinIdle),最大空闲连接(MaxIdle),最大等待时间(MaxWait)等相关参数,请根据业务实际来调优。
- Springboot+Lettuce单连方式连接Redis单机/主备/Proxy集群示例。
例子2
https://www.cnblogs.com/John-2011/p/16601248.html
1、重写连接工厂实例,更改其LettuceClientConfiguration 为开启拓扑更新
@Configuration public class RedisConfig { @Autowired private RedisProperties redisProperties; //这是固定的模板 //自己定义了一个RedisTemplate @Bean @SuppressWarnings("all") public RedisTemplate<String, Object> redisTemplate(@Qualifier("lettuceConnectionFactoryUvPv") RedisConnectionFactory factory) { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(factory); //Json序列化配置 Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class); ObjectMapper om = new ObjectMapper(); om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); om.activateDefaultTyping(om.getPolymorphicTypeValidator()); om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); //解决序列化问题 om.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); jackson2JsonRedisSerializer.setObjectMapper(om); //String的序列化 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; } /** * 为RedisTemplate配置Redis连接工厂实现 * LettuceConnectionFactory实现了RedisConnectionFactory接口 * UVPV用Redis * * @return 返回LettuceConnectionFactory */ @Bean(destroyMethod = "destroy") //这里要注意的是,在构建LettuceConnectionFactory 时,如果不使用内置的destroyMethod,可能会导致Redis连接早于其它Bean被销毁 public LettuceConnectionFactory lettuceConnectionFactoryUvPv() throws Exception { List<String> clusterNodes = redisProperties.getCluster().getNodes(); Set<RedisNode> nodes = new HashSet<>(); clusterNodes.forEach(address -> nodes.add(new RedisNode(address.split(":")[0].trim(), Integer.parseInt(address.split(":")[1])))); RedisClusterConfiguration clusterConfiguration = new RedisClusterConfiguration(); clusterConfiguration.setClusterNodes(nodes); clusterConfiguration.setPassword(RedisPassword.of(redisProperties.getPassword())); clusterConfiguration.setMaxRedirects(redisProperties.getCluster().getMaxRedirects()); RedisStandaloneConfiguration redisStandaloneConfiguration=new RedisStandaloneConfiguration(); redisStandaloneConfiguration.setHostName(redisProperties.getHost()); redisStandaloneConfiguration.setPassword(redisProperties.getPassword()); redisStandaloneConfiguration.setDatabase(redisProperties.getDatabase()); redisStandaloneConfiguration.setPort(redisProperties.getPort()); GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig(); poolConfig.setMaxIdle(redisProperties.getLettuce().getPool().getMaxIdle()); poolConfig.setMinIdle(redisProperties.getLettuce().getPool().getMinIdle()); poolConfig.setMaxTotal(redisProperties.getLettuce().getPool().getMaxActive()); return new LettuceConnectionFactory(redisStandaloneConfiguration, getLettuceClientConfiguration(poolConfig)); } /** * 配置LettuceClientConfiguration 包括线程池配置和安全项配置 * * @param genericObjectPoolConfig common-pool2线程池 * @return lettuceClientConfiguration */ private LettuceClientConfiguration getLettuceClientConfiguration(GenericObjectPoolConfig genericObjectPoolConfig) { /* ClusterTopologyRefreshOptions配置用于开启自适应刷新和定时刷新。如自适应刷新不开启,Redis集群变更时将会导致连接异常! */ ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder() //开启自适应刷新 //.enableAdaptiveRefreshTrigger(ClusterTopologyRefreshOptions.RefreshTrigger.MOVED_REDIRECT, ClusterTopologyRefreshOptions.RefreshTrigger.PERSISTENT_RECONNECTS) //开启所有自适应刷新,MOVED,ASK,PERSISTENT都会触发 .enableAllAdaptiveRefreshTriggers() // 自适应刷新超时时间(默认30秒) .adaptiveRefreshTriggersTimeout(Duration.ofSeconds(25)) //默认关闭开启后时间为30秒 // 开周期刷新 .enablePeriodicRefresh(Duration.ofSeconds(20)) // 默认关闭开启后时间为60秒 ClusterTopologyRefreshOptions.DEFAULT_REFRESH_PERIOD 60 .enablePeriodicRefresh(Duration.ofSeconds(2)) = .enablePeriodicRefresh().refreshPeriod(Duration.ofSeconds(2)) .build(); return LettucePoolingClientConfiguration.builder() .poolConfig(genericObjectPoolConfig) .clientOptions(ClusterClientOptions.builder().topologyRefreshOptions(topologyRefreshOptions).build()) //将appID传入连接,方便Redis监控中查看 //.clientName(appName + "_lettuce") .build(); } }
2、SpringBoot2.3.x后,可使用配置文件中开启lettuce的拓扑刷新
lettuce: pool: max-active: 20 max-wait: -1ms max-idle: 10 min-idle: 2 cluster: refresh: adaptive: true #20秒自动刷新一次 period: 20
3、更改连接redis的连接方式,使用jedis连接
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <exclusions> <exclusion> <groupId>io.lettuce</groupId> <artifactId>lettuce-core</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency>
spring: redis: jedis: pool: max-active: ${redis.config.maxTotal:1024} max-idle: ${redis.config.maxIdle:50} min-idle: ${redis.config.minIdle:1} max-wait: ${redis.config.maxWaitMillis:5000} #lettuce: #pool: #max-active: ${redis.config.maxTotal:1024} #max-idle: ${redis.config.maxIdle:50} #min-idle: ${redis.config.minIdle:1} #max-wait: ${redis.config.maxWaitMillis:5000}
例子3
配置LettuceConnectionFactory ,设置拓扑刷新策略。
@Bean
public DefaultClientResources lettuceClientResources() {
return DefaultClientResources.create();
}
@Bean
public LettuceConnectionFactory lettuceConnectionFactory(RedisProperties redisProperties, ClientResources clientResources) {
ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()
.enablePeriodicRefresh(Duration.ofSeconds(30)) //按照周期刷新拓扑
.enableAllAdaptiveRefreshTriggers() //根据事件刷新拓扑
.build();
ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()
//redis命令超时时间,超时后才会使用新的拓扑信息重新建立连接
.timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(10)))
.topologyRefreshOptions(topologyRefreshOptions)
.build();
LettuceClientConfiguration clientConfiguration = LettuceClientConfiguration.builder()
.clientResources(clientResources)
.clientOptions(clusterClientOptions)
.build();
RedisClusterConfiguration clusterConfig = new RedisClusterConfiguration(redisProperties.getCluster().getNodes());
clusterConfig.setMaxRedirects(redisProperties.getCluster().getMaxRedirects());
clusterConfig.setPassword(RedisPassword.of(redisProperties.getPassword()));
LettuceConnectionFactory lettuceConnectionFactory = new LettuceConnectionFactory(clusterConfig, clientConfiguration);
return lettuceConnectionFactory;
}