淘宝商品详情API性能优化：Java缓存策略与数据同步方案

import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.LoadingCache;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.TimeUnit;
@Configuration
public class LocalCacheConfig {
    /**
     * 淘宝商品本地缓存配置
     * - 最大容量：10000条（热门商品）
     * - 过期策略：访问后5分钟过期（避免内存占用过高）
     * - 自动加载：缓存未命中时自动调用Redis/API加载
     */
    @Bean
    public LoadingCache<String, TaobaoItemDetailDTO> taobaoItemLocalCache() {
        return Caffeine.newBuilder()
                .maximumSize(10000) // 最大缓存条目
                .expireAfterAccess(5, TimeUnit.MINUTES) // 访问后过期
                .recordStats() // 记录缓存统计（命中率/耗时）
                .build(key -> loadItemFromRedisOrApi(key)); // 缓存未命中时的加载逻辑
    }
    // 缓存加载器：先查Redis，再查API
    private TaobaoItemDetailDTO loadItemFromRedisOrApi(String itemId) {
        // 第二步：查Redis（下文实现）
        TaobaoItemDetailDTO redisData = redisTemplate.opsForValue().get("taobao:item:" + itemId);
        if (redisData != null) {
            return redisData;
        }
        // 第三步：查淘宝API
        TaobaoItemDetailDTO apiData = taobaoItemApiService.callTaobaoApi(itemId);
        if (apiData != null) {
            // 写入Redis（设置过期时间）
            redisTemplate.opsForValue().set("taobao:item:" + itemId, apiData, 30, TimeUnit.MINUTES);
        }
        return apiData;
    }
}

@Service
@RequiredArgsConstructor
public class TaobaoItemCacheService {
    private final StringRedisTemplate redisTemplate;
    private static final String CACHE_KEY_PREFIX = "taobao:item:";
    private static final String PRICE_KEY_PREFIX = "taobao:item:price:";
    // 缓存商品全量数据（30分钟过期）
    public void cacheItemDetail(String itemId, TaobaoItemDetailDTO dto) {
        String key = CACHE_KEY_PREFIX + itemId;
        redisTemplate.opsForValue().set(
            key, 
            JSON.toJSONString(dto), 
            30, 
            TimeUnit.MINUTES
        );
    }
    // 缓存商品价格（5分钟过期，高频更新）
    public void cacheItemPrice(String itemId, String price) {
        String key = PRICE_KEY_PREFIX + itemId;
        redisTemplate.opsForValue().set(
            key, 
            price, 
            5, 
            TimeUnit.MINUTES
        );
    }
    // 获取缓存数据（优先查价格缓存，再查全量缓存）
    public TaobaoItemDetailDTO getCachedItem(String itemId) {
        // 1. 先查价格缓存（实时性要求高）
        String price = redisTemplate.opsForValue().get(PRICE_KEY_PREFIX + itemId);
        // 2. 再查全量缓存
        String fullData = redisTemplate.opsForValue().get(CACHE_KEY_PREFIX + itemId);
        if (fullData == null) {
            return null;
        }
        TaobaoItemDetailDTO dto = JSON.parseObject(fullData, TaobaoItemDetailDTO.class);
        // 覆盖最新价格（保证价格实时性）
        if (price != null) {
            dto.setPrice(price);
        }
        return dto;
    }
}

// 空值缓存（解决穿透）
public TaobaoItemDetailDTO getItemDetail(String itemId) {
    // 1. 查本地缓存
    TaobaoItemDetailDTO localData = taobaoItemLocalCache.get(itemId);
    if (localData != null) {
        // 空值标记，直接返回null
        if ("NULL".equals(localData.getNumIid())) {
            return null;
        }
        return localData;
    }
    // 2. 查Redis，无数据则加锁调用API
    String lockKey = "lock:taobao:item:" + itemId;
    boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, "1", 3, TimeUnit.SECONDS);
    if (locked) {
        try {
            // 调用API
            TaobaoItemDetailDTO apiData = taobaoItemApiService.callTaobaoApi(itemId);
            if (apiData == null) {
                // 空值缓存
                TaobaoItemDetailDTO nullDto = new TaobaoItemDetailDTO();
                nullDto.setNumIid("NULL");
                cacheItemDetail(itemId, nullDto);
                taobaoItemLocalCache.put(itemId, nullDto);
                return null;
            }
            // 缓存有效数据
            cacheItemDetail(itemId, apiData);
            taobaoItemLocalCache.put(itemId, apiData);
            return apiData;
        } finally {
            // 释放锁
            redisTemplate.delete(lockKey);
        }
    } else {
        // 等待锁释放，重试查缓存
        Thread.sleep(100);
        return getItemDetail(itemId);
    }
}

@Configuration
@EnableScheduling
public class DataSyncTask {
    private final TaobaoItemApiService taobaoItemApiService;
    private final TaobaoItemCacheService taobaoItemCacheService;
    private final List<String> hotItemIds = Arrays.asList("690123456789", "690123456790"); // 热门商品ID
    // 每5分钟同步热门商品价格（高频更新）
    @Scheduled(fixedRate = 5 * 60 * 1000)
    public void syncHotItemPrice() {
        log.info("开始同步热门商品价格");
        for (String itemId : hotItemIds) {
            try {
                // 调用API获取最新价格
                String latestPrice = taobaoItemApiService.getOnlyPrice(itemId);
                // 更新Redis价格缓存
                taobaoItemCacheService.cacheItemPrice(itemId, latestPrice);
                // 更新本地缓存（先查全量，再覆盖价格）
                TaobaoItemDetailDTO localData = taobaoItemLocalCache.getIfPresent(itemId);
                if (localData != null) {
                    localData.setPrice(latestPrice);
                    taobaoItemLocalCache.put(itemId, localData);
                }
            } catch (Exception e) {
                log.error("同步商品{}价格失败", itemId, e);
            }
        }
        log.info("热门商品价格同步完成");
    }
    // 每天凌晨2点全量同步基础信息
    @Scheduled(cron = "0 0 2 * * ?")
    public void syncAllItemBaseInfo() {
        log.info("开始全量同步商品基础信息");
        // 从数据库/配置读取全量商品ID，批量同步
        // ...
        log.info("全量商品基础信息同步完成");
    }
}

// 主动更新缓存
public void updateItemCache(String itemId) {
    // 1. 调用API获取最新数据
    TaobaoItemDetailDTO latestData = taobaoItemApiService.callTaobaoApi(itemId);
    if (latestData == null) {
        return;
    }
    // 2. 更新Redis
    taobaoItemCacheService.cacheItemDetail(itemId, latestData);
    // 3. 更新本地缓存
    taobaoItemLocalCache.put(itemId, latestData);
    log.info("主动更新商品{}缓存完成", itemId);
}

// 缓存命中率指标
Gauge.build()
    .name("taobao_item_cache_hit_rate")
    .help("淘宝商品缓存命中率")
    .register()
    .set(taobaoItemLocalCache.stats().hitRate());
// API调用次数指标
Counter.build()
    .name("taobao_api_call_count")
    .labelNames("status") // success/fail
    .help("淘宝API调用次数")
    .register()
    .labels("success")
    .inc();

// 降级开关（配置中心动态调整）
@Value("${taobao.api.degrade:false}")
private boolean degrade;
public TaobaoItemDetailDTO getItemDetail(String itemId) {
    if (degrade) {
        // 降级：仅返回缓存数据，不调用API
        return getCachedItem(itemId);
    }
    // 正常流程
    // ...
}