429 Too Many Requests\u00a0\u72b6\u6001\u7801\u8868\u793a\u7528\u6237\u5728\u7ed9\u5b9a\u65f6\u95f4\u5185\u53d1\u9001\u4e86\u592a\u591a\u8bf7\u6c42（"\u901f\u7387\u9650\u5236"）\u3002\u8be5\u72b6\u6001\u7801\u7684\u6838\u5fc3\u542b\u4e49\u662f：<\/p>\n
\u5ba2\u6237\u7aef\u8bf7\u6c42\u9891\u7387\u8d85\u8fc7\u670d\u52a1\u5668\u9650\u5236<\/p>\n<\/li>\n
\u670d\u52a1\u5668\u6682\u65f6\u62d2\u7edd\u5904\u7406\u5f53\u524d\u8bf7\u6c42<\/p>\n<\/li>\n
\u5ba2\u6237\u7aef\u5e94\u8be5\u5728\u7b49\u5f85\u4e00\u6bb5\u65f6\u95f4\u540e\u91cd\u8bd5<\/p>\n<\/li>\n<\/ul>\n
\u5173\u952e\u7279\u6027：<\/p>\n
\u901f\u7387\u9650\u5236：\u9650\u5236\u5355\u4f4d\u65f6\u95f4\u5185\u7684\u8bf7\u6c42\u6570\u91cf<\/p>\n<\/li>\n
\u53ef\u6062\u590d\u9519\u8bef：\u7b49\u5f85\u4e00\u6bb5\u65f6\u95f4\u540e\u53ef\u6062\u590d\u6b63\u5e38<\/p>\n<\/li>\n
\u5305\u542b\u91cd\u8bd5\u4fe1\u606f：\u54cd\u5e94\u901a\u5e38\u5305\u542b\u4f55\u65f6\u53ef\u91cd\u8bd5\u7684\u6307\u793a<\/p>\n<\/li>\n<\/ul>\n
\u534f\u8bae\u8981\u6c42：<\/p>\n
\u5e94\u5305\u542b\u63cf\u8ff0\u9650\u5236\u8be6\u60c5\u7684\u54cd\u5e94\u4f53<\/p>\n<\/li>\n
\u53ef\u4ee5\u5305\u542b\u00a0Retry-After\u00a0\u5934\u90e8\u6307\u793a\u91cd\u8bd5\u65f6\u95f4<\/p>\n<\/li>\n
\u53ef\u80fd\u5305\u542b\u901f\u7387\u9650\u5236\u914d\u989d\u4fe1\u606f<\/p>\n<\/li>\n<\/ul>\n
python<\/p>\n
# \u901f\u7387\u9650\u5236\u7b97\u6cd5\u5206\u7c7b\u4e0e\u5b9e\u73b0
\nfrom abc import ABC, abstractmethod
\nimport time
\nfrom typing import Dict, List, Optional, Tuple
\nimport math
\nfrom collections import deque
\nimport threading<\/p>\n
class RateLimiter(ABC):
\n """\u901f\u7387\u9650\u5236\u5668\u62bd\u8c61\u57fa\u7c7b"""<\/p>\n
@abstractmethod
\n def is_allowed(self, key: str, weight: int = 1) -> Tuple[bool, Dict]:
\n """\u68c0\u67e5\u662f\u5426\u5141\u8bb8\u8bf7\u6c42"""
\n pass<\/p>\n
@abstractmethod
\n def get_remaining(self, key: str) -> int:
\n """\u83b7\u53d6\u5269\u4f59\u914d\u989d"""
\n pass<\/p>\n
@abstractmethod
\n def get_reset_time(self, key: str) -> float:
\n """\u83b7\u53d6\u91cd\u7f6e\u65f6\u95f4"""
\n pass<\/p>\n
class TokenBucketLimiter(RateLimiter):
\n """\u4ee4\u724c\u6876\u7b97\u6cd5\u5b9e\u73b0"""<\/p>\n
def __init__(self, capacity: int, refill_rate: float):
\n """
\n Args:
\n capacity: \u6876\u5bb9\u91cf
\n refill_rate: \u6bcf\u79d2\u8865\u5145\u7684\u4ee4\u724c\u6570
\n """
\n self.capacity = capacity
\n self.refill_rate = refill_rate
\n self.buckets: Dict[str, Dict] = {}
\n self.lock = threading.RLock()<\/p>\n
def is_allowed(self, key: str, weight: int = 1) -> Tuple[bool, Dict]:
\n with self.lock:
\n current_time = time.time()<\/p>\n
# \u83b7\u53d6\u6216\u521b\u5efa\u6876
\n if key not in self.buckets:
\n self.buckets[key] = {
\n 'tokens': self.capacity,
\n 'last_refill': current_time
\n }<\/p>\n
bucket = self.buckets[key]<\/p>\n
# \u8865\u5145\u4ee4\u724c
\n time_passed = current_time – bucket['last_refill']
\n tokens_to_add = time_passed * self.refill_rate
\n bucket['tokens'] = min(self.capacity, bucket['tokens'] + tokens_to_add)
\n bucket['last_refill'] = current_time<\/p>\n
# \u68c0\u67e5\u662f\u5426\u6709\u8db3\u591f\u4ee4\u724c
\n if bucket['tokens'] >= weight:
\n bucket['tokens'] -= weight
\n remaining = bucket['tokens']
\n reset_time = current_time + (self.capacity – bucket['tokens']) \/ self.refill_rate<\/p>\n
return True, {
\n 'remaining': int(remaining),
\n 'reset_time': reset_time,
\n 'limit': self.capacity
\n }
\n else:
\n # \u8ba1\u7b97\u9700\u8981\u7b49\u5f85\u7684\u65f6\u95f4
\n tokens_needed = weight – bucket['tokens']
\n wait_time = tokens_needed \/ self.refill_rate
\n remaining = 0
\n reset_time = current_time + wait_time<\/p>\n
return False, {
\n 'remaining': remaining,
\n 'reset_time': reset_time,
\n 'retry_after': math.ceil(wait_time),
\n 'limit': self.capacity
\n }<\/p>\n
def get_remaining(self, key: str) -> int:
\n with self.lock:
\n if key not in self.buckets:
\n return self.capacity<\/p>\n
bucket = self.buckets[key]
\n current_time = time.time()<\/p>\n
# \u8865\u5145\u4ee4\u724c
\n time_passed = current_time – bucket['last_refill']
\n tokens_to_add = time_passed * self.refill_rate
\n tokens = min(self.capacity, bucket['tokens'] + tokens_to_add)<\/p>\n
return int(tokens)<\/p>\n
def get_reset_time(self, key: str) -> float:
\n with self.lock:
\n if key not in self.buckets:
\n return time.time()<\/p>\n
bucket = self.buckets[key]
\n current_time = time.time()<\/p>\n
# \u8ba1\u7b97\u4ee4\u724c\u5b8c\u5168\u8865\u5145\u7684\u65f6\u95f4
\n if bucket['tokens'] < self.capacity:
\n tokens_needed = self.capacity – bucket['tokens']
\n return current_time + tokens_needed \/ self.refill_rate
\n else:
\n return current_time<\/p>\n
class FixedWindowLimiter(RateLimiter):
\n """\u56fa\u5b9a\u7a97\u53e3\u7b97\u6cd5\u5b9e\u73b0"""<\/p>\n
def __init__(self, requests_per_window: int, window_seconds: int):
\n """
\n Args:
\n requests_per_window: \u6bcf\u4e2a\u7a97\u53e3\u5141\u8bb8\u7684\u8bf7\u6c42\u6570
\n window_seconds: \u7a97\u53e3\u5927\u5c0f（\u79d2）
\n """
\n self.requests_per_window = requests_per_window
\n self.window_seconds = window_seconds
\n self.windows: Dict[str, Dict] = {}
\n self.lock = threading.RLock()<\/p>\n
def is_allowed(self, key: str, weight: int = 1) -> Tuple[bool, Dict]:
\n with self.lock:
\n current_time = time.time()
\n window_start = math.floor(current_time \/ self.window_seconds) * self.window_seconds<\/p>\n
# \u83b7\u53d6\u6216\u521b\u5efa\u7a97\u53e3
\n if key not in self.windows:
\n self.windows[key] = {
\n 'window_start': window_start,
\n 'count': 0
\n }<\/p>\n
window = self.windows[key]<\/p>\n
# \u5982\u679c\u7a97\u53e3\u5df2\u8fc7\u671f，\u91cd\u7f6e
\n if window['window_start'] < window_start:
\n window['window_start'] = window_start
\n window['count'] = 0<\/p>\n
# \u68c0\u67e5\u662f\u5426\u8d85\u8fc7\u9650\u5236
\n if window['count'] + weight <= self.requests_per_window:
\n window['count'] += weight
\n remaining = self.requests_per_window – window['count']
\n reset_time = window['window_start'] + self.window_seconds<\/p>\n
return True, {
\n 'remaining': remaining,
\n 'reset_time': reset_time,
\n 'limit': self.requests_per_window
\n }
\n else:
\n # \u5df2\u8d85\u8fc7\u9650\u5236
\n remaining = 0
\n reset_time = window['window_start'] + self.window_seconds
\n retry_after = math.ceil(reset_time – current_time)<\/p>\n
return False, {
\n 'remaining': remaining,
\n 'reset_time': reset_time,
\n 'retry_after': retry_after,
\n 'limit': self.requests_per_window
\n }<\/p>\n
def get_remaining(self, key: str) -> int:
\n with self.lock:
\n current_time = time.time()
\n window_start = math.floor(current_time \/ self.window_seconds) * self.window_seconds<\/p>\n
if key not in self.windows:
\n return self.requests_per_window<\/p>\n
window = self.windows[key]<\/p>\n
# \u5982\u679c\u7a97\u53e3\u5df2\u8fc7\u671f，\u8fd4\u56de\u5b8c\u6574\u914d\u989d
\n if window['window_start'] < window_start:
\n return self.requests_per_window<\/p>\n
return max(0, self.requests_per_window – window['count'])<\/p>\n
def get_reset_time(self, key: str) -> float:
\n with self.lock:
\n current_time = time.time()
\n window_start = math.floor(current_time \/ self.window_seconds) * self.window_seconds<\/p>\n
if key not in self.windows:
\n return window_start + self.window_seconds<\/p>\n
window = self.windows[key]<\/p>\n
# \u5982\u679c\u7a97\u53e3\u5df2\u8fc7\u671f，\u8fd4\u56de\u4e0b\u4e00\u4e2a\u7a97\u53e3\u7ed3\u675f\u65f6\u95f4
\n if window['window_start'] < window_start:
\n return window_start + self.window_seconds<\/p>\n
return window['window_start'] + self.window_seconds<\/p>\n
class SlidingWindowLogLimiter(RateLimiter):
\n """\u6ed1\u52a8\u7a97\u53e3\u65e5\u5fd7\u7b97\u6cd5\u5b9e\u73b0"""<\/p>\n
def __init__(self, requests_per_window: int, window_seconds: int):
\n """
\n Args:
\n requests_per_window: \u6bcf\u4e2a\u7a97\u53e3\u5141\u8bb8\u7684\u8bf7\u6c42\u6570
\n window_seconds: \u7a97\u53e3\u5927\u5c0f（\u79d2）
\n """
\n self.requests_per_window = requests_per_window
\n self.window_seconds = window_seconds
\n self.logs: Dict[str, deque] = {}
\n self.lock = threading.RLock()<\/p>\n
def is_allowed(self, key: str, weight: int = 1) -> Tuple[bool, Dict]:
\n with self.lock:
\n current_time = time.time()
\n window_start = current_time – self.window_seconds<\/p>\n
# \u83b7\u53d6\u6216\u521b\u5efa\u65e5\u5fd7\u961f\u5217
\n if key not in self.logs:
\n self.logs[key] = deque()<\/p>\n
log = self.logs[key]<\/p>\n
# \u6e05\u7406\u8fc7\u671f\u8bb0\u5f55
\n while log and log[0] < window_start:
\n log.popleft()<\/p>\n
# \u68c0\u67e5\u662f\u5426\u8d85\u8fc7\u9650\u5236
\n if len(log) + weight <= self.requests_per_window:
\n # \u5141\u8bb8\u8bf7\u6c42，\u8bb0\u5f55\u65f6\u95f4\u6233
\n for _ in range(weight):
\n log.append(current_time)<\/p>\n
remaining = self.requests_per_window – len(log)
\n # \u8ba1\u7b97\u91cd\u7f6e\u65f6\u95f4（\u6700\u65e9\u8bf7\u6c42\u7684\u65f6\u95f4 + \u7a97\u53e3\u5927\u5c0f）
\n reset_time = log[0] + self.window_seconds if log else current_time + self.window_seconds<\/p>\n
return True, {
\n 'remaining': remaining,
\n 'reset_time': reset_time,
\n 'limit': self.requests_per_window
\n }
\n else:
\n # \u5df2\u8d85\u8fc7\u9650\u5236
\n remaining = 0
\n # \u8ba1\u7b97\u6700\u65e9\u53ef\u91cd\u8bd5\u65f6\u95f4
\n retry_time = log[0] + self.window_seconds if log else current_time
\n retry_after = math.ceil(retry_time – current_time)
\n reset_time = retry_time<\/p>\n
return False, {
\n 'remaining': remaining,
\n 'reset_time': reset_time,
\n 'retry_after': max(0, retry_after),
\n 'limit': self.requests_per_window
\n }<\/p>\n
def get_remaining(self, key: str) -> int:
\n with self.lock:
\n current_time = time.time()
\n window_start = current_time – self.window_seconds<\/p>\n
if key not in self.logs:
\n return self.requests_per_window<\/p>\n
log = self.logs[key]<\/p>\n
# \u6e05\u7406\u8fc7\u671f\u8bb0\u5f55
\n while log and log[0] < window_start:
\n log.popleft()<\/p>\n
return max(0, self.requests_per_window – len(log))<\/p>\n
def get_reset_time(self, key: str) -> float:
\n with self.lock:
\n current_time = time.time()
\n window_start = current_time – self.window_seconds<\/p>\n
if key not in self.logs:
\n return current_time + self.window_seconds<\/p>\n
log = self.logs[key]<\/p>\n
# \u6e05\u7406\u8fc7\u671f\u8bb0\u5f55
\n while log and log[0] < window_start:
\n log.popleft()<\/p>\n
if log:
\n # \u6700\u65e9\u8bf7\u6c42\u7684\u65f6\u95f4 + \u7a97\u53e3\u5927\u5c0f
\n return log[0] + self.window_seconds
\n else:
\n return current_time + self.window_seconds<\/p>\n
class AdaptiveRateLimiter:
\n """\u81ea\u9002\u5e94\u901f\u7387\u9650\u5236\u5668"""<\/p>\n
def __init__(self, base_limiter: RateLimiter, adaptation_config: Dict = None):
\n self.base_limiter = base_limiter
\n self.config = {
\n 'min_requests_per_second': 1,
\n 'max_requests_per_second': 100,
\n 'scale_up_factor': 1.1, # \u589e\u52a010%
\n 'scale_down_factor': 0.9, # \u51cf\u5c1110%
\n 'scale_up_interval': 60, # \u6bcf60\u79d2\u8bc4\u4f30\u4e00\u6b21\u589e\u52a0
\n 'scale_down_threshold': 0.8, # \u4f7f\u7528\u738780%\u65f6\u8003\u8651\u589e\u52a0
\n 'load_shedding_threshold': 0.95, # \u4f7f\u7528\u738795%\u65f6\u5f00\u59cb\u964d\u7ea7
\n ** (adaptation_config or {})
\n }<\/p>\n
self.usage_history = deque(maxlen=100)
\n self.adaptation_history = []
\n self.last_adaptation_time = time.time()<\/p>\n
def is_allowed(self, key: str, weight: int = 1) -> Tuple[bool, Dict]:
\n # \u68c0\u67e5\u57fa\u7840\u9650\u5236\u5668
\n allowed, result = self.base_limiter.is_allowed(key, weight)<\/p>\n
# \u8bb0\u5f55\u4f7f\u7528\u60c5\u51b5
\n self.record_usage(key, allowed, result)<\/p>\n
# \u81ea\u9002\u5e94\u8c03\u6574
\n self.adaptive_adjustment()<\/p>\n
return allowed, result<\/p>\n
def record_usage(self, key: str, allowed: bool, result: Dict):
\n """\u8bb0\u5f55\u4f7f\u7528\u60c5\u51b5"""
\n current_time = time.time()<\/p>\n
usage = {
\n 'timestamp': current_time,
\n 'key': key,
\n 'allowed': allowed,
\n 'remaining': result.get('remaining', 0),
\n 'limit': result.get('limit', 0)
\n }<\/p>\n
self.usage_history.append(usage)<\/p>\n
def adaptive_adjustment(self):
\n """\u81ea\u9002\u5e94\u8c03\u6574"""
\n current_time = time.time()<\/p>\n
# \u68c0\u67e5\u662f\u5426\u5230\u8fbe\u8c03\u6574\u95f4\u9694
\n if current_time – self.last_adaptation_time < self.config['scale_up_interval']:
\n return<\/p>\n
# \u5206\u6790\u6700\u8fd1\u7684\u4f7f\u7528\u60c5\u51b5
\n recent_history = [u for u in self.usage_history
\n if u['timestamp'] > current_time – self.config['scale_up_interval']]<\/p>\n
if not recent_history:
\n return<\/p>\n
# \u8ba1\u7b97\u5e73\u5747\u4f7f\u7528\u7387
\n total_requests = len(recent_history)
\n allowed_requests = sum(1 for u in recent_history if u['allowed'])
\n usage_rate = allowed_requests \/ total_requests if total_requests > 0 else 0<\/p>\n
# \u8c03\u6574\u903b\u8f91
\n if usage_rate > self.config['scale_down_threshold']:
\n # \u4f7f\u7528\u7387\u9ad8，\u8003\u8651\u589e\u52a0\u9650\u5236
\n self.scale_up()
\n elif usage_rate < 0.5:
\n # \u4f7f\u7528\u7387\u4f4e，\u8003\u8651\u51cf\u5c11\u9650\u5236
\n self.scale_down()<\/p>\n
self.last_adaptation_time = current_time<\/p>\n
def scale_up(self):
\n """\u589e\u52a0\u901f\u7387\u9650\u5236"""
\n # \u83b7\u53d6\u5f53\u524d\u9650\u5236\u5668\u914d\u7f6e
\n if isinstance(self.base_limiter, TokenBucketLimiter):
\n new_capacity = min(
\n self.base_limiter.capacity * self.config['scale_up_factor'],
\n self.config['max_requests_per_second'] * 60 # \u8f6c\u6362\u4e3a\u6bcf\u5206\u949f
\n )
\n self.base_limiter.capacity = new_capacity<\/p>\n
self.adaptation_history.append({
\n 'timestamp': time.time(),
\n 'action': 'scale_up',
\n 'new_capacity': new_capacity,
\n 'reason': 'high_usage_rate'
\n })<\/p>\n
elif isinstance(self.base_limiter, FixedWindowLimiter):
\n new_limit = min(
\n self.base_limiter.requests_per_window * self.config['scale_up_factor'],
\n self.config['max_requests_per_second'] * self.base_limiter.window_seconds
\n )
\n self.base_limiter.requests_per_window = int(new_limit)<\/p>\n
self.adaptation_history.append({
\n 'timestamp': time.time(),
\n 'action': 'scale_up',
\n 'new_limit': new_limit,
\n 'reason': 'high_usage_rate'
\n })<\/p>\n
def scale_down(self):
\n """\u51cf\u5c11\u901f\u7387\u9650\u5236"""
\n if isinstance(self.base_limiter, TokenBucketLimiter):
\n new_capacity = max(
\n self.base_limiter.capacity * self.config['scale_down_factor'],
\n self.config['min_requests_per_second'] * 60
\n )
\n self.base_limiter.capacity = new_capacity<\/p>\n
self.adaptation_history.append({
\n 'timestamp': time.time(),
\n 'action': 'scale_down',
\n 'new_capacity': new_capacity,
\n 'reason': 'low_usage_rate'
\n })<\/p>\n
elif isinstance(self.base_limiter, FixedWindowLimiter):
\n new_limit = max(
\n self.base_limiter.requests_per_window * self.config['scale_down_factor'],
\n self.config['min_requests_per_second'] * self.base_limiter.window_seconds
\n )
\n self.base_limiter.requests_per_window = int(new_limit)<\/p>\n
self.adaptation_history.append({
\n 'timestamp': time.time(),
\n 'action': 'scale_down',
\n 'new_limit': new_limit,
\n 'reason': 'low_usage_rate'
\n })<\/p>\n
python<\/p>\n
# \u591a\u5c42\u901f\u7387\u9650\u5236\u7b56\u7565
\nfrom typing import List, Dict, Optional, Tuple
\nimport hashlib<\/p>\n
class MultiLayerRateLimiter:
\n """\u591a\u5c42\u901f\u7387\u9650\u5236\u5668"""<\/p>\n
def __init__(self, layers_config: List[Dict]):
\n """
\n Args:
\n layers_config: \u5404\u5c42\u914d\u7f6e\u5217\u8868，\u6309\u987a\u5e8f\u68c0\u67e5
\n [
\n {
\n 'limiter_class': TokenBucketLimiter,
\n 'args': [100, 1.0], # capacity, refill_rate
\n 'kwargs': {},
\n 'key_builder': 'ip', # ip, user, endpoint, custom
\n 'cost': 1, # \u8bf7\u6c42\u6210\u672c
\n 'name': 'ip_layer'
\n },
\n …
\n ]
\n """
\n self.layers = []
\n self.layer_configs = layers_config
\n self.init_layers()<\/p>\n
def init_layers(self):
\n """\u521d\u59cb\u5316\u5404\u5c42\u9650\u5236\u5668"""
\n for config in self.layer_configs:
\n limiter_class = config['limiter_class']
\n args = config.get('args', [])
\n kwargs = config.get('kwargs', {})<\/p>\n
limiter = limiter_class(*args, **kwargs)<\/p>\n
self.layers.append({
\n 'limiter': limiter,
\n 'key_builder': config.get('key_builder', 'ip'),
\n 'cost': config.get('cost', 1),
\n 'name': config.get('name', 'unnamed_layer'),
\n 'priority': config.get('priority', 0)
\n })<\/p>\n
# \u6309\u4f18\u5148\u7ea7\u6392\u5e8f
\n self.layers.sort(key=lambda x: x['priority'], reverse=True)<\/p>\n
def is_allowed(self, request_info: Dict) -> Tuple[bool, Dict]:
\n """
\n \u68c0\u67e5\u8bf7\u6c42\u662f\u5426\u88ab\u5141\u8bb8<\/p>\n
Args:
\n request_info: \u8bf7\u6c42\u4fe1\u606f
\n {
\n 'ip': '127.0.0.1',
\n 'user_id': 'user123',
\n 'endpoint': '\/api\/users',
\n 'method': 'GET',
\n 'headers': {…}
\n }<\/p>\n
Returns:
\n (allowed, result)
\n """
\n results = []<\/p>\n
for layer in self.layers:
\n # \u6784\u5efa\u952e
\n key = self.build_key(layer['key_builder'], request_info)
\n cost = layer['cost']<\/p>\n
# \u68c0\u67e5\u8be5\u5c42\u9650\u5236
\n allowed, result = layer['limiter'].is_allowed(key, cost)
\n result['layer'] = layer['name']<\/p>\n
results.append(result)<\/p>\n
if not allowed:
\n # \u8be5\u5c42\u88ab\u9650\u5236，\u7acb\u5373\u8fd4\u56de
\n return False, {
\n 'allowed': False,
\n 'first_blocking_layer': layer['name'],
\n 'details': results,
\n 'retry_after': result.get('retry_after'),
\n 'reset_time': result.get('reset_time')
\n }<\/p>\n
# \u6240\u6709\u5c42\u90fd\u5141\u8bb8
\n return True, {
\n 'allowed': True,
\n 'details': results
\n }<\/p>\n
def build_key(self, key_builder: str, request_info: Dict) -> str:
\n """\u6784\u5efa\u9650\u5236\u952e"""
\n if key_builder == 'ip':
\n return f"ip:{request_info.get('ip', 'unknown')}"<\/p>\n
elif key_builder == 'user':
\n user_id = request_info.get('user_id')
\n if user_id:
\n return f"user:{user_id}"
\n else:
\n # \u672a\u8ba4\u8bc1\u7528\u6237\u4f7f\u7528IP
\n return f"ip:{request_info.get('ip', 'unknown')}"<\/p>\n
elif key_builder == 'endpoint':
\n endpoint = request_info.get('endpoint', 'unknown')
\n method = request_info.get('method', 'GET')
\n return f"endpoint:{method}:{endpoint}"<\/p>\n
elif key_builder == 'user_endpoint':
\n user_id = request_info.get('user_id', 'anonymous')
\n endpoint = request_info.get('endpoint', 'unknown')
\n method = request_info.get('method', 'GET')
\n return f"user_endpoint:{user_id}:{method}:{endpoint}"<\/p>\n
elif key_builder == 'custom':
\n # \u81ea\u5b9a\u4e49\u952e\u6784\u5efa\u903b\u8f91
\n custom_data = request_info.get('custom_key_data', '')
\n key_hash = hashlib.md5(custom_data.encode()).hexdigest()
\n return f"custom:{key_hash}"<\/p>\n
else:
\n # \u9ed8\u8ba4\u4f7f\u7528IP
\n return f"ip:{request_info.get('ip', 'unknown')}"<\/p>\n
def get_quotas(self, request_info: Dict) -> Dict:
\n """\u83b7\u53d6\u6240\u6709\u5c42\u7684\u914d\u989d\u4fe1\u606f"""
\n quotas = {}<\/p>\n
for layer in self.layers:
\n key = self.build_key(layer['key_builder'], request_info)
\n limiter = layer['limiter']<\/p>\n
remaining = limiter.get_remaining(key)
\n reset_time = limiter.get_reset_time(key)<\/p>\n
quotas[layer['name']] = {
\n 'remaining': remaining,
\n 'reset_time': reset_time,
\n 'limit': self.get_layer_limit(layer),
\n 'key_builder': layer['key_builder']
\n }<\/p>\n
return quotas<\/p>\n
def get_layer_limit(self, layer: Dict) -> int:
\n """\u83b7\u53d6\u5c42\u7684\u9650\u5236\u503c"""
\n limiter = layer['limiter']<\/p>\n
if isinstance(limiter, TokenBucketLimiter):
\n return limiter.capacity
\n elif isinstance(limiter, FixedWindowLimiter):
\n return limiter.requests_per_window
\n elif isinstance(limiter, SlidingWindowLogLimiter):
\n return limiter.requests_per_window
\n else:
\n return 0<\/p>\n
def get_rate_limit_headers(self, request_info: Dict) -> Dict[str, str]:
\n """\u83b7\u53d6\u901f\u7387\u9650\u5236\u5934\u90e8\u4fe1\u606f"""
\n quotas = self.get_quotas(request_info)<\/p>\n
# \u627e\u5230\u6700\u4e25\u683c\u7684\u9650\u5236
\n strictest_layer = None
\n strictest_remaining = float('inf')<\/p>\n
for name, quota in quotas.items():
\n if quota['remaining'] < strictest_remaining:
\n strictest_remaining = quota['remaining']
\n strictest_layer = name<\/p>\n
if strictest_layer:
\n quota = quotas[strictest_layer]<\/p>\n
headers = {
\n 'X-RateLimit-Limit': str(quota['limit']),
\n 'X-RateLimit-Remaining': str(quota['remaining']),
\n 'X-RateLimit-Reset': str(int(quota['reset_time']))
\n }<\/p>\n
# \u6dfb\u52a0\u91cd\u8bd5\u5934\u90e8（\u5982\u679c\u5269\u4f59\u4e3a0）
\n if quota['remaining'] <= 0:
\n retry_after = max(0, math.ceil(quota['reset_time'] – time.time()))
\n headers['Retry-After'] = str(retry_after)<\/p>\n
return headers<\/p>\n
return {}<\/p>\n
# \u4f7f\u7528\u793a\u4f8b
\ndef create_production_rate_limiter():
\n """\u521b\u5efa\u751f\u4ea7\u73af\u5883\u4f7f\u7528\u7684\u591a\u5c42\u901f\u7387\u9650\u5236\u5668"""<\/p>\n
layers_config = [
\n # \u7b2c\u4e00\u5c42：IP\u57fa\u7840\u9650\u5236（\u9632\u6b62\u6ee5\u7528）
\n {
\n 'limiter_class': TokenBucketLimiter,
\n 'args': [100, 1.0], # 100\u8bf7\u6c42，\u6bcf\u79d2\u8865\u51451\u4e2a
\n 'key_builder': 'ip',
\n 'cost': 1,
\n 'name': 'ip_basic',
\n 'priority': 10
\n },<\/p>\n
# \u7b2c\u4e8c\u5c42：\u7528\u6237\u7ea7\u522b\u9650\u5236
\n {
\n 'limiter_class': FixedWindowLimiter,
\n 'args': [1000, 3600], # 1000\u8bf7\u6c42\/\u5c0f\u65f6
\n 'key_builder': 'user',
\n 'cost': 1,
\n 'name': 'user_hourly',
\n 'priority': 20
\n },<\/p>\n
# \u7b2c\u4e09\u5c42：\u7aef\u70b9\u7ea7\u522b\u9650\u5236
\n {
\n 'limiter_class': SlidingWindowLogLimiter,
\n 'args': [60, 60], # 60\u8bf7\u6c42\/\u5206\u949f
\n 'key_builder': 'endpoint',
\n 'cost': 1,
\n 'name': 'endpoint_minute',
\n 'priority': 30
\n },<\/p>\n
# \u7b2c\u56db\u5c42：\u654f\u611f\u7aef\u70b9\u66f4\u4e25\u683c\u9650\u5236
\n {
\n 'limiter_class': FixedWindowLimiter,
\n 'args': [10, 60], # 10\u8bf7\u6c42\/\u5206\u949f（\u7528\u4e8e\u654f\u611f\u64cd\u4f5c）
\n 'key_builder': 'user_endpoint',
\n 'cost': 1,
\n 'name': 'sensitive_endpoint',
\n 'priority': 40,
\n 'condition': lambda req: req.get('endpoint', '').startswith('\/api\/admin\/')
\n }
\n ]<\/p>\n
return MultiLayerRateLimiter(layers_config)<\/p>\n
python<\/p>\n
# \u57fa\u4e8eRedis\u7684\u5206\u5e03\u5f0f\u901f\u7387\u9650\u5236\u5668
\nimport redis
\nimport json
\nimport pickle
\nfrom typing import Optional, Tuple, Dict, Any
\nimport time
\nimport hashlib<\/p>\n
class RedisRateLimiter:
\n """\u57fa\u4e8eRedis\u7684\u5206\u5e03\u5f0f\u901f\u7387\u9650\u5236\u5668"""<\/p>\n
def __init__(self, redis_client: redis.Redis, namespace: str = "ratelimit"):
\n self.redis = redis_client
\n self.namespace = namespace
\n self.lua_scripts = self.load_lua_scripts()<\/p>\n
def load_lua_scripts(self) -> Dict[str, str]:
\n """\u52a0\u8f7dLua\u811a\u672c（\u539f\u5b50\u64cd\u4f5c）"""<\/p>\n
# \u4ee4\u724c\u6876\u7b97\u6cd5\u7684Lua\u811a\u672c
\n token_bucket_script = """
\n local key = KEYS[1]
\n local capacity = tonumber(ARGV[1])
\n local refill_rate = tonumber(ARGV[2])
\n local weight = tonumber(ARGV[3])
\n local now = tonumber(ARGV[4])<\/p>\n
local bucket = redis.call('HMGET', key, 'tokens', 'last_refill')
\n local tokens
\n local last_refill<\/p>\n
if bucket[1] == false then
\n — \u521d\u59cb\u5316\u6876
\n tokens = capacity
\n last_refill = now
\n redis.call('HMSET', key, 'tokens', tokens, 'last_refill', last_refill)
\n else
\n tokens = tonumber(bucket[1])
\n last_refill = tonumber(bucket[2])<\/p>\n
— \u8865\u5145\u4ee4\u724c
\n local time_passed = now – last_refill
\n local tokens_to_add = time_passed * refill_rate
\n tokens = math.min(capacity, tokens + tokens_to_add)
\n last_refill = now
\n end<\/p>\n
— \u68c0\u67e5\u662f\u5426\u6709\u8db3\u591f\u4ee4\u724c
\n if tokens >= weight then
\n tokens = tokens – weight
\n redis.call('HMSET', key, 'tokens', tokens, 'last_refill', last_refill)<\/p>\n
— \u8ba1\u7b97\u91cd\u7f6e\u65f6\u95f4
\n local reset_time = now + (capacity – tokens) \/ refill_rate<\/p>\n
return {1, tokens, reset_time, capacity}
\n else
\n — \u8ba1\u7b97\u9700\u8981\u7b49\u5f85\u7684\u65f6\u95f4
\n local tokens_needed = weight – tokens
\n local wait_time = tokens_needed \/ refill_rate
\n local reset_time = now + wait_time<\/p>\n
return {0, tokens, reset_time, capacity, wait_time}
\n end
\n """<\/p>\n
# \u56fa\u5b9a\u7a97\u53e3\u7b97\u6cd5\u7684Lua\u811a\u672c
\n fixed_window_script = """
\n local key = KEYS[1]
\n local limit = tonumber(ARGV[1])
\n local window = tonumber(ARGV[2])
\n local weight = tonumber(ARGV[3])
\n local now = tonumber(ARGV[4])<\/p>\n
local window_start = math.floor(now \/ window) * window
\n local window_key = key .. ':' .. tostring(window_start)<\/p>\n
— \u83b7\u53d6\u5f53\u524d\u8ba1\u6570
\n local count = redis.call('GET', window_key)
\n if count == false then
\n count = 0
\n else
\n count = tonumber(count)
\n end<\/p>\n
— \u68c0\u67e5\u662f\u5426\u8d85\u8fc7\u9650\u5236
\n if count + weight <= limit then
\n — \u589e\u52a0\u8ba1\u6570
\n redis.call('INCRBY', window_key, weight)
\n — \u8bbe\u7f6e\u8fc7\u671f\u65f6\u95f4（\u7a97\u53e3\u7ed3\u675f\u65f6）
\n redis.call('EXPIRE', window_key, window)<\/p>\n
local remaining = limit – (count + weight)
\n local reset_time = window_start + window<\/p>\n
return {1, remaining, reset_time, limit}
\n else
\n — \u5df2\u8d85\u8fc7\u9650\u5236
\n local remaining = 0
\n local reset_time = window_start + window
\n local retry_after = reset_time – now<\/p>\n
return {0, remaining, reset_time, limit, retry_after}
\n end
\n """<\/p>\n
# \u6ed1\u52a8\u7a97\u53e3\u7b97\u6cd5\u7684Lua\u811a\u672c
\n sliding_window_script = """
\n local key = KEYS[1]
\n local limit = tonumber(ARGV[1])
\n local window = tonumber(ARGV[2])
\n local weight = tonumber(ARGV[3])
\n local now = tonumber(ARGV[4])<\/p>\n
local window_start = now – window<\/p>\n
— \u83b7\u53d6\u6240\u6709\u8bb0\u5f55
\n local records = redis.call('ZRANGEBYSCORE', key, window_start, now)
\n local count = #records<\/p>\n
— \u68c0\u67e5\u662f\u5426\u8d85\u8fc7\u9650\u5236
\n if count + weight <= limit then
\n — \u6dfb\u52a0\u65b0\u8bb0\u5f55
\n for i = 1, weight do
\n redis.call('ZADD', key, now, now .. ':' .. i)
\n end<\/p>\n
— \u6e05\u7406\u8fc7\u671f\u8bb0\u5f55
\n redis.call('ZREMRANGEBYSCORE', key, 0, window_start)<\/p>\n
— \u8bbe\u7f6e\u8fc7\u671f\u65f6\u95f4
\n redis.call('EXPIRE', key, window)<\/p>\n
— \u8ba1\u7b97\u5269\u4f59\u914d\u989d
\n local remaining = limit – (count + weight)<\/p>\n
— \u8ba1\u7b97\u91cd\u7f6e\u65f6\u95f4（\u6700\u65e9\u8bb0\u5f55\u7684\u65f6\u95f4 + \u7a97\u53e3\u5927\u5c0f）
\n local reset_time
\n if count > 0 then
\n local oldest = redis.call('ZRANGE', key, 0, 0, 'WITHSCORES')[2]
\n reset_time = oldest + window
\n else
\n reset_time = now + window
\n end<\/p>\n
return {1, remaining, reset_time, limit}
\n else
\n — \u5df2\u8d85\u8fc7\u9650\u5236
\n local remaining = 0<\/p>\n
— \u8ba1\u7b97\u6700\u65e9\u53ef\u91cd\u8bd5\u65f6\u95f4
\n local reset_time
\n if count > 0 then
\n local oldest = redis.call('ZRANGE', key, 0, 0, 'WITHSCORES')[2]
\n reset_time = oldest + window
\n else
\n reset_time = now + window
\n end<\/p>\n
local retry_after = reset_time – now<\/p>\n
return {0, remaining, reset_time, limit, retry_after}
\n end
\n """<\/p>\n
return {
\n 'token_bucket': self.redis.script_load(token_bucket_script),
\n 'fixed_window': self.redis.script_load(fixed_window_script),
\n 'sliding_window': self.redis.script_load(sliding_window_script)
\n }<\/p>\n
def token_bucket_is_allowed(self, key: str, capacity: int,
\n refill_rate: float, weight: int = 1) -> Tuple[bool, Dict]:
\n """\u4ee4\u724c\u6876\u7b97\u6cd5\u68c0\u67e5"""
\n redis_key = f"{self.namespace}:token_bucket:{key}"
\n now = time.time()<\/p>\n
result = self.redis.evalsha(
\n self.lua_scripts['token_bucket'],
\n 1, # key\u6570\u91cf
\n redis_key,
\n capacity,
\n refill_rate,
\n weight,
\n now
\n )<\/p>\n
allowed = bool(result[0])
\n tokens = result[1]
\n reset_time = result[2]
\n limit = result[3]<\/p>\n
if allowed:
\n return True, {
\n 'remaining': int(tokens),
\n 'reset_time': reset_time,
\n 'limit': limit
\n }
\n else:
\n wait_time = result[4]
\n return False, {
\n 'remaining': int(tokens),
\n 'reset_time': reset_time,
\n 'retry_after': math.ceil(wait_time),
\n 'limit': limit
\n }<\/p>\n
def fixed_window_is_allowed(self, key: str, limit: int,
\n window_seconds: int, weight: int = 1) -> Tuple[bool, Dict]:
\n """\u56fa\u5b9a\u7a97\u53e3\u7b97\u6cd5\u68c0\u67e5"""
\n redis_key = f"{self.namespace}:fixed_window:{key}"
\n now = time.time()<\/p>\n
result = self.redis.evalsha(
\n self.lua_scripts['fixed_window'],
\n 1,
\n redis_key,
\n limit,
\n window_seconds,
\n weight,
\n now
\n )<\/p>\n
allowed = bool(result[0])
\n remaining = result[1]
\n reset_time = result[2]
\n limit_val = result[3]<\/p>\n
if allowed:
\n return True, {
\n 'remaining': int(remaining),
\n 'reset_time': reset_time,
\n 'limit': limit_val
\n }
\n else:
\n retry_after = result[4]
\n return False, {
\n 'remaining': int(remaining),
\n 'reset_time': reset_time,
\n 'retry_after': math.ceil(retry_after),
\n 'limit': limit_val
\n }<\/p>\n
def sliding_window_is_allowed(self, key: str, limit: int,
\n window_seconds: int, weight: int = 1) -> Tuple[bool, Dict]:
\n """\u6ed1\u52a8\u7a97\u53e3\u7b97\u6cd5\u68c0\u67e5"""
\n redis_key = f"{self.namespace}:sliding_window:{key}"
\n now = time.time()<\/p>\n
result = self.redis.evalsha(
\n self.lua_scripts['sliding_window'],
\n 1,
\n redis_key,
\n limit,
\n window_seconds,
\n weight,
\n now
\n )<\/p>\n
allowed = bool(result[0])
\n remaining = result[1]
\n reset_time = result[2]
\n limit_val = result[3]<\/p>\n
if allowed:
\n return True, {
\n 'remaining': int(remaining),
\n 'reset_time': reset_time,
\n 'limit': limit_val
\n }
\n else:
\n retry_after = result[4]
\n return False, {
\n 'remaining': int(remaining),
\n 'reset_time': reset_time,
\n 'retry_after': math.ceil(retry_after),
\n 'limit': limit_val
\n }<\/p>\n
def get_quotas(self, key: str, algorithm: str = 'token_bucket',
\n **kwargs) -> Optional[Dict]:
\n """\u83b7\u53d6\u914d\u989d\u4fe1\u606f"""
\n if algorithm == 'token_bucket':
\n capacity = kwargs.get('capacity', 100)
\n refill_rate = kwargs.get('refill_rate', 1.0)<\/p>\n
redis_key = f"{self.namespace}:token_bucket:{key}"
\n bucket = self.redis.hgetall(redis_key)<\/p>\n
if not bucket:
\n return {
\n 'remaining': capacity,
\n 'limit': capacity,
\n 'reset_time': time.time()
\n }<\/p>\n
tokens = float(bucket.get(b'tokens', 0))
\n last_refill = float(bucket.get(b'last_refill', time.time()))<\/p>\n
# \u8865\u5145\u4ee4\u724c
\n now = time.time()
\n time_passed = now – last_refill
\n tokens_to_add = time_passed * refill_rate
\n tokens = min(capacity, tokens + tokens_to_add)<\/p>\n
# \u8ba1\u7b97\u91cd\u7f6e\u65f6\u95f4
\n if tokens < capacity:
\n reset_time = now + (capacity – tokens) \/ refill_rate
\n else:
\n reset_time = now<\/p>\n
return {
\n 'remaining': int(tokens),
\n 'limit': capacity,
\n 'reset_time': reset_time
\n }<\/p>\n
elif algorithm == 'fixed_window':
\n limit = kwargs.get('limit', 100)
\n window_seconds = kwargs.get('window_seconds', 60)<\/p>\n
now = time.time()
\n window_start = math.floor(now \/ window_seconds) * window_seconds
\n redis_key = f"{self.namespace}:fixed_window:{key}:{window_start}"<\/p>\n
count = int(self.redis.get(redis_key) or 0)
\n remaining = max(0, limit – count)
\n reset_time = window_start + window_seconds<\/p>\n
return {
\n 'remaining': remaining,
\n 'limit': limit,
\n 'reset_time': reset_time
\n }<\/p>\n
return None<\/p>\n
def reset_limits(self, key: str, algorithm: str = 'token_bucket'):
\n """\u91cd\u7f6e\u9650\u5236"""
\n if algorithm == 'token_bucket':
\n redis_key = f"{self.namespace}:token_bucket:{key}"
\n self.redis.delete(redis_key)
\n elif algorithm == 'fixed_window':
\n # \u5220\u9664\u6240\u6709\u76f8\u5173\u7684\u7a97\u53e3\u952e
\n pattern = f"{self.namespace}:fixed_window:{key}:*"
\n keys = self.redis.keys(pattern)
\n if keys:
\n self.redis.delete(*keys)
\n elif algorithm == 'sliding_window':
\n redis_key = f"{self.namespace}:sliding_window:{key}"
\n self.redis.delete(redis_key)<\/p>\n
class DistributedRateLimiter:
\n """\u5206\u5e03\u5f0f\u901f\u7387\u9650\u5236\u7ba1\u7406\u5668"""<\/p>\n
def __init__(self, redis_client: redis.Redis, config: Dict):
\n self.redis = redis_client
\n self.config = config
\n self.redis_limiter = RedisRateLimiter(redis_client)<\/p>\n
# \u672c\u5730\u7f13\u5b58，\u51cf\u5c11Redis\u8bbf\u95ee
\n self.local_cache = {}
\n self.cache_ttl = 1 # \u672c\u5730\u7f13\u5b581\u79d2<\/p>\n
def is_allowed(self, identifier: str, rule_name: str) -> Tuple[bool, Dict]:
\n """\u68c0\u67e5\u662f\u5426\u5141\u8bb8\u8bf7\u6c42"""<\/p>\n
# \u68c0\u67e5\u672c\u5730\u7f13\u5b58
\n cache_key = f"{identifier}:{rule_name}"
\n cached = self.local_cache.get(cache_key)
\n if cached and time.time() – cached['timestamp'] < self.cache_ttl:
\n return cached['allowed'], cached['result']<\/p>\n
# \u83b7\u53d6\u89c4\u5219\u914d\u7f6e
\n rule = self.config.get('rules', {}).get(rule_name)
\n if not rule:
\n # \u6ca1\u6709\u89c4\u5219\u914d\u7f6e，\u9ed8\u8ba4\u5141\u8bb8
\n return True, {'allowed': True, 'rule': rule_name}<\/p>\n
algorithm = rule.get('algorithm', 'token_bucket')
\n params = rule.get('params', {})<\/p>\n
# \u6839\u636e\u7b97\u6cd5\u8c03\u7528\u76f8\u5e94\u7684Redis\u9650\u5236\u5668
\n if algorithm == 'token_bucket':
\n allowed, result = self.redis_limiter.token_bucket_is_allowed(
\n f"{rule_name}:{identifier}",
\n params.get('capacity', 100),
\n params.get('refill_rate', 1.0),
\n params.get('cost', 1)
\n )
\n elif algorithm == 'fixed_window':
\n allowed, result = self.redis_limiter.fixed_window_is_allowed(
\n f"{rule_name}:{identifier}",
\n params.get('limit', 100),
\n params.get('window_seconds', 60),
\n params.get('cost', 1)
\n )
\n elif algorithm == 'sliding_window':
\n allowed, result = self.redis_limiter.sliding_window_is_allowed(
\n f"{rule_name}:{identifier}",
\n params.get('limit', 100),
\n params.get('window_seconds', 60),
\n params.get('cost', 1)
\n )
\n else:
\n # \u672a\u77e5\u7b97\u6cd5，\u9ed8\u8ba4\u5141\u8bb8
\n return True, {'allowed': True, 'rule': rule_name}<\/p>\n
# \u6dfb\u52a0\u89c4\u5219\u4fe1\u606f\u5230\u7ed3\u679c
\n result['rule'] = rule_name
\n result['algorithm'] = algorithm<\/p>\n
# \u7f13\u5b58\u7ed3\u679c
\n self.local_cache[cache_key] = {
\n 'allowed': allowed,
\n 'result': result,
\n 'timestamp': time.time()
\n }<\/p>\n
return allowed, result<\/p>\n
def get_all_quotas(self, identifier: str) -> Dict:
\n """\u83b7\u53d6\u6240\u6709\u89c4\u5219\u7684\u914d\u989d\u4fe1\u606f"""
\n quotas = {}<\/p>\n
for rule_name, rule in self.config.get('rules', {}).items():
\n algorithm = rule.get('algorithm', 'token_bucket')
\n params = rule.get('params', {})<\/p>\n
quota = self.redis_limiter.get_quotas(
\n f"{rule_name}:{identifier}",
\n algorithm,
\n **params
\n )<\/p>\n
if quota:
\n quotas[rule_name] = {
\n **quota,
\n 'algorithm': algorithm,
\n 'rule': rule_name
\n }<\/p>\n
return quotas<\/p>\n
def create_rate_limit_response(self, identifier: str, rule_name: str,
\n result: Dict) -> Tuple[Dict, Dict]:
\n """\u521b\u5efa\u901f\u7387\u9650\u5236\u54cd\u5e94"""<\/p>\n
if result.get('allowed', True):
\n # \u5141\u8bb8\u8bf7\u6c42，\u6dfb\u52a0\u901f\u7387\u9650\u5236\u5934\u90e8
\n headers = {
\n 'X-RateLimit-Limit': str(result.get('limit', 0)),
\n 'X-RateLimit-Remaining': str(result.get('remaining', 0)),
\n 'X-RateLimit-Reset': str(int(result.get('reset_time', time.time()))),
\n 'X-RateLimit-Rule': rule_name
\n }<\/p>\n
return {'allowed': True}, headers<\/p>\n
else:
\n # \u8bf7\u6c42\u88ab\u9650\u5236
\n retry_after = result.get('retry_after', 60)
\n reset_time = result.get('reset_time', time.time() + retry_after)<\/p>\n
# \u54cd\u5e94\u4f53
\n response_body = {
\n 'error': {
\n 'code': 'RATE_LIMIT_EXCEEDED',
\n 'message': 'Too many requests',
\n 'details': {
\n 'rule': rule_name,
\n 'retry_after': retry_after,
\n 'reset_time': reset_time,
\n 'limit': result.get('limit', 0),
\n 'remaining': result.get('remaining', 0)
\n }
\n }
\n }<\/p>\n
# \u54cd\u5e94\u5934\u90e8
\n headers = {
\n 'Retry-After': str(retry_after),
\n 'X-RateLimit-Limit': str(result.get('limit', 0)),
\n 'X-RateLimit-Remaining': str(result.get('remaining', 0)),
\n 'X-RateLimit-Reset': str(int(reset_time)),
\n 'X-RateLimit-Rule': rule_name
\n }<\/p>\n
return response_body, headers<\/p>\n
# \u914d\u7f6e\u793a\u4f8b
\nRATE_LIMIT_CONFIG = {
\n 'rules': {
\n 'ip_global': {
\n 'algorithm': 'token_bucket',
\n 'params': {
\n 'capacity': 1000,
\n 'refill_rate': 10.0, # 10\u8bf7\u6c42\/\u79d2
\n 'cost': 1
\n },
\n 'description': '\u5168\u5c40IP\u9650\u5236'
\n },
\n 'user_auth': {
\n 'algorithm': 'fixed_window',
\n 'params': {
\n 'limit': 10,
\n 'window_seconds': 60, # 10\u8bf7\u6c42\/\u5206\u949f
\n 'cost': 1
\n },
\n 'description': '\u7528\u6237\u8ba4\u8bc1\u9650\u5236'
\n },
\n 'api_endpoint': {
\n 'algorithm': 'sliding_window',
\n 'params': {
\n 'limit': 60,
\n 'window_seconds': 60, # 60\u8bf7\u6c42\/\u5206\u949f
\n 'cost': 1
\n },
\n 'description': 'API\u7aef\u70b9\u9650\u5236'
\n },
\n 'upload_endpoint': {
\n 'algorithm': 'token_bucket',
\n 'params': {
\n 'capacity': 10,
\n 'refill_rate': 0.1, # \u6bcf10\u79d21\u4e2a\u8bf7\u6c42
\n 'cost': 1
\n },
\n 'description': '\u4e0a\u4f20\u7aef\u70b9\u9650\u5236'
\n }
\n },
\n 'default_rule': 'ip_global'
\n}<\/p>\n
python<\/p>\n
# \u667a\u80fd\u901f\u7387\u9650\u5236\u4e2d\u95f4\u4ef6
\nfrom flask import Flask, request, jsonify, g
\nimport time
\nfrom functools import wraps
\nimport uuid<\/p>\n
class IntelligentRateLimitMiddleware:
\n """\u667a\u80fd\u901f\u7387\u9650\u5236\u4e2d\u95f4\u4ef6"""<\/p>\n
def __init__(self, app: Flask = None, config: Dict = None):
\n self.app = app
\n self.config = {
\n 'enabled': True,
\n 'default_limits': {
\n 'ip': '100 per hour',
\n 'user': '1000 per day',
\n 'endpoint': '60 per minute'
\n },
\n 'exempt_paths': ['\/health', '\/metrics'],
\n 'exempt_methods': ['OPTIONS'],
\n 'cost_calculator': self.default_cost_calculator,
\n 'identifier_extractor': self.default_identifier_extractor,
\n 'response_handler': self.default_response_handler,
\n 'adaptive_enabled': True,
\n 'anomaly_detection_enabled': True,
\n ** (config or {})
\n }<\/p>\n
# \u521d\u59cb\u5316\u9650\u5236\u5668
\n self.rate_limiter = DistributedRateLimiter(
\n redis_client=redis.Redis(),
\n config=RATE_LIMIT_CONFIG
\n )<\/p>\n
# \u5f02\u5e38\u68c0\u6d4b\u5668
\n self.anomaly_detector = RateLimitAnomalyDetector()<\/p>\n
# \u81ea\u9002\u5e94\u8c03\u6574\u5668
\n self.adaptive_adjuster = AdaptiveRateAdjuster()<\/p>\n
if app:
\n self.init_app(app)<\/p>\n
def init_app(self, app: Flask):
\n """\u521d\u59cb\u5316Flask\u5e94\u7528"""
\n self.app = app<\/p>\n
# \u6ce8\u518c\u4e2d\u95f4\u4ef6
\n @app.before_request
\n def rate_limit_check():
\n self.check_rate_limit()<\/p>\n
# \u6ce8\u518c\u9519\u8bef\u5904\u7406\u5668
\n @app.errorhandler(429)
\n def handle_rate_limit(e):
\n return self.handle_rate_limit_error(e)<\/p>\n
def check_rate_limit(self):
\n """\u68c0\u67e5\u901f\u7387\u9650\u5236"""<\/p>\n
# \u68c0\u67e5\u662f\u5426\u542f\u7528
\n if not self.config['enabled']:
\n return<\/p>\n
# \u68c0\u67e5\u8c41\u514d\u8def\u5f84
\n if request.path in self.config['exempt_paths']:
\n return<\/p>\n
# \u68c0\u67e5\u8c41\u514d\u65b9\u6cd5
\n if request.method in self.config['exempt_methods']:
\n return<\/p>\n
# \u63d0\u53d6\u6807\u8bc6\u7b26
\n identifiers = self.extract_identifiers(request)<\/p>\n
# \u786e\u5b9a\u9002\u7528\u7684\u89c4\u5219
\n rules = self.determine_applicable_rules(request, identifiers)<\/p>\n
# \u68c0\u67e5\u6bcf\u4e2a\u89c4\u5219
\n for rule_name, identifier in rules:
\n allowed, result = self.rate_limiter.is_allowed(identifier, rule_name)<\/p>\n
if not allowed:
\n # \u68c0\u6d4b\u5f02\u5e38\u884c\u4e3a
\n if self.config['anomaly_detection_enabled']:
\n self.anomaly_detector.record_violation(
\n identifier, rule_name, request
\n )<\/p>\n
# \u89e6\u53d1\u901f\u7387\u9650\u5236
\n self.trigger_rate_limit(identifier, rule_name, result)
\n break<\/p>\n
# \u8bb0\u5f55\u8bf7\u6c42（\u7528\u4e8e\u81ea\u9002\u5e94\u8c03\u6574）
\n if self.config['adaptive_enabled']:
\n self.adaptive_adjuster.record_request(request, identifiers)<\/p>\n
def extract_identifiers(self, request) -> Dict[str, str]:
\n """\u63d0\u53d6\u6807\u8bc6\u7b26"""
\n identifiers = {}<\/p>\n
# \u63d0\u53d6IP
\n if request.headers.get('X-Forwarded-For'):
\n ip = request.headers['X-Forwarded-For'].split(',')[0].strip()
\n else:
\n ip = request.remote_addr
\n identifiers['ip'] = ip<\/p>\n
# \u63d0\u53d6\u7528\u6237ID（\u5982\u679c\u5df2\u8ba4\u8bc1）
\n if hasattr(g, 'user') and g.user:
\n identifiers['user'] = g.user.id
\n elif request.headers.get('X-User-ID'):
\n identifiers['user'] = request.headers['X-User-ID']<\/p>\n
# \u63d0\u53d6API\u5bc6\u94a5
\n if request.headers.get('X-API-Key'):
\n identifiers['api_key'] = request.headers['X-API-Key']<\/p>\n
# \u63d0\u53d6\u4f1a\u8bddID
\n if request.cookies.get('session_id'):
\n identifiers['session'] = request.cookies['session_id']<\/p>\n
return identifiers<\/p>\n
def determine_applicable_rules(self, request, identifiers: Dict) -> List[Tuple[str, str]]:
\n """\u786e\u5b9a\u9002\u7528\u7684\u89c4\u5219"""
\n rules = []<\/p>\n
# \u57fa\u7840\u89c4\u5219：IP\u9650\u5236
\n if 'ip' in identifiers:
\n rules.append(('ip_global', identifiers['ip']))<\/p>\n
# \u7528\u6237\u89c4\u5219
\n if 'user' in identifiers:
\n # \u7528\u6237\u7279\u5b9a\u9650\u5236
\n rules.append(('user_auth', identifiers['user']))<\/p>\n
# \u7aef\u70b9\u7279\u5b9a\u7528\u6237\u9650\u5236
\n endpoint_rule = f"user_endpoint:{request.path}"
\n rules.append((endpoint_rule, identifiers['user']))<\/p>\n
# API\u5bc6\u94a5\u89c4\u5219
\n if 'api_key' in identifiers:
\n rules.append(('api_key', identifiers['api_key']))<\/p>\n
# \u7aef\u70b9\u89c4\u5219
\n endpoint_key = f"endpoint:{request.method}:{request.path}"
\n rules.append(('api_endpoint', endpoint_key))<\/p>\n
# \u7279\u6b8a\u7aef\u70b9\u89c4\u5219
\n if request.path.startswith('\/api\/upload'):
\n rules.append(('upload_endpoint', identifiers.get('ip', 'unknown')))<\/p>\n
return rules<\/p>\n
def default_cost_calculator(self, request) -> int:
\n """\u9ed8\u8ba4\u6210\u672c\u8ba1\u7b97\u5668"""
\n # \u6839\u636e\u8bf7\u6c42\u5927\u5c0f\u3001\u590d\u6742\u5ea6\u7b49\u8ba1\u7b97\u6210\u672c
\n cost = 1<\/p>\n
# \u8bf7\u6c42\u4f53\u5927\u5c0f\u6210\u672c
\n content_length = request.content_length or 0
\n if content_length > 1024 * 1024: # 1MB
\n cost += 1
\n elif content_length > 10 * 1024 * 1024: # 10MB
\n cost += 5<\/p>\n
# \u590d\u6742\u64cd\u4f5c\u6210\u672c
\n if request.method in ['POST', 'PUT', 'DELETE']:
\n cost += 1<\/p>\n
# \u654f\u611f\u7aef\u70b9\u6210\u672c
\n if request.path.startswith('\/api\/admin\/'):
\n cost += 2<\/p>\n
return cost<\/p>\n
def default_identifier_extractor(self, request) -> str:
\n """\u9ed8\u8ba4\u6807\u8bc6\u7b26\u63d0\u53d6\u5668"""
\n # \u4f7f\u7528IP\u4f5c\u4e3a\u9ed8\u8ba4\u6807\u8bc6\u7b26
\n if request.headers.get('X-Forwarded-For'):
\n return request.headers['X-Forwarded-For'].split(',')[0].strip()
\n return request.remote_addr<\/p>\n
def default_response_handler(self, rule_name: str, result: Dict) -> Tuple[Dict, int, Dict]:
\n """\u9ed8\u8ba4\u54cd\u5e94\u5904\u7406\u5668"""
\n retry_after = result.get('retry_after', 60)<\/p>\n
response_body = {
\n 'error': {
\n 'code': 'RATE_LIMIT_EXCEEDED',
\n 'message': 'Too many requests. Please try again later.',
\n 'details': {
\n 'rule': rule_name,
\n 'retry_after': retry_after,
\n 'reset_time': result.get('reset_time'),
\n 'limit': result.get('limit'),
\n 'remaining': result.get('remaining')
\n }
\n }
\n }<\/p>\n
headers = {
\n 'Retry-After': str(retry_after),
\n 'X-RateLimit-Limit': str(result.get('limit', 0)),
\n 'X-RateLimit-Remaining': str(result.get('remaining', 0)),
\n 'X-RateLimit-Reset': str(int(result.get('reset_time', time.time()))),
\n 'X-RateLimit-Rule': rule_name
\n }<\/p>\n
return response_body, 429, headers<\/p>\n
def trigger_rate_limit(self, identifier: str, rule_name: str, result: Dict):
\n """\u89e6\u53d1\u901f\u7387\u9650\u5236"""
\n # \u8bb0\u5f55\u9650\u5236\u4e8b\u4ef6
\n self.log_rate_limit_event(identifier, rule_name, result)<\/p>\n
# \u751f\u6210\u54cd\u5e94
\n response_body, status_code, headers = self.config['response_handler'](
\n rule_name, result
\n )<\/p>\n
# \u629b\u51fa\u5f02\u5e38，\u7531\u9519\u8bef\u5904\u7406\u5668\u5904\u7406
\n from werkzeug.exceptions import TooManyRequests
\n raise TooManyRequests(response=jsonify(response_body), headers=headers)<\/p>\n
def log_rate_limit_event(self, identifier: str, rule_name: str, result: Dict):
\n """\u8bb0\u5f55\u901f\u7387\u9650\u5236\u4e8b\u4ef6"""
\n event = {
\n 'timestamp': time.time(),
\n 'identifier': identifier,
\n 'rule': rule_name,
\n 'remaining': result.get('remaining', 0),
\n 'limit': result.get('limit', 0),
\n 'retry_after': result.get('retry_after', 0),
\n 'request_path': request.path,
\n 'request_method': request.method,
\n 'user_agent': request.headers.get('User-Agent'),
\n 'client_ip': request.remote_addr
\n }<\/p>\n
# \u5728\u5b9e\u9645\u5e94\u7528\u4e2d，\u8fd9\u91cc\u4f1a\u8bb0\u5f55\u5230\u65e5\u5fd7\u7cfb\u7edf
\n print(f"[Rate Limit] {json.dumps(event)}")<\/p>\n
# \u5199\u5165\u6587\u4ef6\u65e5\u5fd7
\n with open('rate_limit_events.log', 'a') as f:
\n f.write(json.dumps(event) + '\\\\n')<\/p>\n
def handle_rate_limit_error(self, error):
\n """\u5904\u7406\u901f\u7387\u9650\u5236\u9519\u8bef"""
\n # \u4ece\u9519\u8bef\u4e2d\u63d0\u53d6\u54cd\u5e94\u548c\u5934\u90e8
\n response = error.response
\n return response<\/p>\n
def get_rate_limit_info(self, identifier: str) -> Dict:
\n """\u83b7\u53d6\u901f\u7387\u9650\u5236\u4fe1\u606f"""
\n return self.rate_limiter.get_all_quotas(identifier)<\/p>\n
class RateLimitAnomalyDetector:
\n """\u901f\u7387\u9650\u5236\u5f02\u5e38\u68c0\u6d4b\u5668"""<\/p>\n
def __init__(self):
\n self.violation_history = {}
\n self.anomaly_patterns = {}<\/p>\n
def record_violation(self, identifier: str, rule_name: str, request):
\n """\u8bb0\u5f55\u8fdd\u89c4"""
\n key = f"{identifier}:{rule_name}"<\/p>\n
if key not in self.violation_history:
\n self.violation_history[key] = {
\n 'count': 0,
\n 'first_violation': time.time(),
\n 'last_violation': time.time(),
\n 'requests': []
\n }<\/p>\n
record = self.violation_history[key]
\n record['count'] += 1
\n record['last_violation'] = time.time()<\/p>\n
# \u8bb0\u5f55\u8bf7\u6c42\u8be6\u60c5
\n request_info = {
\n 'timestamp': time.time(),
\n 'path': request.path,
\n 'method': request.method,
\n 'user_agent': request.headers.get('User-Agent'),
\n 'client_ip': request.remote_addr
\n }
\n record['requests'].append(request_info)<\/p>\n
# \u68c0\u6d4b\u5f02\u5e38\u6a21\u5f0f
\n self.detect_anomaly(key, record)<\/p>\n
def detect_anomaly(self, key: str, record: Dict):
\n """\u68c0\u6d4b\u5f02\u5e38\u6a21\u5f0f"""<\/p>\n
# \u68c0\u6d4b\u9891\u7e41\u8fdd\u89c4
\n time_window = 300 # 5\u5206\u949f
\n violations_in_window = sum(
\n 1 for req in record['requests']
\n if time.time() – req['timestamp'] < time_window
\n )<\/p>\n
if violations_in_window > 10:
\n # \u9891\u7e41\u8fdd\u89c4，\u53ef\u80fd\u662f\u6076\u610f\u653b\u51fb
\n self.trigger_anomaly_alert(key, 'frequent_violations', {
\n 'violations_in_window': violations_in_window,
\n 'time_window': time_window
\n })<\/p>\n
# \u68c0\u6d4b\u5206\u5e03\u5f0f\u653b\u51fb\u6a21\u5f0f
\n if self.is_distributed_attack_pattern(record):
\n self.trigger_anomaly_alert(key, 'distributed_attack', {
\n 'request_patterns': len(set(r['client_ip'] for r in record['requests']))
\n })<\/p>\n
def is_distributed_attack_pattern(self, record: Dict) -> bool:
\n """\u68c0\u6d4b\u5206\u5e03\u5f0f\u653b\u51fb\u6a21\u5f0f"""
\n if len(record['requests']) < 20:
\n return False<\/p>\n
# \u68c0\u67e5\u662f\u5426\u6765\u81ea\u591a\u4e2aIP\u5730\u5740
\n unique_ips = set(r['client_ip'] for r in record['requests'])
\n if len(unique_ips) > 5:
\n return True<\/p>\n
# \u68c0\u67e5\u662f\u5426\u6709\u89c4\u5f8b\u7684\u8bf7\u6c42\u6a21\u5f0f
\n timestamps = [r['timestamp'] for r in record['requests']]
\n if len(timestamps) >= 10:
\n intervals = [timestamps[i+1] – timestamps[i] for i in range(len(timestamps)-1)]
\n avg_interval = sum(intervals) \/ len(intervals)<\/p>\n
# \u68c0\u67e5\u95f4\u9694\u662f\u5426\u8fc7\u4e8e\u89c4\u5f8b
\n if avg_interval > 0:
\n deviation = sum(abs(i – avg_interval) for i in intervals) \/ len(intervals)
\n if deviation \/ avg_interval < 0.1: # \u504f\u5dee\u5c0f\u4e8e10%
\n return True<\/p>\n
return False<\/p>\n
def trigger_anomaly_alert(self, key: str, anomaly_type: str, details: Dict):
\n """\u89e6\u53d1\u5f02\u5e38\u8b66\u62a5"""
\n alert = {
\n 'timestamp': time.time(),
\n 'key': key,
\n 'type': anomaly_type,
\n 'details': details,
\n 'severity': 'high'
\n }<\/p>\n
print(f"[Rate Limit Anomaly] {json.dumps(alert)}")<\/p>\n
with open('rate_limit_anomalies.log', 'a') as f:
\n f.write(json.dumps(alert) + '\\\\n')<\/p>\n
class AdaptiveRateAdjuster:
\n """\u81ea\u9002\u5e94\u901f\u7387\u8c03\u6574\u5668"""<\/p>\n
def __init__(self):
\n self.request_history = deque(maxlen=1000)
\n self.adjustment_history = []<\/p>\n
def record_request(self, request, identifiers: Dict):
\n """\u8bb0\u5f55\u8bf7\u6c42"""
\n request_record = {
\n 'timestamp': time.time(),
\n 'path': request.path,
\n 'method': request.method,
\n 'identifiers': identifiers,
\n 'response_time': None, # \u5c06\u5728\u54cd\u5e94\u65f6\u586b\u5145
\n 'status_code': None
\n }<\/p>\n
self.request_history.append(request_record)<\/p>\n
# \u5b9a\u671f\u5206\u6790\u5e76\u8c03\u6574
\n if len(self.request_history) % 100 == 0:
\n self.analyze_and_adjust()<\/p>\n
def analyze_and_adjust(self):
\n """\u5206\u6790\u5e76\u8c03\u6574\u901f\u7387\u9650\u5236"""
\n # \u5206\u6790\u8bf7\u6c42\u6a21\u5f0f
\n recent_requests = list(self.request_history)[-100:] # \u6700\u8fd1100\u4e2a\u8bf7\u6c42<\/p>\n
if not recent_requests:
\n return<\/p>\n
# \u8ba1\u7b97\u8bf7\u6c42\u901f\u7387
\n time_window = recent_requests[-1]['timestamp'] – recent_requests[0]['timestamp']
\n request_rate = len(recent_requests) \/ time_window if time_window > 0 else 0<\/p>\n
# \u8ba1\u7b97\u9519\u8bef\u7387
\n error_requests = [r for r in recent_requests if r.get('status_code', 200) >= 400]
\n error_rate = len(error_requests) \/ len(recent_requests) if recent_requests else 0<\/p>\n
# \u6839\u636e\u5206\u6790\u7ed3\u679c\u8c03\u6574
\n if error_rate > 0.1: # \u9519\u8bef\u7387\u8d85\u8fc710%
\n # \u964d\u4f4e\u9650\u5236，\u53ef\u80fd\u662f\u670d\u52a1\u5668\u538b\u529b\u5927
\n self.adjust_limits('decrease', {
\n 'reason': 'high_error_rate',
\n 'error_rate': error_rate,
\n 'request_rate': request_rate
\n })
\n elif request_rate > 100 and error_rate < 0.01: # \u9ad8\u8bf7\u6c42\u7387，\u4f4e\u9519\u8bef\u7387
\n # \u53ef\u4ee5\u8003\u8651\u589e\u52a0\u9650\u5236
\n self.adjust_limits('increase', {
\n 'reason': 'high_throughput_low_errors',
\n 'request_rate': request_rate,
\n 'error_rate': error_rate
\n })<\/p>\n
def adjust_limits(self, direction: str, context: Dict):
\n """\u8c03\u6574\u9650\u5236"""
\n adjustment = {
\n 'timestamp': time.time(),
\n 'direction': direction,
\n 'context': context
\n }<\/p>\n
self.adjustment_history.append(adjustment)<\/p>\n
print(f"[Rate Limit Adjustment] {json.dumps(adjustment)}")<\/p>\n
javascript<\/p>\n
\/\/ \u5ba2\u6237\u7aef\u901f\u7387\u9650\u5236\u5904\u7406\u7b56\u7565
\nclass RateLimitAwareClient {
\n constructor(config = {}) {
\n this.config = {
\n baseDelay: 1000,
\n maxDelay: 60000,
\n backoffFactor: 2,
\n jitter: 0.1,
\n maxRetries: 5,
\n respectRetryAfter: true,
\n quotaMonitoring: true,
\n adaptiveBackoff: true,
\n …config
\n };<\/p>\n
this.rateLimitInfo = new Map();
\n this.retryQueue = [];
\n this.quotaHistory = [];
\n this.circuitBreakers = new Map();<\/p>\n
\/\/ \u521d\u59cb\u5316\u76d1\u63a7
\n this.initQuotaMonitoring();
\n }<\/p>\n
async request(endpoint, options = {}) {
\n const requestId = this.generateRequestId();
\n const startTime = Date.now();<\/p>\n
\/\/ \u68c0\u67e5\u901f\u7387\u9650\u5236\u72b6\u6001
\n const rateLimitCheck = this.checkRateLimitState(endpoint, options);
\n if (!rateLimitCheck.allowed) {
\n \/\/ \u901f\u7387\u9650\u5236\u5df2\u89e6\u53d1，\u7b49\u5f85\u6216\u62d2\u7edd
\n if (options.ignoreRateLimit) {
\n return this.executeRequest(requestId, endpoint, options);
\n } else {
\n return this.handleRateLimitedRequest(requestId, endpoint, options, rateLimitCheck);
\n }
\n }<\/p>\n
\/\/ \u6267\u884c\u8bf7\u6c42
\n try {
\n const response = await this.executeRequest(requestId, endpoint, options);<\/p>\n
\/\/ \u66f4\u65b0\u901f\u7387\u9650\u5236\u4fe1\u606f
\n this.updateRateLimitInfo(endpoint, response);<\/p>\n
return response;<\/p>\n
} catch (error) {
\n \/\/ \u5904\u7406\u9519\u8bef
\n if (error.name === 'RateLimitError') {
\n return this.handleRateLimitError(requestId, endpoint, options, error);
\n }<\/p>\n
throw error;
\n }
\n }<\/p>\n
checkRateLimitState(endpoint, options) {
\n const endpointKey = this.getEndpointKey(endpoint, options);
\n const info = this.rateLimitInfo.get(endpointKey);<\/p>\n
if (!info) {
\n return { allowed: true };
\n }<\/p>\n
\/\/ \u68c0\u67e5\u5269\u4f59\u914d\u989d
\n if (info.remaining <= 0) {
\n const now = Date.now();
\n const resetTime = info.resetTime * 1000; \/\/ \u8f6c\u6362\u4e3a\u6beb\u79d2<\/p>\n
if (now < resetTime) {
\n \/\/ \u4ecd\u5728\u9650\u5236\u671f\u5185
\n const retryAfter = Math.ceil((resetTime – now) \/ 1000);<\/p>\n
return {
\n allowed: false,
\n reason: 'quota_exhausted',
\n retryAfter,
\n resetTime
\n };
\n } else {
\n \/\/ \u9650\u5236\u5df2\u8fc7\u671f
\n return { allowed: true };
\n }
\n }<\/p>\n
\/\/ \u68c0\u67e5\u7535\u8def\u65ad\u8def\u5668
\n const circuitKey = this.getCircuitKey(endpoint, options);
\n if (!this.isCircuitClosed(circuitKey)) {
\n return {
\n allowed: false,
\n reason: 'circuit_open',
\n circuitKey
\n };
\n }<\/p>\n
return { allowed: true };
\n }<\/p>\n
async executeRequest(requestId, endpoint, options) {
\n const controller = new AbortController();
\n const timeoutId = setTimeout(() => controller.abort(), options.timeout || 30000);<\/p>\n
try {
\n const response = await fetch(endpoint, {
\n …options,
\n signal: controller.signal,
\n headers: {
\n …options.headers,
\n 'X-Request-ID': requestId,
\n 'X-Client-Version': '1.0.0'
\n }
\n });<\/p>\n
clearTimeout(timeoutId);<\/p>\n
\/\/ \u68c0\u67e5\u901f\u7387\u9650\u5236\u5934\u90e8
\n this.extractRateLimitHeaders(endpoint, response);<\/p>\n
\/\/ \u68c0\u67e5\u72b6\u6001\u7801
\n if (response.status === 429) {
\n throw new RateLimitError('Rate limit exceeded', response);
\n }<\/p>\n
return response;<\/p>\n
} catch (error) {
\n clearTimeout(timeoutId);
\n throw error;
\n }
\n }<\/p>\n
extractRateLimitHeaders(endpoint, response) {
\n const endpointKey = this.getEndpointKey(endpoint);<\/p>\n
const limit = response.headers.get('X-RateLimit-Limit');
\n const remaining = response.headers.get('X-RateLimit-Remaining');
\n const reset = response.headers.get('X-RateLimit-Reset');
\n const retryAfter = response.headers.get('Retry-After');
\n const rule = response.headers.get('X-RateLimit-Rule');<\/p>\n
if (limit !== null && remaining !== null && reset !== null) {
\n this.rateLimitInfo.set(endpointKey, {
\n limit: parseInt(limit, 10),
\n remaining: parseInt(remaining, 10),
\n resetTime: parseInt(reset, 10),
\n rule: rule,
\n lastUpdated: Date.now()
\n });<\/p>\n
\/\/ \u8bb0\u5f55\u914d\u989d\u5386\u53f2
\n this.recordQuotaHistory(endpointKey, {
\n limit: parseInt(limit, 10),
\n remaining: parseInt(remaining, 10),
\n timestamp: Date.now()
\n });
\n }<\/p>\n
\/\/ \u5904\u7406Retry-After\u5934\u90e8
\n if (retryAfter !== null && this.config.respectRetryAfter) {
\n const retryAfterSeconds = parseInt(retryAfter, 10);
\n this.scheduleRetryDelay(endpointKey, retryAfterSeconds * 1000);
\n }
\n }<\/p>\n
async handleRateLimitedRequest(requestId, endpoint, options, rateLimitCheck) {
\n const endpointKey = this.getEndpointKey(endpoint, options);<\/p>\n
\/\/ \u6839\u636e\u539f\u56e0\u91c7\u53d6\u4e0d\u540c\u7b56\u7565
\n switch (rateLimitCheck.reason) {
\n case 'quota_exhausted':
\n return this.handleQuotaExhausted(requestId, endpoint, options, rateLimitCheck);<\/p>\n
case 'circuit_open':
\n return this.handleCircuitOpen(requestId, endpoint, options, rateLimitCheck);<\/p>\n
default:
\n throw new RateLimitError(`Rate limited: ${rateLimitCheck.reason}`);
\n }
\n }<\/p>\n
async handleQuotaExhausted(requestId, endpoint, options, rateLimitCheck) {
\n const { retryAfter, resetTime } = rateLimitCheck;<\/p>\n
\/\/ \u8ba1\u7b97\u7b49\u5f85\u65f6\u95f4
\n let waitTime = retryAfter * 1000; \/\/ \u8f6c\u6362\u4e3a\u6beb\u79d2<\/p>\n
if (this.config.adaptiveBackoff) {
\n \/\/ \u81ea\u9002\u5e94\u8c03\u6574\u7b49\u5f85\u65f6\u95f4
\n waitTime = this.calculateAdaptiveWaitTime(endpoint, waitTime);
\n }<\/p>\n
\/\/ \u6dfb\u52a0\u6296\u52a8
\n waitTime = this.addJitter(waitTime);<\/p>\n
\/\/ \u8bb0\u5f55\u7b49\u5f85
\n this.logRateLimitWait(endpoint, waitTime, 'quota_exhausted');<\/p>\n
\/\/ \u7b49\u5f85\u540e\u91cd\u8bd5
\n await this.sleep(waitTime);<\/p>\n
\/\/ \u91cd\u8bd5\u8bf7\u6c42
\n return this.request(endpoint, {
\n …options,
\n retryCount: (options.retryCount || 0) + 1
\n });
\n }<\/p>\n
async handleRateLimitError(requestId, endpoint, options, error) {
\n const retryCount = options.retryCount || 0;<\/p>\n
if (retryCount >= this.config.maxRetries) {
\n throw new MaxRetriesError('Maximum retries exceeded', error);
\n }<\/p>\n
\/\/ \u4ece\u54cd\u5e94\u4e2d\u63d0\u53d6Retry-After
\n let retryAfter = 60; \/\/ \u9ed8\u8ba460\u79d2<\/p>\n
if (error.response) {
\n const retryAfterHeader = error.response.headers.get('Retry-After');
\n if (retryAfterHeader) {
\n retryAfter = parseInt(retryAfterHeader, 10);
\n }
\n }<\/p>\n
\/\/ \u8ba1\u7b97\u9000\u907f\u5ef6\u8fdf
\n const delay = this.calculateBackoffDelay(retryCount, retryAfter);<\/p>\n
\/\/ \u8bb0\u5f55\u91cd\u8bd5
\n this.logRetry(endpoint, retryCount, delay, 'rate_limit');<\/p>\n
\/\/ \u7b49\u5f85\u540e\u91cd\u8bd5
\n await this.sleep(delay);<\/p>\n
return this.request(endpoint, {
\n …options,
\n retryCount: retryCount + 1
\n });
\n }<\/p>\n
calculateBackoffDelay(retryCount, retryAfter = 0) {
\n \/\/ \u6307\u6570\u9000\u907f
\n let delay = this.config.baseDelay * Math.pow(this.config.backoffFactor, retryCount);<\/p>\n
\/\/ \u8003\u8651Retry-After\u5934\u90e8
\n if (retryAfter > 0) {
\n delay = Math.max(delay, retryAfter * 1000);
\n }<\/p>\n
\/\/ \u9650\u5236\u6700\u5927\u5ef6\u8fdf
\n delay = Math.min(delay, this.config.maxDelay);<\/p>\n
\/\/ \u6dfb\u52a0\u6296\u52a8
\n delay = this.addJitter(delay);<\/p>\n
return delay;
\n }<\/p>\n
calculateAdaptiveWaitTime(endpoint, baseWaitTime) {
\n const endpointKey = this.getEndpointKey(endpoint);
\n const history = this.getQuotaHistory(endpointKey);<\/p>\n
if (history.length < 5) {
\n return baseWaitTime;
\n }<\/p>\n
\/\/ \u5206\u6790\u5386\u53f2\u914d\u989d\u4f7f\u7528\u6a21\u5f0f
\n const recentUsage = history.slice(-10);
\n const avgUsageRate = this.calculateUsageRate(recentUsage);<\/p>\n
\/\/ \u6839\u636e\u4f7f\u7528\u7387\u8c03\u6574\u7b49\u5f85\u65f6\u95f4
\n if (avgUsageRate > 0.8) {
\n \/\/ \u9ad8\u4f7f\u7528\u7387，\u589e\u52a0\u7b49\u5f85\u65f6\u95f4
\n return baseWaitTime * 1.5;
\n } else if (avgUsageRate < 0.3) {
\n \/\/ \u4f4e\u4f7f\u7528\u7387，\u51cf\u5c11\u7b49\u5f85\u65f6\u95f4
\n return baseWaitTime * 0.7;
\n }<\/p>\n
return baseWaitTime;
\n }<\/p>\n
calculateUsageRate(quotaHistory) {
\n if (quotaHistory.length < 2) {
\n return 0;
\n }<\/p>\n
let totalUsage = 0;
\n let totalTime = 0;<\/p>\n
for (let i = 1; i < quotaHistory.length; i++) {
\n const prev = quotaHistory[i – 1];
\n const curr = quotaHistory[i];<\/p>\n
const usage = prev.remaining – curr.remaining;
\n const timeDiff = curr.timestamp – prev.timestamp;<\/p>\n
if (timeDiff > 0 && prev.limit > 0) {
\n totalUsage += usage;
\n totalTime += timeDiff;
\n }
\n }<\/p>\n
if (totalTime === 0) {
\n return 0;
\n }<\/p>\n
const avgUsagePerMs = totalUsage \/ totalTime;
\n const limitPerMs = quotaHistory[0].limit \/ (24 * 60 * 60 * 1000); \/\/ \u6bcf\u5929\u7684\u9650\u5236<\/p>\n
return avgUsagePerMs \/ limitPerMs;
\n }<\/p>\n
addJitter(delay) {
\n const jitter = this.config.jitter;
\n const jitterAmount = delay * jitter;
\n const randomJitter = (Math.random() * 2 – 1) * jitterAmount;<\/p>\n
return Math.max(0, delay + randomJitter);
\n }<\/p>\n
\/\/ \u7535\u8def\u65ad\u8def\u5668
\n isCircuitClosed(circuitKey) {
\n if (!this.circuitBreakers.has(circuitKey)) {
\n return true;
\n }<\/p>\n
const circuit = this.circuitBreakers.get(circuitKey);<\/p>\n
if (circuit.state === 'open') {
\n \/\/ \u68c0\u67e5\u662f\u5426\u5e94\u8be5\u8fdb\u5165\u534a\u5f00\u72b6\u6001
\n if (Date.now() – circuit.openedAt > 60000) { \/\/ 60\u79d2\u540e
\n circuit.state = 'half_open';
\n circuit.halfOpenAttempts = 0;
\n return true;
\n }
\n return false;
\n }<\/p>\n
if (circuit.state === 'half_open') {
\n if (circuit.halfOpenAttempts >= 3) {
\n return false;
\n }
\n circuit.halfOpenAttempts++;
\n return true;
\n }<\/p>\n
return true; \/\/ closed
\n }<\/p>\n
updateCircuitBreaker(circuitKey, success) {
\n if (!this.circuitBreakers.has(circuitKey)) {
\n this.circuitBreakers.set(circuitKey, {
\n state: 'closed',
\n failureCount: 0,
\n successCount: 0
\n });
\n }<\/p>\n
const circuit = this.circuitBreakers.get(circuitKey);<\/p>\n
if (success) {
\n circuit.successCount++;
\n circuit.failureCount = Math.max(0, circuit.failureCount – 1);<\/p>\n
if (circuit.state === 'half_open' && circuit.successCount >= 3) {
\n circuit.state = 'closed';
\n circuit.failureCount = 0;
\n circuit.successCount = 0;
\n }
\n } else {
\n circuit.failureCount++;<\/p>\n
if (circuit.failureCount >= 5 && circuit.state === 'closed') {
\n circuit.state = 'open';
\n circuit.openedAt = Date.now();
\n }
\n }
\n }<\/p>\n
\/\/ \u914d\u989d\u76d1\u63a7
\n initQuotaMonitoring() {
\n if (this.config.quotaMonitoring) {
\n \/\/ \u5b9a\u671f\u5237\u65b0\u914d\u989d\u4fe1\u606f
\n setInterval(() => this.refreshQuotaInfo(), 30000);<\/p>\n
\/\/ \u76d1\u63a7\u914d\u989d\u4f7f\u7528\u7387
\n setInterval(() => this.monitorQuotaUsage(), 60000);
\n }
\n }<\/p>\n
refreshQuotaInfo() {
\n \/\/ \u6e05\u7406\u8fc7\u671f\u7684\u914d\u989d\u4fe1\u606f
\n const now = Date.now();<\/p>\n
for (const [key, info] of this.rateLimitInfo.entries()) {
\n const resetTime = info.resetTime * 1000;<\/p>\n
if (now > resetTime + 60000) { \/\/ \u91cd\u7f6e\u65f6\u95f4\u540e1\u5206\u949f
\n this.rateLimitInfo.delete(key);
\n }
\n }
\n }<\/p>\n
monitorQuotaUsage() {
\n const warnings = [];<\/p>\n
for (const [endpointKey, info] of this.rateLimitInfo.entries()) {
\n const usageRate = info.remaining \/ info.limit;<\/p>\n
if (usageRate < 0.1) { \/\/ \u5269\u4f59\u4e0d\u8db310%
\n warnings.push({
\n endpointKey,
\n remaining: info.remaining,
\n limit: info.limit,
\n resetTime: new Date(info.resetTime * 1000).toISOString()
\n });
\n }
\n }<\/p>\n
if (warnings.length > 0) {
\n this.emitQuotaWarning(warnings);
\n }
\n }<\/p>\n
recordQuotaHistory(endpointKey, quota) {
\n this.quotaHistory.push({
\n endpointKey,
\n …quota
\n });<\/p>\n
\/\/ \u4fdd\u6301\u5386\u53f2\u8bb0\u5f55\u5927\u5c0f
\n if (this.quotaHistory.length > 1000) {
\n this.quotaHistory = this.quotaHistory.slice(-500);
\n }
\n }<\/p>\n
getQuotaHistory(endpointKey, limit = 50) {
\n return this.quotaHistory
\n .filter(q => q.endpointKey === endpointKey)
\n .slice(-limit);
\n }<\/p>\n
\/\/ \u5de5\u5177\u65b9\u6cd5
\n generateRequestId() {
\n return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
\n }<\/p>\n
getEndpointKey(endpoint, options = {}) {
\n const url = new URL(endpoint, window.location.origin);
\n const method = options.method || 'GET';<\/p>\n
return `${method}:${url.pathname}`;
\n }<\/p>\n
getCircuitKey(endpoint, options = {}) {
\n const endpointKey = this.getEndpointKey(endpoint, options);
\n return `circuit:${endpointKey}`;
\n }<\/p>\n
sleep(ms) {
\n return new Promise(resolve => setTimeout(resolve, ms));
\n }<\/p>\n
logRateLimitWait(endpoint, waitTime, reason) {
\n console.log(`Rate limit wait for ${endpoint}: ${waitTime}ms (${reason})`);
\n }<\/p>\n
logRetry(endpoint, retryCount, delay, reason) {
\n console.log(`Retry ${retryCount + 1} for ${endpoint} in ${delay}ms (${reason})`);
\n }<\/p>\n
emitQuotaWarning(warnings) {
\n \/\/ \u5728\u5b9e\u9645\u5e94\u7528\u4e2d，\u8fd9\u91cc\u4f1a\u89e6\u53d1\u4e8b\u4ef6\u6216\u663e\u793a\u901a\u77e5
\n console.warn('Quota warnings:', warnings);
\n }<\/p>\n
getRateLimitInfo() {
\n return Array.from(this.rateLimitInfo.entries()).map(([key, info]) => ({
\n endpoint: key,
\n …info,
\n lastUpdated: new Date(info.lastUpdated).toISOString()
\n }));
\n }
\n}<\/p>\n
class RateLimitError extends Error {
\n constructor(message, response) {
\n super(message);
\n this.name = 'RateLimitError';
\n this.response = response;
\n }
\n}<\/p>\n
class MaxRetriesError extends Error {
\n constructor(message, originalError) {
\n super(message);
\n this.name = 'MaxRetriesError';
\n this.originalError = originalError;
\n }
\n}<\/p>\n
\/\/ \u4f7f\u7528\u793a\u4f8b
\nconst client = new RateLimitAwareClient({
\n baseDelay: 1000,
\n maxRetries: 3,
\n adaptiveBackoff: true,
\n quotaMonitoring: true
\n});<\/p>\n
\/\/ \u53d1\u8d77\u8bf7\u6c42
\nasync function fetchData() {
\n try {
\n const response = await client.request('\/api\/data', {
\n headers: {
\n 'Authorization': `Bearer ${token}`
\n }
\n });<\/p>\n
return await response.json();<\/p>\n
} catch (error) {
\n if (error.name === 'RateLimitError') {
\n \/\/ \u663e\u793a\u7528\u6237\u53cb\u597d\u7684\u9519\u8bef\u6d88\u606f
\n showRateLimitError(error);
\n return null;
\n }<\/p>\n
throw error;
\n }
\n}<\/p>\n
\/\/ \u663e\u793a\u901f\u7387\u9650\u5236\u9519\u8bef\u7684UI\u7ec4\u4ef6
\nfunction showRateLimitError(error) {
\n const container = document.getElementById('error-container');<\/p>\n
let retryAfter = 60;
\n if (error.response) {
\n const retryAfterHeader = error.response.headers.get('Retry-After');
\n if (retryAfterHeader) {
\n retryAfter = parseInt(retryAfterHeader, 10);
\n }
\n }<\/p>\n
const html = `
\n <div class="rate-limit-error">
\n <h3>\u26a0\ufe0f \u8bf7\u6c42\u8fc7\u4e8e\u9891\u7e41<\/h3>
\n <p>\u60a8\u53d1\u9001\u4e86\u592a\u591a\u8bf7\u6c42，\u8bf7\u7a0d\u540e\u518d\u8bd5\u3002<\/p><\/p>\n
<div class="retry-info">
\n <p>\u5efa\u8bae\u5728 <strong>${retryAfter}<\/strong> \u79d2\u540e\u91cd\u8bd5<\/p>
\n <div class="countdown" data-seconds="${retryAfter}">
\n \u5012\u8ba1\u65f6: <span class="seconds">${retryAfter}<\/span> \u79d2
\n <\/div>
\n <\/div><\/p>\n
<div class="actions">
\n <button \u03bfnclick="retryNow()" class="retry-btn">
\n \u7acb\u5373\u91cd\u8bd5
\n <\/button>
\n <button \u03bfnclick="dismissError()" class="dismiss-btn">
\n \u53d6\u6d88
\n <\/button>
\n <\/div><\/p>\n
<div class="tips">
\n <h4>\u5982\u4f55\u907f\u514d\u6b64\u95ee\u9898：<\/h4>
\n <ul>
\n <li>\u907f\u514d\u9891\u7e41\u5237\u65b0\u9875\u9762<\/li>
\n <li>\u4f7f\u7528\u5206\u9875\u52a0\u8f7d\u66f4\u591a\u6570\u636e<\/li>
\n <li>\u5408\u7406\u4f7f\u7528\u7f13\u5b58<\/li>
\n <\/ul>
\n <\/div>
\n <\/div>
\n `;<\/p>\n
container.innerHTML = html;<\/p>\n
\/\/ \u542f\u52a8\u5012\u8ba1\u65f6
\n startCountdown(retryAfter);
\n}<\/p>\n
javascript<\/p>\n
\/\/ \u901f\u7387\u9650\u5236\u914d\u989d\u53ef\u89c6\u5316\u4eea\u8868\u677f
\nimport React, { useState, useEffect, useCallback } from 'react';
\nimport {
\n LineChart, Line, BarChart, Bar, PieChart, Pie, Cell,
\n XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer,
\n AreaChart, Area, RadarChart, Radar, PolarGrid, PolarAngleAxis, PolarRadiusAxis
\n} from 'recharts';
\nimport { AlertTriangle, Clock, Zap, Battery, RefreshCw, Shield } from 'lucide-react';<\/p>\n
function RateLimitDashboard() {
\n const [timeRange, setTimeRange] = useState('1h');
\n const [quotaData, setQuotaData] = useState([]);
\n const [violationHistory, setViolationHistory] = useState([]);
\n const [endpointStats, setEndpointStats] = useState({});
\n const [realTimeUpdates, setRealTimeUpdates] = useState([]);<\/p>\n
\/\/ \u83b7\u53d6\u914d\u989d\u6570\u636e
\n useEffect(() => {
\n const fetchQuotaData = async () => {
\n try {
\n const response = await fetch(`\/api\/rate-limit\/quotas?range=${timeRange}`);
\n const data = await response.json();
\n setQuotaData(data.quotas || []);
\n setViolationHistory(data.violations || []);
\n setEndpointStats(data.endpointStats || {});
\n } catch (error) {
\n console.error('Failed to fetch quota data:', error);
\n }
\n };<\/p>\n
fetchQuotaData();
\n const interval = setInterval(fetchQuotaData, 30000); \/\/ \u6bcf30\u79d2\u66f4\u65b0<\/p>\n
return () => clearInterval(interval);
\n }, [timeRange]);<\/p>\n
\/\/ WebSocket\u8fde\u63a5\u63a5\u6536\u5b9e\u65f6\u66f4\u65b0
\n useEffect(() => {
\n const ws = new WebSocket('wss:\/\/api.example.com\/rate-limit\/updates');<\/p>\n
ws.onmessage = (event) => {
\n const update = JSON.parse(event.data);
\n setRealTimeUpdates(prev => [update, …prev.slice(0, 49)]);
\n };<\/p>\n
return () => ws.close();
\n }, []);<\/p>\n
\/\/ \u5904\u7406\u91cd\u7f6e\u914d\u989d
\n const handleResetQuota = useCallback(async (endpoint, rule) => {
\n try {
\n await fetch('\/api\/rate-limit\/reset', {
\n method: 'POST',
\n headers: { 'Content-Type': 'application\/json' },
\n body: JSON.stringify({ endpoint, rule })
\n });<\/p>\n
alert('\u914d\u989d\u5df2\u91cd\u7f6e');
\n } catch (error) {
\n alert('\u91cd\u7f6e\u5931\u8d25: ' + error.message);
\n }
\n }, []);<\/p>\n
\/\/ \u5904\u7406\u8c03\u6574\u9650\u5236
\n const handleAdjustLimit = useCallback(async (endpoint, rule, newLimit) => {
\n try {
\n await fetch('\/api\/rate-limit\/adjust', {
\n method: 'POST',
\n headers: { 'Content-Type': 'application\/json' },
\n body: JSON.stringify({ endpoint, rule, newLimit })
\n });<\/p>\n
alert('\u9650\u5236\u5df2\u8c03\u6574');
\n } catch (error) {
\n alert('\u8c03\u6574\u5931\u8d25: ' + error.message);
\n }
\n }, []);<\/p>\n
\/\/ \u751f\u6210\u56fe\u8868\u6570\u636e
\n const generateUsageChartData = () => {
\n if (!quotaData.length) return [];<\/p>\n
\/\/ \u6309\u65f6\u95f4\u5206\u7ec4
\n const timeGroups = {};<\/p>\n
quotaData.forEach(quota => {
\n const date = new Date(quota.timestamp);
\n const hour = `${date.getHours()}:00`;<\/p>\n
if (!timeGroups[hour]) {
\n timeGroups[hour] = {
\n time: hour,
\n used: 0,
\n total: 0,
\n violations: 0
\n };
\n }<\/p>\n
timeGroups[hour].used += quota.used || 0;
\n timeGroups[hour].total += quota.limit || 0;<\/p>\n
if (quota.remaining === 0) {
\n timeGroups[hour].violations++;
\n }
\n });<\/p>\n
return Object.values(timeGroups).sort((a, b) => a.time.localeCompare(b.time));
\n };<\/p>\n
const generateEndpointDistributionData = () => {
\n const endpointData = [];<\/p>\n
Object.entries(endpointStats).forEach(([endpoint, stats]) => {
\n endpointData.push({
\n name: endpoint.length > 20 ? endpoint.substring(0, 20) + '…' : endpoint,
\n violations: stats.violations || 0,
\n requests: stats.requests || 0,
\n usageRate: stats.usageRate || 0
\n });
\n });<\/p>\n
return endpointData.sort((a, b) => b.violations – a.violations).slice(0, 10);
\n };<\/p>\n
const generateRuleDistributionData = () => {
\n const ruleData = [];
\n const ruleMap = {};<\/p>\n
quotaData.forEach(quota => {
\n const rule = quota.rule || 'default';<\/p>\n
if (!ruleMap[rule]) {
\n ruleMap[rule] = {
\n name: rule,
\n violations: 0,
\n total: 0
\n };
\n }<\/p>\n
ruleMap[rule].violations += quota.remaining === 0 ? 1 : 0;
\n ruleMap[rule].total++;
\n });<\/p>\n
Object.values(ruleMap).forEach(rule => {
\n ruleData.push({
\n name: rule.name,
\n value: rule.violations,
\n percentage: rule.total > 0 ? (rule.violations \/ rule.total * 100).toFixed(1) : 0
\n });
\n });<\/p>\n
return ruleData.sort((a, b) => b.value – a.value).slice(0, 8);
\n };<\/p>\n
\/\/ \u989c\u8272\u914d\u7f6e
\n const COLORS = ['#0088FE', '#00C49F', '#FFBB28', '#FF8042', '#8884D8', '#82CA9D', '#FF6B6B', '#FFD166'];<\/p>\n
return (
\n <div className="dashboard rate-limit-dashboard">
\n {\/* \u4eea\u8868\u677f\u5934\u90e8 *\/}
\n <div className="dashboard-header">
\n <div className="header-left">
\n <Shield size={32} className="header-icon" \/>
\n <h1>\u901f\u7387\u9650\u5236\u76d1\u63a7<\/h1>
\n <span className="time-range-label">
\n {timeRange === '1h' ? '1\u5c0f\u65f6' :
\n timeRange === '24h' ? '24\u5c0f\u65f6' :
\n timeRange === '7d' ? '7\u5929' : '30\u5929'}
\n <\/span>
\n <\/div><\/p>\n
<div className="header-right">
\n <div className="time-range-selector">
\n {['1h', '24h', '7d', '30d'].map(range => (
\n <button
\n key={range}
\n className={`time-range-btn ${timeRange === range ? 'active' : ''}`}
\n onClick={() => setTimeRange(range)}
\n >
\n {range}
\n <\/button>
\n ))}
\n <\/div><\/p>\n
<button className="refresh-btn" onClick={() => window.location.reload()}>
\n <RefreshCw size={16} \/> \u5237\u65b0
\n <\/button>
\n <\/div>
\n <\/div><\/p>\n
{\/* \u5173\u952e\u6307\u6807\u5361\u7247 *\/}
\n <div className="key-metrics-cards">
\n <div className="metric-card total-requests">
\n <div className="metric-icon">
\n <Zap size={24} \/>
\n <\/div>
\n <div className="metric-content">
\n <h3>\u603b\u8bf7\u6c42\u6570<\/h3>
\n <p className="metric-value">
\n {endpointStats.totalRequests?.toLocaleString() || '0'}
\n <\/p>
\n <p className="metric-trend">
\n \u6210\u529f\u7387: {endpointStats.successRate ? (endpointStats.successRate * 100).toFixed(1) + '%' : 'N\/A'}
\n <\/p>
\n <\/div>
\n <\/div><\/p>\n
<div className="metric-card violations">
\n <div className="metric-icon">
\n <AlertTriangle size={24} \/>
\n <\/div>
\n <div className="metric-content">
\n <h3>\u8fdd\u89c4\u6b21\u6570<\/h3>
\n <p className="metric-value">
\n {violationHistory.length.toLocaleString()}
\n <\/p>
\n <p className="metric-trend">
\n \u8fdd\u89c4\u7387: {quotaData.length > 0 ?
\n ((violationHistory.length \/ quotaData.length) * 100).toFixed(1) + '%' : '0%'}
\n <\/p>
\n <\/div>
\n <\/div><\/p>\n
<div className="metric-card quota-usage">
\n <div className="metric-icon">
\n <Battery size={24} \/>
\n <\/div>
\n <div className="metric-content">
\n <h3>\u914d\u989d\u4f7f\u7528\u7387<\/h3>
\n <p className="metric-value">
\n {endpointStats.avgUsageRate ?
\n (endpointStats.avgUsageRate * 100).toFixed(1) + '%' : '0%'}
\n <\/p>
\n <p className="metric-trend">
\n \u5cf0\u503c: {endpointStats.peakUsageRate ?
\n (endpointStats.peakUsageRate * 100).toFixed(1) + '%' : 'N\/A'}
\n <\/p>
\n <\/div>
\n <\/div><\/p>\n
<div className="metric-card avg-wait-time">
\n <div className="metric-icon">
\n <Clock size={24} \/>
\n <\/div>
\n <div className="metric-content">
\n <h3>\u5e73\u5747\u7b49\u5f85\u65f6\u95f4<\/h3>
\n <p className="metric-value">
\n {endpointStats.avgWaitTime ?
\n endpointStats.avgWaitTime.toFixed(1) + 's' : '0s'}
\n <\/p>
\n <p className="metric-trend">
\n \u6700\u957f: {endpointStats.maxWaitTime ?
\n endpointStats.maxWaitTime.toFixed(1) + 's' : 'N\/A'}
\n <\/p>
\n <\/div>
\n <\/div>
\n <\/div><\/p>\n
{\/* \u56fe\u8868\u533a\u57df *\/}
\n <div className="charts-section">
\n <div className="chart-row">
\n <div className="chart-container large">
\n <h3>\u914d\u989d\u4f7f\u7528\u8d8b\u52bf<\/h3>
\n <ResponsiveContainer width="100%" height={300}>
\n <AreaChart data={generateUsageChartData()}>
\n <CartesianGrid strokeDasharray="3 3" \/>
\n <XAxis dataKey="time" \/>
\n <YAxis \/>
\n <Tooltip \/>
\n <Legend \/>
\n <Area
\n type="monotone"
\n dataKey="used"
\n stackId="1"
\n stroke="#8884d8"
\n fill="#8884d8"
\n fillOpacity={0.3}
\n name="\u5df2\u4f7f\u7528"
\n \/>
\n <Area
\n type="monotone"
\n dataKey="total"
\n stackId="1"
\n stroke="#82ca9d"
\n fill="#82ca9d"
\n fillOpacity={0.3}
\n name="\u603b\u914d\u989d"
\n \/>
\n <Line
\n type="monotone"
\n dataKey="violations"
\n stroke="#ff6b6b"
\n strokeWidth={2}
\n dot={{ r: 4 }}
\n name="\u8fdd\u89c4\u6b21\u6570"
\n \/>
\n <\/AreaChart>
\n <\/ResponsiveContainer>
\n <\/div><\/p>\n
<div className="chart-container">
\n <h3>\u89c4\u5219\u8fdd\u89c4\u5206\u5e03<\/h3>
\n <ResponsiveContainer width="100%" height={300}>
\n <PieChart>
\n <Pie
\n data={generateRuleDistributionData()}
\n cx="50%"
\n cy="50%"
\n labelLine={false}
\n label={({ name, percentage }) => `${name}: ${percentage}%`}
\n outerRadius={80}
\n fill="#8884d8"
\n dataKey="value"
\n >
\n {generateRuleDistributionData().map((entry, index) => (
\n <Cell key={`cell-${index}`} fill={COLORS[index % COLORS.length]} \/>
\n ))}
\n <\/Pie>
\n <Tooltip formatter={(value, name, props) => [
\n `${value}\u6b21 (${props.payload.percentage}%)`,
\n '\u8fdd\u89c4\u6b21\u6570'
\n ]} \/>
\n <\/PieChart>
\n <\/ResponsiveContainer>
\n <\/div>
\n <\/div><\/p>\n
<div className="chart-row">
\n <div className="chart-container large">
\n <h3>\u7aef\u70b9\u8fdd\u89c4\u6392\u540d<\/h3>
\n <ResponsiveContainer width="100%" height={300}>
\n <BarChart data={generateEndpointDistributionData()}>
\n <CartesianGrid strokeDasharray="3 3" \/>
\n <XAxis dataKey="name" angle={-45} textAnchor="end" height={80} \/>
\n <YAxis \/>
\n <Tooltip \/>
\n <Legend \/>
\n <Bar dataKey="violations" fill="#ff6b6b" name="\u8fdd\u89c4\u6b21\u6570" \/>
\n <Bar dataKey="requests" fill="#8884d8" name="\u603b\u8bf7\u6c42\u6570" \/>
\n <\/BarChart>
\n <\/ResponsiveContainer>
\n <\/div><\/p>\n
<div className="chart-container">
\n <h3>\u914d\u989d\u4f7f\u7528\u7387\u96f7\u8fbe\u56fe<\/h3>
\n <ResponsiveContainer width="100%" height={300}>
\n <RadarChart data={generateRadarData()}>
\n <PolarGrid \/>
\n <PolarAngleAxis dataKey="subject" \/>
\n <PolarRadiusAxis angle={30} domain={[0, 100]} \/>
\n <Radar
\n name="\u4f7f\u7528\u7387"
\n dataKey="usage"
\n stroke="#8884d8"
\n fill="#8884d8"
\n fillOpacity={0.3}
\n \/>
\n <Radar
\n name="\u76ee\u6807"
\n dataKey="target"
\n stroke="#82ca9d"
\n fill="#82ca9d"
\n fillOpacity={0.3}
\n \/>
\n <Legend \/>
\n <Tooltip \/>
\n <\/RadarChart>
\n <\/ResponsiveContainer>
\n <\/div>
\n <\/div>
\n <\/div><\/p>\n
{\/* \u5b9e\u65f6\u8fdd\u89c4\u4e8b\u4ef6 *\/}
\n <div className="realtime-events-section">
\n <h3>\u5b9e\u65f6\u8fdd\u89c4\u4e8b\u4ef6<\/h3>
\n <div className="events-table-container">
\n <table className="events-table">
\n <thead>
\n <tr>
\n <th>\u65f6\u95f4<\/th>
\n <th>\u7aef\u70b9<\/th>
\n <th>\u89c4\u5219<\/th>
\n <th>\u5ba2\u6237\u7aefIP<\/th>
\n <th>\u5269\u4f59\u914d\u989d<\/th>
\n <th>\u91cd\u8bd5\u7b49\u5f85<\/th>
\n <th>\u64cd\u4f5c<\/th>
\n <\/tr>
\n <\/thead>
\n <tbody>
\n {realTimeUpdates.map((event, index) => (
\n <tr key={index} className="event-row">
\n <td>
\n {new Date(event.timestamp).toLocaleTimeString()}
\n <\/td>
\n <td className="endpoint-cell">
\n <code title={event.endpoint}>
\n {event.endpoint?.length > 30 ?
\n event.endpoint.substring(0, 30) + '…' :
\n event.endpoint}
\n <\/code>
\n <\/td>
\n <td>
\n <span className="rule-badge">
\n {event.rule || 'default'}
\n <\/span>
\n <\/td>
\n <td>
\n <code>{event.client_ip}<\/code>
\n <\/td>
\n <td>
\n <span className={`quota-badge ${event.remaining === 0 ? 'exhausted' : 'available'}`}>
\n {event.remaining}\/{event.limit}
\n <\/span>
\n <\/td>
\n <td>
\n <span className="wait-time">
\n {event.retry_after || 0}s
\n <\/span>
\n <\/td>
\n <td>
\n <button
\n className="action-btn view-details"
\n onClick={() => viewEventDetails(event)}
\n >
\n \u8be6\u60c5
\n <\/button>
\n <button
\n className="action-btn reset-quota"
\n onClick={() => handleResetQuota(event.endpoint, event.rule)}
\n >
\n \u91cd\u7f6e\u914d\u989d
\n <\/button>
\n <\/td>
\n <\/tr>
\n ))}
\n <\/tbody>
\n <\/table>
\n <\/div>
\n <\/div><\/p>\n
{\/* \u914d\u989d\u7ba1\u7406 *\/}
\n <div className="quota-management-section">
\n <h3>\u914d\u989d\u7ba1\u7406<\/h3>
\n <div className="quota-list">
\n {quotaData.slice(0, 10).map((quota, index) => (
\n <div key={index} className="quota-item">
\n <div className="quota-header">
\n <span className="quota-endpoint">{quota.endpoint}<\/span>
\n <span className="quota-rule">{quota.rule}<\/span>
\n <\/div><\/p>\n
<div className="quota-progress">
\n <div className="progress-bar">
\n <div
\n className="progress-fill"
\n style={{ width: `${(quota.used \/ quota.limit) * 100}%` }}
\n ><\/div>
\n <\/div>
\n <div className="quota-numbers">
\n <span>{quota.used} \/ {quota.limit}<\/span>
\n <span>{((quota.used \/ quota.limit) * 100).toFixed(1)}%<\/span>
\n <\/div>
\n <\/div><\/p>\n
<div className="quota-actions">
\n <button
\n className="btn btn-sm btn-primary"
\n onClick={() => handleAdjustLimit(quota.endpoint, quota.rule, quota.limit * 1.1)}
\n >
\n \u589e\u52a010%
\n <\/button>
\n <button
\n className="btn btn-sm btn-secondary"
\n onClick={() => handleAdjustLimit(quota.endpoint, quota.rule, quota.limit * 0.9)}
\n >
\n \u51cf\u5c1110%
\n <\/button>
\n <button
\n className="btn btn-sm btn-tertiary"
\n onClick={() => handleResetQuota(quota.endpoint, quota.rule)}
\n >
\n \u7acb\u5373\u91cd\u7f6e
\n <\/button>
\n <\/div>
\n <\/div>
\n ))}
\n <\/div>
\n <\/div><\/p>\n
{\/* \u914d\u7f6e\u5efa\u8bae *\/}
\n <div className="recommendations-section">
\n <h3>\u914d\u7f6e\u5efa\u8bae<\/h3>
\n <div className="recommendations-list">
\n {generateRecommendations().map((rec, index) => (
\n <div key={index} className="recommendation-card">
\n <div className="recommendation-icon">💡<\/div>
\n <div className="recommendation-content">
\n <h4>{rec.title}<\/h4>
\n <p>{rec.description}<\/p>
\n <div className="recommendation-actions">
\n <button
\n className="btn btn-sm btn-primary"
\n onClick={() => applyRecommendation(rec)}
\n >
\n \u5e94\u7528\u5efa\u8bae
\n <\/button>
\n <button
\n className="btn btn-sm btn-secondary"
\n onClick={() => dismissRecommendation(rec.id)}
\n >
\n \u5ffd\u7565
\n <\/button>
\n <\/div>
\n <\/div>
\n <\/div>
\n ))}
\n <\/div>
\n <\/div>
\n <\/div>
\n );<\/p>\n
\/\/ \u8f85\u52a9\u51fd\u6570
\n function generateRadarData() {
\n return [
\n { subject: '\u8ba4\u8bc1\u7aef\u70b9', usage: 85, target: 70 },
\n { subject: '\u6570\u636e\u67e5\u8be2', usage: 60, target: 80 },
\n { subject: '\u6587\u4ef6\u4e0a\u4f20', usage: 95, target: 50 },
\n { subject: '\u7ba1\u7406\u63a5\u53e3', usage: 40, target: 30 },
\n { subject: '\u516c\u5171API', usage: 75, target: 90 },
\n { subject: 'Webhook', usage: 20, target: 40 }
\n ];
\n }<\/p>\n
function generateRecommendations() {
\n const recommendations = [];<\/p>\n
\/\/ \u57fa\u4e8e\u6570\u636e\u5206\u6790\u751f\u6210\u5efa\u8bae
\n const highViolationEndpoints = generateEndpointDistributionData()
\n .filter(e => e.violations > 10);<\/p>\n
if (highViolationEndpoints.length > 0) {
\n highViolationEndpoints.forEach(endpoint => {
\n recommendations.push({
\n id: `increase-${endpoint.name}`,
\n title: `\u589e\u52a0 ${endpoint.name} \u7684\u914d\u989d\u9650\u5236`,
\n description: `\u8be5\u7aef\u70b9\u6709 ${endpoint.violations} \u6b21\u8fdd\u89c4，\u5efa\u8bae\u589e\u52a0\u914d\u989d\u9650\u5236\u4ee5\u63d0\u9ad8\u53ef\u7528\u6027\u3002`,
\n type: 'increase_limit',
\n endpoint: endpoint.name,
\n currentLimit: endpoint.requests,
\n suggestedLimit: Math.ceil(endpoint.requests * 1.5)
\n });
\n });
\n }<\/p>\n
\/\/ \u68c0\u67e5\u4f7f\u7528\u7387\u4f4e\u7684\u7aef\u70b9
\n const lowUsageEndpoints = generateEndpointDistributionData()
\n .filter(e => e.usageRate < 0.3 && e.requests > 100);<\/p>\n
if (lowUsageEndpoints.length > 0) {
\n lowUsageEndpoints.forEach(endpoint => {
\n recommendations.push({
\n id: `decrease-${endpoint.name}`,
\n title: `\u4f18\u5316 ${endpoint.name} \u7684\u914d\u989d\u914d\u7f6e`,
\n description: `\u8be5\u7aef\u70b9\u4f7f\u7528\u7387\u8f83\u4f4e（${(endpoint.usageRate * 100).toFixed(1)}%），\u53ef\u4ee5\u8003\u8651\u51cf\u5c11\u914d\u989d\u4ee5\u91ca\u653e\u8d44\u6e90\u3002`,
\n type: 'decrease_limit',
\n endpoint: endpoint.name,
\n currentLimit: endpoint.requests,
\n suggestedLimit: Math.ceil(endpoint.requests * 0.7)
\n });
\n });
\n }<\/p>\n
\/\/ \u901a\u7528\u5efa\u8bae
\n recommendations.push({
\n id: 'implement-adaptive',
\n title: '\u5b9e\u65bd\u81ea\u9002\u5e94\u901f\u7387\u9650\u5236',
\n description: '\u6839\u636e\u5386\u53f2\u4f7f\u7528\u6a21\u5f0f\u52a8\u6001\u8c03\u6574\u9650\u5236，\u63d0\u9ad8\u7cfb\u7edf\u6548\u7387\u548c\u7528\u6237\u4f53\u9a8c\u3002',
\n type: 'feature',
\n priority: 'high'
\n });<\/p>\n
recommendations.push({
\n id: 'add-client-education',
\n title: '\u6dfb\u52a0\u5ba2\u6237\u7aef\u914d\u989d\u6559\u80b2',
\n description: '\u5728API\u54cd\u5e94\u4e2d\u6dfb\u52a0\u914d\u989d\u4f7f\u7528\u4fe1\u606f，\u5e2e\u52a9\u5ba2\u6237\u7aef\u66f4\u597d\u5730\u7ba1\u7406\u8bf7\u6c42\u3002',
\n type: 'improvement',
\n priority: 'medium'
\n });<\/p>\n
return recommendations.slice(0, 5);
\n }<\/p>\n
function viewEventDetails(event) {
\n console.log('Event details:', event);
\n alert(`\u4e8b\u4ef6\u8be6\u60c5:\\\\n${JSON.stringify(event, null, 2)}`);
\n }<\/p>\n
function applyRecommendation(recommendation) {
\n console.log('Applying recommendation:', recommendation);<\/p>\n
if (recommendation.type === 'increase_limit' || recommendation.type === 'decrease_limit') {
\n handleAdjustLimit(
\n recommendation.endpoint,
\n 'custom_rule',
\n recommendation.suggestedLimit
\n );
\n }<\/p>\n
alert(`\u5df2\u5e94\u7528\u5efa\u8bae: ${recommendation.title}`);
\n }<\/p>\n
function dismissRecommendation(id) {
\n console.log('Dismissing recommendation:', id);
\n \/\/ \u5728\u5b9e\u9645\u5e94\u7528\u4e2d，\u8fd9\u91cc\u4f1a\u6807\u8bb0\u5efa\u8bae\u4e3a\u5df2\u5ffd\u7565
\n }
\n}<\/p>\n
HTTP\u72b6\u6001\u7801\u662fWeb\u901a\u4fe1\u7684\u57fa\u7840\u8bed\u8a00，\u5176\u4e2d4xx\u7cfb\u5217\u4e13\u95e8\u6307\u793a\u5ba2\u6237\u7aef\u9519\u8bef\u3002\u867d\u7136404\u3001403\u548c400\u5e7f\u4e3a\u4eba\u77e5，\u4f46HTTP\u534f\u8bae\u8fd8\u5b9a\u4e49\u4e86\u8bb8\u591a\u4e13\u95e8\u5316\u76844xx\u72b6\u6001\u7801，\u4e3a\u7279\u5b9a\u9519\u8bef\u573a\u666f\u63d0\u4f9b\u7cbe\u786e\u8bed\u4e49\u3002\u8fd9\u4e9b"\u8fb9\u7f18\u6848\u4f8b"\u72b6\u6001\u7801\u5728\u73b0\u4ee3API\u8bbe\u8ba1\u3001\u5fae\u670d\u52a1\u67b6\u6784\u548cRESTful\u670d\u52a1\u4e2d\u626e\u6f14\u7740\u8d8a\u6765\u8d8a\u91cd\u8981\u7684\u89d2\u8272\u3002\u672c\u7ae0\u5c06\u6df1\u5165\u63a2\u8ba823\u4e2a\u4e0d\u5e38\u7528\u4f46\u91cd\u8981\u76844xx\u72b6\u6001\u7801，\u6db5\u76d6\u4ece\u652f\u4ed8\u7cfb\u7edf\u5230\u6cd5\u5f8b\u5408\u89c4\u7684\u5e7f\u6cdb\u573a\u666f\u3002<\/p>\n
402\u72b6\u6001\u7801\u5728HTTP\/1.1\u89c4\u8303\u4e2d\u5b9a\u4e49\u4e3a"\u4fdd\u7559\u7528\u4e8e\u672a\u6765\u4f7f\u7528"，\u4f46\u5b9e\u9645\u4e0a\u5df2\u88ab\u5e7f\u6cdb\u63a5\u53d7\u4e3a\u8868\u793a\u9700\u8981\u4ed8\u6b3e\u624d\u80fd\u8bbf\u95ee\u8d44\u6e90\u7684\u72b6\u6001\u3002\u867d\u7136\u4ece\u672a\u88ab\u6b63\u5f0f\u6807\u51c6\u5316，\u4f46\u5b83\u5df2\u6210\u4e3a\u652f\u4ed8\u7f51\u5173\u3001\u8ba2\u9605\u670d\u52a1\u548c\u5fae\u4ea4\u6613API\u7684\u4e8b\u5b9e\u6807\u51c6\u3002<\/p>\n
\u8ba2\u9605\u5185\u5bb9\u8bbf\u95ee：\u7528\u6237\u5c1d\u8bd5\u8bbf\u95ee\u9700\u8981\u8ba2\u9605\u7684\u5185\u5bb9<\/p>\n<\/li>\n
API\u8c03\u7528\u8ba1\u8d39：\u8d85\u8fc7\u514d\u8d39\u989d\u5ea6\u7684API\u8bf7\u6c42<\/p>\n<\/li>\n
\u6570\u5b57\u5546\u54c1\u8d2d\u4e70：\u5c1d\u8bd5\u4e0b\u8f7d\u672a\u8d2d\u4e70\u7684\u7535\u5b50\u4e66\u3001\u8f6f\u4ef6\u7b49<\/p>\n<\/li>\n
\u670d\u52a1\u989d\u5ea6\u8017\u5c3d：\u4e91\u670d\u52a1\u3001SaaS\u5e73\u53f0\u7684\u7528\u91cf\u8d85\u9650<\/p>\n<\/li>\n
http<\/p>\n
HTTP\/1.1 402 Payment Required
\nContent-Type: application\/json
\nX-Payment-URL: https:\/\/api.example.com\/payment\/order_123
\nRetry-After: 3600<\/p>\n
{
\n "error": "payment_required",
\n "message": "You have exceeded your free API call limit",
\n "upgrade_url": "https:\/\/api.example.com\/plans",
\n "current_usage": {
\n "used": 1000,
\n "limit": 100
\n }
\n}<\/p>\n
\u59cb\u7ec8\u63d0\u4f9b\u6e05\u6670\u7684\u9519\u8bef\u4fe1\u606f\u548c\u89e3\u51b3\u6307\u5f15<\/p>\n<\/li>\n
\u5305\u542b\u652f\u4ed8URL\u6216\u5347\u7ea7\u8def\u5f84<\/p>\n<\/li>\n
\u5bf9\u4e8eAPI\u9650\u6d41，\u4f7f\u7528429\u72b6\u6001\u7801\u53ef\u80fd\u66f4\u5408\u9002<\/p>\n<\/li>\n
\u8003\u8651\u652f\u6301\u591a\u79cd\u652f\u4ed8\u534f\u8bae（\u5982Web Monetization API）<\/p>\n<\/li>\n<\/ul>\n
406\u72b6\u6001\u7801\u8868\u793a\u670d\u52a1\u5668\u65e0\u6cd5\u751f\u6210\u5ba2\u6237\u7aefAccept\u5934\u6307\u5b9a\u7684\u54cd\u5e94\u5185\u5bb9\u3002\u5f53\u670d\u52a1\u5668\u4e0d\u652f\u6301\u5ba2\u6237\u7aef\u8bf7\u6c42\u7684\u5a92\u4f53\u7c7b\u578b\u65f6\u8fd4\u56de\u6b64\u72b6\u6001\u7801\u3002<\/p>\n
HTTP\u5185\u5bb9\u534f\u5546\u6d89\u53ca\u591a\u4e2a\u8bf7\u6c42\u5934：<\/p>\n
Accept：\u5ba2\u6237\u7aef\u63a5\u53d7\u7684\u5a92\u4f53\u7c7b\u578b<\/p>\n<\/li>\n
Accept-Charset：\u5b57\u7b26\u96c6\u504f\u597d<\/p>\n<\/li>\n
Accept-Encoding：\u5185\u5bb9\u7f16\u7801\u504f\u597d<\/p>\n<\/li>\n
Accept-Language：\u8bed\u8a00\u504f\u597d<\/p>\n<\/li>\n<\/ul>\n
python<\/p>\n
# Flask\u793a\u4f8b：\u5904\u7406\u5185\u5bb9\u534f\u5546
\n@app.route('\/resource')
\ndef get_resource():
\n accepted_types = request.accept_mimetypes
\n if 'application\/json' in accepted_types:
\n return jsonify(data)
\n elif 'application\/xml' in accepted_types:
\n return xml_response(data)
\n else:
\n # \u8fd4\u56de406\u5e76\u63d0\u4f9b\u652f\u6301\u7684\u683c\u5f0f
\n response = jsonify({
\n 'error': 'Unsupported media type requested',
\n 'supported_types': [
\n 'application\/json',
\n 'application\/xml',
\n 'text\/html'
\n ]
\n })
\n response.status_code = 406
\n response.headers['Content-Type'] = 'application\/json'
\n return response<\/p>\n
HTTP\/1.1\u5f15\u5165\u4e86Vary\u5934，\u6307\u793a\u7f13\u5b58\u670d\u52a1\u5668\u6839\u636e\u54ea\u4e9b\u8bf7\u6c42\u5934\u751f\u6210\u4e0d\u540c\u54cd\u5e94：<\/p>\n
text<\/p>\n
Vary: Accept, Accept-Language, User-Agent<\/p>\n
\u5b9e\u73b0\u4f18\u96c5\u964d\u7ea7（\u5982JSON\u4f5c\u4e3a\u9ed8\u8ba4\u683c\u5f0f）<\/p>\n<\/li>\n
\u5728406\u54cd\u5e94\u4e2d\u5217\u51fa\u652f\u6301\u7684\u5a92\u4f53\u7c7b\u578b<\/p>\n<\/li>\n
\u6b63\u786e\u8bbe\u7f6eVary\u5934\u4ee5\u652f\u6301\u7f13\u5b58<\/p>\n<\/li>\n
\u8003\u8651\u4f7f\u7528\u683c\u5f0f\u53c2\u6570\u4f5c\u4e3a\u540e\u5907\u65b9\u6848（\u5982?format=json）<\/p>\n<\/li>\n<\/ul>\n
407\u72b6\u6001\u7801\u8868\u793a\u5ba2\u6237\u7aef\u5fc5\u987b\u9996\u5148\u901a\u8fc7\u4ee3\u7406\u670d\u52a1\u5668\u7684\u8eab\u4efd\u9a8c\u8bc1\u3002\u4e0e401\u7c7b\u4f3c，\u4f46\u4e13\u95e8\u7528\u4e8e\u4ee3\u7406\u8ba4\u8bc1\u3002<\/p>\n
Basic：\u57fa\u672c\u8ba4\u8bc1（Base64\u7f16\u7801）<\/p>\n<\/li>\n
Digest：\u6458\u8981\u8ba4\u8bc1（\u66f4\u5b89\u5168）<\/p>\n<\/li>\n
Bearer：\u4ee4\u724c\u8ba4\u8bc1<\/p>\n<\/li>\n
NTLM：Windows\u8ba4\u8bc1\u534f\u8bae<\/p>\n<\/li>\n
text<\/p>\n
\u5ba2\u6237\u7aef \u2192 \u4ee3\u7406: GET \/resource HTTP\/1.1
\n\u4ee3\u7406 \u2192 \u5ba2\u6237\u7aef: HTTP\/1.1 407 Proxy Authentication Required
\n Proxy-Authenticate: Basic realm="CorpProxy"
\n\u5ba2\u6237\u7aef \u2192 \u4ee3\u7406: GET \/resource HTTP\/1.1
\n Proxy-Authorization: Basic dXNlcjpwYXNz
\n\u4ee3\u7406 \u2192 \u540e\u7aef: \u8f6c\u53d1\u8bf7\u6c42
\n\u540e\u7aef \u2192 \u5ba2\u6237\u7aef: \u901a\u8fc7\u4ee3\u7406\u8fd4\u56de\u54cd\u5e94<\/p>\n
\u59cb\u7ec8\u4f7f\u7528HTTPS\u4f20\u8f93\u4ee3\u7406\u51ed\u8bc1<\/p>\n<\/li>\n
\u8003\u8651\u4f7f\u7528\u6458\u8981\u8ba4\u8bc1\u907f\u514d\u660e\u6587\u4f20\u8f93<\/p>\n<\/li>\n
\u5b9e\u73b0\u51ed\u8bc1\u8f6e\u6362\u673a\u5236<\/p>\n<\/li>\n
\u76d1\u63a7\u4ee3\u7406\u8ba4\u8bc1\u5931\u8d25\u5c1d\u8bd5<\/p>\n<\/li>\n<\/ul>\n
nginx<\/p>\n
# Nginx\u4ee3\u7406\u8ba4\u8bc1\u914d\u7f6e
\nlocation \/ {
\n auth_basic "Proxy Authentication Required";
\n auth_basic_user_file \/etc\/nginx\/.htpasswd;
\n proxy_pass http:\/\/backend;<\/p>\n
# \u8f6c\u53d1\u8ba4\u8bc1\u5934\u5230\u540e\u7aef（\u5982\u679c\u9700\u8981）
\n proxy_set_header Authorization $http_authorization;
\n}<\/p>\n
408\u72b6\u6001\u7801\u8868\u793a\u670d\u52a1\u5668\u5728\u7b49\u5f85\u8bf7\u6c42\u65f6\u8d85\u65f6\u3002\u670d\u52a1\u5668\u613f\u610f\u7ee7\u7eed\u7b49\u5f85，\u4f46\u5ba2\u6237\u7aef\u6ca1\u6709\u5728\u670d\u52a1\u5668\u51c6\u5907\u7b49\u5f85\u7684\u65f6\u95f4\u5185\u5b8c\u6210\u8bf7\u6c42\u53d1\u9001\u3002<\/p>\n
\u7f51\u7edc\u5ef6\u8fdf：\u5ba2\u6237\u7aef\u4e0e\u670d\u52a1\u5668\u95f4\u7684\u9ad8\u5ef6\u8fdf<\/p>\n<\/li>\n
\u8bf7\u6c42\u4f53\u8fc7\u5927：\u4e0a\u4f20\u5927\u6587\u4ef6\u65f6\u4f20\u8f93\u7f13\u6162<\/p>\n<\/li>\n
\u5ba2\u6237\u7aef\u6545\u969c：\u5ba2\u6237\u7aef\u5d29\u6e83\u6216\u8fde\u63a5\u4e2d\u65ad<\/p>\n<\/li>\n
\u7f51\u7edc\u4e2d\u65ad：\u4e2d\u95f4\u7f51\u7edc\u8bbe\u5907\u95ee\u9898<\/p>\n<\/li>\n
nginx<\/p>\n
# Nginx\u8d85\u65f6\u914d\u7f6e
\nhttp {
\n # \u5ba2\u6237\u7aef\u8bfb\u53d6\u8d85\u65f6（\u4e24\u4e2a\u8fde\u7eed\u64cd\u4f5c\u95f4\u9694）
\n client_header_timeout 60s;<\/p>\n
# \u5ba2\u6237\u7aef\u53d1\u9001\u8bf7\u6c42\u4f53\u8d85\u65f6
\n client_body_timeout 60s;<\/p>\n
# \u4fdd\u6301\u8fde\u63a5\u8d85\u65f6
\n keepalive_timeout 75s;<\/p>\n
# \u53d1\u9001\u54cd\u5e94\u5230\u5ba2\u6237\u7aef\u8d85\u65f6
\n send_timeout 60s;
\n}<\/p>\n
javascript<\/p>\n
\/\/ \u6307\u6570\u9000\u907f\u91cd\u8bd5\u7b56\u7565
\nasync function fetchWithRetry(url, options, maxRetries = 3) {
\n let lastError;<\/p>\n
for (let i = 0; i < maxRetries; i++) {
\n try {
\n const response = await fetch(url, options);
\n return response;
\n } catch (error) {
\n lastError = error;<\/p>\n
\/\/ \u68c0\u67e5\u662f\u5426\u4e3a\u8d85\u65f6\u9519\u8bef
\n if (error.name === 'TimeoutError' || error.status === 408) {
\n \/\/ \u6307\u6570\u9000\u907f：1s, 2s, 4s…
\n const delay = Math.pow(2, i) * 1000;
\n await new Promise(resolve => setTimeout(resolve, delay));
\n continue;
\n }<\/p>\n
\/\/ \u975e\u8d85\u65f6\u9519\u8bef，\u7acb\u5373\u629b\u51fa
\n throw error;
\n }
\n }<\/p>\n
throw lastError;
\n}<\/p>\n
\u5b9e\u73b0\u5e42\u7b49\u8bf7\u6c42\u4ee5\u5b89\u5168\u91cd\u8bd5<\/p>\n<\/li>\n
\u5ba2\u6237\u7aef\u4f7f\u7528\u6307\u6570\u9000\u907f\u7b97\u6cd5<\/p>\n<\/li>\n
\u670d\u52a1\u5668\u8bbe\u7f6e\u5408\u7406\u7684\u8d85\u65f6\u9608\u503c<\/p>\n<\/li>\n
\u76d1\u63a7\u8d85\u65f6\u7387\u4ee5\u8bc6\u522b\u6027\u80fd\u95ee\u9898<\/p>\n<\/li>\n<\/ul>\n
409\u72b6\u6001\u7801\u8868\u793a\u8bf7\u6c42\u4e0e\u670d\u52a1\u5668\u5f53\u524d\u72b6\u6001\u51b2\u7a81\u3002\u901a\u5e38\u7528\u4e8e\u5e76\u53d1\u4fee\u6539\u573a\u666f，\u5982\u7248\u672c\u51b2\u7a81\u6216\u8d44\u6e90\u9501\u5b9a\u3002<\/p>\n
\u7248\u672c\u51b2\u7a81：\u57fa\u4e8e\u7248\u672c\u53f7\u7684\u4e50\u89c2\u9501<\/p>\n<\/li>\n
\u552f\u4e00\u7ea6\u675f\u8fdd\u53cd：\u6570\u636e\u5e93\u552f\u4e00\u952e\u51b2\u7a81<\/p>\n<\/li>\n
\u4e1a\u52a1\u89c4\u5219\u51b2\u7a81：\u8fdd\u53cd\u9886\u57df\u7279\u5b9a\u89c4\u5219<\/p>\n<\/li>\n
\u8d44\u6e90\u72b6\u6001\u51b2\u7a81：\u5c1d\u8bd5\u4fee\u6539\u5df2\u5220\u9664\u7684\u8d44\u6e90<\/p>\n<\/li>\n
java<\/p>\n
\/\/ Spring Boot\u793a\u4f8b：\u4f7f\u7528ETag\u5b9e\u73b0\u4e50\u89c2\u9501
\n@PutMapping("\/products\/{id}")
\npublic ResponseEntity<?> updateProduct(
\n @PathVariable Long id,
\n @RequestBody Product product,
\n @RequestHeader("If-Match") String ifMatch) {<\/p>\n
Product existing = productRepository.findById(id)
\n .orElseThrow(() -> new ResourceNotFoundException());<\/p>\n
\/\/ \u68c0\u67e5ETag\u662f\u5426\u5339\u914d
\n String currentETag = generateETag(existing);
\n if (!currentETag.equals(ifMatch)) {
\n return ResponseEntity.status(409)
\n .header("ETag", currentETag)
\n .body(Map.of(
\n "error", "conflict",
\n "message", "Resource has been modified by another user",
\n "current_version", currentETag
\n ));
\n }<\/p>\n
\/\/ \u66f4\u65b0\u8d44\u6e90\u5e76\u751f\u6210\u65b0ETag
\n Product updated = productRepository.save(product);
\n String newETag = generateETag(updated);<\/p>\n
return ResponseEntity.ok()
\n .header("ETag", newETag)
\n .body(updated);
\n}<\/p>\n
\u6700\u540e\u5199\u5165\u83b7\u80dc：\u7b80\u5355\u7684\u8986\u76d6\u7b56\u7565<\/p>\n<\/li>\n
\u624b\u52a8\u5408\u5e76：\u63d0\u793a\u7528\u6237\u89e3\u51b3\u51b2\u7a81<\/p>\n<\/li>\n
\u81ea\u52a8\u5408\u5e76：\u57fa\u4e8e\u89c4\u5219\u7684\u81ea\u52a8\u5408\u5e76<\/p>\n<\/li>\n
\u64cd\u4f5c\u8f6c\u6362：\u5b9e\u65f6\u534f\u4f5c\u7cfb\u7edf\u4f7f\u7528<\/p>\n<\/li>\n
json<\/p>\n
{
\n "error": "conflict",
\n "message": "Resource update conflict",
\n "conflict_details": {
\n "field": "email",
\n "reason": "already_exists",
\n "existing_value": "user@example.com"
\n },
\n "resolution_options": [
\n {
\n "action": "overwrite",
\n "method": "PUT",
\n "url": "\/resource\/123?force=true"
\n },
\n {
\n "action": "merge",
\n "method": "PATCH",
\n "url": "\/resource\/123"
\n }
\n ]
\n}<\/p>\n
410\u72b6\u6001\u7801\u8868\u793a\u8bf7\u6c42\u7684\u8d44\u6e90\u5728\u670d\u52a1\u5668\u4e0a\u5df2\u6c38\u4e45\u5220\u9664，\u4e14\u6ca1\u6709\u8f6c\u53d1\u5730\u5740\u3002\u4e0e404\u4e0d\u540c，410\u660e\u786e\u8868\u793a\u8d44\u6e90\u66fe\u7ecf\u5b58\u5728\u4f46\u88ab\u6709\u610f\u5220\u9664\u3002<\/p>\n
| \u8d44\u6e90\u662f\u5426\u5b58\u5728\u8fc7<\/td>\n | \u672a\u77e5<\/td>\n | \u66fe\u7ecf\u5b58\u5728<\/td>\n<\/tr>\n | ||||||||||||||||||||||||||||||||||||||||||
| \u662f\u5426\u6c38\u4e45\u6027<\/td>\n | \u53ef\u80fd\u662f\u4e34\u65f6\u7684<\/td>\n | \u6c38\u4e45\u5220\u9664<\/td>\n<\/tr>\n | ||||||||||||||||||||||||||||||||||||||||||
| \u7f13\u5b58\u5efa\u8bae<\/td>\n | \u53ef\u77ed\u671f\u7f13\u5b58<\/td>\n | \u5e94\u957f\u671f\u7f13\u5b58<\/td>\n<\/tr>\n | ||||||||||||||||||||||||||||||||||||||||||
| \u5ba2\u6237\u7aef\u54cd\u5e94<\/td>\n | \u53ef\u91cd\u8bd5<\/td>\n | \u5e94\u5220\u9664\u5f15\u7528<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n23.6.3 \u4f7f\u7528\u573a\u666f<\/h4>\n\u7528\u6237\u5220\u9664\u5185\u5bb9：\u793e\u4ea4\u5a92\u4f53\u5e16\u5b50\u3001\u8bc4\u8bba<\/p>\n<\/li>\n \u5185\u5bb9\u4e0b\u67b6：\u5df2\u505c\u6b62\u7684\u4ea7\u54c1\u9875\u9762<\/p>\n<\/li>\n URL\u91cd\u6784：\u65e7URL\u4e0d\u518d\u53ef\u7528\u4e14\u65e0\u91cd\u5b9a\u5411<\/p>\n<\/li>\n \u5408\u89c4\u8981\u6c42：\u6cd5\u5f8b\u8981\u6c42\u5220\u9664\u7684\u5185\u5bb9<\/p>\n<\/li>\n 23.6.4 SEO\u8003\u8651<\/h4>\nhtml<\/p>\n <!– \u5bf9\u4e8eSEO\u53cb\u597d\u7684410\u9875\u9762 –> <!– \u63d0\u4f9b\u76f8\u5173\u66ff\u4ee3\u5185\u5bb9 –> <!– \u7ed3\u6784\u5316\u6570\u636e\u5e2e\u52a9\u641c\u7d22\u5f15\u64ce\u7406\u89e3 –> 23.6.5 \u5b9e\u73b0\u6a21\u5f0f<\/h4>\npython<\/p>\n # Django\u89c6\u56fe\u793a\u4f8b class DeletedResourceView(DetailView): if resource.deleted_at: return super().get(request, *args, **kwargs)<\/p>\n 23.6.6 \u6700\u4f73\u5b9e\u8df5<\/h4>\n\u4e3a\u5df2\u5220\u9664\u8d44\u6e90\u4fdd\u7559\u5143\u6570\u636e\u4e00\u6bb5\u65f6\u95f4<\/p>\n<\/li>\n \u5728\u54cd\u5e94\u4e2d\u5305\u542b\u5220\u9664\u539f\u56e0\u548c\u65f6\u95f4\u6233<\/p>\n<\/li>\n \u63d0\u4f9b\u76f8\u5173\u8d44\u6e90\u7684\u94fe\u63a5<\/p>\n<\/li>\n \u66f4\u65b0\u5185\u90e8\u94fe\u63a5\u548c\u7ad9\u70b9\u5730\u56fe<\/p>\n<\/li>\n<\/ul>\n 23.7 411 Length Required（\u9700\u8981\u5185\u5bb9\u957f\u5ea6）<\/h3>\n |
411\u72b6\u6001\u7801\u8868\u793a\u670d\u52a1\u5668\u62d2\u7edd\u5904\u7406\u6ca1\u6709Content-Length\u5934\u7684\u8bf7\u6c42\u3002\u67d0\u4e9b\u670d\u52a1\u5668\u8981\u6c42\u63d0\u524d\u77e5\u9053\u8bf7\u6c42\u4f53\u5927\u5c0f\u4ee5\u8fdb\u884c\u5b89\u5168\u6216\u6548\u7387\u4f18\u5316\u3002<\/p>\n
\u6587\u4ef6\u4e0a\u4f20：\u9700\u8981\u77e5\u9053\u4e0a\u4f20\u6587\u4ef6\u5927\u5c0f<\/p>\n<\/li>\n
API\u9650\u6d41：\u57fa\u4e8e\u5185\u5bb9\u957f\u5ea6\u7684\u914d\u989d\u68c0\u67e5<\/p>\n<\/li>\n
\u5b89\u5168\u626b\u63cf：\u63d0\u524d\u68c0\u6d4b\u8fc7\u5927\u8bf7\u6c42<\/p>\n<\/li>\n
\u8d44\u6e90\u9884\u5206\u914d：\u63d0\u524d\u5206\u914d\u5b58\u50a8\u7a7a\u95f4<\/p>\n<\/li>\n
\u5f53\u65e0\u6cd5\u63d0\u524d\u77e5\u9053\u5185\u5bb9\u5927\u5c0f\u65f6，\u53ef\u4f7f\u7528\u5206\u5757\u4f20\u8f93\u7f16\u7801：<\/p>\n
http<\/p>\n
POST \/upload HTTP\/1.1
\nHost: example.com
\nTransfer-Encoding: chunked<\/p>\n
7\\\\r\\\\n
\nMozilla\\\\r\\\\n
\n9\\\\r\\\\n
\nDeveloper\\\\r\\\\n
\n7\\\\r\\\\n
\nNetwork\\\\r\\\\n
\n0\\\\r\\\\n
\n\\\\r\\\\n<\/p>\n
javascript<\/p>\n
\/\/ \u73b0\u4ee3JavaScript\u4e2d\u81ea\u52a8\u5904\u7406Content-Length
\nasync function uploadFile(file) {
\n const formData = new FormData();
\n formData.append('file', file);<\/p>\n
\/\/ Fetch API\u4f1a\u81ea\u52a8\u8ba1\u7b97\u548c\u8bbe\u7f6eContent-Length
\n const response = await fetch('\/upload', {
\n method: 'POST',
\n body: formData,
\n \/\/ \u6ce8\u610f：FormData\u4f7f\u7528multipart\/form-data\u65f6
\n \/\/ \u6d4f\u89c8\u5668\u4f1a\u81ea\u52a8\u5904\u7406，\u4e0d\u9700\u8981\u624b\u52a8\u8bbe\u7f6e
\n });<\/p>\n
return response.json();
\n}<\/p>\n
\/\/ \u624b\u52a8\u8bbe\u7f6eContent-Length\u7684\u793a\u4f8b
\nasync function sendJsonData(data) {
\n const jsonString = JSON.stringify(data);<\/p>\n
const response = await fetch('\/api\/data', {
\n method: 'POST',
\n headers: {
\n 'Content-Type': 'application\/json',
\n 'Content-Length': Buffer.byteLength(jsonString, 'utf8').toString()
\n },
\n body: jsonString
\n });<\/p>\n
return response.json();
\n}<\/p>\n
nginx<\/p>\n
# Nginx\u914d\u7f6e：\u9650\u5236\u8bf7\u6c42\u4f53\u5927\u5c0f\u5e76\u9700\u8981Content-Length
\nhttp {
\n # \u542f\u7528\u8bf7\u6c42\u4f53\u5927\u5c0f\u68c0\u67e5
\n client_max_body_size 10m;<\/p>\n
# \u5bf9\u4e8e\u67d0\u4e9b\u7aef\u70b9\u8981\u6c42Content-Length
\n location \/api\/upload {
\n # \u5982\u679c\u8bf7\u6c42\u4f53\u8d85\u8fc71M，\u8981\u6c42Content-Length
\n if ($request_body_length > 1m) {
\n # \u68c0\u67e5\u662f\u5426\u6709Content-Length\u5934
\n if ($http_content_length = "") {
\n return 411;
\n }
\n }<\/p>\n
# \u6b63\u5e38\u5904\u7406
\n proxy_pass http:\/\/backend;
\n }
\n}<\/p>\n
\u5bf9\u4e8e\u5c0f\u8bf7\u6c42\u4f53，\u670d\u52a1\u5668\u53ef\u66f4\u7075\u6d3b<\/p>\n<\/li>\n
\u5927\u6587\u4ef6\u4e0a\u4f20\u5e94\u8981\u6c42Content-Length<\/p>\n<\/li>\n
\u652f\u6301\u5206\u5757\u4f20\u8f93\u4f5c\u4e3a\u5907\u9009\u65b9\u6848<\/p>\n<\/li>\n
\u63d0\u4f9b\u6e05\u6670\u7684\u9519\u8bef\u4fe1\u606f\u8bf4\u660e\u8981\u6c42<\/p>\n<\/li>\n<\/ul>\n
412\u72b6\u6001\u7801\u8868\u793a\u8bf7\u6c42\u4e2d\u63d0\u4f9b\u7684\u6761\u4ef6\u5934（\u5982If-Match\u3001If-None-Match\u3001If-Modified-Since\u7b49）\u8bc4\u4f30\u5931\u8d25\u3002<\/p>\n
If-Match：\u8981\u6c42ETag\u5339\u914d<\/p>\n<\/li>\n
If-None-Match：\u8981\u6c42ETag\u4e0d\u5339\u914d<\/p>\n<\/li>\n
If-Modified-Since：\u8981\u6c42\u8d44\u6e90\u5728\u6307\u5b9a\u65f6\u95f4\u540e\u88ab\u4fee\u6539<\/p>\n<\/li>\n
If-Unmodified-Since：\u8981\u6c42\u8d44\u6e90\u5728\u6307\u5b9a\u65f6\u95f4\u540e\u672a\u4fee\u6539<\/p>\n<\/li>\n
If-Range：\u7528\u4e8e\u65ad\u70b9\u7eed\u4f20<\/p>\n<\/li>\n
python<\/p>\n
# FastAPI\u793a\u4f8b：\u4f7f\u7528ETag\u5b9e\u73b0\u4e50\u89c2\u9501
\nfrom fastapi import FastAPI, Header, HTTPException
\nimport hashlib
\nimport json<\/p>\n
app = FastAPI()<\/p>\n
def generate_etag(data: dict) -> str:
\n """\u751f\u6210\u8d44\u6e90\u7684ETag"""
\n data_str = json.dumps(data, sort_keys=True)
\n return hashlib.md5(data_str.encode()).hexdigest()<\/p>\n
resources = {
\n "1": {"id": 1, "name": "Resource 1", "version": 1}
\n}<\/p>\n
@app.put("\/resources\/{resource_id}")
\nasync def update_resource(
\n resource_id: str,
\n updates: dict,
\n if_match: str = Header(None, alias="If-Match")
\n):
\n if resource_id not in resources:
\n raise HTTPException(status_code=404)<\/p>\n
current = resources[resource_id]
\n current_etag = generate_etag(current)<\/p>\n
# \u68c0\u67e5ETag\u662f\u5426\u5339\u914d
\n if if_match and if_match != current_etag:
\n raise HTTPException(
\n status_code=412,
\n detail={
\n "error": "precondition_failed",
\n "message": "Resource has been modified",
\n "current_etag": current_etag
\n }
\n )<\/p>\n
# \u66f4\u65b0\u8d44\u6e90
\n current.update(updates)
\n current["version"] += 1<\/p>\n
new_etag = generate_etag(current)<\/p>\n
return {
\n "data": current,
\n "etag": new_etag
\n }<\/p>\n
http<\/p>\n
# \u7f13\u5b58\u9a8c\u8bc1\u8bf7\u6c42
\nGET \/resource HTTP\/1.1
\nHost: api.example.com
\nIf-None-Match: "abc123"<\/p>\n
# \u54cd\u5e94（\u5982\u679c\u672a\u4fee\u6539）
\nHTTP\/1.1 304 Not Modified
\nETag: "abc123"
\nCache-Control: max-age=3600<\/p>\n
# \u54cd\u5e94（\u5982\u679c\u5df2\u4fee\u6539）
\nHTTP\/1.1 200 OK
\nETag: "def456"
\nCache-Control: max-age=3600
\nContent-Type: application\/json<\/p>\n
{"data": "updated"}<\/p>\n
\u4e3a\u53ef\u53d8\u8d44\u6e90\u5b9e\u73b0ETag\u652f\u6301<\/p>\n<\/li>\n
\u5728\u54cd\u5e94\u4e2d\u59cb\u7ec8\u8fd4\u56deETag\u5934<\/p>\n<\/li>\n
\u652f\u6301\u5f31ETag（\u4ee5W\/\u5f00\u5934）\u7528\u4e8e\u542f\u53d1\u5f0f\u6bd4\u8f83<\/p>\n<\/li>\n
\u63d0\u4f9b\u6e05\u6670\u7684\u9519\u8bef\u4fe1\u606f\u8bf4\u660e\u524d\u63d0\u6761\u4ef6<\/p>\n<\/li>\n<\/ul>\n
413\u72b6\u6001\u7801\u8868\u793a\u8bf7\u6c42\u4f53\u8d85\u8fc7\u670d\u52a1\u5668\u80fd\u591f\u5904\u7406\u7684\u5927\u5c0f\u9650\u5236\u3002\u670d\u52a1\u5668\u53ef\u4ee5\u5173\u95ed\u8fde\u63a5\u6216\u8fd4\u56deRetry-After\u5934\u6307\u793a\u4f55\u65f6\u91cd\u8bd5\u3002<\/p>\n
nginx<\/p>\n
# Nginx\u8bf7\u6c42\u4f53\u5927\u5c0f\u9650\u5236
\nhttp {
\n # \u5168\u5c40\u8bf7\u6c42\u4f53\u5927\u5c0f\u9650\u5236
\n client_max_body_size 10m;<\/p>\n
# \u7279\u5b9a\u4f4d\u7f6e\u66f4\u5927\u9650\u5236
\n location \/api\/upload {
\n client_max_body_size 100m;<\/p>\n
# \u5927\u6587\u4ef6\u4e0a\u4f20\u8d85\u65f6\u8bbe\u7f6e
\n client_body_timeout 300s;
\n client_header_timeout 300s;<\/p>\n
# \u7f13\u51b2\u533a\u8bbe\u7f6e
\n client_body_buffer_size 128k;
\n client_body_temp_path \/tmp\/nginx_upload;
\n }<\/p>\n
# \u7279\u5b9a\u4f4d\u7f6e\u66f4\u5c0f\u9650\u5236
\n location \/api\/json {
\n client_max_body_size 1m;
\n }
\n}<\/p>\n
http<\/p>\n
HTTP\/1.1 413 Payload Too Large
\nContent-Type: application\/problem+json
\nRetry-After: 3600<\/p>\n
{
\n "type": "https:\/\/example.com\/errors\/payload-too-large",
\n "title": "Request payload too large",
\n "status": 413,
\n "detail": "Maximum request body size is 10MB",
\n "instance": "\/api\/upload",
\n "max_size": 10485760,
\n "current_size": 15728640,
\n "suggestions": [
\n "Compress your data before uploading",
\n "Split the data into smaller chunks",
\n "Use our resumable upload API at \/api\/resumable-upload"
\n ]
\n}<\/p>\n
\u5206\u5757\u4e0a\u4f20：\u5c06\u5927\u6587\u4ef6\u5206\u6210\u5c0f\u5757<\/p>\n<\/li>\n
\u65ad\u70b9\u7eed\u4f20：\u652f\u6301\u4ece\u4e2d\u65ad\u5904\u7ee7\u7eed<\/p>\n<\/li>\n
\u6d41\u5f0f\u4e0a\u4f20：\u8fb9\u4e0a\u4f20\u8fb9\u5904\u7406<\/p>\n<\/li>\n
\u5916\u90e8\u5b58\u50a8：\u4e0a\u4f20\u5230S3\u7b49\u5bf9\u8c61\u5b58\u50a8<\/p>\n<\/li>\n
javascript<\/p>\n
\/\/ \u5ba2\u6237\u7aef\u5206\u5757\u4e0a\u4f20\u5b9e\u73b0
\nclass ChunkedUploader {
\n constructor(file, chunkSize = 5 * 1024 * 1024) { \/\/ 5MB
\n this.file = file;
\n this.chunkSize = chunkSize;
\n this.totalChunks = Math.ceil(file.size \/ chunkSize);
\n this.uploadedChunks = new Set();
\n this.uploadId = null;
\n }<\/p>\n
async startUpload() {
\n \/\/ \u521d\u59cb\u5316\u4e0a\u4f20\u4f1a\u8bdd
\n const response = await fetch('\/api\/upload\/init', {
\n method: 'POST',
\n headers: {'Content-Type': 'application\/json'},
\n body: JSON.stringify({
\n filename: this.file.name,
\n file_size: this.file.size,
\n chunk_size: this.chunkSize,
\n total_chunks: this.totalChunks
\n })
\n });<\/p>\n
const { upload_id } = await response.json();
\n this.uploadId = upload_id;<\/p>\n
\/\/ \u4e0a\u4f20\u6240\u6709\u5206\u5757
\n for (let chunkIndex = 0; chunkIndex < this.totalChunks; chunkIndex++) {
\n await this.uploadChunk(chunkIndex);
\n }<\/p>\n
\/\/ \u5b8c\u6210\u4e0a\u4f20
\n await this.completeUpload();
\n }<\/p>\n
async uploadChunk(chunkIndex) {
\n if (this.uploadedChunks.has(chunkIndex)) {
\n return; \/\/ \u5df2\u4e0a\u4f20
\n }<\/p>\n
const start = chunkIndex * this.chunkSize;
\n const end = Math.min(start + this.chunkSize, this.file.size);
\n const chunk = this.file.slice(start, end);<\/p>\n
const formData = new FormData();
\n formData.append('chunk', chunk);
\n formData.append('chunk_index', chunkIndex);
\n formData.append('upload_id', this.uploadId);<\/p>\n
await fetch('\/api\/upload\/chunk', {
\n method: 'POST',
\n body: formData
\n });<\/p>\n
this.uploadedChunks.add(chunkIndex);
\n }<\/p>\n
async completeUpload() {
\n await fetch('\/api\/upload\/complete', {
\n method: 'POST',
\n headers: {'Content-Type': 'application\/json'},
\n body: JSON.stringify({
\n upload_id: this.uploadId,
\n uploaded_chunks: Array.from(this.uploadedChunks)
\n })
\n });
\n }
\n}<\/p>\n
\u63d0\u4f9b\u6e05\u6670\u7684\u9519\u8bef\u4fe1\u606f，\u5305\u62ec\u6700\u5927\u5141\u8bb8\u5927\u5c0f<\/p>\n<\/li>\n
\u5b9e\u73b0\u5206\u5757\u4e0a\u4f20\u652f\u6301\u5927\u6587\u4ef6<\/p>\n<\/li>\n
\u8003\u8651\u4f7f\u7528CDN\u6216\u5bf9\u8c61\u5b58\u50a8\u5904\u7406\u5927\u6587\u4ef6<\/p>\n<\/li>\n
\u76d1\u63a7\u5927\u6587\u4ef6\u4e0a\u4f20\u9891\u7387\u548c\u5927\u5c0f\u5206\u5e03<\/p>\n<\/li>\n<\/ul>\n
414\u72b6\u6001\u7801\u8868\u793a\u5ba2\u6237\u7aef\u8bf7\u6c42\u7684URI\u957f\u5ea6\u8d85\u8fc7\u670d\u52a1\u5668\u80fd\u591f\u5904\u7406\u7684\u9650\u5236\u3002\u867d\u7136HTTP\u89c4\u8303\u6ca1\u6709\u6307\u5b9a\u6700\u5927URI\u957f\u5ea6，\u4f46\u670d\u52a1\u5668\u5b9e\u73b0\u901a\u5e38\u6709\u9650\u5236\u3002<\/p>\n
| Nginx<\/td>\n | \u53d6\u51b3\u4e8e\u7cfb\u7edf，\u901a\u5e388KB<\/td>\n | large_client_header_buffers<\/td>\n<\/tr>\n | |||||||||||||||||||||||||||
| Apache<\/td>\n | 8KB<\/td>\n | LimitRequestLine<\/td>\n<\/tr>\n | |||||||||||||||||||||||||||
| IIS<\/td>\n | 16KB<\/td>\n | maxUrl\u00a0in web.config<\/td>\n<\/tr>\n | |||||||||||||||||||||||||||
| Node.js<\/td>\n | \u53d6\u51b3\u4e8e\u5b9e\u73b0<\/td>\n | \u53ef\u914d\u7f6e<\/td>\n<\/tr>\n | |||||||||||||||||||||||||||
| \u6d4f\u89c8\u5668<\/td>\n | \u7ea62000\u5b57\u7b26<\/td>\n | \u65e0\u6807\u51c6<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n23.10.3 \u5e38\u89c1\u539f\u56e0<\/h4>\n\u8fc7\u5ea6\u4f7f\u7528\u67e5\u8be2\u53c2\u6570：GET\u8bf7\u6c42\u643a\u5e26\u5927\u91cf\u53c2\u6570<\/p>\n<\/li>\n \u6df1\u5ea6\u5d4c\u5957\u8def\u5f84：RESTful API\u7684\u6df1\u5ea6\u8d44\u6e90\u5f15\u7528<\/p>\n<\/li>\n Base64\u7f16\u7801\u6570\u636e：\u5728URL\u4e2d\u5d4c\u5165\u6570\u636e<\/p>\n<\/li>\n \u9519\u8bef\u7684\u94fe\u63a5\u751f\u6210：\u65e0\u9650\u5faa\u73af\u751f\u6210\u53c2\u6570<\/p>\n<\/li>\n 23.10.4 \u89e3\u51b3\u65b9\u6848<\/h4>\njavascript<\/p>\n \/\/ \u5c06\u957fGET\u8bf7\u6c42\u8f6c\u6362\u4e3aPOST \/\/ \u5982\u679cURL\u8d85\u8fc7\u5b89\u5168\u957f\u5ea6，\u8f6c\u6362\u4e3aPOST return { return { method: 'GET', url }; \/\/ \u670d\u52a1\u5668\u7aef\u5904\u7406 23.10.5 \u6700\u4f73\u5b9e\u8df5<\/h4>\n\u5bf9\u4e8e\u590d\u6742\u67e5\u8be2，\u4f7f\u7528POST\u66ff\u4ee3GET<\/p>\n<\/li>\n \u907f\u514d\u5728URL\u4e2d\u5d4c\u5165\u5927\u5757\u6570\u636e<\/p>\n<\/li>\n \u4f7f\u7528\u5206\u9875\u548c\u8fc7\u6ee4\u51cf\u5c11\u6570\u636e\u91cf<\/p>\n<\/li>\n \u76d1\u63a7URI\u957f\u5ea6\u5f02\u5e38<\/p>\n<\/li>\n<\/ul>\n 23.11 415 Unsupported Media Type（\u4e0d\u652f\u6301\u7684\u5a92\u4f53\u7c7b\u578b）<\/h3>\n |
415\u72b6\u6001\u7801\u8868\u793a\u670d\u52a1\u5668\u4e0d\u652f\u6301\u8bf7\u6c42\u7684\u5a92\u4f53\u7c7b\u578b\u3002\u901a\u5e38\u53d1\u751f\u5728\u8bf7\u6c42\u7684Content-Type\u4e0d\u88ab\u670d\u52a1\u5668\u63a5\u53d7\u65f6\u3002<\/p>\n
| application\/json<\/td>\n | JSON\u6570\u636e<\/td>\n | REST API<\/td>\n<\/tr>\n | ||||||||||||
| application\/xml<\/td>\n | XML\u6570\u636e<\/td>\n | SOAP API<\/td>\n<\/tr>\n | ||||||||||||
| multipart\/form-data<\/td>\n | \u8868\u5355\u6570\u636e<\/td>\n | \u6587\u4ef6\u4e0a\u4f20<\/td>\n<\/tr>\n | ||||||||||||
| application\/x-www-form-urlencoded<\/td>\n | URL\u7f16\u7801\u8868\u5355<\/td>\n | \u7b80\u5355\u8868\u5355<\/td>\n<\/tr>\n | ||||||||||||
| text\/plain<\/td>\n | \u7eaf\u6587\u672c<\/td>\n | \u7b80\u5355\u6570\u636e<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n23.11.3 \u5b9e\u73b0\u793a\u4f8b<\/h4>\npython<\/p>\n # FastAPI\u5a92\u4f53\u7c7b\u578b\u9a8c\u8bc1 app = FastAPI()<\/p>\n # \u5141\u8bb8\u7684\u5a92\u4f53\u7c7b\u578b @app.middleware("http") # \u63d0\u53d6\u4e3b\u5a92\u4f53\u7c7b\u578b # \u5982\u679c\u63d0\u4f9b\u4e86Content-Type\u4f46\u4e0d\u88ab\u652f\u6301 response = await call_next(request) @app.post("\/api\/data") 23.11.4 \u5185\u5bb9\u7c7b\u578b\u534f\u5546<\/h4>\nhttp<\/p>\n # \u5ba2\u6237\u7aef\u8bf7\u6c42 {"name": "test"}<\/p>\n # \u670d\u52a1\u5668\u54cd\u5e94 {"id": 1, "name": "test"}<\/p>\n 23.11.5 \u6700\u4f73\u5b9e\u8df5<\/h4>\n\u5728415\u54cd\u5e94\u4e2d\u5217\u51fa\u652f\u6301\u7684\u5a92\u4f53\u7c7b\u578b<\/p>\n<\/li>\n \u63d0\u4f9b\u9ed8\u8ba4\u5a92\u4f53\u7c7b\u578b\u4f5c\u4e3a\u540e\u5907<\/p>\n<\/li>\n \u5b9e\u73b0\u4e25\u683c\u6a21\u5f0f\u7528\u4e8e\u751f\u4ea7，\u5bbd\u677e\u6a21\u5f0f\u7528\u4e8e\u5f00\u53d1<\/p>\n<\/li>\n \u8bb0\u5f55API\u671f\u671b\u7684\u5a92\u4f53\u7c7b\u578b<\/p>\n<\/li>\n<\/ul>\n 23.12 416 Range Not Satisfiable（\u8303\u56f4\u8bf7\u6c42\u65e0\u6cd5\u6ee1\u8db3）<\/h3>\n |
416\u72b6\u6001\u7801\u8868\u793a\u670d\u52a1\u5668\u65e0\u6cd5\u63d0\u4f9b\u8bf7\u6c42\u7684Range\u5934\u6307\u5b9a\u7684\u5b57\u8282\u8303\u56f4\u3002\u901a\u5e38\u53d1\u751f\u5728\u8bf7\u6c42\u7684\u8303\u56f4\u8d85\u51fa\u8d44\u6e90\u5927\u5c0f\u65f6\u3002<\/p>\n
http<\/p>\n
# \u8bf7\u6c42\u7279\u5b9a\u8303\u56f4
\nGET \/large-file.pdf HTTP\/1.1
\nHost: example.com
\nRange: bytes=0-999<\/p>\n
# \u6210\u529f\u54cd\u5e94
\nHTTP\/1.1 206 Partial Content
\nContent-Type: application\/pdf
\nContent-Range: bytes 0-999\/5000
\nContent-Length: 1000<\/p>\n
[\u4e8c\u8fdb\u5236\u6570\u636e]<\/p>\n
# \u65e0\u6548\u8303\u56f4\u8bf7\u6c42
\nGET \/large-file.pdf HTTP\/1.1
\nHost: example.com
\nRange: bytes=5000-6000<\/p>\n
# 416\u54cd\u5e94
\nHTTP\/1.1 416 Range Not Satisfiable
\nContent-Range: bytes *\/5000<\/p>\n
python<\/p>\n
# Flask\u65ad\u70b9\u7eed\u4f20\u5b9e\u73b0
\nfrom flask import Flask, request, send_file, Response
\nimport os<\/p>\n
app = Flask(__name__)<\/p>\n
@app.route('\/download\/<filename>')
\ndef download_file(filename):
\n filepath = os.path.join('uploads', filename)<\/p>\n
if not os.path.exists(filepath):
\n return {'error': 'file_not_found'}, 404<\/p>\n
file_size = os.path.getsize(filepath)<\/p>\n
# \u68c0\u67e5Range\u5934
\n range_header = request.headers.get('Range')<\/p>\n
if range_header:
\n # \u89e3\u6790\u8303\u56f4\u8bf7\u6c42
\n try:
\n byte1, byte2 = 0, None<\/p>\n
# \u683c\u5f0f：bytes=start-end
\n range_ = range_header.replace('bytes=', '').split('-')
\n byte1 = int(range_[0]) if range_[0] else 0
\n if range_[1]:
\n byte2 = int(range_[1])<\/p>\n
if byte2 is None:
\n byte2 = file_size – 1
\n elif byte2 >= file_size:
\n # \u8303\u56f4\u8d85\u51fa\u6587\u4ef6\u5927\u5c0f
\n return Response(
\n status=416,
\n headers={
\n 'Content-Range': f'bytes *\/{file_size}',
\n 'Accept-Ranges': 'bytes'
\n }
\n )<\/p>\n
length = byte2 – byte1 + 1<\/p>\n
# \u53d1\u9001\u90e8\u5206\u5185\u5bb9
\n def generate():
\n with open(filepath, 'rb') as f:
\n f.seek(byte1)
\n remaining = length
\n chunk_size = 8192<\/p>\n
while remaining > 0:
\n chunk = f.read(min(chunk_size, remaining))
\n if not chunk:
\n break
\n remaining -= len(chunk)
\n yield chunk<\/p>\n
response = Response(generate(), 206)
\n response.headers.add('Content-Range', f'bytes {byte1}-{byte2}\/{file_size}')
\n response.headers.add('Accept-Ranges', 'bytes')
\n response.headers.add('Content-Length', str(length))
\n response.headers.add('Content-Type', 'application\/octet-stream')<\/p>\n
return response<\/p>\n
except ValueError:
\n # \u65e0\u6548\u7684Range\u5934\u683c\u5f0f
\n pass<\/p>\n
# \u5b8c\u6574\u6587\u4ef6\u4e0b\u8f7d
\n return send_file(filepath, as_attachment=True)<\/p>\n
javascript<\/p>\n
\/\/ \u652f\u6301\u65ad\u70b9\u7eed\u4f20\u7684\u4e0b\u8f7d\u5668
\nclass ResumableDownloader {
\n constructor(url, filename) {
\n this.url = url;
\n this.filename = filename;
\n this.downloadedBytes = 0;
\n this.totalBytes = 0;
\n this.isPaused = false;
\n }<\/p>\n
async start() {
\n try {
\n \/\/ \u5c1d\u8bd5\u83b7\u53d6\u6587\u4ef6\u4fe1\u606f
\n const headResponse = await fetch(this.url, { method: 'HEAD' });<\/p>\n
if (!headResponse.ok) {
\n throw new Error(`Failed to get file info: ${headResponse.status}`);
\n }<\/p>\n
this.totalBytes = parseInt(headResponse.headers.get('Content-Length')) || 0;
\n const acceptRanges = headResponse.headers.get('Accept-Ranges') === 'bytes';<\/p>\n
\/\/ \u68c0\u67e5\u672c\u5730\u5df2\u4e0b\u8f7d\u90e8\u5206
\n const downloaded = await this.getDownloadedSize();
\n this.downloadedBytes = downloaded;<\/p>\n
if (acceptRanges && downloaded > 0 && downloaded < this.totalBytes) {
\n \/\/ \u65ad\u70b9\u7eed\u4f20
\n await this.resumeDownload();
\n } else {
\n \/\/ \u5168\u65b0\u4e0b\u8f7d
\n await this.startNewDownload();
\n }
\n } catch (error) {
\n console.error('Download failed:', error);
\n throw error;
\n }
\n }<\/p>\n
async resumeDownload() {
\n const headers = {
\n 'Range': `bytes=${this.downloadedBytes}-`
\n };<\/p>\n
const response = await fetch(this.url, { headers });<\/p>\n
if (response.status === 416) {
\n \/\/ \u8303\u56f4\u65e0\u6548，\u91cd\u65b0\u5f00\u59cb
\n this.downloadedBytes = 0;
\n await this.startNewDownload();
\n return;
\n }<\/p>\n
if (response.status !== 206) {
\n throw new Error(`Unexpected status: ${response.status}`);
\n }<\/p>\n
await this.processResponse(response);
\n }<\/p>\n
async startNewDownload() {
\n const response = await fetch(this.url);<\/p>\n
if (!response.ok) {
\n throw new Error(`Download failed: ${response.status}`);
\n }<\/p>\n
this.downloadedBytes = 0;
\n await this.processResponse(response);
\n }<\/p>\n
async processResponse(response) {
\n const reader = response.body.getReader();
\n const fileStream = await this.getFileStream();<\/p>\n
while (true) {
\n if (this.isPaused) {
\n await new Promise(resolve => {
\n this.resumeCallback = resolve;
\n });
\n }<\/p>\n
const { done, value } = await reader.read();<\/p>\n
if (done) {
\n fileStream.close();
\n console.log('Download completed');
\n return;
\n }<\/p>\n
await fileStream.write(value);
\n this.downloadedBytes += value.length;<\/p>\n
\/\/ \u66f4\u65b0\u8fdb\u5ea6
\n const progress = this.totalBytes > 0
\n ? (this.downloadedBytes \/ this.totalBytes * 100).toFixed(2)
\n : 'unknown';<\/p>\n
console.log(`Progress: ${progress}%`);
\n }
\n }<\/p>\n
pause() {
\n this.isPaused = true;
\n }<\/p>\n
resume() {
\n this.isPaused = false;
\n if (this.resumeCallback) {
\n this.resumeCallback();
\n this.resumeCallback = null;
\n }
\n }<\/p>\n
async getDownloadedSize() {
\n \/\/ \u4ece\u672c\u5730\u5b58\u50a8\u83b7\u53d6\u5df2\u4e0b\u8f7d\u5927\u5c0f
\n \/\/ \u5b9e\u73b0\u53d6\u51b3\u4e8e\u5b58\u50a8\u65b9\u5f0f（IndexedDB\u3001\u6587\u4ef6\u7cfb\u7edfAPI\u7b49）
\n return 0;
\n }<\/p>\n
async getFileStream() {
\n \/\/ \u83b7\u53d6\u6587\u4ef6\u5199\u5165\u6d41
\n \/\/ \u5b9e\u73b0\u53d6\u51b3\u4e8e\u5b58\u50a8\u65b9\u5f0f
\n return {
\n write: async () => {},
\n close: () => {}
\n };
\n }
\n}<\/p>\n
\u59cb\u7ec8\u5728\u54cd\u5e94\u4e2d\u5305\u542bAccept-Ranges\u5934<\/p>\n<\/li>\n
\u5bf9\u4e8e416\u54cd\u5e94，\u5305\u542bContent-Range\u5934\u663e\u793a\u6709\u6548\u8303\u56f4<\/p>\n<\/li>\n
\u5b9e\u73b0\u5b8c\u6574\u7684\u5206\u5757\u4e0b\u8f7d\u652f\u6301<\/p>\n<\/li>\n
\u8003\u8651\u652f\u6301\u591a\u8303\u56f4\u8bf7\u6c42（multipart\/byteranges）<\/p>\n<\/li>\n<\/ul>\n
417\u72b6\u6001\u7801\u8868\u793a\u670d\u52a1\u5668\u65e0\u6cd5\u6ee1\u8db3\u8bf7\u6c42\u7684Expect\u5934\u4e2d\u7684\u671f\u671b\u3002\u6700\u5e38\u89c1\u7684\u573a\u666f\u662fExpect: 100-continue\u3002<\/p>\n
http<\/p>\n
# \u5ba2\u6237\u7aef\u8bf7\u6c42（\u4f7f\u7528100-continue）
\nPOST \/upload HTTP\/1.1
\nHost: example.com
\nContent-Type: application\/json
\nContent-Length: 1024
\nExpect: 100-continue<\/p>\n
# \u670d\u52a1\u5668\u54cd\u5e94
\n# \u60c5\u51b51：\u63a5\u53d7\u8bf7\u6c42
\nHTTP\/1.1 100 Continue<\/p>\n
# \u5ba2\u6237\u7aef\u53d1\u9001\u8bf7\u6c42\u4f53
\n{"data": "…"}<\/p>\n
# \u670d\u52a1\u5668\u6700\u7ec8\u54cd\u5e94
\nHTTP\/1.1 201 Created<\/p>\n
# \u60c5\u51b52：\u62d2\u7edd\u8bf7\u6c42
\nHTTP\/1.1 417 Expectation Failed
\nContent-Type: application\/json<\/p>\n
{
\n "error": "expectation_failed",
\n "message": "Server cannot accept the request",
\n "reason": "File size limit exceeded"
\n}<\/p>\n
\u5927\u6587\u4ef6\u4e0a\u4f20\u9a8c\u8bc1：\u68c0\u67e5\u6743\u9650\u548c\u914d\u989d\u540e\u518d\u63a5\u6536\u6570\u636e<\/p>\n<\/li>\n
\u5b9e\u65f6\u5904\u7406\u9a8c\u8bc1：\u786e\u4fdd\u670d\u52a1\u5668\u80fd\u5904\u7406\u8bf7\u6c42<\/p>\n<\/li>\n
\u6761\u4ef6\u8bf7\u6c42：\u57fa\u4e8e\u7279\u5b9a\u6761\u4ef6\u63a5\u53d7\u8bf7\u6c42<\/p>\n<\/li>\n
\u8d44\u6e90\u9884\u7559：\u68c0\u67e5\u8d44\u6e90\u53ef\u7528\u6027<\/p>\n<\/li>\n
python<\/p>\n
# FastAPI Expect\u5934\u5904\u7406
\nfrom fastapi import FastAPI, Request, HTTPException
\nfrom fastapi.responses import JSONResponse<\/p>\n
app = FastAPI()<\/p>\n
@app.middleware("http")
\nasync def handle_expect_header(request: Request, call_next):
\n expect_header = request.headers.get("expect", "").lower()<\/p>\n
if expect_header == "100-continue":
\n # \u6267\u884c\u9884\u68c0\u67e5
\n content_length = request.headers.get("content-length")<\/p>\n
if content_length and int(content_length) > 10 * 1024 * 1024: # 10MB
\n # \u8bf7\u6c42\u4f53\u592a\u5927，\u62d2\u7edd
\n return JSONResponse(
\n status_code=417,
\n content={
\n "error": "expectation_failed",
\n "message": "File size exceeds limit",
\n "max_size": 10 * 1024 * 1024,
\n "requested_size": int(content_length)
\n }
\n )<\/p>\n
# \u68c0\u67e5\u8ba4\u8bc1
\n auth_header = request.headers.get("authorization")
\n if not auth_header or not validate_token(auth_header):
\n return JSONResponse(
\n status_code=417,
\n content={
\n "error": "expectation_failed",
\n "message": "Authentication required"
\n }
\n )<\/p>\n
# \u53d1\u9001100 Continue\u54cd\u5e94
\n from starlette.responses import Response
\n response = Response(status_code=100)
\n await response(scope=request.scope, receive=request.receive, send=request.send)<\/p>\n
# \u7ee7\u7eed\u6b63\u5e38\u5904\u7406
\n response = await call_next(request)
\n return response<\/p>\n
def validate_token(token: str) -> bool:
\n # \u5b9e\u73b0\u4ee4\u724c\u9a8c\u8bc1
\n return token.startswith("Bearer ")<\/p>\n
javascript<\/p>\n
\/\/ \u4f7f\u7528Expect: 100-continue\u7684\u5ba2\u6237\u7aef
\nasync function uploadWithContinue(file, url) {
\n return new Promise((resolve, reject) => {
\n const xhr = new XMLHttpRequest();<\/p>\n
xhr.open('POST', url, true);<\/p>\n
\/\/ \u8bbe\u7f6eExpect\u5934
\n xhr.setRequestHeader('Expect', '100-continue');
\n xhr.setRequestHeader('Content-Type', 'application\/octet-stream');<\/p>\n
\/\/ \u76d1\u542c100-continue\u54cd\u5e94
\n xhr.onreadystatechange = function() {
\n if (xhr.readyState === XMLHttpRequest.HEADERS_RECEIVED) {
\n \/\/ \u68c0\u67e5\u72b6\u6001\u7801
\n if (xhr.status === 100) {
\n console.log('Server ready to receive data');
\n } else if (xhr.status === 417) {
\n reject(new Error('Server rejected the request'));
\n }
\n }
\n };<\/p>\n
xhr.onload = function() {
\n if (xhr.status >= 200 && xhr.status < 300) {
\n resolve(xhr.response);
\n } else {
\n reject(new Error(`Upload failed: ${xhr.status}`));
\n }
\n };<\/p>\n
xhr.onerror = function() {
\n reject(new Error('Network error'));
\n };<\/p>\n
xhr.send(file);
\n });
\n}<\/p>\n
\/\/ \u4f7f\u7528Fetch API（\u81ea\u52a8\u5904\u7406100-continue）
\nasync function uploadWithFetch(file, url) {
\n const response = await fetch(url, {
\n method: 'POST',
\n headers: {
\n 'Content-Type': 'application\/octet-stream',
\n \/\/ Fetch API\u4f1a\u81ea\u52a8\u5904\u7406Expect\u5934
\n },
\n body: file
\n });<\/p>\n
if (!response.ok) {
\n throw new Error(`Upload failed: ${response.status}`);
\n }<\/p>\n
return response.json();
\n}<\/p>\n
\u5bf9\u4e8e\u5927\u6587\u4ef6\u4e0a\u4f20\u5b9e\u73b0100-continue\u652f\u6301<\/p>\n<\/li>\n
\u63d0\u4f9b\u6e05\u6670\u7684\u62d2\u7edd\u539f\u56e0<\/p>\n<\/li>\n
\u8003\u8651\u8d85\u65f6\u5904\u7406（\u5ba2\u6237\u7aef\u7b49\u5f85100\u54cd\u5e94\u7684\u8d85\u65f6）<\/p>\n<\/li>\n
\u76d1\u63a7417\u9519\u8bef\u9891\u7387\u4ee5\u8bc6\u522b\u5ba2\u6237\u7aef\u95ee\u9898<\/p>\n<\/li>\n<\/ul>\n
418\u72b6\u6001\u7801\u6700\u521d\u662f1998\u5e74\u611a\u4eba\u8282\u7684RFC 2324（\u8d85\u6587\u672c\u5496\u5561\u58f6\u63a7\u5236\u534f\u8bae）\u7684\u4e00\u90e8\u5206，\u7528\u4e8e\u8868\u793a\u670d\u52a1\u5668\u662f\u4e00\u4e2a\u8336\u58f6，\u65e0\u6cd5\u716e\u5496\u5561\u3002\u867d\u7136\u6700\u521d\u662f\u73a9\u7b11，\u4f46\u5df2\u88ab\u8bb8\u591a\u670d\u52a1\u5668\u5b9e\u73b0\u5e76\u7528\u4e8e\u8868\u793a"\u8fd9\u4e2a\u7aef\u70b9\u6c38\u8fdc\u4e0d\u4f1a\u5de5\u4f5c"\u3002<\/p>\n
API\u7aef\u70b9\u5360\u4f4d\u7b26：\u8868\u793a\u5c1a\u672a\u5b9e\u73b0\u7684\u7aef\u70b9<\/p>\n<\/li>\n
\u5185\u90e8\u73a9\u7b11：\u5f00\u53d1\u56e2\u961f\u95f4\u7684\u5e7d\u9ed8<\/p>\n<\/li>\n
\u5b89\u5168\u63aa\u65bd：\u6df7\u6dc6\u653b\u51fb\u8005<\/p>\n<\/li>\n
\u590d\u6d3b\u8282\u5f69\u86cb：\u9690\u85cf\u529f\u80fd\u6216\u73a9\u7b11\u54cd\u5e94<\/p>\n<\/li>\n
python<\/p>\n
# Flask 418\u5b9e\u73b0
\nfrom flask import Flask, jsonify<\/p>\n
app = Flask(__name__)<\/p>\n
@app.route('\/brew-coffee')
\ndef brew_coffee():
\n """HTCPCP\u7aef\u70b9 – \u603b\u662f\u8fd4\u56de418"""
\n response = jsonify({
\n "error": "I'm a teapot",
\n "message": "The requested entity body is short and stout.",
\n "hint": "Tip me over and pour me out.",
\n "rfc": "https:\/\/tools.ietf.org\/html\/rfc2324",
\n "solution": "Try making tea instead."
\n })
\n response.status_code = 418
\n response.headers['X-Teapot-Type'] = 'Robust Brown Betty'
\n response.headers['X-Brewing-Time'] = '4 minutes'
\n return response<\/p>\n
@app.route('\/make-tea')
\ndef make_tea():
\n """\u6b63\u786e\u7684HTCPCP\u7aef\u70b9"""
\n return jsonify({
\n "status": "brewing",
\n "type": "Earl Grey",
\n "strength": "medium",
\n "message": "Your tea will be ready shortly."
\n })<\/p>\n
javascript<\/p>\n
\/\/ \u521b\u610f418\u9875\u9762
\nfunction createTeapotResponse() {
\n return {
\n status: 418,
\n headers: {
\n 'Content-Type': 'application\/json',
\n 'X-Teapot': 'true',
\n 'X-Brew-Advice': 'Use freshly boiled water at 95\u00b0C',
\n 'X-Tea-Type': 'Oolong'
\n },
\n body: JSON.stringify({
\n error: "I'm a teapot",
\n message: "This server is a teapot, not a coffee pot.",
\n instructions: {
\n step1: "Fill me with fresh water",
\n step2: "Heat to 95\u00b0C (203\u00b0F)",
\n step3: "Add 1 teaspoon of tea leaves per cup",
\n step4: "Steep for 3-5 minutes",
\n step5: "Pour and enjoy"
\n },
\n tea_suggestions: [
\n {
\n name: "Green Tea",
\n temperature: "80\u00b0C",
\n time: "2-3 minutes"
\n },
\n {
\n name: "Black Tea",
\n temperature: "95\u00b0C",
\n time: "3-5 minutes"
\n },
\n {
\n name: "Herbal Tea",
\n temperature: "100\u00b0C",
\n time: "5-7 minutes"
\n }
\n ],
\n fun_fact: "The 418 status code was defined in RFC 2324 (Hyper Text Coffee Pot Control Protocol) as an April Fools' joke in 1998."
\n }, null, 2)
\n };
\n}<\/p>\n
\/\/ Express\u4e2d\u95f4\u4ef6\u68c0\u6d4b418\u8bf7\u6c42
\napp.use((req, res, next) => {
\n \/\/ \u68c0\u67e5\u662f\u5426\u4e3a\u5496\u5561\u76f8\u5173\u8bf7\u6c42
\n if (req.path.includes('coffee') ||
\n req.get('X-Beverage') === 'coffee') {<\/p>\n
const teapotResponse = createTeapotResponse();<\/p>\n
res.status(teapotResponse.status);
\n Object.entries(teapotResponse.headers)
\n .forEach(([key, value]) => res.set(key, value));
\n res.send(teapotResponse.body);
\n return;
\n }<\/p>\n
next();
\n});<\/p>\n
\u8c28\u614e\u4f7f\u7528418，\u907f\u514d\u6df7\u6dc6\u771f\u6b63\u7684\u9519\u8bef<\/p>\n<\/li>\n
\u8003\u8651\u5728\u5f00\u53d1\u73af\u5883\u4f7f\u7528，\u751f\u4ea7\u73af\u5883\u7981\u7528<\/p>\n<\/li>\n
\u53ef\u4ee5\u7528\u4e8eAPI\u7248\u672c\u63a7\u5236（\u65e7\u7248\u672c\u8fd4\u56de418）<\/p>\n<\/li>\n
\u786e\u4fdd\u4e0d\u4f1a\u5f71\u54cdSEO\u6216\u722c\u866b<\/p>\n<\/li>\n<\/ul>\n
421\u72b6\u6001\u7801\u5728HTTP\/2\u4e2d\u5f15\u5165，\u8868\u793a\u8bf7\u6c42\u88ab\u53d1\u9001\u5230\u65e0\u6cd5\u751f\u6210\u54cd\u5e94\u7684\u670d\u52a1\u5668\u3002\u901a\u5e38\u53d1\u751f\u5728\u8fde\u63a5\u91cd\u7528\u548c\u670d\u52a1\u5668\u540d\u79f0\u6307\u793a（SNI）\u4e0d\u5339\u914d\u65f6\u3002<\/p>\n
HTTP\/2\u5141\u8bb8\u5728\u5355\u4e2a\u8fde\u63a5\u4e0a\u591a\u8def\u590d\u7528\u591a\u4e2a\u8bf7\u6c42\u3002\u4f46\u5f53\u5ba2\u6237\u7aef\u5c1d\u8bd5\u5728\u8fde\u63a5\u4e0a\u53d1\u9001\u9488\u5bf9\u4e0d\u540c\u4e3b\u673a\u7684\u8bf7\u6c42\u65f6，\u670d\u52a1\u5668\u53ef\u80fd\u8fd4\u56de421\u3002<\/p>\n
SNI\u662fTLS\u6269\u5c55，\u5141\u8bb8\u5ba2\u6237\u7aef\u5728\u63e1\u624b\u65f6\u6307\u5b9a\u8981\u8fde\u63a5\u7684\u4e3b\u673a\u540d\u3002\u8fd9\u5bf9\u4e8e\u865a\u62df\u4e3b\u673a\u6258\u7ba1\u81f3\u5173\u91cd\u8981\u3002<\/p>\n
text<\/p>\n
\u5ba2\u6237\u7aef \u2192 \u670d\u52a1\u5668: TLS\u63e1\u624b（SNI: api.example.com）
\n\u5ba2\u6237\u7aef \u2192 \u670d\u52a1\u5668: \u8bf7\u6c421: GET \/users (Host: api.example.com)
\n\u670d\u52a1\u5668 \u2192 \u5ba2\u6237\u7aef: 200 OK<\/p>\n
\u5ba2\u6237\u7aef \u2192 \u670d\u52a1\u5668: \u8bf7\u6c422: GET \/orders (Host: shop.example.com)
\n\u670d\u52a1\u5668 \u2192 \u5ba2\u6237\u7aef: 421 Misdirected Request
\n (\u56e0\u4e3a\u8fde\u63a5\u662f\u4e3aapi.example.com\u5efa\u7acb\u7684)<\/p>\n
nginx<\/p>\n
# Nginx\u914d\u7f6e\u5904\u7406\u591a\u4e2a\u4e3b\u673a\u540d
\nserver {
\n listen 443 ssl http2;
\n server_name api.example.com;
\n ssl_certificate \/certs\/api.example.com.crt;
\n ssl_certificate_key \/certs\/api.example.com.key;<\/p>\n
location \/ {
\n proxy_pass http:\/\/api_backend;
\n }
\n}<\/p>\n
server {
\n listen 443 ssl http2;
\n server_name shop.example.com;
\n ssl_certificate \/certs\/shop.example.com.crt;
\n ssl_certificate_key \/certs\/shop.example.com.key;<\/p>\n
location \/ {
\n proxy_pass http:\/\/shop_backend;
\n }
\n}<\/p>\n
# \u6216\u8005\u4f7f\u7528\u901a\u914d\u7b26\u8bc1\u4e66
\nserver {
\n listen 443 ssl http2;
\n server_name api.example.com shop.example.com;
\n ssl_certificate \/certs\/wildcard.example.com.crt;
\n ssl_certificate_key \/certs\/wildcard.example.com.key;<\/p>\n
# \u57fa\u4e8eHost\u5934\u8def\u7531
\n location \/ {
\n if ($host = "api.example.com") {
\n proxy_pass http:\/\/api_backend;
\n }
\n if ($host = "shop.example.com") {
\n proxy_pass http:\/\/shop_backend;
\n }
\n }
\n}<\/p>\n
javascript<\/p>\n
\/\/ HTTP\/2\u5ba2\u6237\u7aef\u8fde\u63a5\u7ba1\u7406
\nclass H2ConnectionManager {
\n constructor() {
\n this.connections = new Map(); \/\/ host -> connection
\n this.pendingRequests = new Map(); \/\/ host -> [requests]
\n }<\/p>\n
async request(host, path, options = {}) {
\n \/\/ \u68c0\u67e5\u662f\u5426\u6709\u73b0\u6709\u8fde\u63a5
\n let connection = this.connections.get(host);<\/p>\n
if (!connection) {
\n \/\/ \u521b\u5efa\u65b0\u8fde\u63a5
\n connection = await this.createConnection(host);
\n this.connections.set(host, connection);<\/p>\n
\/\/ \u76d1\u542c\u8fde\u63a5\u9519\u8bef
\n connection.on('error', (error) => {
\n console.error(`Connection to ${host} failed:`, error);
\n this.connections.delete(host);
\n });<\/p>\n
\/\/ \u76d1\u542c421\u9519\u8bef
\n connection.on('stream', (stream) => {
\n stream.on('response', (headers) => {
\n if (headers[':status'] === '421') {
\n console.log(`Received 421 for ${host}, closing connection`);
\n connection.close();
\n this.connections.delete(host);<\/p>\n
\/\/ \u91cd\u8bd5\u5f85\u5904\u7406\u8bf7\u6c42
\n this.retryPendingRequests(host);
\n }
\n });
\n });
\n }<\/p>\n
\/\/ \u53d1\u9001\u8bf7\u6c42
\n return new Promise((resolve, reject) => {
\n const stream = connection.request({
\n ':method': options.method || 'GET',
\n ':path': path,
\n ':authority': host,
\n …options.headers
\n });<\/p>\n
stream.on('response', (headers) => {
\n const chunks = [];<\/p>\n
stream.on('data', (chunk) => {
\n chunks.push(chunk);
\n });<\/p>\n
stream.on('end', () => {
\n const response = {
\n status: headers[':status'],
\n headers,
\n body: Buffer.concat(chunks)
\n };
\n resolve(response);
\n });<\/p>\n
stream.on('error', reject);
\n });<\/p>\n
if (options.body) {
\n stream.end(options.body);
\n } else {
\n stream.end();
\n }
\n });
\n }<\/p>\n
async createConnection(host) {
\n \/\/ \u5b9e\u73b0HTTP\/2\u8fde\u63a5\u521b\u5efa
\n \/\/ \u6ce8\u610f：\u9700\u8981\u9002\u5f53\u7684HTTP\/2\u5ba2\u6237\u7aef\u5e93
\n throw new Error('Not implemented');
\n }<\/p>\n
retryPendingRequests(host) {
\n const pending = this.pendingRequests.get(host) || [];
\n this.pendingRequests.delete(host);<\/p>\n
pending.forEach(request => {
\n this.request(host, request.path, request.options)
\n .then(request.resolve)
\n .catch(request.reject);
\n });
\n }
\n}<\/p>\n
\u4e3a\u4e0d\u540c\u4e3b\u673a\u540d\u4f7f\u7528\u901a\u914d\u7b26\u6216\u591a\u57df\u540d\u8bc1\u4e66<\/p>\n<\/li>\n
\u5ba2\u6237\u7aef\u6b63\u786e\u7ba1\u7406HTTP\/2\u8fde\u63a5\u6c60<\/p>\n<\/li>\n
\u76d1\u63a7421\u9519\u8bef\u4ee5\u8bc6\u522b\u914d\u7f6e\u95ee\u9898<\/p>\n<\/li>\n
\u8003\u8651\u4f7f\u7528HTTP\/1.1\u4f5c\u4e3a\u5907\u7528\u65b9\u6848<\/p>\n<\/li>\n<\/ul>\n
422\u72b6\u6001\u7801\u6765\u81eaWebDAV\u89c4\u8303，\u8868\u793a\u670d\u52a1\u5668\u7406\u89e3\u8bf7\u6c42\u5b9e\u4f53\u7684\u5185\u5bb9\u7c7b\u578b，\u4e14\u8bed\u6cd5\u6b63\u786e，\u4f46\u65e0\u6cd5\u5904\u7406\u5176\u4e2d\u5305\u542b\u7684\u6307\u4ee4\u3002\u5e38\u7528\u4e8e\u9a8c\u8bc1\u9519\u8bef\u3002<\/p>\n
400 Bad Request：\u8bf7\u6c42\u8bed\u6cd5\u9519\u8bef\u6216\u65e0\u6cd5\u89e3\u6790<\/p>\n<\/li>\n
422 Unprocessable Entity：\u8bf7\u6c42\u8bed\u6cd5\u6b63\u786e，\u4f46\u8bed\u4e49\u9519\u8bef<\/p>\n<\/li>\n<\/ul>\n
json<\/p>\n
\/\/ \u8bf7\u6c42
\nPOST \/api\/users HTTP\/1.1
\nContent-Type: application\/json<\/p>\n
{
\n "email": "invalid-email",
\n "age": -5,
\n "password": "123"
\n}<\/p>\n
\/\/ \u54cd\u5e94
\nHTTP\/1.1 422 Unprocessable Entity
\nContent-Type: application\/problem+json<\/p>\n
{
\n "type": "https:\/\/example.com\/errors\/validation",
\n "title": "Validation Failed",
\n "status": 422,
\n "detail": "The request contains validation errors",
\n "instance": "\/api\/users",
\n "errors": [
\n {
\n "field": "email",
\n "code": "invalid_format",
\n "message": "Must be a valid email address",
\n "value": "invalid-email"
\n },
\n {
\n "field": "age",
\n "code": "minimum",
\n "message": "Must be greater than 0",
\n "value": -5,
\n "constraint": 0
\n },
\n {
\n "field": "password",
\n "code": "min_length",
\n "message": "Must be at least 8 characters",
\n "value": "123",
\n "constraint": 8
\n }
\n ]
\n}<\/p>\n
python<\/p>\n
# FastAPI\u9a8c\u8bc1\u9519\u8bef\u5904\u7406
\nfrom fastapi import FastAPI, HTTPException, Request
\nfrom fastapi.responses import JSONResponse
\nfrom pydantic import BaseModel, EmailStr, validator
\nfrom typing import List<\/p>\n
app = FastAPI()<\/p>\n
class UserCreate(BaseModel):
\n email: EmailStr
\n age: int
\n password: str<\/p>\n
@validator('age')
\n def age_must_be_positive(cls, v):
\n if v <= 0:
\n raise ValueError('age must be positive')
\n return v<\/p>\n
@validator('password')
\n def password_length(cls, v):
\n if len(v) < 8:
\n raise ValueError('password must be at least 8 characters')
\n return v<\/p>\n
@app.exception_handler(ValueError)
\nasync def validation_exception_handler(request: Request, exc: ValueError):
\n # \u5c06\u9a8c\u8bc1\u9519\u8bef\u8f6c\u6362\u4e3a422\u54cd\u5e94
\n return JSONResponse(
\n status_code=422,
\n content={
\n "detail": str(exc),
\n "errors": [
\n {
\n "loc": ["body"],
\n "msg": str(exc),
\n "type": "value_error"
\n }
\n ]
\n }
\n )<\/p>\n
@app.post("\/users\/")
\nasync def create_user(user: UserCreate):
\n # \u5982\u679c\u9a8c\u8bc1\u901a\u8fc7，\u521b\u5efa\u7528\u6237
\n return {"message": "User created", "user": user.dict()}<\/p>\n
# \u66f4\u7cbe\u7ec6\u7684\u9519\u8bef\u5904\u7406
\nfrom pydantic import ValidationError<\/p>\n
@app.exception_handler(ValidationError)
\nasync def pydantic_validation_handler(request: Request, exc: ValidationError):
\n errors = []<\/p>\n
for error in exc.errors():
\n errors.append({
\n "field": ".".join(str(loc) for loc in error["loc"]),
\n "code": error["type"],
\n "message": error["msg"],
\n "context": error.get("ctx")
\n })<\/p>\n
return JSONResponse(
\n status_code=422,
\n content={
\n "error": "validation_failed",
\n "message": "The request contains validation errors",
\n "errors": errors
\n }
\n )<\/p>\n
javascript<\/p>\n
\/\/ \u524d\u7aef\u8868\u5355\u9a8c\u8bc1\u548c422\u9519\u8bef\u5904\u7406
\nclass FormValidator {
\n constructor(formId) {
\n this.form = document.getElementById(formId);
\n this.errorsContainer = document.createElement('div');
\n this.errorsContainer.className = 'validation-errors';
\n this.form.parentNode.insertBefore(this.errorsContainer, this.form);<\/p>\n
this.form.addEventListener('submit', this.handleSubmit.bind(this));
\n }<\/p>\n
async handleSubmit(event) {
\n event.preventDefault();<\/p>\n
\/\/ \u6e05\u9664\u4e4b\u524d\u7684\u9519\u8bef
\n this.clearErrors();<\/p>\n
\/\/ \u6536\u96c6\u8868\u5355\u6570\u636e
\n const formData = new FormData(this.form);
\n const data = Object.fromEntries(formData.entries());<\/p>\n
try {
\n const response = await fetch(this.form.action, {
\n method: this.form.method,
\n headers: {
\n 'Content-Type': 'application\/json'
\n },
\n body: JSON.stringify(data)
\n });<\/p>\n
if (response.status === 422) {
\n \/\/ \u5904\u7406\u9a8c\u8bc1\u9519\u8bef
\n const result = await response.json();
\n this.displayErrors(result.errors);
\n return;
\n }<\/p>\n
if (!response.ok) {
\n throw new Error(`Request failed: ${response.status}`);
\n }<\/p>\n
\/\/ \u6210\u529f\u5904\u7406
\n const result = await response.json();
\n this.onSuccess(result);<\/p>\n
} catch (error) {
\n console.error('Form submission error:', error);
\n this.displayGenericError(error.message);
\n }
\n }<\/p>\n
displayErrors(errors) {
\n this.errorsContainer.innerHTML = '';<\/p>\n
\/\/ \u6309\u5b57\u6bb5\u5206\u7ec4\u9519\u8bef
\n const fieldErrors = {};<\/p>\n
errors.forEach(error => {
\n if (!fieldErrors[error.field]) {
\n fieldErrors[error.field] = [];
\n }
\n fieldErrors[error.field].push(error.message);
\n });<\/p>\n
\/\/ \u663e\u793a\u9519\u8bef
\n Object.entries(fieldErrors).forEach(([field, messages]) => {
\n const fieldElement = this.form.querySelector(`[name="${field}"]`);
\n if (fieldElement) {
\n \/\/ \u6dfb\u52a0\u9519\u8bef\u7c7b
\n fieldElement.classList.add('error');<\/p>\n
\/\/ \u521b\u5efa\u9519\u8bef\u6d88\u606f
\n const errorElement = document.createElement('div');
\n errorElement.className = 'field-error';
\n errorElement.textContent = messages.join(', ');<\/p>\n
fieldElement.parentNode.appendChild(errorElement);
\n }<\/p>\n
\/\/ \u6dfb\u52a0\u5230\u9519\u8bef\u5bb9\u5668
\n const errorSummary = document.createElement('div');
\n errorSummary.className = 'error-summary';
\n errorSummary.innerHTML = `
\n <strong>${field}:<\/strong>
\n <ul>
\n ${messages.map(msg => `<li>${msg}<\/li>`).join('')}
\n <\/ul>
\n `;
\n this.errorsContainer.appendChild(errorSummary);
\n });<\/p>\n
\/\/ \u6eda\u52a8\u5230\u9519\u8bef
\n this.errorsContainer.scrollIntoView({ behavior: 'smooth' });
\n }<\/p>\n
clearErrors() {
\n \/\/ \u6e05\u9664\u5b57\u6bb5\u9519\u8bef\u6837\u5f0f
\n this.form.querySelectorAll('.error').forEach(el => {
\n el.classList.remove('error');
\n });<\/p>\n
\/\/ \u79fb\u9664\u9519\u8bef\u6d88\u606f
\n this.form.querySelectorAll('.field-error').forEach(el => {
\n el.remove();
\n });<\/p>\n
\/\/ \u6e05\u7a7a\u9519\u8bef\u5bb9\u5668
\n this.errorsContainer.innerHTML = '';
\n }<\/p>\n
displayGenericError(message) {
\n this.errorsContainer.innerHTML = `
\n <div class="alert alert-danger">
\n <strong>Error:<\/strong> ${message}
\n <\/div>
\n `;
\n }<\/p>\n
onSuccess(result) {
\n \/\/ \u6210\u529f\u56de\u8c03
\n console.log('Form submitted successfully:', result);
\n this.form.reset();
\n this.clearErrors();<\/p>\n
alert('Form submitted successfully!');
\n }
\n}<\/p>\n
\u63d0\u4f9b\u8be6\u7ec6\u7684\u9a8c\u8bc1\u9519\u8bef\u4fe1\u606f<\/p>\n<\/li>\n
\u4f7f\u7528\u6807\u51c6\u9519\u8bef\u683c\u5f0f（\u5982RFC 7807）<\/p>\n<\/li>\n
\u5b9e\u73b0\u5ba2\u6237\u7aef\u9a8c\u8bc1\u4ee5\u51cf\u5c11422\u8bf7\u6c42<\/p>\n<\/li>\n
\u8003\u8651\u4f7f\u7528JSON Schema\u8fdb\u884c\u9a8c\u8bc1<\/p>\n<\/li>\n<\/ul>\n
423\u72b6\u6001\u7801\u6765\u81eaWebDAV\u89c4\u8303，\u8868\u793a\u8bf7\u6c42\u7684\u8d44\u6e90\u88ab\u9501\u5b9a\u3002\u5ba2\u6237\u7aef\u5e94\u7b49\u5f85\u9501\u91ca\u653e\u6216\u8054\u7cfb\u9501\u6301\u6709\u8005\u3002<\/p>\n
\u72ec\u5360\u9501：\u53ea\u6709\u4e00\u4e2a\u5ba2\u6237\u7aef\u53ef\u4fee\u6539\u8d44\u6e90<\/p>\n<\/li>\n
\u5171\u4eab\u9501：\u591a\u4e2a\u5ba2\u6237\u7aef\u53ef\u8bfb\u53d6，\u4f46\u53ea\u6709\u4e00\u4e2a\u53ef\u5199\u5165<\/p>\n<\/li>\n
\u6df1\u5ea6\u9501：\u9501\u4f4f\u8d44\u6e90\u53ca\u5176\u6240\u6709\u5b50\u8d44\u6e90<\/p>\n<\/li>\n
http<\/p>\n
# \u9501\u5b9a\u8bf7\u6c42
\nLOCK \/document.txt HTTP\/1.1
\nHost: example.com
\nTimeout: Infinite, Second-3600
\nDepth: infinity
\nContent-Type: application\/xml<\/p>\n
<?xml version="1.0" encoding="utf-8" ?>
\n<D:lockinfo xmlns:D="DAV:">
\n <D:lockscope><D:exclusive\/><\/D:lockscope>
\n <D:locktype><D:write\/><\/D:locktype>
\n <D:owner>
\n <D:href>mailto:user@example.com<\/D:href>
\n <\/D:owner>
\n<\/D:lockinfo><\/p>\n
# \u9501\u5b9a\u54cd\u5e94
\nHTTP\/1.1 200 OK
\nContent-Type: application\/xml<\/p>\n
<?xml version="1.0" encoding="utf-8" ?>
\n<D:prop xmlns:D="DAV:">
\n <D:lockdiscovery>
\n <D:activelock>
\n <D:locktype><D:write\/><\/D:locktype>
\n <D:lockscope><D:exclusive\/><\/D:lockscope>
\n <D:depth>infinity<\/D:depth>
\n <D:owner>
\n <D:href>mailto:user@example.com<\/D:href>
\n <\/D:owner>
\n <D:locktoken>
\n <D:href>urn:uuid:e71d4fae-5dec-11d0-a765-00a0c91e6bf6<\/D:href>
\n <\/D:locktoken>
\n <D:timeout>Second-3600<\/D:timeout>
\n <\/D:activelock>
\n <\/D:lockdiscovery>
\n<\/D:prop><\/p>\n
# \u5c1d\u8bd5\u4fee\u6539\u5df2\u9501\u5b9a\u7684\u8d44\u6e90
\nPUT \/document.txt HTTP\/1.1
\nHost: example.com
\nIf: <urn:uuid:e71d4fae-5dec-11d0-a765-00a0c91e6bf6>
\nContent-Type: text\/plain<\/p>\n
New content<\/p>\n
# \u54cd\u5e94（\u5982\u679c\u6ca1\u6709\u6b63\u786e\u7684\u9501\u4ee4\u724c）
\nHTTP\/1.1 423 Locked
\nContent-Type: application\/xml<\/p>\n
<?xml version="1.0" encoding="utf-8" ?>
\n<D:error xmlns:D="DAV:">
\n <D:lock-token-submitted>
\n <D:href>\/document.txt<\/D:href>
\n <\/D:lock-token-submitted>
\n<\/D:error><\/p>\n
python<\/p>\n
# Flask\u8d44\u6e90\u9501\u5b9e\u73b0
\nfrom flask import Flask, request, jsonify
\nimport threading
\nimport time
\nimport uuid
\nfrom datetime import datetime, timedelta<\/p>\n
app = Flask(__name__)<\/p>\n
class ResourceLock:
\n def __init__(self):
\n self.locks = {}
\n self.lock = threading.Lock()<\/p>\n
def acquire(self, resource_id, client_id, timeout=300):
\n """\u83b7\u53d6\u8d44\u6e90\u9501"""
\n with self.lock:
\n current_time = datetime.now()<\/p>\n
# \u68c0\u67e5\u662f\u5426\u5df2\u9501\u5b9a
\n if resource_id in self.locks:
\n lock_info = self.locks[resource_id]<\/p>\n
# \u68c0\u67e5\u9501\u662f\u5426\u8fc7\u671f
\n if lock_info['expires'] < current_time:
\n # \u9501\u5df2\u8fc7\u671f，\u53ef\u4ee5\u83b7\u53d6
\n pass
\n elif lock_info['client_id'] == client_id:
\n # \u540c\u4e00\u5ba2\u6237\u7aef，\u66f4\u65b0\u8d85\u65f6
\n lock_info['expires'] = current_time + timedelta(seconds=timeout)
\n return True
\n else:
\n # \u8d44\u6e90\u88ab\u5176\u4ed6\u5ba2\u6237\u7aef\u9501\u5b9a
\n return False<\/p>\n
# \u83b7\u53d6\u65b0\u9501
\n lock_token = str(uuid.uuid4())
\n self.locks[resource_id] = {
\n 'client_id': client_id,
\n 'token': lock_token,
\n 'created': current_time,
\n 'expires': current_time + timedelta(seconds=timeout),
\n 'timeout': timeout
\n }<\/p>\n
return lock_token<\/p>\n
def release(self, resource_id, client_id=None, token=None):
\n """\u91ca\u653e\u8d44\u6e90\u9501"""
\n with self.lock:
\n if resource_id not in self.locks:
\n return True<\/p>\n
lock_info = self.locks[resource_id]<\/p>\n
# \u68c0\u67e5\u6743\u9650
\n if client_id and lock_info['client_id'] != client_id:
\n return False<\/p>\n
if token and lock_info['token'] != token:
\n return False<\/p>\n
# \u91ca\u653e\u9501
\n del self.locks[resource_id]
\n return True<\/p>\n
def check(self, resource_id, token=None):
\n """\u68c0\u67e5\u8d44\u6e90\u662f\u5426\u88ab\u9501\u5b9a"""
\n with self.lock:
\n if resource_id not in self.locks:
\n return True<\/p>\n
lock_info = self.locks[resource_id]<\/p>\n
# \u68c0\u67e5\u662f\u5426\u8fc7\u671f
\n if lock_info['expires'] < datetime.now():
\n del self.locks[resource_id]
\n return True<\/p>\n
# \u68c0\u67e5\u4ee4\u724c
\n if token and lock_info['token'] == token:
\n return True<\/p>\n
return False<\/p>\n
# \u5168\u5c40\u9501\u7ba1\u7406\u5668
\nlock_manager = ResourceLock()<\/p>\n
@app.route('\/api\/documents\/<document_id>\/lock', methods=['POST'])
\ndef lock_document(document_id):
\n """\u9501\u5b9a\u6587\u6863"""
\n client_id = request.headers.get('X-Client-ID')
\n if not client_id:
\n return jsonify({'error': 'client_id_required'}), 400<\/p>\n
timeout = request.json.get('timeout', 300)<\/p>\n
# \u5c1d\u8bd5\u83b7\u53d6\u9501
\n result = lock_manager.acquire(document_id, client_id, timeout)<\/p>\n
if result is True:
\n # \u5df2\u6301\u6709\u9501
\n return jsonify({'status': 'already_locked'}), 200
\n elif result is False:
\n # \u88ab\u5176\u4ed6\u5ba2\u6237\u7aef\u9501\u5b9a
\n lock_info = get_lock_info(document_id)
\n return jsonify({
\n 'error': 'resource_locked',
\n 'message': 'Document is locked by another client',
\n 'locked_by': lock_info['client_id'],
\n 'expires_at': lock_info['expires'].isoformat()
\n }), 423
\n else:
\n # \u6210\u529f\u83b7\u53d6\u9501
\n return jsonify({
\n 'lock_token': result,
\n 'timeout': timeout,
\n 'expires_in': timeout
\n }), 200<\/p>\n
@app.route('\/api\/documents\/<document_id>', methods=['PUT'])
\ndef update_document(document_id):
\n """\u66f4\u65b0\u6587\u6863（\u9700\u8981\u9501）"""
\n lock_token = request.headers.get('X-Lock-Token')<\/p>\n
# \u68c0\u67e5\u9501
\n if not lock_manager.check(document_id, lock_token):
\n return jsonify({
\n 'error': 'resource_locked',
\n 'message': 'Document is locked. Provide valid lock token.',
\n 'required_header': 'X-Lock-Token'
\n }), 423<\/p>\n
# \u66f4\u65b0\u6587\u6863\u903b\u8f91
\n # …<\/p>\n
return jsonify({'status': 'updated'}), 200<\/p>\n
def get_lock_info(resource_id):
\n """\u83b7\u53d6\u9501\u4fe1\u606f（\u7b80\u5316\u5b9e\u73b0）"""
\n # \u5b9e\u9645\u5b9e\u73b0\u9700\u8981\u7ebf\u7a0b\u5b89\u5168\u5730\u8bbf\u95eelock_manager
\n return {'client_id': 'unknown', 'expires': datetime.now()}<\/p>\n
\u5b9e\u73b0\u9501\u8d85\u65f6\u673a\u5236\u9632\u6b62\u6b7b\u9501<\/p>\n<\/li>\n
\u63d0\u4f9b\u9501\u4ee4\u724c\u4ee5\u4fbf\u5ba2\u6237\u7aef\u540e\u7eed\u64cd\u4f5c<\/p>\n<\/li>\n
\u652f\u6301\u9501\u67e5\u8be2\u548c\u91ca\u653e\u64cd\u4f5c<\/p>\n<\/li>\n
\u8003\u8651\u5206\u5e03\u5f0f\u9501\u65b9\u6848（\u5982Redis）<\/p>\n<\/li>\n<\/ul>\n
424\u72b6\u6001\u7801\u6765\u81eaWebDAV\u89c4\u8303，\u8868\u793a\u8bf7\u6c42\u7684\u64cd\u4f5c\u4f9d\u8d56\u4e8e\u53e6\u4e00\u4e2a\u64cd\u4f5c，\u4e14\u90a3\u4e2a\u64cd\u4f5c\u5931\u8d25\u3002\u7528\u4e8e\u4e8b\u52a1\u6027\u64cd\u4f5c\u6216\u591a\u8d44\u6e90\u64cd\u4f5c\u3002<\/p>\n
\u6279\u91cf\u64cd\u4f5c：\u90e8\u5206\u64cd\u4f5c\u5931\u8d25\u5bfc\u81f4\u6574\u4f53\u5931\u8d25<\/p>\n<\/li>\n
\u4e8b\u52a1\u5904\u7406：\u6570\u636e\u5e93\u4e8b\u52a1\u56de\u6eda<\/p>\n<\/li>\n
\u6587\u4ef6\u64cd\u4f5c：\u79fb\u52a8\u5305\u542b\u591a\u4e2a\u6587\u4ef6\u7684\u6587\u4ef6\u5939<\/p>\n<\/li>\n
API\u7ec4\u5408：\u8c03\u7528\u591a\u4e2a\u5fae\u670d\u52a1<\/p>\n<\/li>\n
python<\/p>\n
# Django\u4e8b\u52a1\u6027\u64cd\u4f5c
\nfrom django.db import transaction
\nfrom django.http import JsonResponse
\nfrom django.views import View
\nimport logging<\/p>\n
logger = logging.getLogger(__name__)<\/p>\n
class BatchCreateView(View):
\n @transaction.atomic
\n def post(self, request):
\n data = request.json
\n created_resources = []
\n errors = []<\/p>\n
# \u521b\u5efa\u4fdd\u5b58\u70b9
\n sid = transaction.savepoint()<\/p>\n
try:
\n for item in data['items']:
\n try:
\n # \u521b\u5efa\u8d44\u6e90
\n resource = self.create_resource(item)
\n created_resources.append(resource)<\/p>\n
except ValidationError as e:
\n # \u5355\u4e2a\u8d44\u6e90\u521b\u5efa\u5931\u8d25
\n errors.append({
\n 'item': item,
\n 'error': str(e),
\n 'field': getattr(e, 'field', None)
\n })
\n # \u56de\u6eda\u5230\u4fdd\u5b58\u70b9
\n transaction.savepoint_rollback(sid)
\n raise BatchOperationError(f"Failed to create item: {item}")<\/p>\n
# \u6240\u6709\u64cd\u4f5c\u6210\u529f，\u63d0\u4ea4\u4e8b\u52a1
\n transaction.savepoint_commit(sid)<\/p>\n
return JsonResponse({
\n 'status': 'success',
\n 'created': len(created_resources),
\n 'resources': created_resources
\n })<\/p>\n
except BatchOperationError as e:
\n # \u8fd4\u56de424\u54cd\u5e94
\n return JsonResponse({
\n 'error': 'failed_dependency',
\n 'message': 'Batch operation failed due to dependency errors',
\n 'details': errors,
\n 'successful_count': len(created_resources),
\n 'failed_count': len(errors)
\n }, status=424)<\/p>\n
except Exception as e:
\n # \u5176\u4ed6\u9519\u8bef
\n logger.error(f"Batch operation failed: {e}")
\n return JsonResponse({
\n 'error': 'internal_error',
\n 'message': 'Internal server error'
\n }, status=500)<\/p>\n
def create_resource(self, item):
\n # \u5b9e\u73b0\u8d44\u6e90\u521b\u5efa\u903b\u8f91
\n # \u53ef\u80fd\u629b\u51faValidationError
\n pass<\/p>\n
class BatchOperationError(Exception):
\n pass<\/p>\n
javascript<\/p>\n
\/\/ \u5fae\u670d\u52a1\u7f16\u6392\u4e2d\u7684\u4f9d\u8d56\u5931\u8d25\u5904\u7406
\nclass Orchestrator {
\n async processOrder(order) {
\n const steps = [
\n this.validateOrder.bind(this, order),
\n this.reserveInventory.bind(this, order),
\n this.processPayment.bind(this, order),
\n this.shipOrder.bind(this, order),
\n this.sendConfirmation.bind(this, order)
\n ];<\/p>\n
const results = [];
\n const errors = [];<\/p>\n
for (let i = 0; i < steps.length; i++) {
\n try {
\n const result = await steps[i]();
\n results.push({
\n step: i + 1,
\n success: true,
\n result
\n });
\n } catch (error) {
\n errors.push({
\n step: i + 1,
\n success: false,
\n error: error.message,
\n dependency_failed: i > 0 ? i : null
\n });<\/p>\n
\/\/ \u5982\u679c\u4f9d\u8d56\u6b65\u9aa4\u5931\u8d25，\u540e\u7eed\u6b65\u9aa4\u65e0\u6cd5\u6267\u884c
\n if (i > 0) {
\n \/\/ \u8865\u507f\u5df2\u5b8c\u6210\u7684\u6b65\u9aa4
\n await this.compensate(results.slice(0, i));<\/p>\n
return {
\n status: 'failed',
\n error_type: 'dependency_failed',
\n status_code: 424,
\n completed_steps: results.length,
\n failed_step: i + 1,
\n errors,
\n compensation_status: 'executed'
\n };
\n }<\/p>\n
\/\/ \u7b2c\u4e00\u6b65\u5931\u8d25，\u76f4\u63a5\u8fd4\u56de\u9519\u8bef
\n return {
\n status: 'failed',
\n error_type: 'initial_failure',
\n status_code: 400,
\n failed_step: 1,
\n error: error.message
\n };
\n }
\n }<\/p>\n
return {
\n status: 'success',
\n results
\n };
\n }<\/p>\n
async compensate(completedSteps) {
\n \/\/ \u6267\u884c\u8865\u507f\u64cd\u4f5c
\n for (const step of completedSteps.reverse()) {
\n try {
\n await this.reverseStep(step);
\n } catch (error) {
\n console.error(`Compensation failed for step ${step.step}:`, error);
\n }
\n }
\n }<\/p>\n
async reverseStep(step) {
\n \/\/ \u5b9e\u73b0\u6b65\u9aa4\u56de\u6eda\u903b\u8f91
\n switch (step.step) {
\n case 2: \/\/ \u5e93\u5b58\u9884\u7559
\n await this.releaseInventory(step.result.inventory_id);
\n break;
\n case 3: \/\/ \u652f\u4ed8\u5904\u7406
\n await this.refundPayment(step.result.payment_id);
\n break;
\n \/\/ \u5176\u4ed6\u6b65\u9aa4\u7684\u56de\u6eda…
\n }
\n }
\n}<\/p>\n
\u5b9e\u73b0\u539f\u5b50\u64cd\u4f5c\u6216\u4e8b\u52a1\u8865\u507f<\/p>\n<\/li>\n
\u63d0\u4f9b\u8be6\u7ec6\u7684\u5931\u8d25\u4f9d\u8d56\u4fe1\u606f<\/p>\n<\/li>\n
\u8bbe\u8ba1\u5e42\u7b49\u64cd\u4f5c\u4ee5\u4fbf\u91cd\u8bd5<\/p>\n<\/li>\n
\u76d1\u63a7\u4f9d\u8d56\u5931\u8d25\u7387\u4ee5\u8bc6\u522b\u7cfb\u7edf\u5f31\u70b9<\/p>\n<\/li>\n<\/ul>\n
425\u72b6\u6001\u7801\u6765\u81eaRFC 8470，\u8868\u793a\u670d\u52a1\u5668\u4e0d\u613f\u610f\u5904\u7406\u8bf7\u6c42，\u56e0\u4e3a\u5b83\u53ef\u80fd\u88ab\u91cd\u653e\u3002\u7528\u4e8e\u9632\u6b62\u91cd\u653e\u653b\u51fb，\u7279\u522b\u662f\u57280-RTT（\u96f6\u5f80\u8fd4\u65f6\u95f4）TLS\u8fde\u63a5\u4e2d\u3002<\/p>\n
TLS 1.3\u5f15\u5165\u4e860-RTT\u7279\u6027，\u5141\u8bb8\u5ba2\u6237\u7aef\u5728TLS\u63e1\u624b\u5b8c\u6210\u524d\u53d1\u9001\u6570\u636e\u3002\u8fd9\u5e26\u6765\u4e86\u91cd\u653e\u653b\u51fb\u7684\u98ce\u9669\u3002<\/p>\n
python<\/p>\n
# Flask 0-RTT\u8bf7\u6c42\u5904\u7406
\nfrom flask import Flask, request, jsonify
\nimport hashlib
\nimport time
\nfrom collections import deque<\/p>\n
app = Flask(__name__)<\/p>\n
class ReplayProtection:
\n def __init__(self, window_size=300): # 5\u5206\u949f\u7a97\u53e3
\n self.window_size = window_size
\n self.seen_requests = deque(maxlen=10000)<\/p>\n
def is_replay(self, request_data, client_id):
\n """\u68c0\u67e5\u662f\u5426\u4e3a\u91cd\u653e\u8bf7\u6c42"""
\n # \u521b\u5efa\u8bf7\u6c42\u6307\u7eb9
\n fingerprint = self.create_fingerprint(request_data, client_id)<\/p>\n
# \u68c0\u67e5\u662f\u5426\u5df2\u89c1\u8fc7
\n if fingerprint in self.seen_requests:
\n return True<\/p>\n
# \u6dfb\u52a0\u5230\u5df2\u89c1\u5217\u8868
\n self.seen_requests.append(fingerprint)<\/p>\n
# \u6e05\u7406\u8fc7\u671f\u6307\u7eb9（\u7b80\u5316\u5b9e\u73b0）
\n if len(self.seen_requests) % 100 == 0:
\n self.cleanup()<\/p>\n
return False<\/p>\n
def create_fingerprint(self, request_data, client_id):
\n """\u521b\u5efa\u8bf7\u6c42\u6307\u7eb9"""
\n components = [
\n client_id,
\n str(time.time() \/\/ self.window_size), # \u65f6\u95f4\u7a97\u53e3
\n request.method,
\n request.path,
\n hashlib.sha256(request.get_data()).hexdigest()[:16]
\n ]<\/p>\n
return hashlib.sha256('|'.join(components).encode()).hexdigest()<\/p>\n
def cleanup(self):
\n """\u6e05\u7406\u8fc7\u671f\u6307\u7eb9（\u7b80\u5316）"""
\n # \u5b9e\u9645\u5b9e\u73b0\u9700\u8981\u57fa\u4e8e\u65f6\u95f4\u6233\u6e05\u7406
\n pass<\/p>\n
replay_protection = ReplayProtection()<\/p>\n
@app.before_request
\ndef check_replay():
\n # \u68c0\u67e5\u662f\u5426\u4e3a0-RTT\u8bf7\u6c42
\n early_data = request.headers.get('Early-Data') == '1'<\/p>\n
if early_data:
\n # \u63d0\u53d6\u5ba2\u6237\u7aef\u6807\u8bc6
\n client_id = request.headers.get('X-Client-ID') or request.remote_addr<\/p>\n
# \u68c0\u67e5\u91cd\u653e
\n if replay_protection.is_replay(request, client_id):
\n return jsonify({
\n 'error': 'too_early',
\n 'message': 'Request may be replayed',
\n 'retry_after': 1,
\n 'hint': 'Wait 1 second and retry without early data'
\n }), 425<\/p>\n
@app.route('\/api\/order', methods=['POST'])
\ndef create_order():
\n # \u68c0\u67e5\u662f\u5426\u4e3a0-RTT\u8bf7\u6c42
\n early_data = request.headers.get('Early-Data') == '1'<\/p>\n
if early_data:
\n # \u5bf9\u4e8e0-RTT\u8bf7\u6c42，\u53ea\u5141\u8bb8\u5e42\u7b49\u64cd\u4f5c
\n # \u6216\u8005\u6267\u884c\u989d\u5916\u9a8c\u8bc1
\n return jsonify({
\n 'status': 'accepted_with_caution',
\n 'message': 'Order accepted via 0-RTT, additional verification may be required',
\n 'order_id': generate_order_id(),
\n 'warning': 'This request was sent via 0-RTT TLS'
\n })<\/p>\n
# \u6b63\u5e38\u8bf7\u6c42\u5904\u7406
\n return jsonify({
\n 'status': 'created',
\n 'order_id': generate_order_id()
\n })<\/p>\n
def generate_order_id():
\n import uuid
\n return str(uuid.uuid4())<\/p>\n
javascript<\/p>\n
\/\/ \u652f\u63010-RTT\u7684\u5ba2\u6237\u7aef
\nclass EarlyDataClient {
\n constructor(baseURL) {
\n this.baseURL = baseURL;
\n this.earlyDataSupported = false;
\n this.earlyDataAttempts = new Map(); \/\/ requestId -> timestamp
\n }<\/p>\n
async request(endpoint, options = {}) {
\n const requestId = this.generateRequestId();
\n const url = `${this.baseURL}${endpoint}`;<\/p>\n
\/\/ \u68c0\u67e5\u662f\u5426\u652f\u63010-RTT
\n if (this.earlyDataSupported && this.isIdempotent(options.method)) {
\n \/\/ \u5c1d\u8bd50-RTT\u8bf7\u6c42
\n try {
\n const earlyOptions = {
\n …options,
\n headers: {
\n …options.headers,
\n 'Early-Data': '1',
\n 'X-Request-ID': requestId
\n }
\n };<\/p>\n
this.earlyDataAttempts.set(requestId, Date.now());<\/p>\n
const response = await fetch(url, earlyOptions);<\/p>\n
if (response.status === 425) {
\n \/\/ \u592a\u65e9，\u9700\u8981\u91cd\u8bd5
\n console.log('Received 425 Too Early, retrying without early data');<\/p>\n
\/\/ \u79fb\u9664Early-Data\u5934
\n const retryOptions = { …options };
\n if (retryOptions.headers) {
\n delete retryOptions.headers['Early-Data'];
\n }<\/p>\n
\/\/ \u7b49\u5f85\u5efa\u8bae\u7684\u65f6\u95f4
\n const retryAfter = response.headers.get('Retry-After');
\n if (retryAfter) {
\n await this.delay(parseInt(retryAfter) * 1000);
\n }<\/p>\n
return this.requestWithoutEarlyData(url, retryOptions);
\n }<\/p>\n
\/\/ \u68c0\u67e5\u662f\u5426\u4e3a\u8c28\u614e\u63a5\u53d7\u7684\u54cd\u5e94
\n if (response.status === 200) {
\n const data = await response.json();
\n if (data.warning && data.warning.includes('0-RTT')) {
\n console.warn('Request accepted via 0-RTT with caution');
\n }
\n }<\/p>\n
return response;<\/p>\n
} catch (error) {
\n console.error('Early data request failed:', error);
\n \/\/ \u56de\u9000\u5230\u6b63\u5e38\u8bf7\u6c42
\n return this.requestWithoutEarlyData(url, options);
\n }
\n }<\/p>\n
\/\/ \u6b63\u5e38\u8bf7\u6c42
\n return this.requestWithoutEarlyData(url, options);
\n }<\/p>\n
async requestWithoutEarlyData(url, options) {
\n \/\/ \u79fb\u9664\u53ef\u80fd\u7684Early-Data\u5934
\n const cleanOptions = { …options };
\n if (cleanOptions.headers) {
\n delete cleanOptions.headers['Early-Data'];
\n }<\/p>\n
return fetch(url, cleanOptions);
\n }<\/p>\n
isIdempotent(method) {
\n \/\/ \u68c0\u67e5\u65b9\u6cd5\u662f\u5426\u5e42\u7b49
\n const idempotentMethods = ['GET', 'HEAD', 'PUT', 'DELETE', 'OPTIONS', 'TRACE'];
\n return idempotentMethods.includes(method.toUpperCase());
\n }<\/p>\n
generateRequestId() {
\n return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
\n }<\/p>\n
delay(ms) {
\n return new Promise(resolve => setTimeout(resolve, ms));
\n }<\/p>\n
async detectEarlyDataSupport() {
\n \/\/ \u68c0\u6d4b\u670d\u52a1\u5668\u662f\u5426\u652f\u63010-RTT
\n try {
\n const response = await fetch(`${this.baseURL}\/.well-known\/support-early-data`, {
\n method: 'HEAD'
\n });<\/p>\n
this.earlyDataSupported = response.headers.get('Supports-Early-Data') === '1';
\n return this.earlyDataSupported;
\n } catch (error) {
\n this.earlyDataSupported = false;
\n return false;
\n }
\n }
\n}<\/p>\n
\u53ea\u5bf9\u5e42\u7b49\u64cd\u4f5c\u4f7f\u75280-RTT<\/p>\n<\/li>\n
\u5b9e\u73b0\u91cd\u653e\u4fdd\u62a4\u673a\u5236<\/p>\n<\/li>\n
\u4e3a0-RTT\u8bf7\u6c42\u63d0\u4f9b\u660e\u786e\u7684\u8b66\u544a<\/p>\n<\/li>\n
\u76d1\u63a7425\u9519\u8bef\u7387\u4ee5\u8c03\u6574\u91cd\u653e\u7a97\u53e3<\/p>\n<\/li>\n<\/ul>\n
426\u72b6\u6001\u7801\u8868\u793a\u670d\u52a1\u5668\u62d2\u7edd\u4f7f\u7528\u5f53\u524d\u534f\u8bae\u5904\u7406\u8bf7\u6c42，\u4f46\u613f\u610f\u5728\u5ba2\u6237\u7aef\u5347\u7ea7\u5230\u4e0d\u540c\u534f\u8bae\u540e\u5904\u7406\u3002\u901a\u5e38\u7528\u4e8e\u534f\u8bae\u5347\u7ea7\u534f\u5546\u3002<\/p>\n
http<\/p>\n
# \u5ba2\u6237\u7aef\u8bf7\u6c42\u5347\u7ea7
\nGET \/chat HTTP\/1.1
\nHost: server.example.com
\nUpgrade: websocket
\nConnection: Upgrade
\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
\nSec-WebSocket-Version: 13<\/p>\n
# \u670d\u52a1\u5668\u540c\u610f\u5347\u7ea7
\nHTTP\/1.1 101 Switching Protocols
\nUpgrade: websocket
\nConnection: Upgrade
\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=<\/p>\n
# \u670d\u52a1\u5668\u62d2\u7edd\u5347\u7ea7（\u8981\u6c42\u5176\u4ed6\u534f\u8bae）
\nHTTP\/1.1 426 Upgrade Required
\nUpgrade: TLS\/1.2, HTTP\/1.1
\nConnection: Upgrade
\nContent-Type: application\/json<\/p>\n
{
\n "error": "upgrade_required",
\n "message": "Please upgrade to a more secure protocol",
\n "supported_upgrades": [
\n {
\n "protocol": "TLS\/1.2",
\n "description": "Transport Layer Security 1.2"
\n },
\n {
\n "protocol": "HTTP\/2",
\n "description": "HTTP version 2"
\n }
\n ]
\n}<\/p>\n
\u5b89\u5168\u534f\u8bae\u5347\u7ea7：\u8981\u6c42\u4eceHTTP\u5347\u7ea7\u5230HTTPS<\/p>\n<\/li>\n
API\u7248\u672c\u5f03\u7528：\u8981\u6c42\u4f7f\u7528\u65b0\u7248\u672cAPI<\/p>\n<\/li>\n
\u4f20\u8f93\u534f\u8bae\u5347\u7ea7：\u4eceHTTP\/1.1\u5347\u7ea7\u5230HTTP\/2\u6216HTTP\/3<\/p>\n<\/li>\n
WebSocket\u63e1\u624b：\u534f\u5546WebSocket\u534f\u8bae<\/p>\n<\/li>\n
python<\/p>\n
# Flask\u534f\u8bae\u5347\u7ea7\u5904\u7406
\nfrom flask import Flask, request, jsonify
\nimport ssl<\/p>\n
app = Flask(__name__)<\/p>\n
@app.before_request
\ndef require_secure_connection():
\n # \u68c0\u67e5\u662f\u5426\u4e3aHTTPS
\n if not request.is_secure:
\n # \u68c0\u67e5\u662f\u5426\u652f\u6301\u5347\u7ea7
\n upgrade_header = request.headers.get('Upgrade')<\/p>\n
if upgrade_header and 'TLS' in upgrade_header:
\n # \u5ba2\u6237\u7aef\u5df2\u8bf7\u6c42\u5347\u7ea7
\n return # \u5141\u8bb8\u7ee7\u7eed，\u5c06\u7531\u5e95\u5c42\u670d\u52a1\u5668\u5904\u7406<\/p>\n
# \u8fd4\u56de426\u8981\u6c42\u5347\u7ea7
\n response = jsonify({
\n 'error': 'upgrade_required',
\n 'message': 'Secure connection required',
\n 'upgrade_to': 'HTTPS',
\n 'url': f'https:\/\/{request.host}{request.path}',
\n 'status_code': 301 # \u4e5f\u63d0\u4f9b\u91cd\u5b9a\u5411\u9009\u9879
\n })
\n response.status_code = 426
\n response.headers['Upgrade'] = 'TLS\/1.2, TLS\/1.3'
\n response.headers['Connection'] = 'Upgrade'
\n return response<\/p>\n
@app.route('\/api\/deprecated', methods=['GET'])
\ndef deprecated_api():
\n """\u5df2\u5f03\u7528\u7684API\u7aef\u70b9"""
\n # \u68c0\u67e5\u5ba2\u6237\u7aef\u662f\u5426\u4f7f\u7528\u65b0\u7248\u672c
\n api_version = request.headers.get('X-API-Version', '1.0')<\/p>\n
if api_version == '1.0':
\n # \u8981\u6c42\u5347\u7ea7\u5230v2
\n response = jsonify({
\n 'error': 'api_version_deprecated',
\n 'message': 'API v1.0 is deprecated',
\n 'upgrade_to': 'v2.0',
\n 'documentation': 'https:\/\/api.example.com\/v2\/docs',
\n 'sunset_date': '2024-12-31'
\n })
\n response.status_code = 426
\n response.headers['X-API-Deprecated'] = 'true'
\n response.headers['X-API-Sunset'] = '2024-12-31T23:59:59Z'
\n return response<\/p>\n
# \u65b0\u7248\u672cAPI\u5904\u7406
\n return jsonify({'data': 'from v2 API'})<\/p>\n
# WebSocket\u5347\u7ea7\u5904\u7406
\n@app.route('\/ws')
\ndef websocket_endpoint():
\n # Flask\u672c\u8eab\u4e0d\u76f4\u63a5\u5904\u7406WebSocket
\n # \u8fd9\u901a\u5e38\u7531\u4e13\u95e8\u7684WebSocket\u670d\u52a1\u5668\u5904\u7406
\n # \u4ee5\u4e0b\u4e3a\u6982\u5ff5\u6027\u4ee3\u7801<\/p>\n
upgrade = request.headers.get('Upgrade', '').lower()<\/p>\n
if upgrade == 'websocket':
\n # \u68c0\u67e5WebSocket\u7248\u672c
\n ws_version = request.headers.get('Sec-WebSocket-Version')<\/p>\n
if ws_version != '13':
\n response = jsonify({
\n 'error': 'unsupported_websocket_version',
\n 'message': f'WebSocket version {ws_version} not supported',
\n 'supported_versions': ['13']
\n })
\n response.status_code = 426
\n response.headers['Sec-WebSocket-Version'] = '13'
\n return response<\/p>\n
# WebSocket\u63e1\u624b\u5c06\u7531\u5e95\u5c42\u670d\u52a1\u5668\u5904\u7406
\n return '', 101 # \u5b9e\u9645\u5e94\u7531WebSocket\u670d\u52a1\u5668\u5904\u7406<\/p>\n
return jsonify({'error': 'websocket_upgrade_required'}), 426<\/p>\n
javascript<\/p>\n
\/\/ \u5904\u7406426\u5347\u7ea7\u7684\u5ba2\u6237\u7aef
\nclass UpgradeAwareClient {
\n constructor(baseURL) {
\n this.baseURL = baseURL;
\n this.upgradeHandlers = new Map();<\/p>\n
\/\/ \u6ce8\u518c\u5347\u7ea7\u5904\u7406\u5668
\n this.registerUpgradeHandler('TLS', this.handleTlsUpgrade.bind(this));
\n this.registerUpgradeHandler('websocket', this.handleWebSocketUpgrade.bind(this));
\n this.registerUpgradeHandler('h2', this.handleHttp2Upgrade.bind(this));
\n }<\/p>\n
async request(options) {
\n try {
\n const response = await fetch(this.baseURL + options.path, options);<\/p>\n
if (response.status === 426) {
\n \/\/ \u9700\u8981\u5347\u7ea7
\n return this.handleUpgradeResponse(response, options);
\n }<\/p>\n
return response;
\n } catch (error) {
\n console.error('Request failed:', error);
\n throw error;
\n }
\n }<\/p>\n
async handleUpgradeResponse(response, originalOptions) {
\n const upgradeHeader = response.headers.get('Upgrade');<\/p>\n
if (!upgradeHeader) {
\n throw new Error('426 response without Upgrade header');
\n }<\/p>\n
\/\/ \u89e3\u6790\u652f\u6301\u7684\u5347\u7ea7\u9009\u9879
\n const upgrades = upgradeHeader.split(',').map(s => s.trim());<\/p>\n
\/\/ \u9009\u62e9\u652f\u6301\u7684\u5347\u7ea7
\n for (const upgrade of upgrades) {
\n const handler = this.upgradeHandlers.get(upgrade.toLowerCase());
\n if (handler) {
\n return handler(response, originalOptions);
\n }
\n }<\/p>\n
throw new Error(`No handler for required upgrade: ${upgrades.join(', ')}`);
\n }<\/p>\n
async handleTlsUpgrade(response, originalOptions) {
\n \/\/ \u4eceHTTP\u5347\u7ea7\u5230HTTPS
\n const httpsUrl = this.baseURL.replace('http:\/\/', 'https:\/\/');<\/p>\n
console.log('Upgrading to HTTPS…');<\/p>\n
\/\/ \u91cd\u8bd5\u8bf7\u6c42\u5230HTTPS\u7aef\u70b9
\n const upgradedOptions = { …originalOptions };
\n upgradedOptions.path = originalOptions.path;<\/p>\n
return fetch(httpsUrl + upgradedOptions.path, upgradedOptions);
\n }<\/p>\n
async handleWebSocketUpgrade(response, originalOptions) {
\n \/\/ \u5347\u7ea7\u5230WebSocket
\n const wsUrl = this.baseURL.replace('http', 'ws') + originalOptions.path;<\/p>\n
console.log('Upgrading to WebSocket…');<\/p>\n
\/\/ \u521b\u5efaWebSocket\u8fde\u63a5
\n return new Promise((resolve, reject) => {
\n const ws = new WebSocket(wsUrl);<\/p>\n
ws.onopen = () => {
\n console.log('WebSocket connected');<\/p>\n
\/\/ \u5982\u679c\u539f\u59cb\u8bf7\u6c42\u662fGET，\u53ef\u4ee5\u89e3\u6790\u4e3a\u6210\u529f
\n if (originalOptions.method === 'GET') {
\n resolve({
\n status: 101,
\n ok: true,
\n webSocket: ws
\n });
\n } else {
\n \/\/ \u5bf9\u4e8e\u5176\u4ed6\u65b9\u6cd5，\u9700\u8981\u989d\u5916\u5904\u7406
\n reject(new Error('WebSocket upgrade only supported for GET requests'));
\n }
\n };<\/p>\n
ws.onerror = (error) => {
\n reject(new Error(`WebSocket connection failed: ${error}`));
\n };
\n });
\n }<\/p>\n
async handleHttp2Upgrade(response, originalOptions) {
\n \/\/ HTTP\/2\u5347\u7ea7（\u6d4f\u89c8\u5668\u4e2d\u901a\u5e38\u81ea\u52a8\u5904\u7406）
\n console.log('Upgrading to HTTP\/2…');<\/p>\n
\/\/ \u5bf9\u4e8e\u6d4f\u89c8\u5668，\u53ea\u9700\u91cd\u8bd5\u8bf7\u6c42
\n return fetch(this.baseURL + originalOptions.path, originalOptions);
\n }<\/p>\n
registerUpgradeHandler(protocol, handler) {
\n this.upgradeHandlers.set(protocol.toLowerCase(), handler);
\n }
\n}<\/p>\n
\u63d0\u4f9b\u6e05\u6670\u7684\u5347\u7ea7\u8bf4\u660e\u548c\u6587\u6863\u94fe\u63a5<\/p>\n<\/li>\n
\u652f\u6301\u591a\u79cd\u5347\u7ea7\u9009\u9879<\/p>\n<\/li>\n
\u5b9e\u73b0\u4f18\u96c5\u964d\u7ea7<\/p>\n<\/li>\n
\u76d1\u63a7\u534f\u8bae\u4f7f\u7528\u60c5\u51b5\u4ee5\u8ba1\u5212\u5f03\u7528<\/p>\n<\/li>\n<\/ul>\n
428\u72b6\u6001\u7801\u8868\u793a\u6e90\u670d\u52a1\u5668\u8981\u6c42\u8bf7\u6c42\u662f\u6761\u4ef6\u6027\u7684\u3002\u7528\u4e8e\u9632\u6b62"\u4e22\u5931\u66f4\u65b0"\u95ee\u9898，\u5ba2\u6237\u7aef\u5728\u66f4\u65b0\u8d44\u6e90\u524d\u5fc5\u987b\u5148\u83b7\u53d6\u5f53\u524d\u72b6\u6001\u3002<\/p>\n
412 Precondition Failed：\u5ba2\u6237\u7aef\u63d0\u4f9b\u4e86\u6761\u4ef6\u5934，\u4f46\u6761\u4ef6\u4e0d\u6ee1\u8db3<\/p>\n<\/li>\n
428 Precondition Required：\u670d\u52a1\u5668\u8981\u6c42\u6761\u4ef6\u8bf7\u6c42，\u4f46\u5ba2\u6237\u7aef\u6ca1\u6709\u63d0\u4f9b\u6761\u4ef6\u5934<\/p>\n<\/li>\n<\/ul>\n
python<\/p>\n
# Django\u6761\u4ef6\u8bf7\u6c42\u8981\u6c42
\nfrom django.http import JsonResponse
\nfrom django.views import View
\nfrom django.utils.decorators import method_decorator
\nfrom django.views.decorators.http import require_http_methods
\nimport hashlib
\nimport json<\/p>\n
class ConditionalUpdateMixin:
\n """\u8981\u6c42\u6761\u4ef6\u66f4\u65b0\u7684Mixin"""<\/p>\n
def require_conditional_request(self, request, *args, **kwargs):
\n """\u68c0\u67e5\u662f\u5426\u6ee1\u8db3\u6761\u4ef6\u8bf7\u6c42\u8981\u6c42"""
\n # \u5bf9\u4e8e\u5b89\u5168\u65b9\u6cd5（GET\u3001HEAD）\u4e0d\u9700\u8981\u6761\u4ef6
\n if request.method in ['GET', 'HEAD', 'OPTIONS']:
\n return True<\/p>\n
# \u68c0\u67e5\u6761\u4ef6\u5934
\n has_condition = any([
\n request.META.get('HTTP_IF_MATCH'),
\n request.META.get('HTTP_IF_NONE_MATCH'),
\n request.META.get('HTTP_IF_MODIFIED_SINCE'),
\n request.META.get('HTTP_IF_UNMODIFIED_SINCE')
\n ])<\/p>\n
if not has_condition:
\n # \u8fd4\u56de428，\u8981\u6c42\u6761\u4ef6\u8bf7\u6c42
\n response = JsonResponse({
\n 'error': 'precondition_required',
\n 'message': 'This request requires conditional headers',
\n 'required_headers': [
\n 'If-Match or If-None-Match',
\n 'If-Modified-Since or If-Unmodified-Since'
\n ],
\n 'how_to': 'First perform a GET request to get the current ETag, then include it in If-Match header'
\n })
\n response.status_code = 428
\n response['Precondition-Required'] = 'true'
\n return response<\/p>\n
return True<\/p>\n
class ResourceDetailView(ConditionalUpdateMixin, View):
\n """\u9700\u8981\u6761\u4ef6\u66f4\u65b0\u7684\u8d44\u6e90\u8be6\u60c5\u89c6\u56fe"""<\/p>\n
def dispatch(self, request, *args, **kwargs):
\n # \u68c0\u67e5\u6761\u4ef6\u8bf7\u6c42\u8981\u6c42
\n requirement_check = self.require_conditional_request(request, *args, **kwargs)
\n if requirement_check is not True:
\n return requirement_check<\/p>\n
return super().dispatch(request, *args, **kwargs)<\/p>\n
def get(self, request, resource_id):
\n """\u83b7\u53d6\u8d44\u6e90（\u5305\u542bETag）"""
\n resource = self.get_resource(resource_id)<\/p>\n
# \u751f\u6210ETag
\n etag = self.generate_etag(resource)<\/p>\n
response = JsonResponse(resource)
\n response['ETag'] = etag
\n response['Last-Modified'] = resource['modified_at']<\/p>\n
return response<\/p>\n
def put(self, request, resource_id):
\n """\u66f4\u65b0\u8d44\u6e90（\u9700\u8981If-Match）"""
\n resource = self.get_resource(resource_id)
\n current_etag = self.generate_etag(resource)<\/p>\n
# \u68c0\u67e5If-Match\u5934
\n if_match = request.META.get('HTTP_IF_MATCH')
\n if not if_match:
\n # \u8fd9\u4e0d\u5e94\u8be5\u53d1\u751f，\u56e0\u4e3adispatch\u5df2\u7ecf\u68c0\u67e5\u4e86
\n return JsonResponse({
\n 'error': 'precondition_required',
\n 'message': 'If-Match header is required'
\n }, status=428)<\/p>\n
# \u9a8c\u8bc1ETag
\n if if_match != current_etag and if_match != '*':
\n return JsonResponse({
\n 'error': 'precondition_failed',
\n 'message': 'Resource has been modified',
\n 'current_etag': current_etag
\n }, status=412)<\/p>\n
# \u66f4\u65b0\u8d44\u6e90
\n updated_resource = self.update_resource(resource_id, request.body)
\n new_etag = self.generate_etag(updated_resource)<\/p>\n
response = JsonResponse(updated_resource)
\n response['ETag'] = new_etag
\n return response<\/p>\n
def get_resource(self, resource_id):
\n """\u83b7\u53d6\u8d44\u6e90（\u7b80\u5316\u5b9e\u73b0）"""
\n return {
\n 'id': resource_id,
\n 'name': f'Resource {resource_id}',
\n 'modified_at': '2024-01-15T10:30:00Z',
\n 'data': 'Some data'
\n }<\/p>\n
def generate_etag(self, resource):
\n """\u751f\u6210ETag"""
\n content = json.dumps(resource, sort_keys=True)
\n return hashlib.md5(content.encode()).hexdigest()<\/p>\n
def update_resource(self, resource_id, data):
\n """\u66f4\u65b0\u8d44\u6e90（\u7b80\u5316\u5b9e\u73b0）"""
\n resource = self.get_resource(resource_id)
\n # \u5b9e\u9645\u5b9e\u73b0\u4f1a\u89e3\u6790\u548c\u66f4\u65b0\u6570\u636e
\n resource['modified_at'] = '2024-01-15T11:00:00Z'
\n return resource<\/p>\n
javascript<\/p>\n
\/\/ \u5904\u7406428\u7684\u5ba2\u6237\u7aef
\nclass ConditionalRequestClient {
\n async updateResource(resourceId, updates) {
\n \/\/ 1. \u9996\u5148\u83b7\u53d6\u8d44\u6e90\u4ee5\u83b7\u53d6ETag
\n const getResponse = await fetch(`\/api\/resources\/${resourceId}`);<\/p>\n
if (!getResponse.ok) {
\n throw new Error(`Failed to get resource: ${getResponse.status}`);
\n }<\/p>\n
const etag = getResponse.headers.get('ETag');
\n const resource = await getResponse.json();<\/p>\n
\/\/ 2. \u4f7f\u7528ETag\u8fdb\u884c\u6761\u4ef6\u66f4\u65b0
\n const updateResponse = await fetch(`\/api\/resources\/${resourceId}`, {
\n method: 'PUT',
\n headers: {
\n 'Content-Type': 'application\/json',
\n 'If-Match': etag
\n },
\n body: JSON.stringify({
\n …resource,
\n …updates
\n })
\n });<\/p>\n
if (updateResponse.status === 428) {
\n \/\/ \u670d\u52a1\u5668\u8981\u6c42\u6761\u4ef6\u8bf7\u6c42，\u4f46\u6211\u4eec\u5df2\u7ecf\u63d0\u4f9b\u4e86
\n \/\/ \u8fd9\u53ef\u80fd\u662f\u914d\u7f6e\u9519\u8bef
\n throw new Error('Server requires conditional request but rejected our If-Match header');
\n }<\/p>\n
if (updateResponse.status === 412) {
\n \/\/ \u524d\u63d0\u6761\u4ef6\u5931\u8d25（\u8d44\u6e90\u5df2\u88ab\u4fee\u6539）
\n \/\/ \u83b7\u53d6\u65b0\u7248\u672c\u5e76\u91cd\u8bd5\u6216\u901a\u77e5\u7528\u6237
\n const error = await updateResponse.json();
\n throw new Error(`Update conflict: ${error.message}`);
\n }<\/p>\n
if (!updateResponse.ok) {
\n throw new Error(`Update failed: ${updateResponse.status}`);
\n }<\/p>\n
return updateResponse.json();
\n }<\/p>\n
async safeUpdateWithRetry(resourceId, updates, maxRetries = 3) {
\n for (let attempt = 0; attempt < maxRetries; attempt++) {
\n try {
\n return await this.updateResource(resourceId, updates);
\n } catch (error) {
\n if (error.message.includes('Update conflict') && attempt < maxRetries – 1) {
\n \/\/ \u51b2\u7a81\u9519\u8bef，\u7b49\u5f85\u540e\u91cd\u8bd5
\n console.log(`Update conflict, retrying (attempt ${attempt + 1})…`);
\n await this.delay(100 * Math.pow(2, attempt)); \/\/ \u6307\u6570\u9000\u907f
\n continue;
\n }
\n throw error;
\n }
\n }
\n }<\/p>\n
delay(ms) {
\n return new Promise(resolve => setTimeout(resolve, ms));
\n }
\n}<\/p>\n
\u4e3a\u6240\u6709\u975e\u5b89\u5168\u65b9\u6cd5\u8981\u6c42\u6761\u4ef6\u8bf7\u6c42<\/p>\n<\/li>\n
\u63d0\u4f9b\u6e05\u6670\u7684\u9519\u8bef\u4fe1\u606f\u548c\u89e3\u51b3\u6b65\u9aa4<\/p>\n<\/li>\n
\u5b9e\u73b0\u4e50\u89c2\u9501\u907f\u514d\u66f4\u65b0\u51b2\u7a81<\/p>\n<\/li>\n
\u8003\u8651\u652f\u6301\u5f31ETag\u7528\u4e8e\u6027\u80fd\u4f18\u5316<\/p>\n<\/li>\n<\/ul>\n
\u6ce8：\u867d\u7136\u6807\u9898\u4e2d\u672a\u5217\u51fa429，\u4f46\u7531\u4e8e\u5b83\u5e38\u4e0e\u5176\u4ed64xx\u72b6\u6001\u7801\u4e00\u8d77\u8ba8\u8bba，\u4e14\u975e\u5e38\u91cd\u8981，\u6b64\u5904\u7b80\u8981\u6db5\u76d6\u3002<\/p>\n
429\u72b6\u6001\u7801\u8868\u793a\u7528\u6237\u5728\u7ed9\u5b9a\u65f6\u95f4\u5185\u53d1\u9001\u4e86\u592a\u591a\u8bf7\u6c42（"\u9650\u6d41"）\u3002\u7528\u4e8e\u9632\u6b62\u6ee5\u7528\u548c\u4fdd\u8bc1\u670d\u52a1\u53ef\u7528\u6027\u3002<\/p>\n
http<\/p>\n
HTTP\/1.1 429 Too Many Requests
\nContent-Type: application\/json
\nRetry-After: 3600
\nX-RateLimit-Limit: 100
\nX-RateLimit-Remaining: 0
\nX-RateLimit-Reset: 1673780400<\/p>\n
{
\n "error": "rate_limit_exceeded",
\n "message": "Too many requests, please try again later",
\n "retry_after": 3600,
\n "limit": 100,
\n "period": "hour",
\n "documentation": "https:\/\/api.example.com\/docs\/rate-limiting"
\n}<\/p>\n
\u4ee4\u724c\u6876\u7b97\u6cd5：\u5e73\u6ed1\u9650\u6d41，\u5141\u8bb8\u7a81\u53d1<\/p>\n<\/li>\n
\u6f0f\u6876\u7b97\u6cd5：\u6052\u5b9a\u901f\u7387\u5904\u7406<\/p>\n<\/li>\n
\u56fa\u5b9a\u7a97\u53e3\u8ba1\u6570\u5668：\u7b80\u5355\u8ba1\u6570，\u4f46\u53ef\u80fd\u5141\u8bb8\u77ac\u65f6\u8d85\u9650<\/p>\n<\/li>\n
\u6ed1\u52a8\u7a97\u53e3\u65e5\u5fd7：\u7cbe\u786e\u4f46\u5185\u5b58\u6d88\u8017\u5927<\/p>\n<\/li>\n
\u5206\u5e03\u5f0f\u9650\u6d41：\u7528\u4e8e\u5fae\u670d\u52a1\u67b6\u6784<\/p>\n<\/li>\n
431\u72b6\u6001\u7801\u8868\u793a\u670d\u52a1\u5668\u4e0d\u613f\u610f\u5904\u7406\u8bf7\u6c42，\u56e0\u4e3a\u5355\u4e2a\u5934\u5b57\u6bb5\u6216\u6240\u6709\u5934\u5b57\u6bb5\u7684\u603b\u5927\u5c0f\u8d85\u8fc7\u9650\u5236\u3002<\/p>\n
| Nginx<\/td>\n | 4KB\/8KB（\u53d6\u51b3\u4e8e\u7cfb\u7edf）<\/td>\n | large_client_header_buffers<\/td>\n<\/tr>\n |
| Apache<\/td>\n | 8KB<\/td>\n | LimitRequestFieldSize<\/td>\n<\/tr>\n |
| IIS<\/td>\n | 16KB<\/td>\n | maxRequestLength<\/td>\n<\/tr>\n |
| Node.js<\/td>\n | 16KB<\/td>\n | maxHeaderSize<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n23.23.3 \u95ee\u9898\u8bca\u65ad<\/h4>\npython<\/p>\n # \u8bca\u65ad\u5934\u5927\u5c0f\u95ee\u9898 for key, value in request.headers.items(): return { # \u4e2d\u95f4\u4ef6\u68c0\u67e5\u5934\u5927\u5c0f class HeaderSizeMiddleware: def __call__(self, request): if header_size > self.max_header_size: return self.get_response(request)<\/p>\n def get_largest_headers(self, request): return sorted(headers, key=lambda x: x['size'], reverse=True)[:3]<\/p>\n 23.23.4 \u5ba2\u6237\u7aef\u4f18\u5316<\/h4>\njavascript<\/p>\n \/\/ \u4f18\u5316\u8bf7\u6c42\u5934\u5927\u5c0f optimizeHeaders(headers) { for (const [key, value] of Object.entries(headers)) { \/\/ \u53ea\u4fdd\u7559\u5fc5\u8981\u5934 optimized[key] = value; \/\/ \u68c0\u67e5\u662f\u5426\u8d85\u8fc7\u9650\u5236 \/\/ \u5c1d\u8bd5\u538b\u7f29\u5927\u503c\u5934 return optimized; compressHeaders(headers) { \/\/ \u5bf9\u4e8e\u5927\u503c\u7684\u81ea\u5b9a\u4e49\u5934，\u53ef\u4ee5\u8003\u8651\u538b\u7f29 return compressed; compressValue(value) { return value; async makeRequest(url, options) { const optimizedOptions = { const response = await fetch(url, optimizedOptions);<\/p>\n if (response.status === 431) { \/\/ \u83b7\u53d6\u8bca\u65ad\u4fe1\u606f throw new Error('Request headers too large'); return response; 23.23.5 \u670d\u52a1\u5668\u914d\u7f6e<\/h4>\nnginx<\/p>\n # Nginx\u5934\u5927\u5c0f\u914d\u7f6e # \u5927\u5ba2\u6237\u7aef\u5934\u7f13\u51b2\u533a # \u8bf7\u6c42\u884c\u6700\u5927\u5927\u5c0f # \u7279\u5b9a\u4f4d\u7f6e\u66f4\u4e25\u683c\u7684\u9650\u5236 # \u81ea\u5b9a\u4e49\u9519\u8bef\u5904\u7406 location = \/431.json { 23.23.6 \u6700\u4f73\u5b9e\u8df5<\/h4>\n\u76d1\u63a7\u5934\u5927\u5c0f\u5206\u5e03\u4ee5\u8bbe\u7f6e\u5408\u7406\u9650\u5236<\/p>\n<\/li>\n \u63d0\u4f9b\u6e05\u6670\u7684\u9519\u8bef\u4fe1\u606f\u6307\u51fa\u54ea\u4e9b\u5934\u592a\u5927<\/p>\n<\/li>\n \u8003\u8651\u652f\u6301\u5934\u538b\u7f29（\u5982HTTP\/2 HPACK）<\/p>\n<\/li>\n \u907f\u514d\u5728\u5934\u4e2d\u5b58\u50a8\u5927\u91cf\u6570\u636e<\/p>\n<\/li>\n<\/ul>\n 23.24 451 Unavailable For Legal Reasons（\u56e0\u6cd5\u5f8b\u539f\u56e0\u4e0d\u53ef\u7528）<\/h3>\n |
451\u72b6\u6001\u7801\u8868\u793a\u670d\u52a1\u5668\u7531\u4e8e\u6cd5\u5f8b\u539f\u56e0\u65e0\u6cd5\u63d0\u4f9b\u8bf7\u6c42\u7684\u8d44\u6e90\u3002\u5f15\u7528\u81ea\u96f7\u00b7\u5e03\u62c9\u5fb7\u4f2f\u91cc\u7684\u300a\u534e\u6c0f451\u300b，\u8be5\u72b6\u6001\u7801\u4e13\u95e8\u7528\u4e8e\u5185\u5bb9\u5ba1\u67e5\u573a\u666f\u3002<\/p>\n
\u653f\u5e9c\u5ba1\u67e5：\u653f\u5e9c\u8981\u6c42\u5c4f\u853d\u7684\u5185\u5bb9<\/p>\n<\/li>\n
\u7248\u6743\u95ee\u9898：\u4fb5\u6743\u5185\u5bb9\u79fb\u9664<\/p>\n<\/li>\n
\u6cd5\u9662\u547d\u4ee4：\u6839\u636e\u6cd5\u5f8b\u547d\u4ee4\u5c4f\u853d<\/p>\n<\/li>\n
\u5730\u533a\u9650\u5236：\u5185\u5bb9\u5730\u7406\u5c01\u9501<\/p>\n<\/li>\n
GDPR\u5408\u89c4：\u6570\u636e\u4fdd\u62a4\u8981\u6c42\u79fb\u9664<\/p>\n<\/li>\n
http<\/p>\n
HTTP\/1.1 451 Unavailable For Legal Reasons
\nContent-Type: application\/json
\nX-Censorship-Reason: government-order
\nX-Blocking-Authority: Ministry of Truth
\nX-Appeal-URL: https:\/\/example.com\/appeal
\nLink: <https:\/\/eff.org\/censorship>; rel="related"<\/p>\n
{
\n "error": "unavailable_for_legal_reasons",
\n "message": "This resource is not available in your country due to legal restrictions",
\n "reference": "Government Order 2024-01",
\n "reason": "violates_local_laws",
\n "country": "DE",
\n "blocking_authority": "Federal Agency",
\n "block_date": "2024-01-15",
\n "appeal_process": {
\n "url": "https:\/\/example.com\/appeal",
\n "email": "legal@example.com",
\n "deadline": "2024-02-15"
\n },
\n "alternatives": [
\n {
\n "description": "Similar content available in other regions",
\n "url": "https:\/\/global.example.com\/content\/123"
\n }
\n ]
\n}<\/p>\n
python<\/p>\n
# Django\u5730\u7406\u5c01\u9501\u548c\u5185\u5bb9\u5ba1\u67e5
\nfrom django.http import JsonResponse
\nfrom django.views import View
\nfrom django.utils.decorators import method_decorator
\nfrom django.views.decorators.vary import vary_on_headers
\nimport geoip2.database
\nimport json<\/p>\n
class LegalComplianceMiddleware:
\n """\u6cd5\u5f8b\u5408\u89c4\u4e2d\u95f4\u4ef6"""<\/p>\n
def __init__(self, get_response):
\n self.get_response = get_response
\n self.geoip_reader = geoip2.database.Reader('\/path\/to\/GeoLite2-Country.mmdb')
\n self.blocked_content = self.load_blocked_content()<\/p>\n
def __call__(self, request):
\n response = self.get_response(request)<\/p>\n
# \u68c0\u67e5\u662f\u5426\u9700\u8981\u5730\u7406\u5c01\u9501
\n if self.is_blocked_in_country(request):
\n return self.create_451_response(request)<\/p>\n
return response<\/p>\n
def is_blocked_in_country(self, request):
\n """\u68c0\u67e5\u5185\u5bb9\u662f\u5426\u5728\u7528\u6237\u6240\u5728\u56fd\u5bb6\u88ab\u5c01\u9501"""
\n try:
\n # \u83b7\u53d6\u7528\u6237\u56fd\u5bb6
\n country_code = self.get_user_country(request)<\/p>\n
# \u83b7\u53d6\u8bf7\u6c42\u7684\u8def\u5f84
\n path = request.path<\/p>\n
# \u68c0\u67e5\u662f\u5426\u5728\u5c01\u9501\u5217\u8868\u4e2d
\n if path in self.blocked_content:
\n blocked_in = self.blocked_content[path].get('blocked_countries', [])
\n return country_code in blocked_in<\/p>\n
except Exception as e:
\n print(f"Error checking geo-block: {e}")<\/p>\n
return False<\/p>\n
def get_user_country(self, request):
\n """\u4eceIP\u83b7\u53d6\u7528\u6237\u56fd\u5bb6"""
\n # \u4eceX-Forwarded-For\u6216\u76f4\u63a5IP\u83b7\u53d6
\n ip = self.get_client_ip(request)<\/p>\n
try:
\n response = self.geoip_reader.country(ip)
\n return response.country.iso_code
\n except:
\n # \u9ed8\u8ba4\u56fd\u5bb6\u6216\u57fa\u4e8e\u5176\u4ed6\u5934\u5224\u65ad
\n return request.META.get('HTTP_CF_IPCOUNTRY', 'US')<\/p>\n
def get_client_ip(self, request):
\n """\u83b7\u53d6\u5ba2\u6237\u7aefIP"""
\n x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
\n if x_forwarded_for:
\n ip = x_forwarded_for.split(',')[0]
\n else:
\n ip = request.META.get('REMOTE_ADDR')
\n return ip<\/p>\n
def create_451_response(self, request):
\n """\u521b\u5efa451\u54cd\u5e94"""
\n path = request.path
\n blocking_info = self.blocked_content.get(path, {})<\/p>\n
response = JsonResponse({
\n 'error': 'unavailable_for_legal_reasons',
\n 'message': blocking_info.get('message', 'Content not available in your region'),
\n 'reason': blocking_info.get('reason', 'legal_restriction'),
\n 'reference': blocking_info.get('reference'),
\n 'country': self.get_user_country(request),
\n 'blocking_authority': blocking_info.get('authority'),
\n 'block_date': blocking_info.get('block_date'),
\n 'appeal': blocking_info.get('appeal_url'),
\n 'alternatives': blocking_info.get('alternatives', [])
\n })
\n response.status_code = 451<\/p>\n
# \u6dfb\u52a0\u4fe1\u606f\u5934
\n response['X-Censorship-Reason'] = blocking_info.get('reason', 'unknown')
\n if blocking_info.get('authority'):
\n response['X-Blocking-Authority'] = blocking_info['authority']
\n if blocking_info.get('appeal_url'):
\n response['X-Appeal-URL'] = blocking_info['appeal_url']<\/p>\n
return response<\/p>\n
def load_blocked_content(self):
\n """\u52a0\u8f7d\u5c01\u9501\u5185\u5bb9\u5217\u8868（\u4ece\u6570\u636e\u5e93\u6216\u6587\u4ef6）"""
\n # \u793a\u4f8b\u6570\u636e
\n return {
\n '\/content\/restricted-article': {
\n 'blocked_countries': ['CN', 'RU', 'IR'],
\n 'reason': 'government_order',
\n 'authority': 'Ministry of Culture',
\n 'reference': 'GO-2024-001',
\n 'block_date': '2024-01-01',
\n 'appeal_url': 'https:\/\/example.com\/appeal\/restricted-article',
\n 'alternatives': [
\n {
\n 'url': '\/content\/similar-article',
\n 'description': 'Similar topic available'
\n }
\n ]
\n }
\n }<\/p>\n
class ContentDetailView(View):
\n """\u5185\u5bb9\u8be6\u60c5\u89c6\u56fe（\u53ef\u80fd\u8fd4\u56de451）"""<\/p>\n
@method_decorator(vary_on_headers('X-Country-Code'))
\n def get(self, request, content_id):
\n content = self.get_content(content_id)<\/p>\n
if content.get('blocked', False):
\n # \u68c0\u67e5\u7528\u6237\u56fd\u5bb6
\n user_country = request.META.get('HTTP_X_COUNTRY_CODE', 'US')<\/p>\n
if user_country in content.get('blocked_countries', []):
\n return JsonResponse({
\n 'error': 'unavailable_for_legal_reasons',
\n 'message': f'This content is not available in {user_country}',
\n 'content_id': content_id,
\n 'country': user_country
\n }, status=451)<\/p>\n
return JsonResponse(content)<\/p>\n
def get_content(self, content_id):
\n """\u83b7\u53d6\u5185\u5bb9（\u7b80\u5316\u5b9e\u73b0）"""
\n return {
\n 'id': content_id,
\n 'title': 'Sample Content',
\n 'blocked': True,
\n 'blocked_countries': ['CN', 'RU'],
\n 'available_countries': ['US', 'UK', 'DE']
\n }<\/p>\n
json<\/p>\n
{
\n "transparency_report": {
\n "period": "2024-Q1",
\n "total_requests": 1000000,
\n "451_responses": 1250,
\n "blocking_reasons": {
\n "government_order": 800,
\n "copyright": 300,
\n "court_order": 100,
\n "terms_violation": 50
\n },
\n "countries_affected": [
\n {"country": "CN", "blocks": 500},
\n {"country": "RU", "blocks": 300},
\n {"country": "IR", "blocks": 200},
\n {"country": "DE", "blocks": 50}
\n ],
\n "appeals": {
\n "received": 200,
\n "granted": 50,
\n "denied": 100,
\n "pending": 50
\n },
\n "documentation": "https:\/\/example.com\/transparency\/2024-Q1"
\n }
\n}<\/p>\n
\u63d0\u4f9b\u8be6\u7ec6\u7684\u5c01\u9501\u539f\u56e0\u548c\u6cd5\u5f8b\u4f9d\u636e<\/p>\n<\/li>\n
\u5b9e\u73b0\u900f\u660e\u7684\u4e0a\u8bc9\u6d41\u7a0b<\/p>\n<\/li>\n
\u53d1\u5e03\u900f\u660e\u5ea6\u62a5\u544a<\/p>\n<\/li>\n
\u8003\u8651\u7528\u6237\u9690\u79c1（\u907f\u514d\u8fc7\u5ea6\u8ffd\u8e2a）<\/p>\n<\/li>\n
\u63d0\u4f9b\u66ff\u4ee3\u5185\u5bb9\u9009\u9879<\/p>\n<\/li>\n<\/ul>\n
\u672c\u7ae0\u8be6\u7ec6\u63a2\u8ba8\u4e8623\u4e2a"\u5176\u4ed6"4xx HTTP\u72b6\u6001\u7801，\u6bcf\u4e2a\u72b6\u6001\u7801\u90fd\u6709\u5176\u7279\u5b9a\u7684\u4f7f\u7528\u573a\u666f\u548c\u6700\u4f73\u5b9e\u8df5\u3002\u4ece\u652f\u4ed8\u7cfb\u7edf（402）\u5230\u6cd5\u5f8b\u5408\u89c4（451），\u8fd9\u4e9b\u72b6\u6001\u7801\u4e3a\u73b0\u4ee3Web\u5f00\u53d1\u548cAPI\u8bbe\u8ba1\u63d0\u4f9b\u4e86\u4e30\u5bcc\u7684\u8bed\u4e49\u5de5\u5177\u3002<\/p>\n
\u7cbe\u786e\u8bed\u4e49：\u4f7f\u7528\u6b63\u786e\u7684\u72b6\u6001\u7801\u53ef\u4ee5\u63d0\u4f9b\u66f4\u6e05\u6670\u7684\u9519\u8bef\u4fe1\u606f<\/p>\n<\/li>\n
\u7528\u6237\u4f53\u9a8c：\u826f\u597d\u7684\u9519\u8bef\u54cd\u5e94\u53ef\u4ee5\u6307\u5bfc\u7528\u6237\u89e3\u51b3\u95ee\u9898<\/p>\n<\/li>\n
\u5b89\u5168\u6027：\u9002\u5f53\u7684\u72b6\u6001\u7801\u6709\u52a9\u4e8e\u9632\u6b62\u6ee5\u7528\u548c\u653b\u51fb<\/p>\n<\/li>\n
\u5408\u89c4\u6027：\u7279\u5b9a\u72b6\u6001\u7801（\u5982451）\u652f\u6301\u6cd5\u5f8b\u5408\u89c4\u8981\u6c42<\/p>\n<\/li>\n
\u4e92\u64cd\u4f5c\u6027：\u6807\u51c6\u72b6\u6001\u7801\u4fc3\u8fdb\u7cfb\u7edf\u95f4\u7684\u4e92\u64cd\u4f5c\u6027<\/p>\n<\/li>\n
\u6e10\u8fdb\u91c7\u7528：\u4ece\u6700\u91cd\u8981\u7684\u72b6\u6001\u7801\u5f00\u59cb，\u9010\u6b65\u5b9e\u73b0\u66f4\u591a<\/p>\n<\/li>\n
\u6587\u6863\u5316：\u4e3aAPI\u6d88\u8d39\u8005\u63d0\u4f9b\u72b6\u6001\u7801\u7684\u8be6\u7ec6\u6587\u6863<\/p>\n<\/li>\n
\u76d1\u63a7：\u8ddf\u8e2a\u72b6\u6001\u7801\u5206\u5e03\u4ee5\u8bc6\u522b\u95ee\u9898<\/p>\n<\/li>\n
\u6d4b\u8bd5：\u4e3a\u5404\u79cd\u9519\u8bef\u573a\u666f\u7f16\u5199\u6d4b\u8bd5\u7528\u4f8b<\/p>\n<\/li>\n
\u5ba2\u6237\u7aef\u5904\u7406：\u786e\u4fdd\u5ba2\u6237\u7aef\u80fd\u4f18\u96c5\u5904\u7406\u6240\u6709\u72b6\u6001\u7801<\/p>\n<\/li>\n","protected":false},"excerpt":{"rendered":"
\u7b2c22\u7ae0：429 Too Many Requests – \u901f\u7387\u9650\u5236\u5b9e\u73b0\u6df1\u5ea6\u5206\u679022.1 \u5b9a\u4e49\u4e0e\u8bed\u4e49429 Too Many Requests\u00a0\u72b6\u6001\u7801\u8868\u793a\u7528\u6237\u5728\u7ed9\u5b9a\u65f6\u95f4\u5185\u53d1\u9001\u4e86\u592a\u591a\u8bf7\u6c42（\\”\u901f\u7387\u9650\u5236\\”）\u3002\u8be5\u72b6\u6001\u7801\u7684\u6838\u5fc3\u542b\u4e49\u662f：\u5ba2\u6237\u7aef\u8bf7\u6c42\u9891\u7387\u8d85\u8fc7\u670d\u52a1\u5668\u9650\u5236\u670d\u52a1\u5668\u6682\u65f6\u62d2\u7edd\u5904\u7406\u5f53\u524d\u8bf7\u6c42\u5ba2\u6237\u7aef\u5e94\u8be5\u5728\u7b49\u5f85\u4e00\u6bb5\u65f6\u95f4\u540e\u91cd\u8bd5\u5173\u952e\u7279\u6027：\u901f\u7387\u9650\u5236：\u9650\u5236\u5355\u4f4d\u65f6\u95f4\u5185\u7684\u8bf7\u6c42\u6570\u91cf\u53ef\u6062\u590d\u9519\u8bef：\u7b49\u5f85\u4e00\u6bb5\u65f6\u95f4\u540e\u53ef\u6062\u590d<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[81,323,190],"topic":[],"class_list":["post-62984","post","type-post","status-publish","format-standard","hentry","category-server","tag-python","tag-323","tag-190"],"yoast_head":"\n