<!-- SpringBoot Web -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency><!-- Spring Cache 核心依賴 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<!-- Redis 依賴（分布式緩存） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- Caffeine 依賴（單機(jī)緩存，可選） -->
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.1.2</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

spring:
  # Redis 配置（分布式緩存）
  redis:
    host: localhost
    port: 6379
    password: 123456
    database: 0
    lettuce:
      pool:
        maximum-pool-size: 10
        minimum-idle: 2
  # 緩存配置
  cache:
    type: redis # 默認(rèn)使用Redis緩存（單機(jī)可改為caffeine）
    redis:
      time-to-live: 3600000 # 緩存過期時(shí)間（1小時(shí)，根據(jù)業(yè)務(wù)調(diào)整）
      cache-null-values: false # 不緩存null值，避免緩存穿透
    caffeine:
      time-to-live: 3600000 # 單機(jī)緩存過期時(shí)間
      initial-capacity: 100 # 初始緩存容量
      maximum-size: 1000 # 最大緩存數(shù)量（避免內(nèi)存溢出）
# 開啟Spring Cache注解支持
spring.cache.type: redis

import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Optional;
/**
 * 商品服務(wù)（Cache-Aside策略實(shí)現(xiàn)）
 */
@Service
public class ProductService {
    @Resource
    private ProductMapper productMapper;
    /**
     * 查詢商品：先查緩存，無則查數(shù)據(jù)庫(kù)，再寫入緩存
     * value：緩存名稱（自定義）
     * key：緩存key（用商品ID，確保唯一）
     */
    @Cacheable(value = "product", key = "#id")
    public Product getProductById(Long id) {
        // 緩存沒有時(shí)，查詢數(shù)據(jù)庫(kù)（實(shí)際項(xiàng)目可加日志）
        Optional<Product> product = productMapper.selectById(id);
        return product.orElse(null);
    }
    /**
     * 更新商品：先更新數(shù)據(jù)庫(kù)，再刪除緩存
     * @CacheEvict：刪除緩存，allEntries=false表示只刪除當(dāng)前key的緩存
     */
    @CacheEvict(value = "product", key = "#product.id")
    public void updateProduct(Product product) {
        // 1. 先更新數(shù)據(jù)庫(kù)
        productMapper.updateById(product);
        // 2. 注解自動(dòng)刪除緩存（無需手動(dòng)操作Redis）
    }
    /**
     * 刪除商品：先刪除數(shù)據(jù)庫(kù)，再刪除緩存
     */
    @CacheEvict(value = "product", key = "#id")
    public void deleteProduct(Long id) {
        // 1. 先刪除數(shù)據(jù)庫(kù)
        productMapper.deleteById(id);
        // 2. 注解自動(dòng)刪除緩存
    }
}

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
@Service
public class ProductService {
    @Resource
    private ProductMapper productMapper;
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    // 緩存key前綴（避免key沖突）
    private static final String CACHE_KEY_PREFIX = "product:";
    /**
     * 查詢商品（和Cache-Aside一致）
     */
    public Product getProductById(Long id) {
        String cacheKey = CACHE_KEY_PREFIX + id;
        // 1. 先查緩存
        Product product = (Product) redisTemplate.opsForValue().get(cacheKey);
        if (product != null) {
            return product;
        }
        // 2. 緩存無，查數(shù)據(jù)庫(kù)
        Optional<Product> dbProduct = productMapper.selectById(id);
        if (dbProduct.isPresent()) {
            // 3. 寫入緩存（設(shè)置過期時(shí)間，避免緩存雪崩）
            redisTemplate.opsForValue().set(cacheKey, dbProduct.get(), 1, TimeUnit.HOURS);
            return dbProduct.get();
        }
        return null;
    }
    /**
     * 更新商品：先更數(shù)據(jù)庫(kù)，再更緩存（Write-Through策略核心）
     */
    public void updateProduct(Product product) {
        // 1. 先更新數(shù)據(jù)庫(kù)
        productMapper.updateById(product);
        // 2. 同步更新緩存（覆蓋舊數(shù)據(jù)）
        String cacheKey = CACHE_KEY_PREFIX + product.getId();
        redisTemplate.opsForValue().set(cacheKey, product, 1, TimeUnit.HOURS);
    }
    /**
     * 刪除商品：先刪數(shù)據(jù)庫(kù)，再刪緩存
     */
    public void deleteProduct(Long id) {
        // 1. 先刪除數(shù)據(jù)庫(kù)
        productMapper.deleteById(id);
        // 2. 再刪除緩存
        String cacheKey = CACHE_KEY_PREFIX + id;
        redisTemplate.delete(cacheKey);
    }
}

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
@Service
public class ProductService {
    @Resource
    private ProductMapper productMapper;
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    private static final String CACHE_KEY_PREFIX = "product:";
    // 存儲(chǔ)臟數(shù)據(jù)（key：緩存key，value：商品對(duì)象）
    private final Map<String, Product> dirtyDataMap = new HashMap<>();
    /**
     * 查詢商品
     */
    public Product getProductById(Long id) {
        String cacheKey = CACHE_KEY_PREFIX + id;
        Product product = (Product) redisTemplate.opsForValue().get(cacheKey);
        if (product != null) {
            return product;
        }
        Optional<Product> dbProduct = productMapper.selectById(id);
        if (dbProduct.isPresent()) {
            redisTemplate.opsForValue().set(cacheKey, dbProduct.get(), 1, TimeUnit.HOURS);
            return dbProduct.get();
        }
        return null;
    }
    /**
     * 更新商品：先更緩存，標(biāo)記臟數(shù)據(jù)（Write-Back核心）
     */
    public void updateProduct(Product product) {
        String cacheKey = CACHE_KEY_PREFIX + product.getId();
        // 1. 更新緩存
        redisTemplate.opsForValue().set(cacheKey, product, 1, TimeUnit.HOURS);
        // 2. 標(biāo)記為臟數(shù)據(jù)
        dirtyDataMap.put(cacheKey, product);
    }
    /**
     * 定時(shí)同步臟數(shù)據(jù)到數(shù)據(jù)庫(kù)（每5分鐘執(zhí)行一次，可調(diào)整）
     */
    @Scheduled(cron = "0 0/5 * * * ?")
    public void syncDirtyDataToDb() {
        if (dirtyDataMap.isEmpty()) {
            return;
        }
        // 批量同步臟數(shù)據(jù)到數(shù)據(jù)庫(kù)
        for (Product product : dirtyDataMap.values()) {
            productMapper.updateById(product);
        }
        // 清空臟數(shù)據(jù)
        dirtyDataMap.clear();
    }
}

import org.springframework.cache.annotation.Cacheable;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
@Service
public class ProductService {
    @Resource
    private ProductMapper productMapper;
    @Resource
    private ThreadPoolTaskExecutor taskExecutor;
    /**
     * 查詢商品（不變）
     */
    @Cacheable(value = "product", key = "#id")
    public Product getProductById(Long id) {
        Optional<Product> product = productMapper.selectById(id);
        return product.orElse(null);
    }
    /**
     * 更新商品：延遲刪除緩存，解決并發(fā)競(jìng)態(tài)
     */
    public void updateProduct(Product product) {
        // 1. 先更新數(shù)據(jù)庫(kù)
        productMapper.updateById(product);
        // 2. 異步延遲100毫秒刪除緩存（延遲時(shí)間可調(diào)整）
        Long productId = product.getId();
        taskExecutor.schedule(() -> {
            // 手動(dòng)刪除緩存（替代@CacheEvict注解）
            redisTemplate.delete("product:" + productId);
        }, 100, TimeUnit.MILLISECONDS);
    }
}

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
@Service
public class ProductService {
    @Resource
    private ProductMapper productMapper;
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    @Resource
    private RedissonClient redissonClient;
    private static final String CACHE_KEY_PREFIX = "product:";
    private static final String LOCK_KEY_PREFIX = "product:lock:";
    /**
     * 查詢商品：加分布式鎖，避免競(jìng)態(tài)
     */
    public Product getProductById(Long id) {
        String cacheKey = CACHE_KEY_PREFIX + id;
        String lockKey = LOCK_KEY_PREFIX + id;
        RLock lock = redissonClient.getLock(lockKey);
        try {
            // 加鎖（10秒自動(dòng)釋放，避免死鎖）
            lock.lock(10, TimeUnit.SECONDS);
            // 1. 先查緩存
            Product product = (Product) redisTemplate.opsForValue().get(cacheKey);
            if (product != null) {
                return product;
            }
            // 2. 查數(shù)據(jù)庫(kù)，寫緩存
            Optional<Product> dbProduct = productMapper.selectById(id);
            if (dbProduct.isPresent()) {
                redisTemplate.opsForValue().set(cacheKey, dbProduct.get(), 1, TimeUnit.HOURS);
                return dbProduct.get();
            }
            return null;
        } finally {
            // 釋放鎖
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
    /**
     * 更新商品：加分布式鎖，避免競(jìng)態(tài)
     */
    public void updateProduct(Product product) {
        String cacheKey = CACHE_KEY_PREFIX + product.getId();
        String lockKey = LOCK_KEY_PREFIX + product.getId();
        RLock lock = redissonClient.getLock(lockKey);
        try {
            lock.lock(10, TimeUnit.SECONDS);
            // 1. 更新數(shù)據(jù)庫(kù)
            productMapper.updateById(product);
            // 2. 刪除緩存
            redisTemplate.delete(cacheKey);
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}