SpringBoot啟動(dòng)時(shí)將數(shù)據(jù)庫(kù)數(shù)據(jù)預(yù)加載到Redis緩存的幾種實(shí)現(xiàn)方案

更新時(shí)間：2025年09月29日 09:32:37 作者：塔中妖

在實(shí)際項(xiàng)目開(kāi)發(fā)中,我們經(jīng)常需要在應(yīng)用啟動(dòng)時(shí)將一些固定的、頻繁訪問(wèn)的數(shù)據(jù)從數(shù)據(jù)庫(kù)預(yù)加載到 Redis 緩存中,以提高系統(tǒng)性能,本文將介紹幾種實(shí)現(xiàn)方案,需要的朋友可以參考下

引言

在實(shí)際項(xiàng)目開(kāi)發(fā)中，我們經(jīng)常需要在應(yīng)用啟動(dòng)時(shí)將一些固定的、頻繁訪問(wèn)的數(shù)據(jù)從數(shù)據(jù)庫(kù)預(yù)加載到 Redis 緩存中，以提高系統(tǒng)性能。本文將介紹幾種實(shí)現(xiàn)方案。

方案一：使用 @PostConstruct 注解

這是最簡(jiǎn)單直接的方式，在 Spring Bean 初始化完成后執(zhí)行預(yù)加載邏輯。

@Component
@Slf4j
public class CachePreloader {
    
    @Autowired
    private UserService userService;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @PostConstruct
    public void preloadCache() {
        log.info("開(kāi)始預(yù)加載緩存數(shù)據(jù)...");
        
        try {
            // 加載用戶基礎(chǔ)信息
            List<User> users = userService.getAllActiveUsers();
            for (User user : users) {
                String key = "user:" + user.getId();
                redisTemplate.opsForValue().set(key, user, Duration.ofHours(24));
            }
            
            // 加載系統(tǒng)配置
            List<SystemConfig> configs = systemConfigService.getAllConfigs();
            for (SystemConfig config : configs) {
                String key = "config:" + config.getKey();
                redisTemplate.opsForValue().set(key, config.getValue(), Duration.ofDays(7));
            }
            
            log.info("緩存預(yù)加載完成，共加載 {} 條用戶數(shù)據(jù)，{} 條配置數(shù)據(jù)", 
                    users.size(), configs.size());
                    
        } catch (Exception e) {
            log.error("緩存預(yù)加載失敗", e);
        }
    }
}

方案二：實(shí)現(xiàn) ApplicationRunner 接口

ApplicationRunner 在應(yīng)用啟動(dòng)完成后執(zhí)行，可以獲取命令行參數(shù)，更適合復(fù)雜的初始化邏輯。

@Component
@Order(1) // 設(shè)置執(zhí)行順序
@Slf4j
public class CacheApplicationRunner implements ApplicationRunner {
    
    @Autowired
    private DataPreloadService dataPreloadService;
    
    @Override
    public void run(ApplicationArguments args) throws Exception {
        log.info("ApplicationRunner 開(kāi)始執(zhí)行緩存預(yù)加載...");
        
        // 檢查是否需要預(yù)加載
        if (args.containsOption("skip-cache-preload")) {
            log.info("跳過(guò)緩存預(yù)加載");
            return;
        }
        
        dataPreloadService.preloadAllCache();
        log.info("ApplicationRunner 緩存預(yù)加載完成");
    }
}

方案三：監(jiān)聽(tīng) ApplicationReadyEvent 事件

這種方式在應(yīng)用完全啟動(dòng)就緒后執(zhí)行，是最安全的預(yù)加載時(shí)機(jī)。

@Component
@Slf4j
public class CacheEventListener {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private ProductService productService;
    
    @EventListener
    public void handleApplicationReady(ApplicationReadyEvent event) {
        log.info("應(yīng)用啟動(dòng)完成，開(kāi)始預(yù)加載緩存...");
        
        // 異步執(zhí)行預(yù)加載，避免阻塞啟動(dòng)
        CompletableFuture.runAsync(() -> {
            try {
                preloadProductCache();
                preloadCategoryCache();
            } catch (Exception e) {
                log.error("異步預(yù)加載緩存失敗", e);
            }
        });
    }
    
    private void preloadProductCache() {
        List<Product> hotProducts = productService.getHotProducts();
        hotProducts.forEach(product -> {
            String key = "hot_product:" + product.getId();
            redisTemplate.opsForValue().set(key, product, Duration.ofHours(12));
        });
        log.info("熱門(mén)商品緩存預(yù)加載完成，共 {} 條", hotProducts.size());
    }
    
    private void preloadCategoryCache() {
        List<Category> categories = productService.getAllCategories();
        redisTemplate.opsForValue().set("all_categories", categories, Duration.ofDays(1));
        log.info("商品分類(lèi)緩存預(yù)加載完成");
    }
}

方案四：創(chuàng)建專門(mén)的預(yù)加載服務(wù)

將預(yù)加載邏輯封裝成獨(dú)立的服務(wù)，便于管理和測(cè)試。

@Service
@Slf4j
public class DataPreloadService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private DictService dictService;
    
    @Autowired
    private RegionService regionService;
    
    /**
     * 預(yù)加載所有緩存數(shù)據(jù)
     */
    public void preloadAllCache() {
        long startTime = System.currentTimeMillis();
        
        try {
            // 并行加載多種數(shù)據(jù)
            CompletableFuture<Void> dictFuture = CompletableFuture.runAsync(this::preloadDictCache);
            CompletableFuture<Void> regionFuture = CompletableFuture.runAsync(this::preloadRegionCache);
            
            // 等待所有任務(wù)完成
            CompletableFuture.allOf(dictFuture, regionFuture).join();
            
            long endTime = System.currentTimeMillis();
            log.info("所有緩存預(yù)加載完成，耗時(shí): {} ms", endTime - startTime);
            
        } catch (Exception e) {
            log.error("緩存預(yù)加載過(guò)程中發(fā)生異常", e);
        }
    }
    
    /**
     * 預(yù)加載數(shù)據(jù)字典
     */
    private void preloadDictCache() {
        try {
            Map<String, List<DictItem>> dictMap = dictService.getAllDictItems();
            dictMap.forEach((dictType, items) -> {
                String key = "dict:" + dictType;
                redisTemplate.opsForValue().set(key, items, Duration.ofDays(30));
            });
            log.info("數(shù)據(jù)字典緩存預(yù)加載完成，共 {} 種類(lèi)型", dictMap.size());
        } catch (Exception e) {
            log.error("數(shù)據(jù)字典緩存預(yù)加載失敗", e);
        }
    }
    
    /**
     * 預(yù)加載地區(qū)數(shù)據(jù)
     */
    private void preloadRegionCache() {
        try {
            List<Region> regions = regionService.getAllRegions();
            redisTemplate.opsForValue().set("all_regions", regions, Duration.ofDays(30));
            
            // 按層級(jí)緩存
            Map<Integer, List<Region>> regionsByLevel = regions.stream()
                .collect(Collectors.groupingBy(Region::getLevel));
            
            regionsByLevel.forEach((level, levelRegions) -> {
                String key = "regions_level:" + level;
                redisTemplate.opsForValue().set(key, levelRegions, Duration.ofDays(30));
            });
            
            log.info("地區(qū)數(shù)據(jù)緩存預(yù)加載完成，共 {} 條記錄", regions.size());
        } catch (Exception e) {
            log.error("地區(qū)數(shù)據(jù)緩存預(yù)加載失敗", e);
        }
    }
}

配置文件控制

在 application.yml 中添加配置項(xiàng)，控制預(yù)加載行為：

app:
  cache:
    preload:
      enabled: true
      async: true
      timeout: 30000  # 超時(shí)時(shí)間(毫秒)
      batch-size: 1000  # 批處理大小

對(duì)應(yīng)的配置類(lèi)：

@ConfigurationProperties(prefix = "app.cache.preload")
@Data
public class CachePreloadProperties {
    private boolean enabled = true;
    private boolean async = true;
    private long timeout = 30000;
    private int batchSize = 1000;
}

最佳實(shí)踐建議

1. 異常處理

預(yù)加載過(guò)程中的異常不應(yīng)該影響應(yīng)用啟動(dòng)：

@PostConstruct
public void preloadCache() {
    try {
        // 預(yù)加載邏輯
    } catch (Exception e) {
        log.error("緩存預(yù)加載失敗，但不影響應(yīng)用啟動(dòng)", e);
        // 可以發(fā)送告警通知
    }
}

2. 分批處理

對(duì)于大量數(shù)據(jù)，應(yīng)該分批處理避免內(nèi)存溢出：

private void preloadLargeDataset() {
    int pageSize = cachePreloadProperties.getBatchSize();
    int pageNum = 0;
    
    while (true) {
        List<DataEntity> dataList = dataService.getDataByPage(pageNum, pageSize);
        if (dataList.isEmpty()) {
            break;
        }
        
        // 批量寫(xiě)入 Redis
        dataList.forEach(data -> {
            String key = "data:" + data.getId();
            redisTemplate.opsForValue().set(key, data, Duration.ofHours(6));
        });
        
        pageNum++;
        log.info("已預(yù)加載第 {} 批數(shù)據(jù)，本批 {} 條", pageNum, dataList.size());
    }
}

3. 監(jiān)控和告警

添加預(yù)加載狀態(tài)監(jiān)控：

@Component
public class CachePreloadMonitor {
    
    private final MeterRegistry meterRegistry;
    private final Counter preloadSuccessCounter;
    private final Counter preloadFailureCounter;
    
    public CachePreloadMonitor(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.preloadSuccessCounter = Counter.builder("cache.preload.success").register(meterRegistry);
        this.preloadFailureCounter = Counter.builder("cache.preload.failure").register(meterRegistry);
    }
    
    public void recordSuccess(String cacheType, long count) {
        preloadSuccessCounter.increment();
        Gauge.builder("cache.preload.count")
            .tag("type", cacheType)
            .register(meterRegistry, count, Number::doubleValue);
    }
    
    public void recordFailure(String cacheType) {
        preloadFailureCounter.increment();
    }
}

總結(jié)

選擇合適的預(yù)加載方案需要考慮以下因素：

@PostConstruct: 適合簡(jiǎn)單的預(yù)加載邏輯
ApplicationRunner: 適合需要命令行參數(shù)的場(chǎng)景
ApplicationReadyEvent: 最安全的預(yù)加載時(shí)機(jī)
專門(mén)的服務(wù): 適合復(fù)雜的預(yù)加載需求

無(wú)論選擇哪種方案，都要注意異常處理、性能優(yōu)化和監(jiān)控告警，確保預(yù)加載過(guò)程不會(huì)影響應(yīng)用的正常啟動(dòng)和運(yùn)行。

以上就是SpringBoot啟動(dòng)時(shí)將數(shù)據(jù)庫(kù)數(shù)據(jù)預(yù)加載到Redis緩存的幾種實(shí)現(xiàn)方案的詳細(xì)內(nèi)容，更多關(guān)于SpringBoot數(shù)據(jù)加載到Redis緩存的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: