SpringBoot详解整合Spring Cache实现Redis缓存流程

让我来详细讲解一下“SpringBoot详解整合Spring Cache实现Redis缓存流程”的完整攻略。

1. Spring Cache 简介

Spring Cache 是 Spring 官方提供的缓存框架，它通过提供 CacheManager 统一管理缓存和缓存操作，屏蔽了不同缓存框架的差异，使得我们只需要处理统一缓存接口即可，极大地降低了使用缓存的难度。

2. 整合 Spring Cache 实现 Redis 缓存的流程

2.1 配置 Redis

首先，需要在 Spring Boot 项目中引入 Redis 相关的依赖包，这里以 Redisson 为例，实现 Redis 缓存。在 pom.xml 文件中添加以下依赖：

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

然后在 application.properties 中添加 Redis 配置：

# Redis 配置
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=
spring.redis.database=0
spring.redis.timeout=60000

2.2 创建 RedisCacheManager

接着，需要创建一个 RedisCacheManager ，用于统一管理 Redis 缓存，可以通过继承 CachingConfigurerSupport 类并重写 cacheManager() 方法来实现：

@Configuration
@EnableCaching
public class RedisCacheConfig extends CachingConfigurerSupport {
    // redis 配置项
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.timeout}")
    private int timeout;
    @Value("${spring.redis.password}")
    private String password;
    @Value("${spring.redis.database}")
    private int database;

    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        // 配置序列化方式
        RedisSerializationContext.SerializationPair<Object> pair = RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer());
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(pair);

        return RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(redisCacheConfiguration)
                .transactionAware()
                .build();
    }

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration(host, port);
        config.setPassword(password);
        config.setDatabase(database);
        return new LettuceConnectionFactory(config);
    }
}

2.3 在 Service 中使用 RedisCache

最后，在 Service 中使用 RedisCache 注解即可：

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserRepository userRepository;

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

    @Override
    @Cacheable(value="user", key="#username")
    public User getUserByUsername(String username) {
        return userRepository.findByUsername(username);
    }

    @Override
    @CachePut(value="user", key="#user.id")
    public void saveUser(User user) {
        userRepository.save(user);
    }

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

这里使用了 4 个 Spring Cache 注解：

• @Cacheable：查询缓存，如果缓存中有数据，直接返回，否则执行方法并将返回值存入缓存；
• @CachePut：更新缓存，每次都会执行方法并将返回值存入缓存；
• @CacheEvict：删除缓存，移除指定 key 的缓存；
• @Caching：组合注解，允许在一个方法上应用多个注解。

2.4 示例说明

以一个简单的用户系统为例，演示如何使用 Spring Cache 实现 Redis 缓存。

2.4.1 用户实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Entity
@Table(name = "user")
public class User implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String username;

    private String password;

    private String email;

    private Integer age;

    private Boolean enabled;

    private Date createTime;

    private Date updateTime;
}

2.4.2 UserRepository

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findById(Long id);
    User findByUsername(String username);
}

2.4.3 UserService

public interface UserService {
    User getUserById(Long id);

    User getUserByUsername(String username);

    void saveUser(User user);

    void deleteUserById(Long id);
}

2.4.4 UserServiceImpl

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserRepository userRepository;

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

    @Override
    @Cacheable(value="user", key="#username")
    public User getUserByUsername(String username) {
        return userRepository.findByUsername(username);
    }

    @Override
    @CachePut(value="user", key="#user.id")
    public void saveUser(User user) {
        userRepository.save(user);
    }

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

当然，上述示例还需要进行完整的项目部署和测试，这里为了讲解完整流程，就不展开了。

如果您还有疑问，可以通过我的 GitHub 公开代码库了解更具体的代码实现。