Este conteúdo foi traduzido por máquina para sua conveniência e a Huawei Cloud não pode garantir que o conteúdo foi traduzido com precisão. Para exibir o conteúdo original, use o link no canto superior direito para mudar para a página em inglês.
Central de ajuda/ Distributed Cache Service/ Guia de usuário/ Acessando uma instância do DCS Redis/ Acesso em diferentes idiomas/ Integração de alface com Spring Boot
Atualizado em 2022-11-08 GMT+08:00
Ver PDF
Compartilhar

Integração de alface com Spring Boot

Pré-requisitos

  • Uma instância do DCS Redis foi criada e está no estado Running.
  • Foi criado um ECS. Para obter detalhes sobre como criar um ECS, consulte Comprando um ECS .
  • Se o ECS executar o SO de Linux, certifique-se de que o ambiente de compilação Java tenha sido instalado no ECS.

Procedimento

  1. Visualize o endereço IP/nome do domínio e o número da porta da instância do DCS Redis a ser acessada.

    Para mais detalhes, consulte Exibindo Detalhes da Instância.

  2. Acesse o ECS.
  3. Use o Maven para adicionar a seguinte dependência ao arquivo pom.xml:

    • Desde o Spring Boot 2.0, o Lettuce é usado como cliente padrão para conexões.
    • Spring Boot 2.6.6 e Lettuce 6.1.8 são usados.
    <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>

  4. Use o Spring Boot integrado ao Lettuce para se conectar à instância.

    • Exemplo de uso do Spring Boot e do Lettuce para conectar-se a uma instância do DCS Redis de cluster de nó único, mestre/standby ou proxy com uma única conexão
      1. Adicione a configuração do Redis ao arquivo de configuração application.properties. 
        spring.redis.host=host  
spring.redis.database=0  
spring.redis.password=pwd 
spring.redis.port=port
      2. Classe de configuração do Redis RedisConfiguration 
        @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;  
}
      3. Classe de operação do Redis RedisUtil 
         /** 
  * 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;  
     }  
 }
      4. Escreva a classe do controlador para testes. 
          @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;  
	}  

    }
    • Exemplo de uso do Spring Boot e do Lettuce para conectar-se a uma instância do DCS Redis de cluster de nó único, mestre/standby ou proxy com pool de conexão
      1. Adicione a seguinte dependência além da dependência Maven anterior: 
        <dependency>  
  <groupId>org.apache.commons</groupId>  
  <artifactId>commons-pool2</artifactId>  
</dependency>
      2. Adicione a configuração do Redis ao arquivo de configuração 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
      3. Classe de configuração da conexão Redis RedisConfiguration 
        @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;  
}
    • Exemplo de código para usar o Spring Boot e o Lettuce para se conectar ao Redis Cluster usando uma única conexão
      1. Adicione a configuração do Redis ao arquivo de configuração 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
      2. Classe de configuração RedisConfiguration do Redis (a atualização de topologia automatizada deve estar habilitada). 
        @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;  
}
    • Código de exemplo para usar o Spring Boot e o Lettuce para conectar-se ao Redis Cluster com pool de conexão
      1. Adicione a configuração do Redis ao arquivo de configuração 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
      2. Classe de configuração RedisConfiguration do Redis (a atualização automatizada da topologia deve ser ativada). 
        @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 é o endereço IP/nome de domínio da instância do DCS, port é o número da porta da instância do DCS e pwd é a senha da instância do DCS. Especifique esses parâmetros conforme necessário antes de executar o código. O pool de conexão é recomendado. Ajuste parâmetros como TimeOut, MaxTotal (número máximo de conexões), MinIdle (número mínimo de conexões ociosas), MaxIdle (número máximo de conexões ociosas) e MaxWait (tempo máximo de espera) com base nos requisitos de serviço.

Tópico principal: Acesso em diferentes idiomas