Spring Boot 使用 Redis 缓存方法返回值完整示例

在 Spring Boot 中使用 Redis 缓存方法的返回值，可以显著提高应用程序的性能，减少对数据库的访问次数。以下是一个完整的示例，展示了如何在 Spring Boot 中使用 Redis 来缓存方法的返回值。

一、前提条件

1. 安装 Redis：确保你的系统中已经安装并运行 Redis 服务器。
2. 创建 Spring Boot 项目：可以使用 Spring Initializr 或其他方式创建一个新的 Spring Boot 项目。

二、添加依赖

在 pom.xml 文件中添加 Redis 和 Spring Cache 相关的依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

三、配置 Redis

在 application.properties 文件中配置 Redis：

spring.redis.host=localhost
spring.redis.port=6379
spring.cache.type=redis

四、启用缓存

在 Spring Boot 应用主类上添加 @EnableCaching 注解以启用缓存支持：

@SpringBootApplication
@EnableCaching
public class RedisCacheApplication {
    public static void main(String[] args) {
        SpringApplication.run(RedisCacheApplication.class, args);
    }
}

五、创建实体类和存储库

创建一个简单的用户实体类和 JPA 存储库：

User.java：

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private int age;

    // Getters and setters
    // Constructor
}

UserRepository.java：

public interface UserRepository extends JpaRepository<User, Long> {
}

六、创建服务类

在服务类中使用缓存注解：

UserService.java：

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

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

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

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

    @CacheEvict(value = "users", allEntries = true)
    public void clearCache() {
        // 清空缓存
    }
}

七、创建控制器

创建一个简单的控制器来测试缓存功能：

UserController.java：

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        User user = userService.getUserById(id);
        return ResponseEntity.ok(user);
    }

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User createdUser = userService.updateUser(user);
        return ResponseEntity.ok(createdUser);
    }

    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        User updatedUser = userService.updateUser(user);
        return ResponseEntity.ok(updatedUser);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return ResponseEntity.noContent().build();
    }
}

八、测试

启动 Spring Boot 应用，并通过以下方式测试缓存功能：

1. 获取用户：发送 GET 请求到 /users/{id}，第一次请求会从数据库中读取数据并缓存，后续请求会直接从缓存中读取。
2. 创建用户：发送 POST 请求到 /users 创建新用户，数据会更新到数据库并缓存。
3. 更新用户：发送 PUT 请求到 /users/{id} 更新用户，缓存中的数据也会更新。
4. 删除用户：发送 DELETE 请求到 /users/{id} 删除用户，缓存中的数据也会删除。

思维导图

graph TD;
    A[Spring Boot 使用 Redis 缓存] --> B[前提条件]
    B --> B1[安装 Redis]
    B --> B2[创建 Spring Boot 项目]

    A --> C[添加依赖]
    A --> D[配置 Redis]
    A --> E[启用缓存]
    A --> F[创建实体类和存储库]
    A --> G[创建服务类]
    A --> H[创建控制器]
    A --> I[测试]

    F --> F1[User.java]
    F --> F2[UserRepository.java]

    G --> G1[UserService.java]

    H --> H1[UserController.java]

总结

通过上述步骤，我们成功地在 Spring Boot 项目中集成了 Redis 缓存，并通过注解的方式实现了方法返回值的缓存。这种方式不仅提高了系统的性能，还简化了缓存管理的复杂度。使用 Spring Boot 的缓存注解和 Redis，可以轻松地实现高效、可靠的缓存机制。