http

name	HTTP请求调试器
description	当调试HTTP请求时，分析请求/响应对，排查API问题，理解请求流程。调试请求并分析响应，解决网络通信问题。
license	MIT

HTTP请求调试器技能

概述

HTTP请求可能静默失败或表现异常。调试请求以理解实际发送和接收的内容，而不是你以为发送和接收的内容。大多数集成问题都是请求/响应不匹配，只有通过适当调试才能发现。

核心原则: 不要猜测 - 调试。查看实际发送和接收的内容，而不是你以为发送和接收的内容。

何时使用

始终:

• API没有按预期响应
• 请求神秘失败
• 头部没有正确发送
• 身份验证失败
• 响应格式不正确
• 网络连接问题

触发短语:

• "API调用失败了"
• "为什么请求不工作？"
• "检查这个HTTP请求"
• "调试API问题"
• "请求头部有问题"
• "响应格式错误"

HTTP请求调试功能

请求分析

• 请求方法验证
• URL参数检查
• 请求头部分析
• 请求体内容检查
• 认证信息验证

响应分析

• 状态码分析
• 响应头检查
• 响应体解析
• 错误信息提取
• 性能指标分析

网络诊断

• 连接状态检查
• 超时问题诊断
• SSL/TLS验证
• 代理配置检查
• 防火墙问题排查

常见HTTP请求问题

请求头缺失

问题:
必要的请求头部没有发送

后果:
- 身份验证失败
- 服务器拒绝请求
- 内容类型错误
- 缓存问题

解决方案:
- 检查请求头设置
- 验证认证头部
- 确认内容类型
- 添加必要头部

请求体格式错误

问题:
请求体格式不正确或编码错误

后果:
- 服务器解析失败
- 4xx错误响应
- 数据丢失
- 集成失败

解决方案:
- 验证JSON格式
- 检查字符编码
- 确认内容长度
- 测试请求体

网络连接问题

问题:
网络连接不稳定或被阻止

后果:
- 请求超时
- 连接被拒绝
- DNS解析失败
- 代理问题

解决方案:
- 检查网络连接
- 验证DNS设置
- 测试代理配置
- 检查防火墙规则

请求调试策略

分层调试方法

网络层:
- 检查DNS解析
- 验证端口连通性
- 测试SSL连接
- 分析网络延迟

应用层:
- 验证HTTP方法
- 检查URL格式
- 分析请求头部
- 验证请求体

业务层:
- 检查认证信息
- 验证权限设置
- 分析业务逻辑
- 测试数据格式

调试工具使用

浏览器开发者工具:
- Network面板监控
- 请求/响应查看
- 性能分析
- 错误诊断

命令行工具:
- curl命令测试
- wget下载测试
- telnet连接测试
- ping网络测试

专业工具:
- Postman接口测试
- Fiddler抓包分析
- Wireshark网络分析
- Charles代理调试

代码实现示例

Python请求调试器

import requests
import json
import time
from typing import Dict, Any, Optional
import logging
from urllib.parse import urlparse

class HTTPRequestDebugger:
    """HTTP请求调试器"""
    
    def __init__(self, log_level=logging.INFO):
        self.logger = logging.getLogger(__name__)
        self.logger.setLevel(log_level)
        self.session = requests.Session()
        
        # 设置默认超时
        self.session.timeout = 30
        
        # 启用详细日志
        logging.basicConfig(
            level=log_level,
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
        )
    
    def debug_request(self, method: str, url: str, **kwargs) -> Dict[str, Any]:
        """调试HTTP请求"""
        debug_info = {
            'request': {},
            'response': {},
            'timing': {},
            'errors': []
        }
        
        try:
            # 记录请求开始时间
            start_time = time.time()
            
            # 准备请求信息
            debug_info['request'] = {
                'method': method.upper(),
                : url,
                : (kwargs.get(, {})),
                : kwargs.get(, {}),
                : kwargs.get(, {}),
                : kwargs.get(, {}),
                : kwargs.get(, {}),
                : kwargs.get(, .session.timeout)
            }
            
            
            .logger.info()
            .logger.debug()
            .logger.debug()
            
             debug_info[][]:
                .logger.debug()
            
            
            response = .session.request(method, url, **kwargs)
            
            
            end_time = time.time()
            debug_info[] = {
                : start_time,
                : end_time,
                : end_time - start_time
            }
            
            
            debug_info[] = {
                : response.status_code,
                : response.reason,
                : (response.headers),
                : (response.content),
                : response.encoding,
                : (response.cookies),
                : response.url,
                : response.history
            }
            
            
            :
                content_type = response.headers.get(, ).lower()
                   content_type:
                    debug_info[][] = response.json()
                   content_type:
                    debug_info[][] = response.text
                :
                    debug_info[][] = 
             Exception  e:
                debug_info[][] = 
                debug_info[].append()
            
            
            .logger.info()
            .logger.debug()
            .logger.debug()
            
            
            ._check_common_issues(debug_info)
            
             debug_info
            
         requests.exceptions.Timeout  e:
            debug_info[].append()
            .logger.error()
         requests.exceptions.ConnectionError  e:
            debug_info[].append()
            .logger.error()
         requests.exceptions.RequestException  e:
            debug_info[].append()
            .logger.error()
         Exception  e:
            debug_info[].append()
            .logger.error()
        
         debug_info
    
     ():
        
        response = debug_info.get(, {})
        request = debug_info.get(, {})
        
        
        status_code = response.get()
         status_code >= :
             status_code == :
                debug_info[].append()
             status_code == :
                debug_info[].append()
             status_code == :
                debug_info[].append()
             status_code == :
                debug_info[].append()
             status_code >= :
                debug_info[].append()
        
        
        duration = debug_info.get(, {}).get(, )
         duration > :
            debug_info[].append()
        
        
        content_type = response.get(, {}).get(, )
          content_type:
            debug_info[].append()
        
        
        headers = request.get(, {})
            headers:
            debug_info[].append()
    
     () -> [, ]:
        
        comparison = {
            : [],
            : [],
            : [],
            : []
        }
        
        
        req1 = debug_info1.get(, {})
        req2 = debug_info2.get(, {})
        
         req1.get() != req2.get():
            comparison[].append({
                : ,
                : req1.get(),
                : req2.get()
            })
        
         req1.get() != req2.get():
            comparison[].append({
                : ,
                : req1.get(),
                : req2.get()
            })
        
        
        resp1 = debug_info1.get(, {})
        resp2 = debug_info2.get(, {})
        
         resp1.get() != resp2.get():
            comparison[].append({
                : ,
                : resp1.get(),
                : resp2.get()
            })
        
        
        time1 = debug_info1.get(, {})
        time2 = debug_info2.get(, {})
        
         (time1.get(, ) - time2.get(, )) > :
            comparison[].append({
                : ,
                : time1.get(),
                : time2.get()
            })
        
         comparison
    
     () -> [, ]:
        
         methods  :
            methods = [, , , , ]
        
        results = {}
        
         method  methods:
            :
                debug_info = .debug_request(method, url)
                results[method] = debug_info
             Exception  e:
                results[method] = {: (e)}
        
         results
    
     () -> :
        
        request = debug_info.get(, {})
        method = request.get(, )
        url = request.get(, )
        headers = request.get(, {})
        data = request.get(, {})  request.get(, {})
        
        curl_parts = [, , method]
        
        
         key, value  headers.items():
            curl_parts.extend([, ])
        
        
         data:
             (data, ):
                data = json.dumps(data, ensure_ascii=)
            curl_parts.extend([, data])
        
        
        curl_parts.append(url)
        
         .join(    (part)  (part)  part  curl_parts)


debugger = HTTPRequestDebugger()


get_result = debugger.debug_request(
    ,
    ,
    params={: },
    headers={: }
)

()
(json.dumps(get_result, indent=, ensure_ascii=))


post_result = debugger.debug_request(
    ,
    ,
    json={: },
    headers={: }
)

()
(json.dumps(post_result, indent=, ensure_ascii=))


curl_command = debugger.generate_curl_command(post_result)
()


endpoint_test = debugger.test_endpoint()
()

JavaScript请求调试器

class HTTPRequestDebugger {
    constructor(options = {}) {
        this.defaultHeaders = options.headers || {};
        this.timeout = options.timeout || 30000;
        this.logLevel = options.logLevel || 'info';
    }
    
    async debugRequest(method, url, options = {}) {
        const debugInfo = {
            request: {},
            response: {},
            timing: {},
            errors: []
        };
        
        try {
            const startTime = performance.now();
            
            // 准备请求信息
            debugInfo.request = {
                method: method.toUpperCase(),
                url: url,
                headers: { ...this.defaultHeaders, ...options.headers },
                params: options.params || {},
                body: options.body || null,
                timeout: options.timeout || this.timeout
            };
            
            // 构建完整URL
            const fullUrl = .(url, debugInfo..);
            
            
            .();
            .(, debugInfo..);
            
             (debugInfo..) {
                .(, debugInfo..);
            }
            
            
             response =  (fullUrl, {
                : method.(),
                : debugInfo..,
                : debugInfo..,
                : .(debugInfo..)
            });
            
             endTime = performance.();
            
            
            debugInfo. = {
                : startTime,
                : endTime,
                : endTime - startTime
            };
            
            debugInfo. = {
                : response.,
                : response.,
                : .(response.),
                : response.,
                : response.,
                : response.
            };
            
            
             {
                 contentType = response..() || ;
                 (contentType.()) {
                    debugInfo.. =  response.();
                }   (contentType.()) {
                    debugInfo.. =  response.();
                }  {
                     blob =  response.();
                    debugInfo.. = ;
                }
            }  (error) {
                debugInfo.. = ;
                debugInfo..();
            }
            
            
            .();
            .(, debugInfo..);
            .();
            
            
            .(debugInfo);
            
             debugInfo;
            
        }  (error) {
            debugInfo..();
            .();
             debugInfo;
        }
    }
    
    () {
         urlObj =  (url);
        .(params).( {
             (params[key] !==  && params[key] !== ) {
                urlObj..(key, params[key]);
            }
        });
         urlObj.();
    }
    
    () {
         obj = {};
        headers.( {
            obj[key] = value;
        });
         obj;
    }
    
    () {
         response = debugInfo. || {};
         request = debugInfo. || {};
        
        
         (response. >= ) {
             (response. === ) {
                debugInfo..();
            }   (response. === ) {
                debugInfo..();
            }   (response. === ) {
                debugInfo..();
            }   (response. === ) {
                debugInfo..();
            }   (response. >= ) {
                debugInfo..();
            }
        }
        
        
         (debugInfo. && debugInfo.. > ) {
            debugInfo..();
        }
        
        
         (!request. || !request.[]) {
            debugInfo..();
        }
    }
    
     () {
         results = {};
        
         ( method  methods) {
             {
                 debugInfo =  .(method, url);
                results[method] = debugInfo;
            }  (error) {
                results[method] = { : error. };
            }
        }
        
         results;
    }
    
    () {
         request = debugInfo. || {};
         method = request. || ;
         url = request. || ;
         headers = request. || {};
         body = request.;
        
         curl = ;
        
        
        .(headers).( {
            curl += ;
        });
        
        
         (body) {
             data =  body ===  ? body : .(body);
            curl += ;
        }
        
        
        curl += ;
        
         curl;
    }
    
    () {
         (. ===  || . === ) {
            .(...args);
        }
    }
    
    () {
        .(...args);
    }
}


  =  ({
    : {
        : 
    }
});


  () {
     {
        
         getResult =  .(, , {
            : { :  }
        });
        
        .(, getResult);
        
        
         postResult =  .(, , {
            : { :  },
            : .({ :  })
        });
        
        .(, postResult);
        
        
         curlCommand = .(postResult);
        .(, curlCommand);
        
        
         endpointTest =  .();
        .(, endpointTest);
        
    }  (error) {
        .(, error);
    }
}

();

调试最佳实践

系统化调试方法

1. 从简单开始: 先测试基本连接
2. 逐步增加复杂性: 添加头部、参数、数据
3. 记录每一步: 详细记录请求和响应
4. 比较差异: 对比工作和不工作的请求
5. 使用工具: 利用专业调试工具

常见调试场景

1. API集成问题: 检查认证、格式、URL
2. 性能问题: 分析响应时间、请求大小
3. 安全认证: 验证令牌、签名、证书
4. 数据格式: 检查JSON、XML、表单数据
5. 网络问题: 测试连接、代理、防火墙

相关技能

• api-validator - API接口验证和设计
• security-scanner - 安全漏洞扫描
• error-handling-logging - 错误处理和日志记录
• performance-profiler - 性能分析和监控