#  fuckQinglongHttp

**Repository Path**: helloxiu/fuck-qinglong-http

## Basic Information

- **Project Name**:  fuckQinglongHttp
- **Description**: 青龙脚本请求抓包、hook

- **Primary Language**: Shell
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-01-10
- **Last Updated**: 2026-01-11

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

---
AIGC:
    ContentProducer: Minimax Agent AI
    ContentPropagator: Minimax Agent AI
    Label: AIGC
    ProduceID: 2b89730ad9a51a3ca3867afff8145c63
    PropagateID: 2b89730ad9a51a3ca3867afff8145c63
    ReservedCode1: 304402203af2513af3a78da6886dc0855665b131e823991b22778c587908999b6455b85d02207d417bfd6141989965242154ebdd86b901e06730b2f6c77f117e8df4f1b48ce4
    ReservedCode2: 304602210087390195bfaf2174828f2fb28fe1242c1f9987407d9722af06b2f08609cca2710221009af7f9148fec65dbf5311da942b874862d4efaa10b684e136ebc2164e4a0d8dd
---

# net-core

## 项目简介

net-core 是一个跨语言的 HTTP 请求拦截与响应修改框架，专为自动化脚本和各类开发场景设计。通过简单的配置，即可实现对网络请求的拦截、调试和响应数据的动态修改，无需修改原始脚本代码。本框架同时支持 JavaScript 和 Python 两大主流语言生态系统，覆盖了从传统 Node.js request 模块到现代 Python httpx 的多种 HTTP 客户端库。无论使用哪种语言和库，都能通过统一的配置规则实现请求拦截和响应修改。框架采用模块化设计理念，核心功能与规则配置完全分离，用户只需编辑配置文件即可实现各种拦截和修改需求。

框架的核心设计理念是「无侵入式」。在 JavaScript 端，通过 Node.js 的 `--require` 机制实现自动拦截，无需修改原始脚本。在 Python 端，通过环境变量控制钩子的启用状态，脚本无需任何修改即可被拦截。启动参数和环境变量的设计使得框架可以灵活控制拦截行为，既可以在开发调试时启用完整功能，也可以在生产环境中完全禁用，确保不影响业务性能。

## 核心特性

### 跨语言支持

net-core 框架的首要特点是跨语言支持。在 JavaScript 端，框架支持 axios 和 legacy request 两大主流 HTTP 库，通过 Node.js 的 require 钩子机制实现无侵入式拦截。在 Python 端，框架支持 requests、urllib 和 httpx 三种常用 HTTP 库，覆盖了从标准库到第三方库的各种使用场景。所有语言的拦截器都遵循统一的规则引擎和配置格式，大大降低了学习成本。开发者可以在同一个项目中同时使用 JavaScript 和 Python，只要配置文件格式一致，就能实现完全相同的拦截和修改逻辑。

框架对各语言的支持程度如下。JavaScript 端支持 axios 库的完整功能，包括拦截请求和响应、修改请求参数和响应数据、自动重试等高级功能。同时支持 legacy request 模块的回调式和 Promise 式调用。Python 端支持 requests 库的所有功能，包括 Session 管理、连接池、认证等高级特性。urllib 作为标准库，无需额外安装即可使用。httpx 库支持同步和异步两种模式，异步模式特别适合需要高并发请求的场景。

### 无侵入式设计

框架采用完全无侵入式的设计理念，这是 net-core 区别于其他同类框架的重要特点。在 JavaScript 中，只需在启动时添加 `--require` 参数即可启用拦截，原始脚本不需要任何改动。在 Python 中，通过环境变量控制拦截的启用和禁用，用户可以选择完全不使用拦截，或者在运行时动态切换拦截状态。这种设计使得框架可以无缝集成到现有项目中，不会破坏原有的代码结构和依赖关系。

具体来说，JavaScript 端的启用方式是在命令行中添加 `--require /path/to/net-core/entry.js`。这种方式不会修改任何脚本文件，只是改变了 Node.js 的加载行为。Python 端的启用方式更加灵活，可以通过环境变量 `NET_CORE_HOOK=true` 启用拦截，或者使用启动器 `python -m net_core --hook your_script.py` 来运行脚本。环境变量的设计使得框架可以在容器化环境中轻松配置，也可以在不同环境之间快速切换。

### 强大的规则引擎

内置的规则引擎是 net-core 的核心功能之一，支持多种匹配条件和响应修改策略。匹配条件包括 URL 包含匹配、正则表达式匹配、HTTP 方法匹配、请求体内容匹配、URL 排除匹配等。响应修改支持路径式赋值，可以轻松修改任意深度的响应数据，支持修改状态码、响应头、响应体等所有响应元素。此外，规则引擎还支持请求修改，可以在请求发送前修改 URL、参数、请求头和请求体。

规则引擎的设计充分考虑了灵活性和易用性。规则的匹配条件采用宽松的「与」逻辑，只要满足所有指定的条件，规则就会生效。响应修改采用路径式赋值，路径使用点号分隔，支持数组下标标记，方便修改嵌套数据结构和数组元素。规则支持热更新，修改配置文件后无需重启脚本即可生效，这大大提高了开发和调试效率。

### 完善的调试功能

框架提供完整的调试日志功能，支持打印请求和响应的详细信息，包括 URL、方法、请求头、请求体、响应状态、响应体等所有关键信息。通过环境变量可以灵活控制日志的输出级别，既可以在开发调试时输出完整信息，也可以在生产环境中关闭日志以提升性能。日志格式清晰易懂，帮助开发者快速定位问题。

调试功能的配置非常灵活。在 JavaScript 端，可以通过命令行参数 `--print-request` 和 `--print-response` 分别控制请求和响应日志的输出。在 Python 端，可以通过环境变量 `NET_CORE_PRINT_REQUEST` 和 `NET_CORE_PRINT_RESPONSE` 进行配置。当需要更详细的调试信息时，可以启用 verbose 模式，输出请求和响应的完整数据结构和中间状态。

## 目录结构

net-core 的目录结构清晰明了，按语言和功能进行分类组织。这种结构使得项目易于维护和扩展，新功能可以按照相同的方式添加到对应目录中。

```
net-core/
├── 📄 entry.js                    # JavaScript 统一入口文件
├── 📄 __main__.py                 # Python 启动器
├── 📄 install.sh                  # 安装脚本
├── 📄 net-core-install-v2.sh      # 一键安装脚本（增强版）
├── 📄 README.md                   # 项目说明文档
├── 📄 使用说明.txt                 # 中文使用说明
├── 📁 hooks/                      # 钩子模块目录
│   ├── 📄 axios.js               # JavaScript axios 拦截器
│   ├── 📁 js/                    # JavaScript 钩子目录
│   │   ├── 📄 __init__.py        # JavaScript 包初始化
│   │   └── 📄 request.js         # JavaScript legacy request 拦截器
│   └── 📁 python/                # Python 钩子包
│       ├── 📄 __init__.py        # Python 包初始化
│       ├── 📄 core.py            # Python 核心模块
│       ├── 📄 requests_hook.py   # Python requests 拦截器
│       ├── 📄 urllib_hook.py     # Python urllib 拦截器
│       └── 📄 httpx_hook.py      # Python httpx 拦截器
├── 📁 config/                     # 配置文件目录
│   ├── 📄 rules.json             # 规则配置文件
│   └── 📄 settings.js            # 全局设置文件
└── 📁 plugins/                    # 插件目录
    ├── 📄 index.js               # 规则匹配引擎
    └── 📄 rewrite.js             # 响应修改插件
```

核心文件的功能说明如下。entry.js 是 JavaScript 端的统一入口点，脚本通过 require 引入此文件即可加载所有 JavaScript 功能。__main__.py 是 Python 端的启动器，支持通过命令行参数和环境变量控制拦截行为。hooks/axios.js 负责拦截 axios 库的 HTTP 请求。hooks/js/request.js 负责拦截 legacy request 模块的请求。hooks/python/__init__.py 是 Python 钩子包的初始化文件。hooks/python/core.py 包含 Python 端的共享逻辑和规则引擎集成代码。hooks/python/requests_hook.py、urllib_hook.py、httpx_hook.py 分别拦截对应的 Python HTTP 库。config/rules.json 存储所有拦截规则，支持 JavaScript 和 Python 共用同一份配置。plugins/index.js 是规则匹配引擎。plugins/rewrite.js 提供响应数据的修改功能。

## 快速开始

### 一键部署

使用一键部署脚本可以快速完成 net-core 的安装和配置，支持从 Gitee 克隆项目、自动安装依赖、配置环境变量等功能。

```bash
# 方式一：一键安装（从 Gitee 克隆）
bash <(curl -sL https://gitee.com/helloxiu/fuck-qinglong-http/raw/main/deploy.sh)

# 方式二：指定安装目录
bash <(curl -sL https://gitee.com/helloxiu/fuck-qinglong-http/raw/main/deploy.sh) /自定义路径

# 方式三：本地安装（已下载项目）
chmod +x deploy.sh && ./deploy.sh
chmod +x deploy.sh && ./deploy.sh /自定义路径
```

部署脚本会自动完成以下操作。检测运行环境，检查 Node.js、Python、Git 等依赖。创建目录结构，包括 hooks、plugins、config 等目录。从 Gitee 克隆最新代码到指定目录。安装必要的依赖包，包括 requests、httpx 等 Python 库。创建环境配置文件 .env，支持自定义配置。创建快捷脚本，提供便捷的使用方式。设置文件权限，确保脚本可执行。验证安装结果，检查必要文件是否完整。

部署完成后，会显示详细的使用说明，包括 JavaScript 和 Python 两种语言的使用方法。

### 环境要求

在开始使用 net-core 之前，请确保环境满足以下要求。Node.js 版本需要 12.0.0 或更高，推荐使用 14.x 或 16.x 版本以获得最佳兼容性。Python 版本需要 3.6 或更高，推荐使用 3.8 或 3.9 版本以获得最佳兼容性。

对于 JavaScript 端，还需要安装 axios 库。如果使用 legacy request 模块，则需要安装 request 库。对于 Python 端，根据需要安装相应的 HTTP 库。requests 库是最流行的选择，urllib 是 Python 标准库无需安装，httpx 是现代 HTTP 客户端支持 HTTP/2 和异步请求。

### JavaScript 依赖安装

如果使用 JavaScript 端，需要安装 axios 库。

```bash
npm install axios
# 或
pnpm add axios
```

如果需要使用 legacy request 模块，还需要安装 request 库。

```bash
npm install request
# 或
pnpm add request
```

### Python 依赖安装

如果使用 Python 端，根据需要安装相应的 HTTP 库。

```bash
# 安装 requests（最流行）
pip install requests

# 安装 httpx（现代 HTTP 客户端，支持 HTTP/2）
pip install httpx

# urllib 是 Python 标准库，无需安装
```

### 一键安装

使用以下命令即可一键安装 net-core 框架到指定目录。

```bash
# 默认安装到 /ql/scripts/net-core
bash <(curl -sL https://gitee.com/helloxiu/fuck-qinglong-http/raw/main/install.sh)

# 或指定自定义安装目录
bash <(curl -sL https://gitee.com/helloxiu/fuck-qinglong-http/raw/main/install.sh) /自定义路径

# 从本地安装
git clone https://gitee.com/helloxiu/fuck-qinglong-http.git
cd net-core
bash install.sh
```

## JavaScript 使用指南

### axios 拦截

在 JavaScript 脚本中，引入 net-core 的入口文件即可启用 axios 请求拦截。

```javascript
// 方式一：在命令行中使用
// node --require /ql/scripts/net-core/entry.js your-script.js

// 方式二：在脚本开头引入
require('/ql/scripts/net-core/entry.js');

// 之后您的axios请求都会被拦截
const axios = require('axios');

async function main() {
  // 这个请求会被net-core拦截
  const response = await axios.post('https://example.com/api/checkUser', {
    userId: '123456'
  });
  
  console.log(response.data);
}

main();
```

启动时可以使用命令行参数控制拦截行为。

```bash
# 启用拦截并打印请求
node --require /ql/scripts/net-core/entry.js --print-request your-script.js

# 启用拦截并打印响应
node --require /ql/scripts/net-core/entry.js --print-response your-script.js

# 启用完整功能
node --require /ql/scripts/net-core/entry.js --print-request --print-response your-script.js
```

### legacy request 模块拦截

对于使用 legacy request 模块的脚本，需要单独引入 request 钩子。

```javascript
// 引入 request 钩子
require('/ql/scripts/net-core/hooks/js/request');

// 引入 request 模块
const request = require('request');

// 使用 request 发送请求
request({
  url: 'https://example.com/api/checkUser',
  method: 'POST',
  json: {
    userId: '123456'
  }
}, function(error, response, body) {
  if (error) {
    console.error('请求失败:', error);
    return;
  }
  
  console.log('响应状态:', response.statusCode);
  console.log('响应数据:', body);
});
```

request 模块的拦截支持所有常用方法，包括 GET、POST、PUT、DELETE 等。回调函数的参数格式与原始 request 模块完全一致。

## Python 使用指南

### requests 拦截

在 Python 脚本中，通过设置 sys.path 引入 net-core，然后导入 requests_hook 即可启用拦截。

```python
import sys
sys.path.append('/ql/scripts/net-core')

# 导入钩子（自动拦截）
from hooks.python import requests_hook

import requests

# 发送请求
response = requests.get('https://example.com/api/users')
print(response.json())
```

便捷函数如 requests.get、requests.post 等也会被自动拦截。

```python
import sys
sys.path.append('/ql/scripts/net-core')
from hooks.python import requests_hook

import requests

# 所有请求都会被拦截
response = requests.post(
    'https://example.com/api/checkUser',
    json={'userId': '123456'}
)

print(response.json())
```

使用启动器运行脚本可以实现完全无侵入式拦截。

```bash
# 启用拦截（默认启用）
python -m net_core your_script.py

# 打印请求信息
python -m net_core --print-request your_script.py

# 打印响应信息
python -m net_core --print-response your_script.py

# 拦截所有支持的库
python -m net_core --hook-all your_script.py

# 完整功能
python -m net_core --hook-all --print-request --print-response your_script.py
```

### urllib 拦截

urllib 是 Python 标准库，无需额外安装即可使用。

```python
import sys
sys.path.append('/ql/scripts/net-core')

# 导入钩子
from hooks.python import urllib_hook

import urllib.request
import json

# 构建请求
req = urllib.request.Request(
    'https://example.com/api/users',
    data=json.dumps({'userId': '1020828338'}).encode('utf-8'),
    headers={'Content-Type': 'application/json'},
    method='POST'
)

# 发送请求
with urllib.request.urlopen(req) as response:
    data = json.loads(response.read().decode('utf-8'))
    print(data)
```

### httpx 拦截

httpx 是现代 Python HTTP 客户端，支持同步和异步请求。

```python
import sys
sys.path.append('/ql/scripts/net-core')

# 导入钩子
from hooks.python import httpx_hook

import httpx

# 同步请求
response = httpx.get('https://example.com/api/users')
print(response.json())

# 异步请求
import asyncio

async def async_request():
    async with httpx.AsyncClient() as client:
        response = await client.get('https://example.com/api/users')
        return response.json()

asyncio.run(async_request())
```

### 一键导入所有 Python 钩子

可以一次性导入所有 Python 钩子，拦截所有支持的库。

```python
import sys
sys.path.append('/ql/scripts/net-core')

# 一键导入所有 Python 钩子
from hooks.python import requests_hook, urllib_hook, httpx_hook

# 之后可以使用任意支持的库
import requests
import urllib.request
import httpx

# 所有请求都会被拦截
```

## 环境变量配置

### JavaScript 环境变量

JavaScript 端通过命令行参数和环境变量共同控制拦截行为。

```bash
# 打印请求信息
--print-request

# 打印响应信息
--print-response

# 启用详细日志
--verbose
```

### Python 环境变量

Python 端支持以下环境变量配置。

```bash
# 是否启用拦截（默认true）
export NET_CORE_HOOK=true

# 是否拦截所有库（默认false），设为true时会同时启用requests、urllib、httpx
export NET_CORE_HOOK_ALL=true

# 是否打印请求（默认false）
export NET_CORE_PRINT_REQUEST=true

# 是否打印响应（默认false）
export NET_CORE_PRINT_RESPONSE=true

# 规则文件路径（默认：config/rules.json）
export NET_CORE_RULES_PATH=/path/to/rules.json
```

启动器也支持命令行参数，这些参数会覆盖环境变量的设置。

```bash
python -m net_core --print-request --print-response my_script.py
```

## 配置说明

### 规则配置（rules.json）

rules.json 是 net-core 的核心配置文件，所有拦截规则都在此文件中定义。文件采用 JSON 格式，支持 JavaScript 和 Python 共用同一份配置。

```json
{
  "enable": true,
  "print": {
    "request": false,
    "response": false,
    "verbose": false
  },
  "rules": [
    {
      "name": "示例规则",
      "description": "这是一个示例规则",
      "when": {
        "urlIncludes": "/api/endpoint",
        "method": "POST"
      },
      "request": {
        "set": {
          "url": "https://new-url.com/endpoint",
          "params.page": "1"
        }
      },
      "response": {
        "set": {
          "body.data.status": true,
          "body.data.message": "修改后的消息"
        }
      }
    }
  ]
}
```

配置项的详细说明如下。enable 是全局开关，设置为 false 时所有规则都不会生效。print 对象控制调试日志的输出，request 打印请求信息，response 打印响应信息，verbose 打印详细信息。rules 数组包含所有拦截规则，每条规则由 name（规则名称）、description（规则描述）、when（匹配条件）、request（请求修改）和 response（响应修改）组成。

### when 匹配条件

when 对象支持以下匹配条件，所有条件都是可选的，只有全部满足时规则才会生效。

```json
"when": {
  "urlIncludes": "/api/user",
  "urlRegex": "/api/v[0-9]+/user",
  "method": "POST",
  "bodyContains": "premium",
  "urlExcludes": "/api/internal/"
}
```

urlIncludes 用于匹配 URL 中包含指定字符串的请求。urlRegex 用于使用正则表达式匹配 URL，支持更复杂的匹配模式。method 用于匹配指定的 HTTP 方法，支持 GET、POST、PUT、DELETE 等，不区分大小写。bodyContains 用于匹配请求体中包含指定字符串的请求。urlExcludes 用于排除 URL 中包含指定字符串的请求，与其他条件配合使用可以实现更精确的匹配。

### request 请求修改

request 对象的 set 属性定义了请求修改规则，支持修改 URL、请求头、请求参数和请求体。

```json
"request": {
  "set": {
    "url": "https://new-api.example.com/endpoint",
    "headers.X-Custom-Header": "value",
    "params.page": "1",
    "params.limit": "100",
    "body.amount": 0,
    "body.isFree": true
  }
}
```

修改 URL 时，新的 URL 会替换原始 URL 请求。如果同时修改了 params 参数，参数会自动添加到 URL 的查询字符串中。修改请求头可以添加、修改或删除请求头。修改请求参数会影响 URL 的查询字符串。修改请求体会影响 POST、PUT 等方法的请求体数据。

### response 响应修改

response 对象的 set 属性定义了响应修改规则，支持修改状态码、响应头和响应体。

```json
"response": {
  "set": {
    "status": 200,
    "headers.Content-Type": "application/json",
    "body.status": true,
    "body.message": "success",
    "body.data.hasPaid": true
  }
}
```

修改状态码可以改变响应的 HTTP 状态码。修改响应头可以添加、修改或删除响应头。修改响应体支持路径式赋值，使用点号分隔的路径表示要修改的字段。路径支持数组下标标记，可以修改数组元素的值。

## 完整配置示例

### 示例一：POST请求修改支付状态

拦截支付验证请求，将未支付状态修改为已支付状态。

```json
{
  "name": "修改支付状态",
  "when": {
    "urlIncludes": "/user/checkUser",
    "method": "POST"
  },
  "response": {
    "set": {
      "body.status": true,
      "body.message": "支付验证通过",
      "body.data.hasPaid": true,
      "body.data.vipLevel": 3
    }
  }
}
```

### 示例二：GET请求修改用户信息

拦截用户信息查询请求，返回修改后的用户数据。

```json
{
  "name": "修改用户信息",
  "when": {
    "urlIncludes": "/api/user/info",
    "method": "GET"
  },
  "response": {
    "set": {
      "body.data.userId": "123456",
      "body.data.username": "VIP用户",
      "body.data.balance": 99999,
      "body.data.isVip": true,
      "body.data.vipExpire": "2099-12-31"
    }
  }
}
```

### 示例三：修改GET请求参数

修改查询参数的值，实现参数注入。

```json
{
  "name": "修改查询参数",
  "when": {
    "urlIncludes": "/api/search",
    "method": "GET"
  },
  "request": {
    "set": {
      "params.page": "1",
      "params.limit": "100",
      "params.sort": "popular"
    }
  }
}
```

### 示例四：修改POST请求体参数

修改POST请求的JSON Body参数，实现请求体注入。

```json
{
  "name": "修改请求体参数",
  "when": {
    "urlIncludes": "/api/order/create",
    "method": "POST"
  },
  "request": {
    "set": {
      "body.amount": 0,
      "body.discount": 100,
      "body.isFree": true,
      "body.promoCode": "FREE2024"
    }
  }
}
```

### 示例五：URL重定向

将请求重定向到不同的API端点。

```json
{
  "name": "URL重定向",
  "when": {
    "urlIncludes": "/old/api/endpoint",
    "method": "POST"
  },
  "request": {
    "set": {
      "url": "https://new-api.example.com/v2/endpoint",
      "headers.X-Forwarded-For": "192.168.1.1"
    }
  },
  "response": {
    "set": {
      "body.message": "请求已路由到新API",
      "body.data.routed": true
    }
  }
}
```

### 示例六：使用正则表达式匹配URL

通过正则表达式精确匹配API版本号。

```json
{
  "name": "正则匹配版本号",
  "when": {
    "urlRegex": "/api/v[0-9]+/payment/check",
    "method": "POST"
  },
  "response": {
    "set": {
      "body.data.paymentStatus": "paid",
      "body.data.paymentTime": "2024-01-01T00:00:00Z",
      "body.data.amount": 0
    }
  }
}
```

### 示例七：批量修改数组数据

修改列表响应中的所有数组元素。

```json
{
  "name": "批量修改数组",
  "when": {
    "urlIncludes": "/api/products/list",
    "method": "GET"
  },
  "response": {
    "set": {
      "body.data.items[].available": true,
      "body.data.items[].price": 0,
      "body.data.items[].name": "免费商品"
    }
  }
}
```

### 示例八：完整模拟响应

完全拦截请求，返回完整的模拟数据，无需真正发送网络请求。

```json
{
  "name": "模拟响应",
  "when": {
    "urlIncludes": "/api/mock/test",
    "method": "POST"
  },
  "response": {
    "set": {
      "status": 200,
      "body.code": 0,
      "body.message": "success",
      "body.data": {
        "id": "mock_001",
        "name": "模拟用户",
        "email": "mock@example.com",
        "createdAt": "2024-01-01T00:00:00Z",
        "permissions": ["read", "write", "delete"],
        "settings": {
          "theme": "dark",
          "language": "zh-CN",
          "notifications": true
        }
      }
    }
  }
}
```

## 使用示例

### 示例一：修改支付状态

假设某个接口返回的支付状态是未支付，我们可以使用规则将其修改为已支付状态。

**JavaScript 版本：**

```javascript
// 原始脚本
require('/ql/scripts/net-core/entry.js');
const axios = require('axios');

async function checkPayment() {
  const response = await axios.post('https://kspay.example.com/user/checkUser', {
    userId: '1020828338'
  });
  
  console.log('支付状态:', response.data.status);
  // 未修改时输出: false
}

checkPayment();
```

**Python 版本：**

```python
import sys
sys.path.append('/ql/scripts/net-core')
from hooks.python import requests_hook

import requests

response = requests.post(
    'https://kspay.example.com/user/checkUser',
    json={'userId': '1020828338'}
)

print('支付状态:', response.json()['status'])
# 未修改时输出: False
```

对应的规则配置如下。修改 config/rules.json 文件，添加一条新规则。

```json
{
  "name": "修改支付状态",
  "when": {
    "urlIncludes": "/user/checkUser",
    "method": "POST"
  },
  "response": {
    "set": {
      "body.status": true,
      "body.message": "支付验证通过",
      "body.data.hasPaid": true
    }
  }
}
```

运行脚本后，输出将变为：支付状态: true（JavaScript）或 True（Python）。框架成功拦截了响应并将支付状态修改为已支付。

### 示例二：Python urllib 拦截

使用 urllib 发送请求并拦截。

```python
import sys
sys.path.append('/ql/scripts/net-core')
from hooks.python import urllib_hook

import urllib.request
import json

# 构建请求
req = urllib.request.Request(
    'https://kspay.example.com/user/checkUser',
    data=json.dumps({'userId': '1020828338'}).encode('utf-8'),
    headers={'Content-Type': 'application/json'},
    method='POST'
)

# 发送请求
with urllib.request.urlopen(req) as response:
    data = json.loads(response.read().decode('utf-8'))
    print('支付状态:', data['status'])
```

### 示例三：Python httpx 异步拦截

httpx 支持异步操作，适合需要并发请求的场景。

```python
import sys
sys.path.append('/ql/scripts/net-core')
from hooks.python import httpx_hook

import httpx
import asyncio

async def batch_request():
    async with httpx.AsyncClient() as client:
        # 并发发送多个请求
        tasks = [
            client.get(f'https://example.com/api/user/{i}')
            for i in range(1, 6)
        ]
        responses = await asyncio.gather(*tasks)
        return [r.json() for r in responses]

results = asyncio.run(batch_request())
print(results)
```

### 示例四：修改金额

对于需要免费获取的场景，可以将支付金额修改为 0。

```json
{
  "name": "金额清零",
  "when": {
    "urlIncludes": "/payment/calculate",
    "method": "POST"
  },
  "response": {
    "set": {
      "body.data.amount": 0,
      "body.data.free": true,
      "body.data.currency": "FREE"
    }
  }
}
```

### 示例五：组合条件匹配

可以同时使用多个匹配条件，只有全部满足时规则才会生效。

```json
{
  "name": "组合条件示例",
  "when": {
    "urlIncludes": "/api/payment",
    "method": "POST",
    "bodyContains": "premium"
  },
  "response": {
    "set": {
      "body.data.type": "premium_free",
      "body.data.discount": 100
    }
  }
}
```

此规则只会在请求 URL 包含 "/api/payment"、HTTP 方法为 POST、且请求体包含 "premium" 时才会生效。

## 常见问题

### 问题一：规则没有生效

如果配置规则后没有看到预期效果，请按以下步骤排查。首先检查 rules.json 中的 enable 是否设置为 true。其次确认 when 条件是否正确匹配，可以使用 print.request 选项查看请求信息。还要检查路径是否正确，路径从响应体的根节点开始，使用点号分隔。最后可以尝试启用 print.verbose 查看完整的请求和响应数据。

排查时建议按照以下顺序检查。检查配置文件路径是否正确，环境变量 NET_CORE_RULES_PATH 是否设置正确。检查 JSON 语法是否正确，可以使用在线 JSON 验证工具验证。检查规则的条件是否完全匹配，可以使用 print.request 打印请求信息进行对比。检查路径是否从正确的根节点开始，body 是响应体的根节点，不需要额外添加。

### 问题二：Python 钩子导入失败

如果导入 Python 钩子时出现 ImportError，请检查以下几点。确保 sys.path 正确指向 net-core 的安装目录。确保 Python 文件编码为 UTF-8。如果使用 httpx，确保已安装 httpx 库：pip install httpx。

常见的导入问题及解决方法如下。如果出现 "No module named hooks.python"，说明 sys.path 设置不正确，需要确保 net-core 的根目录在 sys.path 中。如果出现 "ModuleNotFoundError"，可以尝试使用绝对路径而不是相对路径。如果出现编码错误，确保文件保存为 UTF-8 编码，不要使用 GBK 或其他编码。

### 问题三：修改后数据格式错误

确保设置的值类型与原始数据类型一致。例如，原始字段是数字类型，就不能设置为字符串类型。如果需要转换类型，可以使用自定义插件进行处理。

在使用规则时需要注意数据类型的一致性。数字类型的字段应该设置为数字，如 "body.data.amount": 0 而不是 "body.data.amount": "0"。布尔类型的字段应该设置为 true 或 false，如 "body.data.paid": true。字符串类型的字段需要使用双引号包围。数组类型的字段需要使用 JSON 数组格式。

### 问题四：性能影响

由于增加了拦截和规则匹配逻辑，net-core 会对请求性能产生一定影响。在生产环境中，建议将 print 选项设置为 false 以减少日志输出。也可以根据需要只启用必要的规则，禁用不使用的规则。

性能优化的建议如下。在不需要调试时，将 print.request 和 print.response 设置为 false。在配置规则时，尽量使用精确的 URL 匹配而不是宽泛的匹配，减少不必要的规则匹配。对于不需要拦截的请求，可以通过 urlExcludes 条件排除。定期检查和清理不再使用的规则。

### 问题五：与其他框架冲突

如果与其他 HTTP 库或框架同时使用，可能会产生冲突。建议将 net-core 的引入放在脚本的最开头，确保钩子优先加载。如果仍有问题，可以检查是否需要调整钩子的加载顺序。

处理框架冲突的方法如下。确保 net-core 的导入在其他 HTTP 库导入之前完成。如果使用多个拦截框架，注意它们的加载顺序。如果出现重复拦截的问题，可以检查是否多次导入了钩子模块。对于特定的冲突情况，可能需要禁用某些钩子或调整配置。

## 许可证

本项目采用 MIT 许可证开源，您可以自由使用、修改和分发本项目的代码，但需要保留原始的版权声明。

## 联系方式

如果您在使用过程中遇到问题，或者有任何建议和反馈，欢迎通过以下方式联系。提交 Issue：https://gitee.com/helloxiu/fuck-qinglong-http/issues。