PHP 怎么限流降级

wen PHP项目 2026-08-10 152

本文目录导读：

PHP 怎么限流降级

限流实现方案
降级实现方案
综合限流降级框架
实践建议
注意事项

在 PHP 中实现限流降级，通常需要结合限流（控制请求速率）和降级（在系统压力过大时返回降级响应），以下是常用的实现方案，从简单到复杂：

限流实现方案

基于 Redis 的固定窗口限流

<?php
class RateLimiter {
    private $redis;
    private $key;
    private $maxRequests;
    private $windowSize;
    public function __construct($redis, $key, $maxRequests, $windowSize = 60) {
        $this->redis = $redis;
        $this->key = $key;
        $this->maxRequests = $maxRequests;
        $this->windowSize = $windowSize;
    }
    public function allow() {
        $current = $this->redis->get($this->key);
        if ($current === false) {
            $this->redis->setex($this->key, $this->windowSize, 1);
            return true;
        }
        if ($current < $this->maxRequests) {
            $this->redis->incr($this->key);
            return true;
        }
        return false;
    }
}

基于 Redis 的滑动窗口限流（更精确）

<?php
class SlidingWindowRateLimiter {
    private $redis;
    private $key;
    public function __construct($redis, $key) {
        $this->redis = $redis;
        $this->key = $key;
    }
    public function allow($maxRequests, $windowSize = 60) {
        $currentTime = time();
        $windowStart = $currentTime - $windowSize;
        // 使用有序集合存储请求时间戳
        $this->redis->zremrangebyscore($this->key, 0, $windowStart);
        $count = $this->redis->zcard($this->key);
        if ($count < $maxRequests) {
            $this->redis->zadd($this->key, $currentTime, uniqid());
            $this->redis->expire($this->key, $windowSize);
            return true;
        }
        return false;
    }
}

基于令牌桶算法（推荐）

<?php
class TokenBucket {
    private $redis;
    private $key;
    private $capacity;      // 令牌桶容量
    private $rate;          // 每秒生成令牌数
    public function __construct($redis, $key, $capacity, $rate) {
        $this->redis = $redis;
        $this->key = $key;
        $this->capacity = $capacity;
        $this->rate = $rate;
    }
    public function allow() {
        $script = "
            local bucket = KEYS[1]
            local capacity = tonumber(ARGV[1])
            local rate = tonumber(ARGV[2])
            local now = tonumber(ARGV[3])
            local tokens = redis.call('get', bucket .. ':tokens')
            if not tokens then
                tokens = capacity
            else
                tokens = tonumber(tokens)
            end
            local lastTime = redis.call('get', bucket .. ':lastTime')
            if not lastTime then
                lastTime = now
            else
                lastTime = tonumber(lastTime)
            end
            local elapsed = now - lastTime
            tokens = math.min(capacity, tokens + elapsed * rate)
            redis.call('set', bucket .. ':tokens', tokens)
            redis.call('set', bucket .. ':lastTime', now)
            redis.call('expire', bucket .. ':tokens', 60)
            redis.call('expire', bucket .. ':lastTime', 60)
            if tokens >= 1 then
                redis.call('set', bucket .. ':tokens', tokens - 1)
                return 1
            else
                return 0
            end
        ";
        return $this->redis->eval($script, 1, $this->key, $this->capacity, $this->rate, time());
    }
}

降级实现方案

简单的降级开关

<?php
class CircuitBreaker {
    private $redis;
    private $key;
    private $failureThreshold;    // 失败阈值
    private $timeoutWindow;       // 超时窗口
    public function __construct($redis, $key, $failureThreshold = 5, $timeoutWindow = 30) {
        $this->redis = $redis;
        $this->key = $key;
        $this->failureThreshold = $failureThreshold;
        $this->timeoutWindow = $timeoutWindow;
    }
    public function isOpen() {
        $state = $this->redis->get($this->key . ':state');
        return $state === 'open';
    }
    public function recordSuccess() {
        $this->redis->del($this->key . ':failures');
        $this->redis->set($this->key . ':state', 'closed');
    }
    public function recordFailure() {
        $failures = $this->redis->incr($this->key . ':failures');
        $this->redis->expire($this->key . ':failures', $this->timeoutWindow);
        if ($failures >= $this->failureThreshold) {
            $this->redis->setex($this->key . ':state', $this->timeoutWindow, 'open');
        }
    }
}

完整降级示例

<?php
class ServiceDegrader {
    private $circuitBreaker;
    public function __construct() {
        $redis = new Redis();
        $redis->connect('127.0.0.1', 6379);
        $this->circuitBreaker = new CircuitBreaker($redis, 'api_name');
    }
    public function callApi($params) {
        // 检查熔断状态
        if ($this->circuitBreaker->isOpen()) {
            return $this->fallbackResponse();
        }
        try {
            // 调用真实服务
            $result = $this->makeRealApiCall($params);
            $this->circuitBreaker->recordSuccess();
            return $result;
        } catch (Exception $e) {
            $this->circuitBreaker->recordFailure();
            return $this->fallbackResponse();
        }
    }
    private function fallbackResponse() {
        // 降级响应：返回缓存数据或默认值
        return [
            'data' => $this->getCacheData(),
            'is_degraded' => true
        ];
    }
    private function getCacheData() {
        // 从缓存获取降级数据
        return Redis::get('fallback_data') ?? [];
    }
    private function makeRealApiCall($params) {
        // 真实 API 调用
    }
}

综合限流降级框架

中间件方式（适用于 Laravel/Slim 等框架）

<?php
class RateLimitAndDegradeMiddleware {
    public function handle($request, $next) {
        $rateLimiter = new TokenBucket(
            Redis::connection(),
            'user:' . $request->user_id,
            $capacity = 100,
            $rate = 10
        );
        // 限流检查
        if (!$rateLimiter->allow()) {
            return response()->json([
                'error' => 'Too Many Requests',
                'retry_after' => 60
            ], 429);
        }
        // 熔断检查
        $circuitBreaker = new CircuitBreaker(Redis::connection(), 'api');
        if ($circuitBreaker->isOpen()) {
            // 降级策略
            return $this->getCachedResponse($request);
        }
        try {
            $response = $next($request);
            $circuitBreaker->recordSuccess();
            return $response;
        } catch (Exception $e) {
            $circuitBreaker->recordFailure();
            return $this->getCachedResponse($request);
        }
    }
    private function getCachedResponse($request) {
        // 从缓存获取降级响应
        return Cache::remember('degraded:' . $request->path(), 60, function() {
            return ['status' => 'degraded'];
        });
    }
}

使用第三方库

Redis 的 Redis::throttle() （Laravel）
Rate Limit 包 - briceburg/php-rate-limiter
Symfony RateLimiter 组件

实践建议

降级策略选择

缓存降级：从 Redis/数据库缓存获取旧数据
默认值降级：返回预设的默认响应
延迟队列：将请求放入队列稍后处理
静态兜底：返回静态页面/响应

监控与告警

// 限流降级监控
public function trackMetrics($metric) {
    $monitor->increment('rate_limit.blocks');
    $monitor->increment('circuit_breaker.opens');
}

配置化

$config = [
    'rate_limits' => [
        'public_api' => ['capacity' => 100, 'rate' => 10],
        'internal_api' => ['capacity' => 1000, 'rate' => 100],
    ],
    'circuit_breaker' => [
        'failure_threshold' => 5,
        'timeout_window' => 30,
        'half_open_timeout' => 10,
    ]
];

降级策略组合

switch ($degradeLevel) {
    case 1: // 轻度降级
        return $this->cacheOnly();
    case 2: // 中度降级
        return $this->defaultResponse();
    case 3: // 重度降级
        return $this->simplePage();
    case 4: // 完全熔断
        throw new ServiceUnavailableException();
}