@Cacheable(cacheNames = "cache:cacheByKey", key = "#id")
    public Integer cacheByKey(@PathVariable("id") Integer id) throws InterruptedException {
        Thread.sleep(5000);
        log.info("執(zhí)行了cacheByKey方法" + id);
        return id;
    }

package com.maple.redis.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
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.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;
import java.time.Duration;

/**
 * @author 笑小楓
 * @date 2025/1/7
 */
@Slf4j
@Configuration
@EnableCaching
public class CacheConfig extends CachingConfigurerSupport {

    /**
     * 默認(rèn)緩存管理器
     * 只有CacheManger才能掃描到cacheable注解
     * spring提供了緩存支持Cache接口，實現(xiàn)了很多個緩存類，其中包括RedisCache。但是我們需要對其進(jìn)行配置，這里就是配置RedisCache
     */
    @Bean
    @Primary
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        return RedisCacheManager.RedisCacheManagerBuilder
                //Redis鏈接工廠
                .fromConnectionFactory(redisConnectionFactory)
                //緩存配置 通用配置  默認(rèn)存儲一小時
                .cacheDefaults(getCacheConfigurationWithTtl(Duration.ofHours(1)))
                //配置同步修改或刪除  put/evict
                .transactionAware()
                //對于不同的cacheName我們可以設(shè)置不同的過期時間
                .withCacheConfiguration("cache2:cacheByUser", getCacheConfigurationWithTtl(Duration.ofHours(2)))
                .build();
    }

    /**
     * 創(chuàng)建并返回一個CacheManager Bean，用于管理Redis緩存。
     * 主要返回結(jié)果為null時使用，會緩存null值，緩存時間為10分鐘，防止緩存穿透。
     * 使用時通過 cacheManager = "cacheNullManager" 指定使用該緩存管理器。
     */
    @Bean
    public CacheManager cacheNullManager(RedisConnectionFactory redisConnectionFactory) {
        return RedisCacheManager.RedisCacheManagerBuilder
                //Redis鏈接工廠
                .fromConnectionFactory(redisConnectionFactory)
                //緩存配置 通用配置  默認(rèn)存儲一小時
                .cacheDefaults(RedisCacheConfiguration
                        .defaultCacheConfig()
                        // 設(shè)置key為String
                        .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                        // 設(shè)置value 為自動轉(zhuǎn)Json的Object
                        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(RedisSerializer.json()))
                        .entryTtl(Duration.ofMinutes(10)))
                //配置同步修改或刪除  put/evict
                .transactionAware()
                .build();
    }

    /**
     * 緩存的基本配置對象
     */
    private RedisCacheConfiguration getCacheConfigurationWithTtl(Duration duration) {
        return RedisCacheConfiguration
                .defaultCacheConfig()
                //設(shè)置key value的序列化方式
                // 設(shè)置key為String
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                // 設(shè)置value 為自動轉(zhuǎn)Json的Object
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(RedisSerializer.json()))
                // 不緩存null
                .disableCachingNullValues()
                // 設(shè)置緩存的過期時間
                .entryTtl(duration);
    }

    /**
     * 緩存的異常處理
     */
    @Bean
    @Override
    public CacheErrorHandler errorHandler() {
        // 異常處理，當(dāng)Redis發(fā)生異常時，打印日志，但是程序正常走
        log.info("初始化 -> [{}]", "Redis CacheErrorHandler");
        return new CacheErrorHandler() {
            @Override
            public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
                log.error("Redis occur handleCacheGetError：key -> [{}]", key, e);
            }

            @Override
            public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
                log.error("Redis occur handleCachePutError：key -> [{}]；value -> [{}]", key, value, e);
            }

            @Override
            public void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {
                log.error("Redis occur handleCacheEvictError：key -> [{}]", key, e);
            }

            @Override
            public void handleCacheClearError(RuntimeException e, Cache cache) {
                log.error("Redis occur handleCacheClearError：", e);
            }
        };
    }

    @Override
    @Bean("myKeyGenerator")
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuffer sb = new StringBuffer();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }
}

package com.maple.redis.controller;

import com.maple.redis.bean.User;
import lombok.extern.slf4j.Slf4j;
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.web.bind.annotation.*;

/**
 * @author 笑小楓
 * @date 2025/1/7
 */
@Slf4j
@RestController
@RequestMapping("/cache")
public class TestCacheController {

    /**
     * 獲取簡單緩存數(shù)據(jù)。
     *
     * <p>通過@Cacheable注解，該方法的結(jié)果會被緩存到名為"cache:simpleCache"的緩存中。
     * 如果在緩存中找到相同請求的結(jié)果，將直接返回緩存的值，避免重復(fù)執(zhí)行方法體中的邏輯。
     *
     * <p>方法內(nèi)部，使用Thread.sleep(5000)模擬了一個耗時操作，
     */
    @GetMapping("/simpleCache")
    @Cacheable(cacheNames = "cache:simpleCache")
    public String simpleCache() throws InterruptedException {
        Thread.sleep(5000);
        log.info("執(zhí)行了simpleCache方法");
        return "test";
    }

    /**
     * 如果緩存中存在對應(yīng)的ID，則直接從緩存中獲取結(jié)果，避免重復(fù)執(zhí)行耗時操作。
     * 如果緩存中不存在，則執(zhí)行方法體中的邏輯，將結(jié)果存入緩存并返回。
     * 方法執(zhí)行過程中，通過Thread.sleep模擬了一個耗時操作。
     */
    @GetMapping("/{id}")
    @Cacheable(cacheNames = "cache:cacheByKey", key = "#id")
    public Integer cacheByKey(@PathVariable("id") Integer id) throws InterruptedException {
        Thread.sleep(5000);
        log.info("執(zhí)行了cacheByKey方法" + id);
        return id;
    }

    /**
     * <p>該方法使用@Caching注解集成了多個緩存策略：</p>
     * <ul>
     *     <li>
     *         當(dāng)方法返回值為null時（即緩存穿透情況），使用名為"cacheNullManager"的CacheManager進(jìn)行緩存處理，
     *         緩存名稱為"cache2:cacheByKey"，緩存鍵為傳入的用戶ID，并設(shè)置緩存過期時間為10分鐘。
     *         這通過@Cacheable注解的cacheManager屬性指定緩存管理器，unless屬性設(shè)置緩存條件（當(dāng)結(jié)果為null時緩存）。
     *     </li>
     *     <li>
     *         當(dāng)方法返回值不為null時，使用默認(rèn)的CacheManager進(jìn)行緩存處理，
     *         緩存名稱和鍵的設(shè)置與上述相同，但此時緩存管理器為默認(rèn)配置。
     *         這通過另一個@Cacheable注解實現(xiàn)，其unless屬性設(shè)置為當(dāng)結(jié)果為null時不緩存。
     *     </li>
     * </ul>
     *
     * <p>在方法執(zhí)行過程中，通過Thread.sleep模擬了一個耗時操作。</p>
     */
    @Caching(
            cacheable = {
                    //result為null時,屬于緩存穿透情況，使用cacheNullManager緩存管理器進(jìn)行緩存，并且設(shè)置過期時間為10分鐘。
                    @Cacheable(cacheNames = "cache2:cacheByKey", key = "#id", unless = "#result != null", cacheManager = "cacheNullManager"),
                    //result不為null時,使用默認(rèn)緩存管理器進(jìn)行緩存。
                    @Cacheable(cacheNames = "cache2:cacheByKey", key = "#id", unless = "#result == null")
            }
    )
    @GetMapping("/cacheMore/{id}")
    public User cacheMore(@PathVariable("id") Integer id) throws InterruptedException {
        Thread.sleep(5000);
        if (id > 100) {
            return null;
        } else {
            return new User(id, "zhangsan");
        }
    }

    @PostMapping("/cacheByUser")
    @Cacheable(cacheNames = "cache2:cacheByUser", key = "#user.id")
    public User cacheByUser(@RequestBody User user) throws InterruptedException {
        Thread.sleep(5000);
        log.info("執(zhí)行了cacheByUser方法" + user.getId());
        return user;
    }

    @PostMapping("/cacheByIdAndName")
    @Cacheable(cacheNames = "cache2:cacheByUser", key = "#user.id")
    public User cacheByIdAndName(@RequestBody User user) throws InterruptedException {
        Thread.sleep(5000);
        log.info("執(zhí)行了cacheByUser方法" + user.getId());
        return user;
    }

    /**
     * 根據(jù)用戶ID大于100的條件進(jìn)行緩存處理。
     *
     * @param user 用戶對象，包含用戶ID等信息。
     * @return 返回傳入的用戶對象。
     * @throws InterruptedException 如果線程被中斷，則拋出此異常。
     *
     *                              通過@Cacheable注解實現(xiàn)了緩存功能，當(dāng)請求的用戶ID大于100時，會觸發(fā)緩存機制。
     *                              緩存的名稱設(shè)置為"cache2:cacheByUser"，緩存的鍵為傳入的用戶對象的ID。
     *                              如果緩存中已存在對應(yīng)的用戶數(shù)據(jù)，則直接從緩存中獲取并返回，避免重復(fù)執(zhí)行耗時操作。
     *                              如果緩存中不存在，則執(zhí)行方法體中的邏輯，將結(jié)果存入緩存并返回。
     *                              在方法執(zhí)行過程中，通過Thread.sleep模擬了一個耗時操作。
     */
    @PostMapping("/cacheByUserIdGt100")
    @Cacheable(cacheNames = "cache2:cacheByUser", key = "#user.id", condition = "#user.id > 100")
    public User cacheByUserIdGt100(@RequestBody User user) throws InterruptedException {
        Thread.sleep(5000);
        log.info("執(zhí)行了cacheByUser方法" + user.getId());
        return user;
    }

    /**
     * 更新用戶信息。
     * <p>
     * 使用@CachePut注解將更新后的用戶信息存入緩存中。
     * 緩存的名稱設(shè)置為"cache2:cacheByUser"，緩存的鍵為傳入的User對象的ID。
     * 如果緩存中已存在對應(yīng)的用戶數(shù)據(jù)，則更新緩存中的值；如果不存在，則創(chuàng)建新的緩存條目。
     * 在方法執(zhí)行過程中，通過Thread.sleep模擬了一個耗時操作。
     */
    @PostMapping("/updateUser")
    @CachePut(cacheNames = "cache2:cacheByUser", key = "#user.id")
    public User updateUser(@RequestBody User user) throws InterruptedException {
        Thread.sleep(5000);
        log.info("執(zhí)行了saveUser方法" + user.getId());
        return user;
    }

    /**
     * 刪除指定ID的用戶，并從緩存中移除對應(yīng)的數(shù)據(jù)。
     * <p>
     * 使用@CacheEvict注解用于從緩存中移除指定ID的用戶數(shù)據(jù)。
     * 緩存的名稱設(shè)置為"cache2:cacheByUser"，緩存的鍵為傳入的用戶ID。
     * 在執(zhí)行刪除操作前，方法通過Thread.sleep模擬了一個耗時操作。
     */
    @DeleteMapping("/{id}")
    @CacheEvict(cacheNames = "cache2:cacheByUser", key = "#id")
    public void deleteUser(@PathVariable("id") Integer id) throws InterruptedException {
        Thread.sleep(10000);
        log.info("執(zhí)行了deleteUser方法" + id);
    }
}

@Nullable
    private Object execute(final CacheOperationInvoker invoker, Method method, CacheOperationContexts contexts) {
        if (contexts.isSynchronized()) {
            CacheOperationContext context = (CacheOperationContext)contexts.get(CacheableOperation.class).iterator().next();
            if (!this.isConditionPassing(context, CacheOperationExpressionEvaluator.NO_RESULT)) {
                return this.invokeOperation(invoker);
            }

            Object key = this.generateKey(context, CacheOperationExpressionEvaluator.NO_RESULT);
            Cache cache = (Cache)context.getCaches().iterator().next();

            try {
                return this.wrapCacheValue(method, this.handleSynchronizedGet(invoker, key, cache));
            } catch (Cache.ValueRetrievalException var10) {
                Cache.ValueRetrievalException ex = var10;
                ReflectionUtils.rethrowRuntimeException(ex.getCause());
            }
        }

        this.processCacheEvicts(contexts.get(CacheEvictOperation.class), true, CacheOperationExpressionEvaluator.NO_RESULT);
        Cache.ValueWrapper cacheHit = this.findCachedItem(contexts.get(CacheableOperation.class));
        List<CachePutRequest> cachePutRequests = new ArrayList();
        if (cacheHit == null) {
            this.collectPutRequests(contexts.get(CacheableOperation.class), CacheOperationExpressionEvaluator.NO_RESULT, cachePutRequests);
        }

        Object cacheValue;
        Object returnValue;
        if (cacheHit != null && !this.hasCachePut(contexts)) {//如果緩存有，則從緩存取
            cacheValue = cacheHit.get();
            returnValue = this.wrapCacheValue(method, cacheValue);
        } else {//緩存沒有，執(zhí)行原始方法
            returnValue = this.invokeOperation(invoker);
            cacheValue = this.unwrapReturnValue(returnValue);//再存緩存
        }

        this.collectPutRequests(contexts.get(CachePutOperation.class), cacheValue, cachePutRequests);
        Iterator var8 = cachePutRequests.iterator();

        while(var8.hasNext()) {
            CachePutRequest cachePutRequest = (CachePutRequest)var8.next();
            cachePutRequest.apply(cacheValue);
        }

        this.processCacheEvicts(contexts.get(CacheEvictOperation.class), false, cacheValue);
        return returnValue;
    }