Spring Caching：缓存抽象与注解 - 智猿学院-IT界的百科全书

Spring Caching：缓存抽象与注解，让你的代码飞起来！🚀

大家好！我是你们的老朋友，一个在代码海洋里摸爬滚打多年的老水手。今天，我们要聊聊一个让你的代码像坐上火箭一样，嗖嗖嗖飞起来的神奇工具——Spring Caching！

想象一下，你辛辛苦苦煮了一锅香喷喷的红烧肉，结果每次有人想吃，你都要重新从选肉、焯水、煸炒开始，再来一遍！这得多累啊！ 😭 而Spring Caching就像一个神奇的冰箱，你把红烧肉放进去，下次有人想吃，直接从冰箱里拿出来热一下就行了，省时省力，岂不美哉？

什么是缓存？别跟我讲那些高深莫测的理论，来点实在的！

简单来说，缓存就是把一些计算结果或者数据暂时存储起来，以便下次需要的时候直接拿来用，而不用重新计算或者从数据库里读取。就像我们的大脑，如果每次看到猫都要重新学习一遍“这是猫”，那得浪费多少脑细胞啊！我们只需要记住“猫”的样子，下次看到，直接调用记忆里的猫就行了。

为什么要用缓存？

性能提升： 这是最直接的好处！避免重复计算和数据库访问，可以显著提高程序的响应速度。
资源节约： 减少数据库压力，降低服务器负载，节省宝贵的资源。
用户体验： 更快的响应速度意味着更好的用户体验，用户会更喜欢你的应用。

Spring Caching：缓存界的瑞士军刀

Spring Caching 并非直接实现缓存，而是一个抽象层，它允许我们使用各种不同的缓存技术，比如：

Ehcache： 一个流行的、基于Java的开源缓存库。
Redis： 一个高性能的键值对存储数据库，常用于缓存。
Memcached： 另一个流行的分布式缓存系统。
Caffeine： 一个高性能的Java本地缓存库。
ConcurrentHashMap： Java自带的线程安全哈希表，可以简单地用作本地缓存。

Spring Caching 就像一个万能遥控器，你可以通过配置，轻松切换不同的缓存提供者，而不用修改大量的代码。这就是“面向接口编程”的魅力！ ✨

Spring Caching 的核心注解：四个金刚

Spring Caching 提供了几个关键的注解，它们就像四位身怀绝技的武林高手，助你轻松驾驭缓存：

@Cacheable： 缓存查询结果。就像红烧肉的冰箱，把查询结果放进去，下次直接拿出来。
@CachePut： 更新缓存。就像你改进了红烧肉的做法，要把新的红烧肉放到冰箱里，替换掉旧的。
@CacheEvict： 清除缓存。就像你想清理冰箱，把一些过期的红烧肉扔掉。
@Caching： 组合多个缓存操作。就像你一次性要放很多红烧肉到冰箱里，或者一次性清理多个冰箱。

接下来，我们逐一详解这四个金刚的用法，并配合生动的例子，让你彻底掌握Spring Caching 的精髓！

1. @Cacheable：缓存查询结果，一劳永逸！

@Cacheable 注解用于方法上，表示该方法的返回值会被缓存起来。下次调用该方法时，如果缓存中已经存在对应的数据，则直接从缓存中返回，而不会执行方法体。

场景： 假设我们有一个 UserService，其中有一个 getUserById(Long id) 方法，用于根据用户ID查询用户信息。用户信息很少变动，但查询频率很高，我们可以使用 @Cacheable 来缓存用户信息，减少数据库访问。

代码示例：

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Cacheable(value = "users", key = "#id")
    public User getUserById(Long id) {
        System.out.println("从数据库查询用户，id = " + id); // 模拟数据库查询
        // 实际应该从数据库查询
        return new User(id, "用户" + id, "user" + id + "@example.com");
    }
}

解释：

@Cacheable(value = "users", key = "#id")：
- value = "users"：指定缓存的名称为 "users"。你可以理解为冰箱的名字叫 "users"。
- key = "#id"：指定缓存的 key，这里使用 Spring Expression Language (SpEL) 表达式 #id，表示使用方法参数 id 作为 key。这就好比在冰箱里给每一份红烧肉贴上标签，方便查找。

使用效果：

第一次调用 userService.getUserById(1L) 时，会执行方法体，从数据库查询用户信息，并将结果缓存到 "users" 缓存中，key 为 "1"。

第二次调用 userService.getUserById(1L) 时，由于缓存中已经存在 key 为 "1" 的数据，所以直接从缓存中返回结果，而不会执行方法体。你会发现控制台只打印一次 "从数据库查询用户，id = 1"。

重要提示：

@Cacheable 只有在方法 正常执行 并 返回结果 时才会缓存。如果方法抛出异常，则不会缓存。
key 的选择至关重要，要保证唯一性，避免缓存冲突。就像冰箱里的红烧肉不能贴一样的标签，否则就乱套了！ 🤯
condition 属性可以用来设置缓存的条件，只有满足条件时才缓存。就像你只想把特定口味的红烧肉放到冰箱里。

2. @CachePut：更新缓存，保持新鲜！

@CachePut 注解也用于方法上，表示该方法的返回值会被更新到缓存中。与 @Cacheable 不同的是，@CachePut 始终会执行方法体，并将结果更新到缓存中。

场景： 假设我们有一个 UserService，其中有一个 updateUser(User user) 方法，用于更新用户信息。更新用户信息后，我们需要同时更新缓存中的用户信息。

代码示例：

import org.springframework.cache.annotation.CachePut;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @CachePut(value = "users", key = "#user.id")
    public User updateUser(User user) {
        System.out.println("更新数据库中的用户，id = " + user.getId()); // 模拟数据库更新
        // 实际应该更新数据库
        return user;
    }
}

解释：

@CachePut(value = "users", key = "#user.id")：
- value = "users"：指定缓存的名称为 "users"。
- key = "#user.id"：指定缓存的 key，这里使用 SpEL 表达式 #user.id，表示使用方法参数 user 的 id 属性作为 key。

使用效果：

每次调用 userService.updateUser(user) 时，都会执行方法体，更新数据库中的用户信息，并将更新后的用户信息更新到 "users" 缓存中，key 为 user.getId()。

重要提示：

@CachePut 始终会执行方法体，所以即使缓存中已经存在对应的数据，也会被覆盖。
key 的选择要与 @Cacheable 保持一致，才能正确更新缓存。否则，你更新的就不是同一份红烧肉了！
condition 属性也可以用来设置缓存的条件，只有满足条件时才更新缓存。

3. @CacheEvict：清除缓存，告别过期！

@CacheEvict 注解用于方法上，表示该方法执行后，会清除缓存中的数据。

场景： 假设我们有一个 UserService，其中有一个 deleteUserById(Long id) 方法，用于删除用户信息。删除用户信息后，我们需要同时清除缓存中的用户信息。

代码示例：

import org.springframework.cache.annotation.CacheEvict;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @CacheEvict(value = "users", key = "#id")
    public void deleteUserById(Long id) {
        System.out.println("从数据库删除用户，id = " + id); // 模拟数据库删除
        // 实际应该从数据库删除
    }
}

解释：

@CacheEvict(value = "users", key = "#id")：
- value = "users"：指定缓存的名称为 "users"。
- key = "#id"：指定要清除的缓存的 key，这里使用 SpEL 表达式 #id，表示使用方法参数 id 作为 key。

使用效果：

每次调用 userService.deleteUserById(id) 时，都会执行方法体，删除数据库中的用户信息，并清除 "users" 缓存中 key 为 id 的数据。

重要提示：

allEntries = true 属性可以用来清除整个缓存区域。就像你要把整个冰箱都清空！
beforeInvocation = true 属性可以用来在方法执行之前清除缓存。这在某些情况下很有用，例如，你需要先清除缓存，再执行方法。默认是 false，即在方法执行之后清除缓存。

4. @Caching：组合拳，威力加倍！

@Caching 注解用于组合多个缓存操作，可以同时使用 @Cacheable、@CachePut 和 @CacheEvict 注解。

场景： 假设我们有一个 ProductService，其中有一个 getProductById(Long id) 方法，用于根据商品ID查询商品信息。我们需要缓存商品信息，并在更新商品信息后更新缓存，并在删除商品信息后清除缓存。

代码示例：

import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.Caching;
import org.springframework.stereotype.Service;

@Service
public class ProductService {

    @Caching(
            cacheable = {
                    @Cacheable(value = "products", key = "#id")
            },
            put = {
                    @CachePut(value = "products", key = "#result.id")
            },
            evict = {
                    @CacheEvict(value = "products", key = "#id")
            }
    )
    public Product getProductById(Long id) {
        System.out.println("从数据库查询商品，id = " + id); // 模拟数据库查询
        // 实际应该从数据库查询
        return new Product(id, "商品" + id, 100.0);
    }

    public void updateProduct(Product product) {
        // 更新数据库
    }

    public void deleteProductById(Long id) {
        // 删除数据库中的商品
    }
}

解释：

@Caching 注解包含了三个缓存操作：
- @Cacheable(value = "products", key = "#id")：缓存查询结果。
- @CachePut(value = "products", key = "#result.id")：更新缓存。注意这里使用了 #result.id，表示使用方法的 返回值 的 id 属性作为 key。
- @CacheEvict(value = "products", key = "#id")：清除缓存。

使用效果：

第一次调用 productService.getProductById(1L) 时，会执行方法体，从数据库查询商品信息，并将结果缓存到 "products" 缓存中，key 为 "1"。
第二次调用 productService.getProductById(1L) 时，由于缓存中已经存在 key 为 "1" 的数据，所以直接从缓存中返回结果，而不会执行方法体。
调用 productService.updateProduct(product) 时，会更新数据库中的商品信息，并将更新后的商品信息更新到 "products" 缓存中，key 为 product.getId()。 (需要添加相应的 @CachePut 注解到 updateProduct 方法上，这里只是演示 @Caching 的用法)
调用 productService.deleteProductById(1L) 时，会删除数据库中的商品信息，并清除 "products" 缓存中 key 为 "1" 的数据。 (需要添加相应的 @CacheEvict 注解到 deleteProductById 方法上，这里只是演示 @Caching 的用法)

Spring Caching 的配置：让缓存跑起来！

要让 Spring Caching 工作起来，我们需要进行一些配置。

启用缓存注解：

在 Spring Boot 应用中，只需要在启动类上添加 @EnableCaching 注解即可启用缓存注解。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
public class MyApplication {

   public static void main(String[] args) {
       SpringApplication.run(MyApplication.class, args);
   }
}

配置缓存管理器：

Spring Caching 需要一个缓存管理器来管理缓存。 Spring Boot 会自动配置一个默认的缓存管理器，但我们可以自定义缓存管理器，以使用不同的缓存提供者。

例如，要使用 Redis 作为缓存提供者，我们需要添加 Redis 的依赖，并配置 Redis 连接信息。

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

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

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

Spring Boot 会自动配置一个 RedisCacheManager。

如果需要更细粒度的控制，可以自定义 RedisCacheManager：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;

import java.time.Duration;

@Configuration
public class RedisCacheConfig {

   @Bean
   public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
       RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
               .entryTtl(Duration.ofMinutes(30)) // 设置缓存过期时间为 30 分钟
               .disableCachingNullValues() // 不缓存空值
               .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer())); // 使用 JSON 序列化

       return RedisCacheManager.builder(redisConnectionFactory)
               .cacheDefaults(cacheConfiguration)
               .build();
   }
}

Spring Caching 的高级用法：让缓存更智能！

自定义 KeyGenerator： 如果你觉得默认的 key 生成策略不够灵活，可以自定义 KeyGenerator 来生成缓存的 key。例如，你可以将多个参数组合成一个 key。
使用 CacheResolver： 如果你需要根据不同的条件使用不同的缓存，可以使用 CacheResolver 来动态选择缓存。就像你有多个冰箱，根据不同的食物选择不同的冰箱存放。
异步缓存： 可以使用 Spring 的异步任务机制来异步更新缓存，避免阻塞主线程。

总结：Spring Caching，让你的代码更上一层楼！

Spring Caching 是一个强大的缓存抽象层，它简化了缓存的使用，提高了应用程序的性能和可伸缩性。掌握 Spring Caching 的核心注解和配置，你就可以轻松地为你的应用程序添加缓存功能，让你的代码像火箭一样飞起来！ 🚀

希望今天的讲解对你有所帮助！记住，缓存是优化性能的利器，但也要谨慎使用，避免出现缓存不一致等问题。要根据实际情况选择合适的缓存策略，才能发挥缓存的最大威力！ 💪

下次再见！ 👋

Spring Caching：缓存抽象与注解，让你的代码飞起来！🚀

发表回复 取消回复

发表回复取消回复