[技术资料] Spring Boot如何整合Redis缓存提升应用性能_redis缓存提升系统性能-优快云博客

本文链接：https://blog.youkuaiyun.com/liliYoung_/article/details/144215125

在现代的Web应用程序中，缓存是一种非常重要的性能优化策略，特别是对于那些需要频繁从数据库中读取数据的应用。Redis，作为一种高性能的开源内存数据存储系统，已经成为分布式缓存的首选解决方案之一。在本文中，我们将介绍如何在Spring Boot中整合Redis缓存，并深入探讨一些高级用例，如分布式锁、计数器和消息队列等。

1. Redis简介与优势

Redis是一种支持多种数据类型（如字符串、列表、集合、有序集合、哈希等）的高性能键值数据库。它运行在内存中，支持快速的数据访问，因此非常适合用作缓存系统。此外，Redis也常用于解决一些分布式系统中的问题，比如分布式锁、计数器和消息队列等。

Redis常见应用场景：

缓存：将频繁访问的数据缓存到Redis，减轻数据库的压力，提升应用性能。
分布式锁：保证分布式系统中共享资源的访问同步。
计数器：如网站的访问量、订单数等统计数据。
消息队列：解耦系统模块，实现异步处理。

2. 在Spring Boot中集成Redis

2.1 引入Redis依赖

首先，在pom.xml中添加Redis的依赖：

<dependency> 
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-starter-data-redis</artifactId> 
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

这两个依赖分别用于集成Spring Boot Redis支持和JSON序列化工具。

2.2 配置Redis连接

在application.properties或者application.yml中配置Redis连接信息：

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=your_password
spring.redis.database=0

这里我们指定了Redis的主机地址、端口和密码，确保Spring Boot可以成功连接到Redis实例。

2.3 Redis序列化方式

Redis支持多种序列化方式，常用的包括：

JdkSerializationRedisSerializer：默认序列化方式，适用于跨平台和跨系统的数据传输。
StringRedisSerializer：推荐用于Redis的键序列化方式，轻量级且效率高。
Jackson2JsonRedisSerializer：推荐用于Redis值的序列化方式，JSON格式存储更加紧凑，且序列化/反序列化速度较快。

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(factory);

    // 设置Key的序列化方式为StringRedisSerializer
    StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    template.setKeySerializer(stringRedisSerializer);
    template.setHashKeySerializer(stringRedisSerializer);

    // 设置Value的序列化方式为Jackson2JsonRedisSerializer
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
    template.setValueSerializer(jackson2JsonRedisSerializer);
    template.setHashValueSerializer(jackson2JsonRedisSerializer);

    template.afterPropertiesSet();
    return template;
}

2.4 启用缓存支持

要在Spring Boot中启用缓存支持，需要添加@EnableCaching注解：

@EnableCaching
@Configuration
public class RedisConfig {
    // RedisTemplate和缓存管理器的配置
}

3. 使用Redis进行缓存管理

Spring Boot通过注解的方式支持非常方便的缓存管理。常用的注解包括：

@Cacheable：用于缓存方法的返回值，适合缓存经常查询的数据。
@CachePut：每次方法调用都会更新缓存，适用于需要修改缓存内容的情况。
@CacheEvict：用于清空缓存，适合删除缓存或者清除过期的缓存数据。

3.1 @Cacheable示例

@Cacheable注解会根据方法的参数自动生成缓存的key，如果缓存中存在该key的值，则直接返回缓存数据，否则执行方法并将返回值缓存：

@Cacheable(value = "userCache", key = "#id")
public User getUserById(Long id) {
    return userRepository.findById(id).orElse(null);
}

3.2 @CachePut示例

@CachePut注解会确保每次方法调用后都更新缓存，适用于需要更新缓存内容的场景：

@CachePut(value = "userCache", key = "#user.id")
public User updateUser(User user) {
    return userRepository.save(user);
}

3.3 @CacheEvict示例

@CacheEvict注解用于清除缓存，可以根据条件选择清除某个缓存或者所有缓存：

@CacheEvict(value = "userCache", key = "#id")
public void deleteUser(Long id) {
    userRepository.deleteById(id);
}

4. Redis事务管理

Redis支持事务操作，可以确保一组Redis命令按顺序执行。Spring提供了两种方式来管理Redis事务：

在Redis中，事务是一种确保多个操作要么全部成功，要么全部失败的机制。Redis事务是通过命令 MULTI（开始事务）和 EXEC（提交事务）来实现的，Redis会将事务中的命令排队执行，直到 EXEC 被调用时才会真正执行。此过程中，事务中的命令是不会被其他客户端的操作所打断的。

4. 1. 方式1：使用 `SessionCallback` 进行事务管理（推荐）

这种方式通过 SessionCallback 来实现事务操作，Spring提供了非常便捷的接口，使得事务操作变得非常简洁。SessionCallback 通过操作 Redis 时自动开启事务，并在 EXEC 被调用时提交。

示例代码：

@Autowired
RedisTemplate redisTemplate;

@Test
@SuppressWarnings("all")
public void testSessionCallback() {
    // 使用 SessionCallback 回调进行事务管理
    SessionCallback callback = new SessionCallback() {
        @Override
        public Object execute(RedisOperations operations) throws DataAccessException {
            operations.multi();  // 开始事务
            operations.opsForValue().set("name", "qinyi");
            operations.opsForValue().set("gender", "male");
            operations.opsForValue().set("age", "19");
            return operations.exec();  // 提交事务
        }
    };

    // 执行 Redis 事务操作
    System.out.println(redisTemplate.execute(callback)); // 输出 [true, true, true]
}

解释：

operations.multi()：开启事务，Redis将后续的操作排队执行。
operations.opsForValue().set(...)：将数据放入Redis，但这些操作不会立刻执行。
operations.exec()：提交事务，执行所有排队的操作。

在事务提交时，如果没有异常发生，所有的操作都会返回 true，表示事务成功提交。

4. 2. 方式2：创建独立的 Redis 操作模板并启用事务支持

有时候，我们希望避免某些Redis操作影响到其他的操作，因此可以为事务创建一个单独的 RedisTemplate 实例，并在其上启用事务支持。

步骤 1：创建一个带事务支持的 `RedisTemplate` 配置

@Bean("tranRedisTemplate")
public RedisTemplate<String, Object> tranRedisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = redisTemplate(factory);
    template.setEnableTransactionSupport(true);  // 启用事务支持
    return template;
}

步骤 2：使用 `@Qualifier` 注解指定事务用的 `RedisTemplate`

@Qualifier("tranRedisTemplate")
@Autowired
RedisTemplate tranRedisTemplate;

示例代码1：使用 `@Transactional` 注解

你可以通过 @Transactional 注解来声明Redis事务操作，并自动管理事务的提交和回滚。

@Test
@SuppressWarnings("all")
@Transactional  // 确保事务的提交和回滚
public void testSessionCallback() {
    tranRedisTemplate.opsForValue().set("name", "qinyi");
    tranRedisTemplate.opsForValue().set("gender", "male");
    tranRedisTemplate.opsForValue().set("age", "19");
}

在这种情况下，事务的提交与回滚由 Spring 管理。所有操作会在同一个事务中执行，如果事务未提交，则所有操作将会回滚。

示例代码2：手动开启和提交事务

@Test
public void testMultiSuccess() {
    // 开启事务支持，在同一个 Connection 中执行命令
    tranRedisTemplate.setEnableTransactionSupport(true);

    // 开始事务
    tranRedisTemplate.multi();  

    tranRedisTemplate.opsForValue().set("name", "qinyi");
    tranRedisTemplate.opsForValue().set("gender", "male");
    tranRedisTemplate.opsForValue().set("age", "19");

    // 提交事务
    System.out.println(tranRedisTemplate.exec());  // 输出 [true, true, true]
}

在此示例中，我们手动启用事务支持，并且显式调用 multi() 开始事务，之后通过 exec() 提交事务。