前提條件

• 已成功申請Redis實例，且狀態為“運行中”。
• 已創建彈性云主機，創建彈性云主機的方法，請參見《彈性云主機用戶指南》。
• 如果彈性云主機為Linux系統，該彈性云主機必須已經安裝java編譯環境。

操作步驟

步驟(zou) 1 查(cha)看(kan)并獲取(qu)待連(lian)接Redis實例的IP地址和端(duan)口。

具體步驟請參見查看實例信息。

步驟(zou) 2 登錄彈性云主機。

步驟 3 首(shou)先使用maven在pom.xml添加如下依賴。

                    
說明
                    
?SpringBoot從2.0起默認使(shi)用lettuce客戶端進行連接。
此(ci)次使用(yong)的(de)版本：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> 

步(bu)驟 4 使用SpringBoot集成Lettuce連接實(shi)例。

• Springboot+Lettuce單連方式連接Redis單機/主備/Proxy集群示例。

a. 在(zai)application.properties配置文件(jian)中(zhong)加上redis相關配置。

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

b. 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;   
}  

c. Redis操(cao)作(zuo)類(lei)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;   
     }   
 }

d. 編寫controller類進行測(ce)試。

  @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集群示例。

e. 在以上maven依賴(lai)的基礎上添(tian)加以下依賴(lai)。

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

f. 在(zai)application.properties配(pei)置(zhi)文件(jian)中加(jia)上redis相關配(pei)置(zhi)。

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  

g. 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集群代碼示例。

h. 在application.properties配置文件中加上redis相關(guan)配置。

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

i. Redis配置(zhi)類RedisConfiguration，請務必開啟(qi)集群自動刷(shua)新拓(tuo)撲(pu)配置(zhi)。

@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集群代碼示例。

J . 在application.properties配置文件(jian)中(zhong)加上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

k. redis配置類(lei)RedisConfiguration，請務必開啟集群(qun)自動刷新拓撲配置。

@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為(wei)(wei)Redis實(shi)例的IP地址(zhi)，port為(wei)(wei)Redis實(shi)例的端口，請(qing)(qing)按(an)實(shi)際(ji)情(qing)(qing)況修改(gai)(gai)后執行(xing)，pwd為(wei)(wei)創建Redis實(shi)例時(shi)自(zi)定義的密碼(ma)，請(qing)(qing)按(an)實(shi)際(ji)情(qing)(qing)況修改(gai)(gai)后執行(xing)。推薦使用(yong)連(lian)接(jie)池方式。超時(shi)時(shi)間（TimeOut），最大連(lian)接(jie)數（MaxTotal），最小空閑連(lian)接(jie)（MinIdle），最大空閑連(lian)接(jie)（MaxIdle），最大等待時(shi)間（MaxWait）等相關參數，請(qing)(qing)根據(ju)業務實(shi)際(ji)來調優(you)。