Apr 21 2023

Redis缓存穿透、击穿、雪崩解决方案：从理论到实践的完整防护体系

作者： 绝缘体..   发布： 2023-04-21 14:09   分类： 未分类   阅读：   抢沙发  
 
更多

Redis缓存穿透、击穿、雪崩解决方案：从理论到实践的完整防护体系

引言

在现代分布式系统中，Redis作为高性能的内存数据库，广泛应用于缓存层以提升系统响应速度和减轻后端数据库压力。然而，随着业务规模的扩大和访问量的增长，Redis缓存系统面临着三大核心挑战：缓存穿透、缓存击穿和缓存雪崩。这些问题不仅会影响系统性能，严重时甚至可能导致整个服务不可用。

本文将深入分析这三种缓存问题的本质原理，详细介绍各种解决方案的技术细节，并提供生产环境下的完整防护策略和监控告警机制设计，帮助开发者构建健壮的缓存系统。

缓存穿透问题分析与解决方案

什么是缓存穿透

缓存穿透是指查询一个不存在的数据，由于缓存层和数据库层都没有该数据，每次请求都会穿透到数据库层进行查询，但数据库也查不到对应的数据，导致请求无法被缓存，每次都直接打到数据库上。

缓存穿透的危害

  1. 数据库压力增大：大量无效请求直接访问数据库
  2. 资源浪费：CPU、内存、连接等资源被无效请求占用
  3. 系统性能下降：数据库响应变慢，影响正常业务请求
  4. 安全隐患：可能被恶意攻击者利用进行DDoS攻击

解决方案一：布隆过滤器

布隆过滤器是一种空间效率极高的概率型数据结构，用于判断一个元素是否在一个集合中。它具有以下特点：

  • 空间效率高：使用位数组存储数据
  • 查询速度快：O(k)时间复杂度，k为哈希函数个数
  • 无假阴性：如果布隆过滤器说元素不存在，那一定不存在
  • 有假阳性：如果布隆过滤器说元素存在，可能存在也可能不存在

布隆过滤器实现原理

public class BloomFilter {
    private final int[] bitArray;
    private final int size;
    private final int hashCount;
    
    public BloomFilter(int size, int hashCount) {
        this.size = size;
        this.hashCount = hashCount;
        this.bitArray = new int[size];
    }
    
    // 添加元素到布隆过滤器
    public void add(String key) {
        for (int i = 0; i < hashCount; i++) {
            int hash = hash(key, i);
            bitArray[hash % size] = 1;
        }
    }
    
    // 判断元素是否存在
    public boolean mightContain(String key) {
        for (int i = 0; i < hashCount; i++) {
            int hash = hash(key, i);
            if (bitArray[hash % size] == 0) {
                return false;
            }
        }
        return true;
    }
    
    // 哈希函数
    private int hash(String key, int seed) {
        return Math.abs((key.hashCode() + seed) % size);
    }
}

Redis集成布隆过滤器

@Service
public class CacheService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private BloomFilter bloomFilter;
    
    @PostConstruct
    public void initBloomFilter() {
        // 初始化布隆过滤器，预计100万数据，误判率0.01
        bloomFilter = new BloomFilter(10000000, 7);
        // 从数据库加载所有存在的key到布隆过滤器
        loadExistKeysToBloomFilter();
    }
    
    public Object getData(String key) {
        // 首先检查布隆过滤器
        if (!bloomFilter.mightContain(key)) {
            // 布隆过滤器判断不存在，直接返回null，避免访问数据库
            return null;
        }
        
        // 布隆过滤器判断可能存在，继续查询缓存
        Object cacheData = redisTemplate.opsForValue().get(key);
        if (cacheData != null) {
            return cacheData;
        }
        
        // 缓存未命中，查询数据库
        Object dbData = queryFromDatabase(key);
        if (dbData != null) {
            // 数据存在，写入缓存
            redisTemplate.opsForValue().set(key, dbData, Duration.ofMinutes(30));
            return dbData;
        } else {
            // 数据不存在，在缓存中设置空值标记，防止缓存穿透
            redisTemplate.opsForValue().set(key + ":null", "NULL", Duration.ofMinutes(5));
            return null;
        }
    }
    
    private void loadExistKeysToBloomFilter() {
        // 从数据库查询所有存在的key，添加到布隆过滤器中
        List<String> existKeys = database.getAllExistKeys();
        for (String key : existKeys) {
            bloomFilter.add(key);
        }
    }
}

解决方案二：缓存空值

对于查询结果为空的数据，也在缓存中存储一个特殊的空值标记，这样下次相同的请求可以直接从缓存返回，避免穿透到数据库。

public class CacheService {
    
    public Object getDataWithNullCache(String key) {
        // 检查是否存在空值标记
        String nullKey = key + ":null";
        if (redisTemplate.hasKey(nullKey)) {
            return null;
        }
        
        // 检查正常缓存
        Object cacheData = redisTemplate.opsForValue().get(key);
        if (cacheData != null) {
            return cacheData;
        }
        
        // 查询数据库
        Object dbData = queryFromDatabase(key);
        if (dbData != null) {
            // 存在数据，缓存真实数据
            redisTemplate.opsForValue().set(key, dbData, Duration.ofMinutes(30));
            return dbData;
        } else {
            // 不存在数据，缓存空值标记
            redisTemplate.opsForValue().set(nullKey, "NULL", Duration.ofMinutes(5));
            return null;
        }
    }
}

缓存击穿问题分析与解决方案

什么是缓存击穿

缓存击穿是指某个热点key在缓存过期的瞬间，大量并发请求同时访问这个key，导致所有请求都穿透到数据库，给数据库造成巨大压力。

缓存击穿的特点

  1. 高并发：多个请求同时访问同一个key
  2. 热点数据：访问频率很高的数据
  3. 缓存失效：正好在缓存过期的时刻
  4. 瞬时压力：短时间内数据库压力激增

解决方案一：互斥锁（分布式锁）

使用分布式锁确保同一时间只有一个线程去查询数据库并更新缓存，其他线程等待缓存更新完成后再从缓存获取数据。

@Service
public class CacheService {
    
    public Object getDataWithMutex(String key) {
        // 先查询缓存
        Object cacheData = redisTemplate.opsForValue().get(key);
        if (cacheData != null) {
            return cacheData;
        }
        
        // 缓存未命中，获取分布式锁
        String lockKey = "lock:" + key;
        String lockValue = UUID.randomUUID().toString();
        Boolean lockAcquired = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, lockValue, Duration.ofSeconds(10));
        
        if (lockAcquired) {
            try {
                // 再次检查缓存，防止其他线程已经更新了缓存
                cacheData = redisTemplate.opsForValue().get(key);
                if (cacheData != null) {
                    return cacheData;
                }
                
                // 查询数据库
                Object dbData = queryFromDatabase(key);
                if (dbData != null) {
                    // 更新缓存
                    redisTemplate.opsForValue().set(key, dbData, Duration.ofMinutes(30));
                }
                return dbData;
            } finally {
                // 释放锁
                releaseLock(lockKey, lockValue);
            }
        } else {
            // 获取锁失败，等待一段时间后重试
            try {
                Thread.sleep(100);
                return getDataWithMutex(key); // 递归重试
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return null;
            }
        }
    }
    
    private void releaseLock(String lockKey, String lockValue) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                       "return redis.call('del', KEYS[1]) else return 0 end";
        redisTemplate.execute(new DefaultRedisScript<>(script, Long.class),
                             Collections.singletonList(lockKey), lockValue);
    }
}

解决方案二：逻辑过期

设置永不过期的缓存，通过逻辑过期时间来判断数据是否需要更新。

public class CacheData {
    private Object data;
    private long expireTime;
    private boolean isExpired;
    
    // 构造函数、getter、setter
    public CacheData(Object data, long expireTime) {
        this.data = data;
        this.expireTime = expireTime;
        this.isExpired = false;
    }
    
    public boolean isExpired() {
        return System.currentTimeMillis() > expireTime;
    }
}

@Service
public class CacheService {
    
    public Object getDataWithLogicalExpire(String key) {
        // 获取带逻辑过期时间的缓存数据
        CacheData cacheData = (CacheData) redisTemplate.opsForValue().get(key);
        if (cacheData != null) {
            if (!cacheData.isExpired()) {
                // 未过期，直接返回数据
                return cacheData.getData();
            } else {
                // 已过期，异步更新缓存
                updateCacheAsync(key);
                // 返回过期数据，保证可用性
                return cacheData.getData();
            }
        }
        
        // 缓存未命中，查询数据库并设置缓存
        Object dbData = queryFromDatabase(key);
        if (dbData != null) {
            CacheData newCacheData = new CacheData(dbData, 
                System.currentTimeMillis() + 30 * 60 * 1000); // 30分钟过期
            redisTemplate.opsForValue().set(key, newCacheData);
        }
        return dbData;
    }
    
    private void updateCacheAsync(String key) {
        // 使用线程池异步更新缓存
        CompletableFuture.runAsync(() -> {
            try {
                Object dbData = queryFromDatabase(key);
                if (dbData != null) {
                    CacheData newCacheData = new CacheData(dbData, 
                        System.currentTimeMillis() + 30 * 60 * 1000);
                    redisTemplate.opsForValue().set(key, newCacheData);
                }
            } catch (Exception e) {
                log.error("异步更新缓存失败", e);
            }
        });
    }
}

解决方案三：热点数据预热

对于已知的热点数据，在系统启动时或定时任务中提前加载到缓存中。

@Component
public class HotDataPreloader {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @PostConstruct
    public void preloadHotData() {
        // 系统启动时预热热点数据
        loadHotData();
    }
    
    @Scheduled(cron = "0 0/30 * * * ?") // 每30分钟执行一次
    public void refreshHotData() {
        // 定时刷新热点数据
        loadHotData();
    }
    
    private void loadHotData() {
        // 获取热点数据列表
        List<String> hotKeys = getHotKeys();
        for (String key : hotKeys) {
            try {
                Object data = queryFromDatabase(key);
                if (data != null) {
                    // 设置较长的过期时间
                    redisTemplate.opsForValue().set(key, data, Duration.ofHours(1));
                }
            } catch (Exception e) {
                log.error("预热热点数据失败: {}", key, e);
            }
        }
    }
    
    private List<String> getHotKeys() {
        // 从配置文件或数据库获取热点key列表
        return Arrays.asList("hot_data_1", "hot_data_2", "hot_data_3");
    }
}

缓存雪崩问题分析与解决方案

什么是缓存雪崩

缓存雪崩是指在某个时间段内，大量缓存数据同时失效，导致大量请求同时穿透到数据库，造成数据库压力骤增，甚至宕机。

缓存雪崩的特点

  1. 批量失效：大量缓存同时过期
  2. 瞬时压力：数据库压力瞬间激增
  3. 连锁反应：可能导致数据库宕机，进而影响整个系统
  4. 恢复困难：系统可能需要较长时间才能恢复正常

解决方案一：设置不同的过期时间

为缓存数据设置随机的过期时间，避免大量数据同时失效。

@Service
public class CacheService {
    
    public void setDataWithRandomExpire(String key, Object data) {
        // 设置基础过期时间（分钟）
        int baseExpireMinutes = 30;
        // 添加随机时间（0-10分钟）
        int randomMinutes = new Random().nextInt(11);
        int totalExpireMinutes = baseExpireMinutes + randomMinutes;
        
        redisTemplate.opsForValue().set(key, data, 
            Duration.ofMinutes(totalExpireMinutes));
    }
    
    // 更精细的随机过期时间控制
    public void setDataWithRandomExpireAdvanced(String key, Object data, 
                                               int baseMinutes, int randomRange) {
        int randomMinutes = new Random().nextInt(randomRange + 1);
        int totalExpireMinutes = baseMinutes + randomMinutes;
        
        redisTemplate.opsForValue().set(key, data, 
            Duration.ofMinutes(totalExpireMinutes));
    }
}

解决方案二：多级缓存架构

构建多级缓存架构，包括本地缓存、分布式缓存和数据库，形成缓存层次结构。

@Service
public class MultiLevelCacheService {
    
    // 本地缓存（Caffeine）
    private final Cache<String, Object> localCache = Caffeine.newBuilder()
        .maximumSize(10000)
        .expireAfterWrite(5, TimeUnit.MINUTES)
        .build();
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    public Object getData(String key) {
        // 1. 先查本地缓存
        Object localData = localCache.getIfPresent(key);
        if (localData != null) {
            return localData;
        }
        
        // 2. 再查Redis缓存
        Object redisData = redisTemplate.opsForValue().get(key);
        if (redisData != null) {
            // 将数据放入本地缓存
            localCache.put(key, redisData);
            return redisData;
        }
        
        // 3. 最后查数据库
        Object dbData = queryFromDatabase(key);
        if (dbData != null) {
            // 同时更新Redis和本地缓存
            redisTemplate.opsForValue().set(key, dbData, Duration.ofMinutes(30));
            localCache.put(key, dbData);
        }
        
        return dbData;
    }
    
    // 更新数据时，需要同时更新各级缓存
    public void updateData(String key, Object data) {
        // 更新数据库
        updateDatabase(key, data);
        
        // 更新Redis缓存
        redisTemplate.opsForValue().set(key, data, Duration.ofMinutes(30));
        
        // 更新本地缓存
        localCache.put(key, data);
    }
    
    // 删除数据时，需要同时删除各级缓存
    public void deleteData(String key) {
        // 删除数据库
        deleteFromDatabase(key);
        
        // 删除Redis缓存
        redisTemplate.delete(key);
        
        // 删除本地缓存
        localCache.invalidate(key);
    }
}

解决方案三：熔断降级机制

当缓存失效导致数据库压力过大时，启用熔断降级机制，保护后端服务。

@Component
public class CircuitBreakerCacheService {
    
    private final CircuitBreaker circuitBreaker;
    
    public CircuitBreakerCacheService() {
        // 配置熔断器
        this.circuitBreaker = CircuitBreaker.ofDefaults("cacheService");
        // 设置熔断规则：失败率超过50%且请求数超过10个时熔断
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
            .failureRateThreshold(50)
            .minimumNumberOfCalls(10)
            .slidingWindowType(CircuitBreakerConfig.SlidingWindowType.TIME_BASED)
            .slidingWindowSize(10)
            .waitDurationInOpenState(Duration.ofSeconds(30))
            .permittedNumberOfCallsInHalfOpenState(5)
            .build();
        this.circuitBreaker = CircuitBreaker.of("cacheService", config);
    }
    
    public Object getDataWithCircuitBreaker(String key) {
        Supplier<Object> decoratedSupplier = CircuitBreaker
            .decorateSupplier(circuitBreaker, () -> getDataFromCache(key));
        
        return Try.ofSupplier(decoratedSupplier)
            .recover(throwable -> {
                // 熔断降级处理
                return handleFallback(key, throwable);
            })
            .get();
    }
    
    private Object getDataFromCache(String key) {
        // 正常的缓存查询逻辑
        Object cacheData = redisTemplate.opsForValue().get(key);
        if (cacheData != null) {
            return cacheData;
        }
        
        // 缓存未命中，查询数据库
        Object dbData = queryFromDatabase(key);
        if (dbData != null) {
            redisTemplate.opsForValue().set(key, dbData, Duration.ofMinutes(30));
        }
        return dbData;
    }
    
    private Object handleFallback(String key, Throwable throwable) {
        log.warn("缓存服务熔断，执行降级逻辑，key: {}", key, throwable);
        
        // 可以返回默认值、缓存旧数据或抛出业务异常
        return getDefaultData(key);
    }
    
    private Object getDefaultData(String key) {
        // 根据业务需求返回默认值
        return new DefaultData("default_value");
    }
}

生产环境完整防护策略

防护策略设计原则

  1. 分层防护：构建多层防护体系，确保任何一层失效都不会导致系统崩溃
  2. 异步处理：关键操作异步化，避免阻塞主线程
  3. 监控告警：建立完善的监控和告警机制
  4. 优雅降级：在极端情况下能够优雅降级，保证核心功能可用

综合防护方案实现

@Service
public class ComprehensiveCacheService {
    
    private final Cache<String, Object> localCache;
    private final BloomFilter bloomFilter;
    private final CircuitBreaker circuitBreaker;
    private final MeterRegistry meterRegistry;
    
    public ComprehensiveCacheService(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.localCache = Caffeine.newBuilder()
            .maximumSize(10000)
            .expireAfterWrite(5, TimeUnit.MINUTES)
            .recordStats()
            .build();
        
        this.bloomFilter = new BloomFilter(10000000, 7);
        this.circuitBreaker = CircuitBreaker.ofDefaults("comprehensiveCache");
        
        // 注册缓存统计指标
        registerCacheMetrics();
    }
    
    public Object getData(String key) {
        try {
            // 1. 布隆过滤器快速过滤
            if (!bloomFilter.mightContain(key)) {
                recordCacheMiss("bloom_filter");
                return null;
            }
            
            // 2. 本地缓存
            Object localData = localCache.getIfPresent(key);
            if (localData != null) {
                recordCacheHit("local");
                return localData;
            }
            
            // 3. 熔断器保护下的Redis查询
            Supplier<Object> decoratedSupplier = CircuitBreaker
                .decorateSupplier(circuitBreaker, () -> queryRedis(key));
            
            return Try.ofSupplier(decoratedSupplier)
                .recover(throwable -> handleFallback(key, throwable))
                .get();
                
        } catch (Exception e) {
            log.error("获取缓存数据异常，key: {}", key, e);
            return handleFallback(key, e);
        }
    }
    
    private Object queryRedis(String key) {
        // 检查空值标记
        String nullKey = key + ":null";
        if (redisTemplate.hasKey(nullKey)) {
            recordCacheHit("null_marker");
            return null;
        }
        
        // 查询正常缓存
        Object cacheData = redisTemplate.opsForValue().get(key);
        if (cacheData != null) {
            recordCacheHit("redis");
            localCache.put(key, cacheData);
            return cacheData;
        }
        
        // 缓存未命中，查询数据库
        recordCacheMiss("redis");
        return queryDatabase(key);
    }
    
    private Object queryDatabase(String key) {
        Object dbData = queryFromDatabase(key);
        if (dbData != null) {
            // 设置随机过期时间
            int baseExpireMinutes = 30;
            int randomMinutes = new Random().nextInt(11);
            int totalExpireMinutes = baseExpireMinutes + randomMinutes;
            
            redisTemplate.opsForValue().set(key, dbData, 
                Duration.ofMinutes(totalExpireMinutes));
            localCache.put(key, dbData);
            bloomFilter.add(key);
        } else {
            // 缓存空值标记
            redisTemplate.opsForValue().set(key + ":null", "NULL", 
                Duration.ofMinutes(5));
        }
        return dbData;
    }
    
    private Object handleFallback(String key, Throwable throwable) {
        log.warn("缓存查询失败，执行降级逻辑，key: {}", key, throwable);
        
        // 尝试返回本地缓存中的过期数据
        Object expiredData = localCache.getIfPresent(key);
        if (expiredData != null) {
            log.info("返回本地缓存中的过期数据，key: {}", key);
            return expiredData;
        }
        
        // 返回默认值或抛出业务异常
        return getDefaultData(key);
    }
    
    private void recordCacheHit(String cacheType) {
        Counter.builder("cache.hit")
            .tag("type", cacheType)
            .register(meterRegistry)
            .increment();
    }
    
    private void recordCacheMiss(String missType) {
        Counter.builder("cache.miss")
            .tag("type", missType)
            .register(meterRegistry)
            .increment();
    }
    
    private void registerCacheMetrics() {
        // 注册本地缓存统计指标
        Gauge.builder("cache.local.hit.rate")
            .register(meterRegistry, localCache, 
                cache -> cache.stats().hitRate());
        
        Gauge.builder("cache.local.miss.rate")
            .register(meterRegistry, localCache, 
                cache -> cache.stats().missRate());
    }
}

监控告警机制设计

关键监控指标

  1. 缓存命中率：衡量缓存效果的重要指标
  2. 缓存穿透率：反映缓存穿透问题的严重程度
  3. 缓存失效频率：监控缓存雪崩风险
  4. 数据库查询QPS：反映缓存保护效果
  5. 响应时间分布：监控系统性能变化

监控指标实现

@Component
public class CacheMetricsCollector {
    
    private final MeterRegistry meterRegistry;
    private final RedisTemplate<String, Object> redisTemplate;
    
    public CacheMetricsCollector(MeterRegistry meterRegistry, 
                                RedisTemplate<String, Object> redisTemplate) {
        this.meterRegistry = meterRegistry;
        this.redisTemplate = redisTemplate;
        registerMetrics();
    }
    
    private void registerMetrics() {
        // 缓存命中率
        Gauge.builder("cache.hit.rate")
            .description("缓存命中率")
            .register(meterRegistry, this, CacheMetricsCollector::calculateHitRate);
        
        // 数据库查询次数
        Counter.builder("database.query.count")
            .description("数据库查询次数")
            .register(meterRegistry);
        
        // 缓存穿透次数
        Counter.builder("cache.penetrated.count")
            .description("缓存穿透次数")
            .register(meterRegistry);
        
        // 缓存失效次数
        Counter.builder("cache.expired.count")
            .description("缓存失效次数")
            .register(meterRegistry);
    }
    
    private double calculateHitRate(CacheMetricsCollector collector) {
        // 从Redis获取统计信息
        Properties info = redisTemplate.getConnectionFactory()
            .getConnection().info("stats");
        
        String hits = info.getProperty("keyspace_hits");
        String misses = info.getProperty("keyspace_misses");
        
        if (hits != null && misses != null) {
            long hitCount = Long.parseLong(hits);
            long missCount = Long.parseLong(misses);
            long totalCount = hitCount + missCount;
            
            return totalCount > 0 ? (double) hitCount / totalCount : 0;
        }
        return 0;
    }
    
    public void recordDatabaseQuery() {
        Counter.builder("database.query.count").register(meterRegistry).increment();
    }
    
    public void recordCachePenetration() {
        Counter.builder("cache.penetrated.count").register(meterRegistry).increment();
    }
    
    public void recordCacheExpired() {
        Counter.builder("cache.expired.count").register(meterRegistry).increment();
    }
}

告警规则配置

# Prometheus告警规则配置
groups:
- name: cache-alerts
  rules:
  # 缓存命中率过低告警
  - alert: LowCacheHitRate
    expr: cache_hit_rate < 0.8
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "缓存命中率过低 (instance {{ $labels.instance }})"
      description: "缓存命中率低于80% (当前值: {{ $value }})"

  # 数据库查询量激增告警
  - alert: HighDatabaseQueryRate
    expr: rate(database_query_count[5m]) > 1000
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: "数据库查询量激增 (instance {{ $labels.instance }})"
      description: "数据库查询QPS超过1000 (当前值: {{ $value }})"

  # 缓存穿透告警
  - alert: HighCachePenetration
    expr: rate(cache_penetrated_count[5m]) > 100
    for: 1m
    labels:
      severity: warning
    annotations:
      summary: "缓存穿透次数过多 (instance {{ $labels.instance }})"
      description: "每分钟缓存穿透次数超过100次 (当前值: {{ $value }})"

最佳实践总结

缓存设计原则

  1. 合理设置过期时间：根据数据更新频率设置合适的过期时间
  2. **

本文来自极简博客，作者：天空之翼，转载请注明原文链接：Redis缓存穿透、击穿、雪崩解决方案：从理论到实践的完整防护体系

打赏

本文固定链接: https://www.cxy163.net/archives/6386 | 绝缘体

该日志由 绝缘体.. 于 2023年04月21日 发表在 未分类 分类下， 你可以发表评论，并在保留原文地址及作者的情况下引用到你的网站或博客。
原创文章转载请注明: Redis缓存穿透、击穿、雪崩解决方案：从理论到实践的完整防护体系 | 绝缘体
关键字: , , , ,
【上一篇】
【下一篇】

您可能还会对这些文章感兴趣！

  1. CVE-2022-0543
  2. docker进阶_dockerswarm
  3. docker进阶_docker-compose
  4. docker基础_网络模式
  5. 命令行清空memcache缓存的两种方法
  6. laravel 缓存系统的使用
  7. mysql 配置ssl ，java应用连接
  8. (转载)Go channel 的妙用
  9. MariaDB/MySQL配置文件my.cnf解读
  10. 如何在 Laravel 代码中正确地使用数据库事务
  11. Mybatis、Mybatis Generator、Mybatis-Plus、
  12. CentOS 上部署达梦数据库
  13. 程序开发中的自动化运维工具推荐
  14. 使用数据库触发器实现数据验证
  15. Redis的集群模式和数据分片方案
  16. SQL中的Invalid object name无效对象名错误的

Redis缓存穿透、击穿、雪崩解决方案：从理论到实践的完整防护体系：等您坐沙发呢！

发表评论


快捷键：Ctrl+Enter