首页 > 软件编程 > java > SpringBoot Redis哨兵模式

SpringBoot整合Redis的哨兵模式的实现

2024-08-19 09:46:20 作者：牛肉胡辣汤

Redis提供了哨兵模式来处理主从切换和故障转移,本文主要介绍了SpringBoot整合Redis的哨兵模式的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

在开发中，Redis是一个非常流行和强大的缓存数据库。为了保证高可用性和容错性，Redis提供了哨兵模式（Sentinel）来处理主从切换和故障转移。本篇技术博客将介绍如何在Spring Boot应用中使用Redis的哨兵模式进行高可用缓存服务的搭建。

准备工作

在开始之前，确保你已经安装和启动了Redis服务器，并按照Redis的哨兵模式配置了主节点和从节点。

添加依赖

在pom.xml文件中添加Spring Data Redis和Jedis的依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

Redis配置

在application.yaml文件中进行Redis的配置，包括主服务器和哨兵节点的信息：

spring:
  redis:
    sentinel:
      master: mymaster  # 主节点名称
      nodes: host1:port1,host2:port2,host3:port3  # 哨兵节点列表

创建Redis配置类

创建一个Redis的配置类，用于配置Redis连接工厂和缓存管理器：

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    @Value("${spring.redis.sentinel.master}")
    private String master;
    @Value("${spring.redis.sentinel.nodes}")
    private String sentinelNodes;
    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        RedisSentinelConfiguration sentinelConfiguration = new RedisSentinelConfiguration()
                .master(master);
        Set<String> nodes = new HashSet<>(Arrays.asList(sentinelNodes.split(",")));
        nodes.forEach(node -> {
            String[] parts = node.split(":");
            sentinelConfiguration.sentinel(parts[0], Integer.parseInt(parts[1]));
        });
        return new JedisConnectionFactory(sentinelConfiguration);
    }
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(10)); // 设置缓存过期时间为10分钟
        return RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(redisCacheConfiguration)
                .transactionAware()
                .build();
    }
}

在这个配置类中，我们首先通过读取配置文件中的主节点名称和哨兵节点列表来创建RedisSentinelConfiguration对象。然后，我们遍历哨兵节点列表并将它们添加到配置中。接下来，我们使用JedisConnectionFactory来创建RedisConnectionFactory，并将之前创建的RedisSentinelConfiguration传递给它。最后，我们创建了RedisCacheConfiguration并设置了一个常见的缓存过期时间，然后使用它来构建RedisCacheManager。

使用Redis缓存

在Spring Boot的服务类或控制器中，我们可以使用@Cacheable、@CachePut和@CacheEvict等注解来实现缓存功能。这些注解可以应用于方法上，以指定需要缓存的方法或操作。

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    @Cacheable(value = "users", key = "#id")
    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
    @CachePut(value = "users", key = "#user.id")
    public User saveUser(User user) {
        return userRepository.save(user);
    }
    @CacheEvict(value = "users", key = "#id")
    public void deleteUserById(Long id) {
        userRepository.deleteById(id);
    }
}

运行应用程序

现在，我们已经完成了Spring Boot的Redis哨兵模式配置和使用Redis缓存的代码编写。运行应用程序，并在需要使用缓存的地方使用上述的@Cacheable、@CachePut和@CacheEvict注解，Spring Boot将自动处理缓存，并通过Redis的哨兵模式提供高可用性和容错性。

当结合实际应用场景进行Redis的哨兵模式配置时，通常是为了实现高可用的缓存服务。下面给出一个示例代码，假设我们有一个商品管理系统，我们使用Redis缓存来存储商品信息，并保证缓存的高可用性。首先，我们需要在Spring Boot应用中配置Redis的哨兵模式并使用Redis缓存。可以参考上面提到的配置和代码。然后，我们可以在商品服务类中使用Redis缓存来存储和获取商品信息。

@Service
public class ProductService {
    @Autowired
    private ProductRepository productRepository;
    @Cacheable(value = "products", key = "#id")
    public Product getProductById(Long id) {
        // 先从缓存中获取商品信息
        // 如果缓存中不存在，从数据库中获取，并将结果存入缓存
        return productRepository.findById(id).orElse(null);
    }
    @CachePut(value = "products", key = "#product.id")
    public Product saveProduct(Product product) {
        // 保存商品信息到数据库，并将结果存入缓存
        return productRepository.save(product);
    }
    @CacheEvict(value = "products", key = "#id")
    public void deleteProductById(Long id) {
        // 从数据库中删除商品信息，并从缓存中移除对应的数据
        productRepository.deleteById(id);
    }
}

在上述代码中，我们使用@Cacheable注解将getProductById方法标记为可缓存的。当调用该方法时，Spring Boot会首先尝试从缓存中获取商品信息。如果缓存中存在对应的数据，则直接返回缓存中的数据；如果缓存中不存在，则会从数据库中获取商品信息，并将结果存入缓存。使用@CachePut注解将saveProduct方法标记为缓存更新的操作。该方法用于保存或更新商品信息到数据库，并将最新的商品信息存入缓存。通过指定相同的缓存名称和缓存键，可以覆盖之前的缓存数据。使用@CacheEvict注解将deleteProductById方法标记为缓存失效的操作。该方法用于删除数据库中的商品信息，并从缓存中移除相应的数据。通过以上示例代码，我们可以实现基于Redis的哨兵模式的高可用缓存服务。在生产环境中，可以部署多个Redis节点，并使用哨兵模式来实现主从切换和故障转移，以确保缓存服务的可用性和容错性。请注意，上述示例代码中的ProductRepository是一个假设的商品数据访问接口，具体的实现根据实际情况进行编写。另外，还需要在application.yaml中配置正确的Redis主节点和哨兵节点的信息。

Spring Boot中如何使用Redis的哨兵模式：首先，确保已经引入Spring Data Redis和Lettuce依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
</dependency>

接下来，在application.properties（或application.yml）中进行配置，包括Redis的哨兵节点和密码等信息：

# Redis配置
spring.redis.sentinel.master=my-master
spring.redis.sentinel.nodes=127.0.0.1:26379,127.0.0.1:26380,127.0.0.1:26381
spring.redis.password=your-password

然后，使用@Configuration注解创建一个配置类，配置RedisTemplate和LettuceConnectionFactory：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisSentinelConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
@Configuration
public class RedisConfig {
    @Bean
    public RedisSentinelConfiguration redisSentinelConfiguration() {
        RedisSentinelConfiguration configuration = new RedisSentinelConfiguration();
        configuration.master("my-master");
        configuration.sentinel("127.0.0.1", 26379);
        configuration.sentinel("127.0.0.1", 26380);
        configuration.sentinel("127.0.0.1", 26381);
        configuration.setPassword(RedisPassword.of("your-password"));
        return configuration;
    }
    @Bean
    public LettuceConnectionFactory lettuceConnectionFactory(RedisSentinelConfiguration redisSentinelConfiguration) {
        return new LettuceConnectionFactory(redisSentinelConfiguration);
    }
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        return redisTemplate;
    }
}

最后，可以在业务逻辑中使用自动注入的RedisTemplate来操作Redis数据：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
@Service
public class RedisService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    public void setValue(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }
    public Object getValue(String key) {
        return redisTemplate.opsForValue().get(key);
    }
}

在上述示例代码中，我们首先创建了一个RedisConfig配置类，通过@Bean注解配置了RedisSentinelConfiguration和LettuceConnectionFactory。然后，我们创建了一个RedisTemplate并将LettuceConnectionFactory注入其中。最后，我们在RedisService服务类中使用自动注入的RedisTemplate来操作Redis数据。请注意，上述示例代码中的配置信息和Redis连接参数是示例，实际应用中需要根据实际情况进行配置和更改。

总结

通过本篇技术博客，我们学习了如何在Spring Boot应用中使用Redis的哨兵模式进行高可用性缓存服务的搭建。要注意的是，为了实现真正的高可用性，需要在实际生产环境中正确配置Redis的主节点和哨兵节点。

到此这篇关于SpringBoot整合Redis的哨兵模式的实现的文章就介绍到这了,更多相关SpringBoot Redis哨兵模式内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！