缓存穿透问题概述

在 Redis 作为缓存使用时，缓存穿透是常见问题。正常查询流程是先从 Redis 缓存获取数据，若有则直接使用；若没有则去数据库查询，查到后存入缓存。但当请求的数据在缓存和数据库中都不存在时，就会出现缓存穿透。大量此类请求会绕过缓存，直接给数据库造成巨大压力，甚至导致数据库崩溃，比如恶意攻击者用不存在的键发起大量请求来攻击系统。

解决方法及 Go 语言实现

1. 缓存空对象

• 原理：当数据库中不存在请求的数据时，将一个空对象存入 Redis 缓存，并设置较短的过期时间。后续相同请求就会从缓存中获取空对象，避免再次访问数据库。
• 示例代码：

go

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/go-redis/redis/v8"
)

var redisClient = redis.NewClient(&redis.Options{
	Addr:     "localhost:6379",
	Password: "",
	DB:       0,
})

// GetData 从缓存或数据库获取数据
func GetData(ctx context.Context, key string) (string, error) {
	// 先从 Redis 缓存获取数据
	val, err := redisClient.Get(ctx, key).Result()
	if err == nil {
		if val == "__NULL__" {
			return "", nil
		}
		return val, nil
	}
	if err != redis.Nil {
		return "", err
	}

	// 缓存中没有数据，去数据库查询（这里模拟）
	data := queryFromDatabase(key)
	if data == "" {
		// 数据库中也没有数据，将空对象存入缓存
		err := redisClient.Set(ctx, key, "__NULL__", 60*time.Second).Err()
		if err != nil {
			return "", err
		}
		return "", nil
	}
	// 数据库中有数据，将数据存入缓存
	err = redisClient.Set(ctx, key, data, 3600*time.Second).Err()
	if err != nil {
		return "", err
	}
	return data, nil
}

// queryFromDatabase 模拟从数据库查询数据
func queryFromDatabase(key string) string {
	// 这里直接返回空字符串表示数据不存在
	return ""
}

func main() {
	ctx := context.Background()
	key := "test_key"
	data, err := GetData(ctx, key)
	if err != nil {
		fmt.Printf("Error getting data: %v\n", err)
		return
	}
	fmt.Printf("Data: %s\n", data)
}

• 优缺点：优点：实现简单，能有效避免大量无效请求访问数据库。缺点：会占用一定缓存空间，若过期时间设置不当，可能影响业务。

2. 布隆过滤器

• 原理：布隆过滤器是一种空间效率高的概率型数据结构，可判断元素是否可能存在于集合中。将数据库中所有数据的键预先存入布隆过滤器，请求到来时先通过它判断键是否可能存在，若判断不存在则直接返回，若可能存在则继续正常查询流程。
• 示例代码：

go

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/go-redis/redis/v8"
	"github.com/RedisBloom/redisbloom-go"
)

var redisClient = redis.NewClient(&redis.Options{
	Addr:     "localhost:6379",
	Password: "",
	DB:       0,
})

var bloomFilter = redisbloom.NewClient(redisClient)

func initBloomFilter() error {
	// 初始化布隆过滤器
	return bloomFilter.Reserve("my_bloom_filter", 0.01, 10000)
}

func addKeysToBloomFilter(keys []string) error {
	// 将键添加到布隆过滤器
	for _, key := range keys {
		err := bloomFilter.Add("my_bloom_filter", key)
		if err != nil {
			return err
		}
	}
	return nil
}

// GetData 从缓存或数据库获取数据
func GetData(ctx context.Context, key string) (string, error) {
	// 先通过布隆过滤器判断键是否可能存在
	exists, err := bloomFilter.Exists("my_bloom_filter", key)
	if err != nil {
		return "", err
	}
	if!exists {
		return "", nil
	}

	// 布隆过滤器判断可能存在，继续正常查询流程
	val, err := redisClient.Get(ctx, key).Result()
	if err == nil {
		return val, nil
	}
	if err != redis.Nil {
		return "", err
	}

	// 缓存中没有数据，去数据库查询（这里模拟）
	data := queryFromDatabase(key)
	if data != "" {
		// 数据库中有数据，将数据存入缓存
		err = redisClient.Set(ctx, key, data, 3600*time.Second).Err()
		if err != nil {
			return "", err
		}
	}
	return data, nil
}

// queryFromDatabase 模拟从数据库查询数据
func queryFromDatabase(key string) string {
	// 这里直接返回空字符串表示数据不存在
	return ""
}

func main() {
	ctx := context.Background()
	err := initBloomFilter()
	if err != nil {
		fmt.Printf("Error initializing bloom filter: %v\n", err)
		return
	}
	keys := []string{"key1", "key2", "key3"}
	err = addKeysToBloomFilter(keys)
	if err != nil {
		fmt.Printf("Error adding keys to bloom filter: %v\n", err)
		return
	}

	key := "test_key"
	data, err := GetData(ctx, key)
	if err != nil {
		fmt.Printf("Error getting data: %v\n", err)
		return
	}
	fmt.Printf("Data: %s\n", data)
}

• 优缺点：优点：空间效率高，能大幅减少不必要的数据库查询。缺点：存在一定误判率，创建和维护布隆过滤器需要额外资源。

3. 接口层进行校验

• 原理：在应用程序的接口层对请求参数进行合法性校验，过滤掉明显不合法的请求，如请求键格式不符、参数范围不合理等，在请求到达缓存和数据库前拦截无效请求。
• 示例代码（使用 Gin 框架）：

go

package main

import (
	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()

	r.GET("/get_data", func(c *gin.Context) {
		key := c.Query("key")
		// 简单的合法性校验，例如判断键是否为空
		if key == "" {
			c.JSON(400, gin.H{"error": "Invalid key"})
			return
		}
		// 继续正常的查询流程
		// ...

		c.JSON(200, gin.H{"message": "Data fetched successfully"})
	})

	r.Run(":8080")
}

• 优缺点：优点：从源头上减少无效请求，实现简单，对业务逻辑侵入性小。缺点：需要了解业务规则并不断完善校验规则。