Flutter鸿蒙开发：请求频率限制详解

欢迎加入开源鸿蒙跨平台社区！ https://openharmonycrossplatform.csdn.net

一、前言

请求频率限制（Rate Limiting）是保护服务器资源、防止恶意攻击的重要手段。本文将详细介绍如何在Flutter鸿蒙应用中实现请求频率限制功能，包括计数器实现、时间窗口管理和策略配置等内容。

二、效果展示

本组件实现了以下功能：

• 请求计数与限制
• 滑动/固定时间窗口
• 实时状态监控
• 限制策略配置
• 请求历史记录

三、技术要点

3.1 时间窗口策略

// 两种时间窗口策略
String _limitStrategy = 'sliding';  // sliding（滑动窗口）, fixed（固定窗口）

// 滑动窗口：每次请求后重新计算窗口
// 固定窗口：在固定时间段内计数

3.2 计数器实现

int _requestCount = 0;
int _maxRequests = 10;
int _timeWindow = 60;  // 秒

DateTime _windowStart = DateTime.now();
List<RequestRecord> _requests = [];

bool _isBlocked = false;
int _remainingRequests = 10;
int _remainingTime = 60;

四、完整实现

4.1 请求记录模型

class RequestRecord {
  final DateTime time;
  final bool success;

  RequestRecord({
    required this.time,
    required this.success,
  });
}

class RateLimitHistory {
  final String action;
  final int requestCount;
  final bool blocked;
  final DateTime time;

  RateLimitHistory({
    required this.action,
    required this.requestCount,
    required this.blocked,
    required this.time,
  });
}

4.2 时间窗口管理

Timer? _timer;

@override
void initState() {
  super.initState();
  _startTimer();
}

void _startTimer() {
  _timer = Timer.periodic(const Duration(seconds: 1), (timer) {
    if (!mounted) return;
    
    setState(() {
      final now = DateTime.now();
      final elapsed = now.difference(_windowStart).inSeconds;
      
      // 窗口过期，重置计数
      if (elapsed >= _timeWindow) {
        _windowStart = now;
        _requestCount = 0;
        _requests.clear();
      }
      
      _remainingTime = _timeWindow - elapsed;
      if (_remainingTime < 0) _remainingTime = 0;
      
      _remainingRequests = _maxRequests - _requestCount;
      if (_remainingRequests < 0) _remainingRequests = 0;
      
      _isBlocked = _requestCount >= _maxRequests;
    });
  });
}

@override
void dispose() {
  _timer?.cancel();
  super.dispose();
}

4.3 请求发送逻辑

void _sendRequest() {
  if (_isBlocked) {
    _addLog('请求被拒绝: 超过频率限制');
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(
        content: Text('请求被拒绝，请等待 $_remainingTime 秒'),
        backgroundColor: Colors.red,
        duration: const Duration(seconds: 1),
      ),
    );
    return;
  }
  
  setState(() {
    _requestCount++;
    _requests.add(RequestRecord(
      time: DateTime.now(),
      success: true,
    ));
    
    _remainingRequests = _maxRequests - _requestCount;
    _isBlocked = _requestCount >= _maxRequests;
  });
  
  _addLog('请求成功 #$_requestCount');
}

void _burstRequests() {
  for (int i = 0; i < 5; i++) {
    Future.delayed(Duration(milliseconds: i * 100), () {
      if (mounted) _sendRequest();
    });
  }
}

五、界面实现

5.1 状态监控面板

Container(
  padding: const EdgeInsets.all(20),
  decoration: BoxDecoration(
    gradient: LinearGradient(
      colors: _isBlocked 
        ? [Colors.red.shade400, Colors.red.shade600]
        : [Colors.green.shade400, Colors.green.shade600],
      begin: Alignment.topLeft,
      end: Alignment.bottomRight,
    ),
    borderRadius: BorderRadius.circular(16),
  ),
  child: Column(
    children: [
      Icon(
        _isBlocked ? Icons.block : Icons.check_circle,
        color: Colors.white,
        size: 48,
      ),
      const SizedBox(height: 12),
      Text(
        _isBlocked ? '请求已限制' : '请求正常',
        style: const TextStyle(
          color: Colors.white,
          fontSize: 20,
          fontWeight: FontWeight.bold,
        ),
      ),
      const SizedBox(height: 20),
      Row(
        mainAxisAlignment: MainAxisAlignment.spaceAround,
        children: [
          _buildStatItem('已发送', '$_requestCount'),
          _buildStatItem('剩余', '$_remainingRequests'),
          _buildStatItem('重置', '${_remainingTime}s'),
        ],
      ),
    ],
  ),
)

Widget _buildStatItem(String label, String value) {
  return Column(
    children: [
      Text(
        value,
        style: const TextStyle(
          color: Colors.white,
          fontSize: 28,
          fontWeight: FontWeight.bold,
        ),
      ),
      Text(
        label,
        style: TextStyle(
          color: Colors.white.withOpacity(0.8),
          fontSize: 14,
        ),
      ),
    ],
  );
}

5.2 进度指示器

Column(
  children: [
    Row(
      mainAxisAlignment: MainAxisAlignment.spaceBetween,
      children: [
        Text('请求进度', style: TextStyle(color: Colors.grey.shade600)),
        Text('$_requestCount / $_maxRequests', 
          style: TextStyle(color: Colors.grey.shade600)),
      ],
    ),
    const SizedBox(height: 8),
    ClipRRect(
      borderRadius: BorderRadius.circular(4),
      child: LinearProgressIndicator(
        value: _requestCount / _maxRequests,
        backgroundColor: Colors.grey.shade200,
        valueColor: AlwaysStoppedAnimation<Color>(
          _isBlocked ? Colors.red : Colors.green,
        ),
        minHeight: 8,
      ),
    ),
  ],
)

5.3 策略配置

Container(
  padding: const EdgeInsets.all(16),
  decoration: BoxDecoration(
    color: Theme.of(context).cardColor,
    borderRadius: BorderRadius.circular(12),
    border: Border.all(color: Colors.grey.shade200),
  ),
  child: Column(
    crossAxisAlignment: CrossAxisAlignment.start,
    children: [
      const Text('限制策略配置', style: TextStyle(fontSize: 16, fontWeight: FontWeight.bold)),
      const SizedBox(height: 16),
      
      // 最大请求数
      Row(
        children: [
          const Expanded(child: Text('最大请求数')),
          SizedBox(
            width: 100,
            child: TextFormField(
              initialValue: '$_maxRequests',
              keyboardType: TextInputType.number,
              textAlign: TextAlign.center,
              decoration: InputDecoration(
                border: OutlineInputBorder(borderRadius: BorderRadius.circular(8)),
                contentPadding: const EdgeInsets.symmetric(horizontal: 8, vertical: 8),
              ),
              onFieldSubmitted: (value) {
                final num = int.tryParse(value);
                if (num != null && num > 0) {
                  setState(() => _maxRequests = num);
                }
              },
            ),
          ),
        ],
      ),
      
      const SizedBox(height: 12),
      
      // 时间窗口
      Row(
        children: [
          const Expanded(child: Text('时间窗口（秒）')),
          SizedBox(
            width: 100,
            child: TextFormField(
              initialValue: '$_timeWindow',
              keyboardType: TextInputType.number,
              textAlign: TextAlign.center,
              decoration: InputDecoration(
                border: OutlineInputBorder(borderRadius: BorderRadius.circular(8)),
                contentPadding: const EdgeInsets.symmetric(horizontal: 8, vertical: 8),
              ),
              onFieldSubmitted: (value) {
                final num = int.tryParse(value);
                if (num != null && num > 0) {
                  setState(() => _timeWindow = num);
                }
              },
            ),
          ),
        ],
      ),
    ],
  ),
)

六、高级实现

6.1 令牌桶算法

class TokenBucket {
  final int capacity;
  final int refillRate;  // 每秒补充的令牌数
  
  int _tokens;
  DateTime _lastRefill;

  TokenBucket({
    required this.capacity,
    required this.refillRate,
  }) : _tokens = capacity, _lastRefill = DateTime.now();

  bool tryConsume([int tokens = 1]) {
    _refill();
    
    if (_tokens >= tokens) {
      _tokens -= tokens;
      return true;
    }
    return false;
  }

  void _refill() {
    final now = DateTime.now();
    final elapsed = now.difference(_lastRefill).inMilliseconds / 1000;
    final tokensToAdd = (elapsed * refillRate).floor();
    
    if (tokensToAdd > 0) {
      _tokens = min(capacity, _tokens + tokensToAdd);
      _lastRefill = now;
    }
  }

  int get availableTokens => _tokens;
}

6.2 滑动窗口日志

class SlidingWindowLog {
  final int maxRequests;
  final Duration windowSize;
  
  final List<DateTime> _requests = [];

  SlidingWindowLog({
    required this.maxRequests,
    required this.windowSize,
  });

  bool tryAcquire() {
    final now = DateTime.now();
    final windowStart = now.subtract(windowSize);
    
    // 移除过期的请求记录
    _requests.removeWhere((time) => time.isBefore(windowStart));
    
    if (_requests.length < maxRequests) {
      _requests.add(now);
      return true;
    }
    return false;
  }

  int get currentCount => _requests.length;
  
  Duration get retryAfter {
    if (_requests.isEmpty) return Duration.zero;
    final oldestRequest = _requests.first;
    final retryTime = oldestRequest.add(windowSize);
    return retryTime.difference(DateTime.now());
  }
}

6.3 分布式限流

// 适用于多实例部署的场景
class DistributedRateLimiter {
  final String key;
  final int maxRequests;
  final Duration windowSize;
  
  // 实际应用中应使用 Redis 等分布式存储
  final Map<String, List<int>> _store = {};

  Future<bool> tryAcquire() async {
    final now = DateTime.now().millisecondsSinceEpoch;
    final windowStart = now - windowSize.inMilliseconds;
    
    // 获取当前窗口内的请求
    final requests = _store[key] ?? [];
    
    // 清理过期请求
    requests.removeWhere((timestamp) => timestamp < windowStart);
    
    if (requests.length < maxRequests) {
      requests.add(now);
      _store[key] = requests;
      return true;
    }
    
    return false;
  }
}

七、最佳实践

7.1 限流策略选择

策略	优点	缺点	适用场景
固定窗口	实现简单	边界突发	简单限流
滑动窗口	更平滑	内存占用高	精确限流
令牌桶	允许突发	实现复杂	API限流
漏桶	流量整形	不允许突发	流量控制

7.2 客户端限流建议

class ClientRateLimiter {
  // API请求限流
  static final apiLimiter = TokenBucket(
    capacity: 100,
    refillRate: 10,
  );
  
  // 搜索请求限流
  static final searchLimiter = SlidingWindowLog(
    maxRequests: 5,
    windowSize: Duration(seconds: 1),
  );
  
  // 文件上传限流
  static final uploadLimiter = TokenBucket(
    capacity: 10,
    refillRate: 1,
  );
}

八、总结

请求频率限制是保护应用和服务的重要机制。通过本文介绍的方法，开发者可以：

1. 实现多种限流算法
2. 根据场景选择合适的策略
3. 提供良好的用户反馈
4. 构建健壮的限流系统

在实际开发中，建议结合服务端限流和客户端限流，构建多层次的防护机制。

九、参考资料

• API速率限制最佳实践
• 令牌桶算法详解
• 鸿蒙网络请求安全指南