Estos contenidos se han traducido de forma automática para su comodidad, pero Huawei Cloud no garantiza la exactitud de estos. Para consultar los contenidos originales, acceda a la versión en inglés.

Centro de ayuda> Distributed Cache Service> Guía del usuario> Acceso a una instancia de DCS para Redis> Acceso en diferentes idiomas> Integración de Lettuce con Spring Boot

Actualización más reciente 2022-11-07 GMT+08:00

Ver PDF

Integración de Lettuce con Spring Boot

Prerrequisitos:

Se ha creado una instancia de DCS Redis y se encuentra en el estado Running.
Se ha creado un ECS. Para obtener más información sobre cómo crear un ECS, consulte Compra de ECS.
Si el ECS ejecuta el SO de Linux, asegúrese de que el entorno de compilación de Java se ha instalado en el ECS.

Procedimiento

Vea la dirección IP/nombre de dominio y el número de puerto de la instancia de DCS Redis a la que se debe acceder.Para más detalles, consulte Consulta de detalles de instancia.
Inicie sesión en el ECS.

Utilice Maven para agregar la siguiente dependencia al archivo pom.xml:

Desde Spring Boot 2.0, Lettuce se utiliza como el cliente predeterminado para las conexiones.
Se utilizan Spring Boot 2.6.6 y 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>

Utilice Spring Boot integrado con Lettuce para conectarse a la instancia.

Ejemplo de uso de Spring Boot y Lettuce para conectarse a una instancia DCS Redis de nodo único, principal/en standby o de Clúster Proxy con una sola conexión

Agregue la configuración de Redis al archivo de configuración application.properties.

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

Clase RedisConfiguration de configuración de Redis

@Bean  
public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {   
    RedisTemplate<String, Object> template = new RedisTemplate<>();  
    template.setConnectionFactory(lettuceConnectionFactory);  
      // Replace the default JdkSerializationRedisSerializer with Jackson2JsonRedisSerializer to serialize and deserialize the 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();  
      // String serialization of keys
    template.setKeySerializer(stringRedisSerializer);  
      // String serialization of hash keys
    template.setHashKeySerializer(stringRedisSerializer);  
      // Jackson serialization of values
    template.setValueSerializer(jackson2JsonRedisSerializer);  
      // Jackson serialization of hash values
    template.setHashValueSerializer(jackson2JsonRedisSerializer);  
    template.afterPropertiesSet();  
    return template;  
}

Clase RedisUtil de operación de Redis

 /** 
  * Obtain data from the cache.
  * @param key
  * @return value
  */  
 public Object get(String key){  
     return key==null?null:redisTemplate.opsForValue().get(key);  
 }  

 /** 
  * Write data to the cache.
  * @param key
  * @param value
  * @return true (successful) false (failed)
  */  
 public boolean set(String key,Object value) {  
     try {  
         redisTemplate.opsForValue().set(key, value);  
         return true;  
     } catch (Exception e) {  
         e.printStackTrace();  
         return false;  
     }  
 }

Escribe la clase de controlador para la prueba.

  @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;  
	}  
    }

Ejemplo de uso de Spring Boot y Lettuce para conectarse a una instancia DCS Redis de nodo único, principal/en standby o de Clúster Proxy con agrupación de conexiones

Agregue la siguiente dependencia además de la anterior dependencia Maven:

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

Agregue la configuración de Redis al archivo de configuración application.properties.

spring.redis.host=host  
spring.redis.database=0  
spring.redis.password=pwd  
spring.redis.port=port  
# Connection timeout.
spring.redis.timeout=1000  
# Maximum number of connections in the connection pool. A negative value indicates no limit.
spring.redis.lettuce.pool.max-active=50  
# Minimum number of idle connections in the connection pool.
spring.redis.lettuce.pool.min-idle=5  
# Maximum number of idle connections in the connection pool.
spring.redis.lettuce.pool.max-idle=50  
# Maximum time for waiting for connections in the connection pool. A negative value indicates no limit.
spring.redis.lettuce.pool.max-wait=5000  
# Interval for scheduling an eviction thread.
spring.redis.pool.time-between-eviction-runs-millis=2000

Clase RedisConfiguration de configuración de conexión Redis

@Bean  
public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {  
    lettuceConnectionFactory.setShareNativeConnection(false);  
    RedisTemplate<String, Object> template = new RedisTemplate<>();  
    template.setConnectionFactory(lettuceConnectionFactory);  
    // Use Jackson2JsonRedisSerializer to replace the default JdkSerializationRedisSerializer to serialize and deserialize the 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();  
    // String serialization of keys
    template.setKeySerializer(stringRedisSerializer);  
    // String serialization of hash keys
    template.setHashKeySerializer(stringRedisSerializer);  
    // Jackson serialization of values
    template.setValueSerializer(jackson2JsonRedisSerializer);  
    // Jackson serialization of hash values
    template.setHashValueSerializer(jackson2JsonRedisSerializer);  
    template.afterPropertiesSet();  
    return template;  
}

Ejemplo de código para usar Spring Boot y Lettuce para conectarse a Clúster Redis mediante una sola conexión

Agregue la configuración de Redis al archivo de configuración application.properties.

spring.redis.cluster.nodes=host:port  
spring.redis.cluster.max-redirects=3  
spring.redis.password= pwd 
# Automated refresh interval
spring.redis.lettuce.cluster.refresh.period=60
# Enable automated refresh
spring.redis.lettuce.cluster.refresh.adaptive=true  
spring.redis.timeout=60

Clase RedisConfiguration de configuración de Redis (se debe habilitar la actualización automática de la topología).SpringBoot 2.3.0 and later support automated topology refresh.

@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);  
      // Configure automated topology refresh.
     ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()  
         .enablePeriodicRefresh(Duration.ofSeconds(period)) // Refresh the topology periodically.
         .enableAllAdaptiveRefreshTriggers() // Refresh the topology based on events.
         .build();  

     ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()  
         // Redis command execution timeout. Only when the command execution times out will a reconnection be triggered using the new topology.
         .timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(period)))  
         .topologyRefreshOptions(topologyRefreshOptions)  
         .build();  
     LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()  
             .commandTimeout(Duration.ofSeconds(timeout))   
             .readFrom(ReadFrom.REPLICA_PREFERRED) // Preferentially read data from the replicas.
             .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);  
     // Use Jackson2JsonRedisSerializer to replace the default JdkSerializationRedisSerializer to serialize and deserialize the 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();  
     // String serialization of keys
    template.setKeySerializer(stringRedisSerializer);  
     // String serialization of hash keys
    template.setHashKeySerializer(stringRedisSerializer);  
     // Jackson serialization of values
    template.setValueSerializer(jackson2JsonRedisSerializer);  
     // Jackson serialization of hash values
    template.setHashValueSerializer(jackson2JsonRedisSerializer);  
    template.afterPropertiesSet();  
    return template;  
}

Ejemplo de código para usar Spring Boot y Lettuce para conectarse al Clúster Redis con conexión pooling

Agregue la configuración de Redis al archivo de configuración application.properties.

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  
# Connection timeout.
spring.redis.timeout=60s   
# Maximum number of connections in the connection pool. A negative value indicates no limit.
spring.redis.lettuce.pool.max-active=50  
# Minimum number of idle connections in the connection pool.
spring.redis.lettuce.pool.min-idle=5  
# Maximum number of idle connections in the connection pool.
spring.redis.lettuce.pool.max-idle=50  
# Maximum time for waiting for connections in the connection pool. A negative value indicates no limit.
spring.redis.lettuce.pool.max-wait=5000  
# Interval for scheduling an eviction thread.
spring.redis.lettuce.pool.time-between-eviction-runs=2000

Clase RedisConfiguration de configuración de Redis (se debe habilitar la actualización automática de la topología).SpringBoot 2.3.0 and later support automated topology refresh.

@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);  
      // Configure automated topology refresh.
     ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()  
         .enablePeriodicRefresh(Duration.ofSeconds(period)) // Refresh the topology periodically.
         .enableAllAdaptiveRefreshTriggers() // Refresh the topology based on events.
         .build();  

     ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()  
         // Redis command execution timeout. Only when the command execution times out will a reconnection be triggered using the new topology.
         .timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(period)))  
         .topologyRefreshOptions(topologyRefreshOptions)  
         .build();  
     LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()  
             .commandTimeout(Duration.ofSeconds(timeout))  
             .poolConfig(genericObjectPoolConfig)  
             .readFrom(ReadFrom.REPLICA_PREFERRED) // Preferentially read data from the replicas.
             .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);  
     // Use Jackson2JsonRedisSerializer to replace the default JdkSerializationRedisSerializer to serialize and deserialize the 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();  
     // String serialization of keys
    template.setKeySerializer(stringRedisSerializer);  
     // String serialization of hash keys
    template.setHashKeySerializer(stringRedisSerializer);  
     // Jackson serialization of values
    template.setValueSerializer(jackson2JsonRedisSerializer);  
     // Jackson serialization of hash values
    template.setHashValueSerializer(jackson2JsonRedisSerializer);  
    template.afterPropertiesSet();  
    return template;  
}

host es la dirección IP/nombre de dominio de la instancia DCS, port es el número de puerto de la instancia DCS y pwd es la contraseña de la instancia DCS. Especifique estos parámetros según sea necesario antes de ejecutar el código. Se recomienda la agrupación de conexiones. Ajuste parámetros como TimeOut, MaxTotal (número máximo de conexiones), MinIdle (número mínimo de conexiones inactivas), MaxIdle (número máximo de conexiones inactivas) y MaxWait (tiempo máximo de espera) según los requisitos de servicio.

Tema principal: Acceso en diferentes idiomas

Tema anterior: Redisson

Tema siguiente: Clientes en Python