Requests请求重写：修改请求URL与方法
【免费下载链接】requests 
项目地址: https://gitcode.com/gh_mirrors/req/requests
在日常的API开发和数据爬取工作中，我们经常会遇到需要动态修改请求URL或HTTP方法的场景。例如API版本升级需要统一替换域名、根据响应状态码自动切换请求方法等。Requests作为Python生态中最流行的HTTP客户端库，提供了灵活的请求拦截与修改机制。本文将深入探讨如何利用Requests的钩子（Hook）系统实现请求URL与方法的重写，解决实际开发中的复杂请求处理问题。
为什么需要请求重写机制
请求重写是API客户端开发中的关键技术，主要应用于以下场景：
- 服务迁移与版本控制：当后端API从
api.example.com/v1迁移到api.example.com/v2时，无需修改所有请求代码，通过统一URL重写即可完成过渡 - 动态协议切换：在HTTPS连接失败时自动降级为HTTP协议（需谨慎使用）
- 请求方法转换：某些老旧服务仅支持GET请求，可将POST请求自动转换为GET并携带请求体参数
- A/B测试路由：根据特定规则将流量分配到不同的API端点
- 故障恢复机制：当主服务不可用时自动切换到备用服务地址
传统解决方案往往需要在每个请求前手动修改参数，这种方式不仅代码冗余，还容易遗漏边缘情况。Requests的钩子系统提供了更优雅的集中式解决方案。
Requests请求生命周期与钩子系统
Requests库在处理请求时遵循特定的生命周期，钩子系统允许我们在关键节点插入自定义逻辑。
请求处理流程图
钩子系统核心实现
Requests的钩子系统在src/requests/hooks.py中实现，核心函数dispatch_hook负责触发注册的钩子函数：
def dispatch_hook(key, hooks, hook_data, **kwargs):
"""Dispatches a hook dictionary on a given piece of data."""
hooks = hooks or {}
hooks = hooks.get(key)
if hooks:
if hasattr(hooks, "__call__"):
hooks = [hooks]
for hook in hooks:
_hook_data = hook(hook_data, **kwargs)
if _hook_data is not None:
hook_data = _hook_data
return hook_data
这段代码的关键在于：
- 支持注册单个钩子函数或函数列表
- 钩子函数的返回值会替代原始数据继续传递
- 如果钩子函数返回
None，则保持原始数据不变
实现URL重写的三种方法
1. 基础URL替换（字符串替换）
最简单的URL重写方式是直接替换URL中的特定部分，适用于域名变更、路径调整等场景。
import requests
def rewrite_url(response, **kwargs):
# 只处理请求准备阶段的钩子
if kwargs.get('pre_request'):
request = kwargs['request']
# 将所有请求从v1 API迁移到v2 API
request.url = request.url.replace('https://api.example.com/v1',
'https://api.example.com/v2')
# 添加版本信息头
request.headers['X-API-Version'] = '2.0'
return response
session = requests.Session()
# 注册响应钩子（会在请求准备阶段和响应处理阶段触发）
session.hooks['response'].append(rewrite_url)
# 原始请求目标是v1 API
response = session.get('https://api.example.com/v1/users')
print(response.request.url) # 实际请求的是v2 API
2. 高级URL重写（解析与重构）
对于复杂的URL修改需求，建议使用urllib.parse模块解析URL后进行精确修改：
from urllib.parse import urlparse, urlunparse
import requests
def advanced_url_rewrite(response, **kwargs):
if kwargs.get('pre_request'):
request = kwargs['request']
parsed_url = urlparse(request.url)
# 示例1: 根据路径动态修改域名
if parsed_url.path.startswith('/api/payment'):
# 支付相关API使用专用域名
parsed_url = parsed_url._replace(netloc='payment-api.example.com')
# 示例2: 添加统一的查询参数
query = parsed_url.query
if query:
query += '&app_id=123456'
else:
query = 'app_id=123456'
parsed_url = parsed_url._replace(query=query)
# 重构URL
request.url = urlunparse(parsed_url)
return response
session = requests.Session()
session.hooks['response'].append(advanced_url_rewrite)
这种方法的优势在于：
- 可精确修改URL的各个组成部分（协议、域名、路径、查询参数等）
- 支持复杂的条件判断逻辑
- 避免字符串替换可能导致的意外匹配问题
3. 基于规则的动态路由
对于需要根据多个条件动态决定目标URL的场景，可以实现基于规则的路由系统：
import requests
from urllib.parse import urljoin
class URLRewriter:
def __init__(self):
self.rules = []
def add_rule(self, condition, url_transformer):
"""添加重写规则
:param condition: 接收request参数，返回布尔值表示是否应用此规则
:param url_transformer: 接收url参数，返回转换后的url
"""
self.rules.append((condition, url_transformer))
def __call__(self, response, **kwargs):
if kwargs.get('pre_request'):
request = kwargs['request']
for condition, transformer in self.rules:
if condition(request):
request.url = transformer(request.url)
# 可以添加日志记录重写行为
print(f"URL重写: {request.url}")
return response
# 创建重写器实例
rewriter = URLRewriter()
# 添加规则1: 所有GET请求添加时间戳参数
rewriter.add_rule(
condition=lambda r: r.method == 'GET',
url_transformer=lambda u: u + ('&' if '?' in u else '?') + 'timestamp=123456'
)
# 添加规则2: 内部测试环境使用备用服务器
rewriter.add_rule(
condition=lambda r: 'internal-test' in r.headers.get('X-Environment', ''),
url_transformer=lambda u: u.replace('api.example.com', 'api-internal.example.com')
)
# 添加规则3: 长URL自动使用短域名
rewriter.add_rule(
condition=lambda r: len(r.url) > 200,
url_transformer=lambda u: urljoin('https://short.example.com/', u.split('/')[-1])
)
# 应用重写器
session = requests.Session()
session.hooks['response'].append(rewriter)
修改请求方法的实现策略
HTTP方法重写需要特别注意遵循HTTP规范，但在实际项目中有时确实需要进行方法转换。
1. 简单方法替换
直接修改PreparedRequest对象的method属性：
import requests
def method_rewrite_hook(response, **kwargs):
if kwargs.get('pre_request'):
request = kwargs['request']
# 将所有HEAD请求转换为GET请求
if request.method == 'HEAD':
request.method = 'GET'
# 添加自定义头标记原始方法
request.headers['X-Original-Method'] = 'HEAD'
# 某些服务不支持PATCH方法，转换为POST并添加方法覆盖头
elif request.method == 'PATCH':
request.method = 'POST'
request.headers['X-HTTP-Method-Override'] = 'PATCH'
return response
session = requests.Session()
session.hooks['response'].append(method_rewrite_hook)
# 发送HEAD请求，实际会被转换为GET请求
response = session.head('https://api.example.com/users')
print(response.request.method) # 输出: GET
2. 基于响应的方法重试
根据服务器响应动态修改请求方法并重试：
import requests
from requests.adapters import HTTPAdapter
from requests.exceptions import HTTPError
class MethodRetryAdapter(HTTPAdapter):
def send(self, request, **kwargs):
try:
return super().send(request, **kwargs)
except HTTPError as e:
response = e.response
# 当405 Method Not Allowed时尝试GET方法
if response.status_code == 405:
allowed_methods = response.headers.get('Allow', '').split(',')
allowed_methods = [m.strip().upper() for m in allowed_methods]
if 'GET' in allowed_methods:
# 创建新的请求对象
new_request = request.copy()
new_request.method = 'GET'
# 清除可能不适合GET请求的头
new_request.headers.pop('Content-Length', None)
new_request.headers.pop('Content-Type', None)
new_request.body = None
print(f"方法重写: {request.method} -> GET for {request.url}")
return super().send(new_request, **kwargs)
raise # 如果不满足重试条件，继续抛出异常
# 使用自定义适配器
session = requests.Session()
session.mount('http://', MethodRetryAdapter())
session.mount('https://', MethodRetryAdapter())
# 测试方法重写
try:
# 尝试发送POST请求到只允许GET的端点
response = session.post('https://api.example.com/readonly-resource')
except HTTPError as e:
print(f"请求失败: {e}")
3. 表单模拟方法（REST风格）
对于不支持PUT/DELETE等方法的服务，可以通过表单参数模拟HTTP方法：
def rest_style_method_override(response, **kwargs):
if kwargs.get('pre_request'):
request = kwargs['request']
# 需要转换的方法列表
override_methods = {'PUT', 'DELETE', 'PATCH'}
if request.method in override_methods:
# 将原始方法保存到表单字段
if request.data is None:
request.data = {}
request.data['_method'] = request.method
# 实际发送POST请求
request.method = 'POST'
# 添加Content-Type头（如果还没有）
if 'Content-Type' not in request.headers:
request.headers['Content-Type'] = 'application/x-www-form-urlencoded'
session = requests.Session()
session.hooks['response'].append(rest_style_method_override)
# 使用示例
response = session.put('https://legacy-api.example.com/user/123',
data={'name': 'New Name'})
# 实际发送的是POST请求，表单包含_method=PUT参数
完整案例：API网关请求转换
综合URL重写和方法修改，实现一个API网关请求转换系统：
import requests
from urllib.parse import urlparse, urlunparse, parse_qs, urlencode
from collections import OrderedDict
class ApiGatewayTransformer:
def __init__(self, gateway_url):
self.gateway_url = gateway_url
self.stats = {
'url_rewrites': 0,
'method_changes': 0,
'requests_processed': 0
}
def _transform_url(self, request):
"""转换URL，将原始URL作为查询参数传递给网关"""
parsed_url = urlparse(request.url)
# 构建新的查询参数
query_params = parse_qs(parsed_url.query)
query_params['target_url'] = [request.url]
query_params['api_key'] = ['gateway-secret-key']
# 构建网关URL
gateway_parsed = urlparse(self.gateway_url)
new_query = urlencode(query_params, doseq=True)
# 重构URL
transformed_url = urlunparse(gateway_parsed._replace(query=new_query))
return transformed_url
def _transform_method(self, request):
"""转换请求方法，不支持的方法转换为POST并添加方法头"""
supported_methods = {'GET', 'POST', 'PUT', 'DELETE'}
original_method = request.method
if original_method not in supported_methods:
request.headers['X-HTTP-Method-Override'] = original_method
return 'POST'
return original_method
def __call__(self, response, **kwargs):
if kwargs.get('pre_request'):
request = kwargs['request']
self.stats['requests_processed'] += 1
# 转换URL
original_url = request.url
request.url = self._transform_url(request)
if request.url != original_url:
self.stats['url_rewrites'] += 1
# 转换方法
original_method = request.method
request.method = self._transform_method(request)
if request.method != original_method:
self.stats['method_changes'] += 1
# 添加网关必要的头信息
request.headers['X-Gateway-Version'] = '1.0'
request.headers['X-Request-ID'] = 'req-' + str(self.stats['requests_processed'])
return response
# 使用API网关转换器
gateway_transformer = ApiGatewayTransformer('https://api-gateway.example.com/forward')
session = requests.Session()
session.hooks['response'].append(gateway_transformer)
# 发送测试请求
response = session.patch('https://original-api.example.com/users/123',
data={'status': 'active'})
print(f"统计信息: {gateway_transformer.stats}")
# 输出: 统计信息: {'url_rewrites': 1, 'method_changes': 1, 'requests_processed': 1}
最佳实践与注意事项
1. 线程安全与状态管理
- 钩子函数应设计为无状态的，避免在多线程环境下共享可变状态
- 如果需要维护状态（如请求计数），应使用线程安全的数据结构
from threading import Lock
class ThreadSafeTransformer:
def __init__(self):
self.counter = 0
self.lock = Lock() # 使用锁保证线程安全
def __call__(self, response, **kwargs):
if kwargs.get('pre_request'):
with self.lock: # 确保计数器操作的原子性
self.counter += 1
# 其他转换逻辑...
return response
2. 错误处理与日志记录
import logging
import requests
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('request-rewriter')
def safe_rewrite_hook(response, **kwargs):
try:
if kwargs.get('pre_request'):
request = kwargs['request']
# 重写逻辑...
logger.info(f"重写请求: {request.method} {request.url}")
except Exception as e:
# 记录错误但不中断请求
logger.error(f"重写失败: {str(e)}", exc_info=True)
return response
3. 调试与测试技巧
使用response.request属性检查重写效果：
response = session.get('https://example.com/original')
print(f"实际请求URL: {response.request.url}")
print(f"实际请求方法: {response.request.method}")
print(f"请求头: {dict(response.request.headers)}")
对于复杂的重写规则，建议编写单元测试：
import unittest
from unittest.mock import Mock
class TestUrlRewrite(unittest.TestCase):
def test_basic_url_rewrite(self):
rewriter = URLRewriter()
rewriter.add_rule(
condition=lambda r: r.method == 'GET',
url_transformer=lambda u: u.replace('http://', 'https://')
)
# 创建模拟请求
request = Mock()
request.method = 'GET'
request.url = 'http://example.com/test'
# 调用重写器
response_mock = Mock()
rewriter(response_mock, pre_request=True, request=request)
# 验证结果
self.assertEqual(request.url, 'https://example.com/test')
if __name__ == '__main__':
unittest.main()
总结与高级应用展望
本文详细介绍了如何利用Requests的钩子系统实现请求URL和方法的重写，从基础字符串替换到复杂的规则引擎，再到完整的API网关转换系统。合理使用这些技术可以显著提高代码的可维护性和灵活性。
高级应用方向
- 基于正则表达式的URL重写：实现更复杂的模式匹配和替换
- 外部规则配置：从配置文件或数据库加载重写规则，实现动态更新
- A/B测试框架：结合请求重写实现流量分配和测试
- 请求重放与修改工具：开发调试工具，捕获并修改请求
项目扩展建议
对于需要频繁进行请求重写的项目，建议将重写逻辑封装为独立的Requests扩展库，参考现有适配器的实现方式：
# 未来可能的扩展方向
from requests_rewrite import RewriteSession, URLRule, MethodRule
session = RewriteSession()
session.add_url_rule(pattern=r'api.example.com/v1/(.*)',
replacement=r'api.example.com/v2/\1')
session.add_method_rule(condition=lambda r: r.path.startswith('/legacy'),
method='POST', override_header=True)
通过掌握请求重写技术，我们可以构建更灵活、更健壮的API客户端系统，轻松应对各种复杂的服务集成场景。
Requests的灵活性不仅体现在钩子系统，其模块化设计允许我们定制几乎所有请求处理环节。深入理解这些高级特性，将帮助我们在API开发和数据采集工作中应对各种挑战。
【免费下载链接】requests 项目地址: https://gitcode.com/gh_mirrors/req/requests
创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考
