Spring Boot集成Redis

发布时间：2023-05-17

Redis是一个开源的内存数据存储系统，常用于缓存和消息传递。它支持字符串、哈希表、列表、集合、有序集合的数据类型，并且支持事务、Lua脚本、LRU淘汰等特性。在Spring Boot应用中集成Redis可以帮助提高应用的性能和可扩展性。

一、Spring Boot集成Redisson

Redisson是基于Redis实现的分布式Java对象和服务库，它提供了许多分布式锁和并发集合，使得集群环境下的代码编写变得更加方便。Spring Boot通过引入Redisson依赖可以快速集成Redisson。 首先，在pom.xml中添加Redisson的依赖：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.11.5</version>
</dependency>

然后在application.properties中配置Redis连接信息：

spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=yourpassword

在Java代码中可以直接使用Redisson提供的分布式锁和并发集合，如下所示：

@Autowired
private RedissonClient redissonClient;
public void doSomething() {
    RLock lock = redissonClient.getLock("myLock");
    try {
        lock.lock();
        // do something in the critical section
    } finally {
        lock.unlock();
    }
    RMap<String, String> map = redissonClient.getMap("myMap");
    map.put("key", "value");
}

二、Spring Boot集成MyBatis和Redis

MyBatis是一款优秀的Java持久层框架，它可以将Java对象和数据库表进行映射，简化了DAO层的代码。Spring Boot可以在MyBatis的基础上集成Redis，实现缓存的功能。 首先，在pom.xml中添加MyBatis和Redis的依赖：

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.3</version>
</dependency>
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>1.2.5</version>
</dependency>
<dependency>
    <groupId>org.mybatis.caches.redis</groupId>
    <artifactId>redis-cache</artifactId>
    <version>1.0.3</version>
</dependency>

其中，pagehelper-spring-boot-starter是MyBatis的分页插件，redis-cache是MyBatis与Redis的缓存插件。 然后在application.properties中配置MyBatis和Redis的连接信息：

spring.datasource.url=jdbc:mysql://localhost:3306/dbname
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.example.mybatis.model
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=yourpassword

在Java代码中，使用@Cacheable注解可以将结果缓存到Redis中，从而加速查询。如下所示：

@Autowired
private UserMapper userMapper;
@Autowired
private RedisTemplate redisTemplate;
@Cacheable(value = "userCache", key = "#id")
public User getUserById(Integer id) {
    // check cache
    User user = (User) redisTemplate.opsForValue().get("user:" + id);
    if (user != null) {
        return user;
    }
    // query from database
    user = userMapper.selectByPrimaryKey(id);
    // set cache
    redisTemplate.opsForValue().set("user:" + id, user, 10, TimeUnit.MINUTES);
    return user;
}

三、Spring Boot集成Redis哨兵

Redis哨兵是一种特殊的Redis实例，它通过自动发现Redis主从节点并进行故障转移来增强Redis的高可用性。Spring Boot可以集成Redis哨兵来保证应用的稳定性。 首先，在pom.xml中添加Redisson的哨兵依赖：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.11.5</version>
</dependency>
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-sentinel</artifactId>
    <version>3.11.5</version>
</dependency>

然后在application.properties中配置Redis哨兵的连接信息：

spring.redis.sentinel.master=mymaster
spring.redis.sentinel.nodes=127.0.0.1:26379,127.0.0.1:26380,127.0.0.1:26381
spring.redis.password=yourpassword

在Java代码中可以使用Redisson提供的RedissonClient对象来操作Redis。同样的，它也提供了分布式锁和并发集合的支持。

四、Spring Boot集成Redis流程

Spring Boot集成Redis的流程如下：

  1. 引入Redis的依赖
  2. 配置Redis的连接信息
  3. 在Java代码中使用RedisTemplate或RedissonClient操作Redis

五、Spring Boot集成Redis缓存

Spring Boot可以使用Spring Cache抽象来集成缓存的功能，它可以方便地切换不同的缓存实现，包括Redis。 首先，在pom.xml中添加Spring Cache和Redis的依赖：

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

然后在application.properties中配置Redis的连接信息：

spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=yourpassword

在Java代码中，使用@Cacheable、@CachePut和@CacheEvict等注解可以直接操作Redis缓存。如下所示：

@Cacheable(value = "userCache", key = "#id")
public User getUserById(Integer id) {
    // query from database
    User user = userMapper.selectByPrimaryKey(id);
    return user;
}
@CachePut(value = "userCache", key = "#user.id")
public User updateUser(User user) {
    // update in database
    userMapper.updateByPrimaryKeySelective(user);
    return user;
}
@CacheEvict(value = "userCache", key = "#id")
public void deleteUserById(Integer id) {
    // delete from database
    userMapper.deleteByPrimaryKey(id);
}

六、Spring Boot集成Redis Stream

Redis Stream是Redis 5.0版本引入的数据类型，它是一个高性能、低延迟的可持久化消息队列，支持消息的顺序消费和消息重试机制。Spring Boot可以通过引入Lettuce或Jedis的依赖来集成Redis Stream。 首先，在pom.xml中添加Lettuce或Jedis的依赖：

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

然后在Java代码中可以使用RedisTemplate或Lettuce提供的API来操作Redis Stream。如下所示：

// send a message to a Redis Stream
redisTemplate.opsForStream().add("mystream", Collections.singletonMap("key", "value"));
// consume messages from a Redis Stream
StreamMessageListenerContainer<Object, ObjectRecord<Object, Object>> container =
    StreamMessageListenerContainer.create(redisTemplate.getConnectionFactory());
StreamListener<Object, ObjectRecord<Object, Object>> listener =
    new StreamListener<Object, ObjectRecord<Object, Object>>() {
        @Override
        public void onMessage(ObjectRecord<Object, Object> record) {
            // handle the received message
        }
    };
String stream = "mystream";
XReadOptions readOptions = StreamOffset.create(stream, ReadOffset.lastConsumed());
container.receive(Consumer.from("mygroup", "myconsumer"), readOptions, listener);

七、Spring Boot集成Redis哨兵集群

Redis哨兵集群是由多个Redis哨兵节点组成的集群环境，它可以实现Redis的高可用和自动故障转移。Spring Boot可以集成Redis哨兵集群来提高应用的可用性。 首先，在pom.xml中添加Redisson的哨兵集群依赖：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.11.5</version>
</dependency>
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-sentinel</artifactId>
    <version>3.11.5</version>
</dependency>

然后在application.properties中配置Redis哨兵集群的连接信息：

spring.redis.sentinel.master=mymaster
spring.redis.sentinel.nodes=127.0.0.1:26379,127.0.0.1:26380,127.0.0.1:26381
spring.redis.password=yourpassword

在Java代码中，可以使用Redisson提供的RedissonCluster对象来操作Redis哨兵集群。如下所示：

@Autowired
private RedissonCluster redissonCluster;
public void doSomething() {
    RLock lock = redissonCluster.getLock("myLock");
    try {
        lock.lock();
        // do something in the critical section
    } finally {
        lock.unlock();
    }
    RMap<String, String> map = redissonCluster.getMap("myMap");
    map.put("key", "value");
}

八、Spring Boot集成Redis主从

Redis主从集群是由一个Redis主节点和多个Redis从节点组成的集群环境，它可以实现读写分离和高可用性。Spring Boot可以集成Redis主从集群来提高应用的性能和可用性。 首先，在pom.xml中添加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中配置Redis主从集群的连接信息：

spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=yourpassword
推荐文章