5 个可扩展的 Laravel 实时应用 Redis 模式

Fred· AI Engineer & Developer EducatorNovember 4, 20254 min read

redis laravel performance caching quick-tips real-time

在从 Redis 迁移到 KeyDB 再迁移回来的过程中处理数十亿美元的物流交易后，我学到了哪些 Redis 模式可以大规模工作。以下是你今天就可以实现的 5 个实战模式。

1. 管道化一切（10 倍性能提升）

糟糕的模式：

// 这会创建 1000 次网络往返！
foreach ($shipments as $shipment) {
    Redis::set("shipment:{$shipment->id}", $shipment->toJson());
    Redis::expire("shipment:{$shipment->id}", 3600);
}

生产模式：

// 一次网络调用，原子执行
Redis::pipeline(function ($pipe) use ($shipments) {
    foreach ($shipments as $shipment) {
        $pipe->setex(
            "shipment:{$shipment->id}",
            3600,
            $shipment->toJson()
        );
    }
});

**实际影响：**将我们的批量导入时间从 10k 记录的 45 秒减少到 4 秒。

2. 实现滑动窗口速率限制

忘掉导致雷群效应的固定窗口。这是我们在生产中使用的：

class RateLimiter
{
    public static function attempt($key, $max = 60, $decay = 60)
    {
        $key = "rate_limit:{$key}";
        $now = microtime(true);
        $window = $now - $decay;

        Redis::pipeline(function ($pipe) use ($key, $now, $window, $max) {
            // 移除旧条目
            $pipe->zremrangebyscore($key, 0, $window);

            // 添加当前请求
            $pipe->zadd($key, $now, $now);

            // 计算窗口内的请求数
            $pipe->zcard($key);

            // 设置过期时间
            $pipe->expire($key, $decay + 1);
        });

        $results = $pipe->execute();
        $count = $results[2];

        return $count <= $max;
    }
}

// 在中间件中使用
if (!RateLimiter::attempt("api:{$request->ip()}", 100, 60)) {
    return response('Rate limit exceeded', 429);
}

**为什么有效：**窗口边界没有峰值，公平分配，自清理。

3. 使用标签进行缓存失效（正确的方式）

Laravel 的缓存标签很棒，直到你需要细粒度控制。这是我们的模式：

class SmartCache
{
    public static function rememberWithDependencies($key, $tags, $ttl, $callback)
    {
        // 存储主缓存
        $value = Cache::remember($key, $ttl, $callback);

        // 在 Redis 集合中跟踪依赖关系
        Redis::pipeline(function ($pipe) use ($key, $tags) {
            foreach ($tags as $tag) {
                $pipe->sadd("cache_tag:{$tag}", $key);
                $pipe->expire("cache_tag:{$tag}", 86400); // 1 天
            }
        });

        return $value;
    }

    public static function invalidateTag($tag)
    {
        $keys = Redis::smembers("cache_tag:{$tag}");

        if (!empty($keys)) {
            // 在一个管道中删除所有标记的键
            Redis::pipeline(function ($pipe) use ($keys, $tag) {
                foreach ($keys as $key) {
                    $pipe->del($key);
                }
                $pipe->del("cache_tag:{$tag}");
            });
        }
    }
}

// 使用
$metrics = SmartCache::rememberWithDependencies(
    'dashboard.metrics',
    ['shipments', 'deliveries', "customer:{$customerId}"],
    300, // 5 分钟
    fn() => $this->calculateExpensiveMetrics()
);

// 使所有货运相关缓存失效
SmartCache::invalidateTag('shipments');

**生产成果：**减少了 73% 的缓存未命中并消除了级联失效。

4. 不会死锁的分布式锁

在一次竞态条件损失 5 万美元后，我们实现了这个防弹锁定：

class DistributedLock
{
    public static function acquire($resource, $timeout = 10)
    {
        $lockKey = "lock:{$resource}";
        $identifier = uniqid(gethostname(), true);

        // 原子设置如果不存在且带过期时间
        $acquired = Redis::set(
            $lockKey,
            $identifier,
            'NX', // 仅在不存在时设置
            'EX', // X 秒后过期
            $timeout
        );

        if ($acquired) {
            return $identifier;
        }

        // 检查锁是否过期（备用机制）
        $lockHolder = Redis::get($lockKey);
        if (!$lockHolder) {
            // 锁在命令之间过期，重试
            return self::acquire($resource, $timeout);
        }

        return false;
    }

    public static function release($resource, $identifier)
    {
        $lockKey = "lock:{$resource}";

        // Lua 脚本用于原子检查和删除
        $script = "
            if redis.call('get', KEYS[1]) == ARGV[1] then
                return redis.call('del', KEYS[1])
            else
                return 0
            end
        ";

        return Redis::eval($script, 1, $lockKey, $identifier);
    }

    public static function withLock($resource, $callback, $timeout = 10)
    {
        $identifier = self::acquire($resource, $timeout);

        if (!$identifier) {
            throw new LockTimeoutException("Could not acquire lock for {$resource}");
        }

        try {
            return $callback();
        } finally {
            self::release($resource, $identifier);
        }
    }
}

// 用于支付处理
DistributedLock::withLock("payment:{$invoice->id}", function () use ($invoice) {
    // 安全处理支付
    if ($invoice->isPaid()) {
        return; // 幂等检查
    }

    $invoice->processPayment();
    $invoice->markAsPaid();
});

**关键：**Lua 脚本确保我们只释放我们自己的锁，防止意外释放别人的锁。

5. 使用 HyperLogLog 的实时指标

跟踪唯一访客/事件而不会内存爆炸：

class MetricsTracker
{
    public static function trackUnique($metric, $identifier, $window = 3600)
    {
        $key = "metric:{$metric}:" . floor(time() / $window);

        // HyperLogLog 以 O(1) 空间添加唯一项
        Redis::pfadd($key, $identifier);
        Redis::expire($key, $window * 2); // 保留 2 个窗口

        return Redis::pfcount($key);
    }

    public static function getCardinality($metric, $windows = 1, $windowSize = 3600)
    {
        $keys = [];
        $now = time();

        for ($i = 0; $i < $windows; $i++) {
            $keys[] = "metric:{$metric}:" . floor(($now - ($i * $windowSize)) / $windowSize);
        }

        // 合并多个 HyperLogLog
        return Redis::pfcount($keys);
    }

    public static function trackAndBroadcast($event, $userId)
    {
        // 跟踪唯一事件
        $count = self::trackUnique("event:{$event}:users", $userId);

        // 跟踪每分钟速率
        $rate = self::trackUnique("event:{$event}:rate", uniqid(), 60);

        // 达到阈值时广播
        if ($rate > 1000) {
            broadcast(new HighTrafficAlert($event, $rate));
        }

        return $count;
    }
}

// 使用
$uniqueVisitors = MetricsTracker::trackUnique('page.visits', $request->ip());
$dailyActive = MetricsTracker::getCardinality('user.active', 24, 3600);

// 跟踪 API 使用而不会有内存问题
MetricsTracker::trackAndBroadcast('api.call', $user->id);

**内存节省：**跟踪 1000 万唯一用户只需约 12KB 而不是传统集合的 40MB。

额外：Redis 内存优化清单

来自我们的生产手册：

// 1. 对大值使用压缩
Redis::setex(
    "large:{$id}",
    3600,
    gzcompress(json_encode($data), 9)
);

// 2. 对小对象使用哈希（节省 90% 内存！）
Redis::hset("user:{$id}", [
    'name' => $user->name,
    'email' => $user->email,
    'status' => $user->status
]);

// 3. 设置激进的过期时间
Redis::setex($key, 300, $value); // 默认 5 分钟，而不是 1 小时

// 4. 使用 SCAN 而不是 KEYS
$cursor = 0;
do {
    [$cursor, $keys] = Redis::scan($cursor, 'MATCH', 'shipment:*', 'COUNT', 100);
    // 处理 $keys
} while ($cursor !== 0);

// 5. 监控内存使用
$info = Redis::info('memory');
if ($info['used_memory'] > 1073741824) { // 1GB
    alert("Redis memory critical: {$info['used_memory_human']}");
}

昂贵的教训

始终设置过期时间 - 一个缺失的 TTL 消耗了 8GB 的 RAM
管道化或灭亡 - 网络延迟会快速累积
使用正确的数据结构 - HyperLogLog 每月为我们节省了 2000 美元的内存
正确锁定 - 金融系统中的竞态条件 = 诉讼
监控一切 - 你无法修复你不测量的东西

这些模式在生产中处理每秒 5 万个请求。从管道化和正确锁定开始——它们将解决你 80% 的 Redis 性能问题。

通过真实项目掌握 Laravel

想要在真实应用中实现这些 Redis 模式？从头开始构建生产就绪的 Laravel 项目：

使用 Laravel 构建博客 - 掌握 Eloquent、认证和带 Redis 缓存的 CRUD 操作
使用 Laravel 构建作品集 - 学习文件上传、关系和 Redis 驱动的会话
使用 Laravel 构建电子商务 - 高级模式包括队列、事件处理和分布式锁

每个教程都包含 AI 辅助提示，指导你构建有效使用 Redis 的可扩展应用程序。

对实现这些模式有疑问？留下评论——我可能在凌晨 3 点调试过那个问题。

Fred

AUTHOR

Full-stack developer with 10+ years building production applications. I write about cloud deployment, DevOps, and modern web development from real-world experience.

About me →More articles →

Need a developer who gets it?

POC builds, vibe-coded fixes, and real engineering. Let's talk.

Hire Me →