第一章：Postman 基础入门
1.1 Postman 简介与安装配置
1.1.1 Postman 是什么
Postman 是一款功能强大的 API 开发和测试平台，由 Postman Inc. 开发维护。它最初作为 Chrome 浏览器扩展程序发布，现已发展成为独立的跨平台桌面应用程序，支持 Windows、macOS 和 Linux 操作系统。
Postman 的核心定位是简化 API 开发流程，为开发者提供从 API 设计、开发、测试到文档编写的全生命周期管理能力。根据官方数据，全球有超过 2500 万开发者使用 Postman，成为 API 测试领域最流行的工具之一。
1.1.2 Postman 的核心能力
Postman 核心能力
API 开发
API 测试
API 文档
API 监控
团队协作
请求构建
响应查看
环境管理
手动测试
自动化测试
数据驱动测试
自动生成
在线发布
版本管理
定时监控
告警通知
性能分析
工作区共享
权限管理
版本控制
1.1.3 安装方式
方式一：官网下载（推荐）
访问 Postman 官网 https://www.postman.com/downloads/ 下载对应平台的安装包：
| 平台 | 系统要求 | 安装包类型 |
|---|---|---|
| Windows | Windows 10/11 64位 | .exe 安装程序 |
| macOS | macOS 10.13+ | .dmg 磁盘镜像 |
| Linux | Ubuntu 18.04+/Debian/Fedora | .tar.gz / .deb / .rpm |
方式二：命令行安装
bash
# Windows 使用 Chocolatey
choco install postman
# macOS 使用 Homebrew
brew install --cask postman
# Linux 使用 Snap
sudo snap install postman1.1.4 首次启动配置
首次启动 Postman 时，需要进行以下配置：
- 账户登录：支持 Google、GitHub、Email 注册登录，登录后可同步数据到云端
- 工作区选择：选择创建个人工作区或加入团队工作区
- 主题设置：支持浅色/深色主题切换
- 快捷键配置：可自定义常用操作快捷键
1.2 界面布局与核心功能概览
1.2.1 主界面结构
Postman 采用现代化的三栏式布局设计，界面清晰直观：
Postman 主界面
左侧边栏
中间工作区
右侧响应区
Collections 集合
APIs 接口定义
Environments 环境
Mock Servers
Monitors 监控
Flows 工作流
请求配置区
参数设置区
请求头设置
请求体设置
响应体
响应头
Cookies
响应头信息
1.2.2 核心功能模块详解
1. Collections（集合）
集合是 Postman 组织 API 请求的核心容器，类似于文件夹的概念。通过集合可以将相关的 API 请求分组管理，支持多级文件夹嵌套结构。
项目集合
├── 用户模块
│ ├── 登录接口
│ ├── 注册接口
│ └── 用户信息接口
├── 订单模块
│ ├── 创建订单
│ ├── 查询订单
│ └── 取消订单
└── 支付模块
├── 支付接口
└── 退款接口2. Environments（环境）
环境管理功能允许用户定义多套环境配置，每套环境包含一组变量键值对。通过切换环境，可以快速在不同服务器地址之间切换，无需修改每个请求的 URL。
3. APIs（接口定义）
APIs 模块支持导入和管理 API 定义文件，包括：
- OpenAPI 3.0/3.1（Swagger）
- RAML
- GraphQL Schema
- WSDL
4. Mock Servers（模拟服务器）
Mock Server 允许开发者在后端 API 未完成时，模拟 API 响应，实现前后端并行开发。
5. Monitors（监控）
Monitor 功能可以定时执行集合中的请求，监控 API 的可用性和性能，并在异常时发送告警通知。
6. Flows（工作流）
Flows 是 Postman 的可视化工作流编排功能，通过拖拽方式将多个请求组合成复杂的业务流程。
1.3 Workspace 工作区管理
1.3.1 工作区类型
Postman 提供三种类型的工作区，满足不同使用场景：
Workspace 工作区
个人工作区 Personal
团队工作区 Team
私有工作区 Private
仅自己可见
个人项目测试
学习实验
团队成员共享
协作开发
权限管理
企业版专属
敏感项目隔离
高级权限控制
1.3.2 工作区创建与管理
创建工作区步骤：
- 点击左上角工作区名称下拉菜单
- 选择 "Create Workspace"
- 填写工作区信息：
- Name：工作区名称
- Summary：工作区描述
- Visibility：可见性（Personal/Team/Private）
工作区配置示例：
json
{
"workspace": {
"id": "ws-abc123",
"name": "电商项目API测试",
"summary": "电商系统接口自动化测试工作区",
"type": "team",
"visibility": "team",
"createdBy": "user-001",
"createdAt": "2024-01-15T10:30:00Z",
"members": [
{
"userId": "user-001",
"role": "admin"
},
{
"userId": "user-002",
"role": "editor"
},
{
"userId": "user-003",
"role": "viewer"
}
]
}
}1.3.3 工作区权限角色
| 角色 | 权限说明 |
|---|---|
| Admin | 完全管理权限，包括删除工作区、管理成员 |
| Editor | 可编辑集合、环境、请求等资源 |
| Viewer | 只读权限，可查看但不能修改 |
1.4 Postman Agent 与 Interceptor
1.4.1 Postman Agent
Postman Agent 是一个本地代理服务，解决浏览器安全限制问题，允许 Postman Web 版访问本地网络资源。
工作原理：
本地服务 Postman Agent Postman Web 本地服务 Postman Agent Postman Web 发送请求到 localhost:端口 转发请求到本地服务 返回响应 转发响应到 Web 客户端
安装与启动：
bash
# macOS/Linux
open -a "Postman Agent"
# Windows
# 通过开始菜单启动 Postman Agent
# 或通过命令行启动
postman-agent配置参数：
| 参数 | 默认值 | 说明 |
|---|---|---|
| Agent Port | 50000 | Agent 监听端口 |
| API Port | 50001 | API 服务端口 |
| Log Level | info | 日志级别 |
1.4.2 Postman Interceptor
Postman Interceptor 是一个 Chrome 浏览器扩展，用于捕获浏览器中的 HTTP 请求并同步到 Postman。
主要功能：
- 请求捕获：自动捕获浏览器中发送的所有 HTTP 请求
- Cookie 同步：将浏览器 Cookie 同步到 Postman
- 请求拦截：可在请求发送前进行修改
安装步骤：
- 打开 Chrome 网上应用店
- 搜索 "Postman Interceptor"
- 点击 "添加至 Chrome" 安装扩展
- 在 Postman 中启用 Interceptor 连接
使用场景：
javascript
// 场景：捕获登录后的请求
// 1. 在浏览器中完成登录操作
// 2. Interceptor 自动捕获登录请求和响应
// 3. Cookie 自动同步到 Postman
// 4. 在 Postman 中直接使用登录态发送后续请求1.5 第一个 API 请求快速上手
1.5.1 创建第一个 GET 请求
让我们通过一个实际案例，快速上手 Postman 的基本操作。
目标： 调用公开的 JSONPlaceholder API 获取用户列表
步骤演示：
-
创建新请求
- 点击左上角 "New" 按钮
- 选择 "HTTP Request"
-
配置请求参数
- 方法：选择
GET - URL：输入
https://jsonplaceholder.typicode.com/users
- 方法：选择
-
发送请求
- 点击 "Send" 按钮
- 等待响应返回
-
查看响应
json
// 响应示例（部分数据）
[
{
"id": 1,
"name": "Leanne Graham",
"username": "Bret",
"email": "Sincere@april.biz",
"address": {
"street": "Kulas Light",
"suite": "Apt. 556",
"city": "Gwenborough",
"zipcode": "92998-3874"
},
"phone": "1-770-736-8031 x56442",
"website": "hildegard.org"
}
]1.5.2 创建第一个 POST 请求
目标： 创建一个新的用户资源
请求配置：
方法：POST
URL：https://jsonplaceholder.typicode.com/users请求头（Headers）：
| Key | Value |
|---|---|
| Content-Type | application/json |
请求体（Body）：
json
{
"name": "张三",
"username": "zhangsan",
"email": "zhangsan@example.com",
"phone": "13800138000",
"website": "zhangsan.com"
}响应结果：
json
{
"id": 11,
"name": "张三",
"username": "zhangsan",
"email": "zhangsan@example.com",
"phone": "13800138000",
"website": "zhangsan.com"
}1.6 请求构建器详解
1.6.1 URL 输入区
URL 输入区是配置 API 请求的核心区域，支持完整的 URL 语法：
协议://主机名:端口/路径?查询参数#锚点URL 组成部分解析：
完整URL
协议 https://
主机名 api.example.com
端口 :8080
路径 /v1/users
查询参数 ?page=1&size=10
锚点 #section
URL 参数化示例：
# 使用环境变量
{{baseUrl}}/api/v1/users
# 使用路径参数
{{baseUrl}}/api/v1/users/{{userId}}
# 使用查询参数
{{baseUrl}}/api/v1/users?page={{page}}&size={{size}}1.6.2 Headers 请求头设置
请求头用于传递请求的元数据信息，Postman 提供了可视化的请求头管理界面。
常用请求头类型：
| Header | 说明 | 示例值 |
|---|---|---|
| Content-Type | 请求体类型 | application/json |
| Accept | 期望响应类型 | application/json |
| Authorization | 认证信息 | Bearer token123 |
| User-Agent | 客户端标识 | PostmanRuntime/7.32.0 |
| Cache-Control | 缓存控制 | no-cache |
| Cookie | Cookie 信息 | session=abc123 |
批量添加请求头：
Content-Type: application/json
Authorization: Bearer {{token}}
X-API-Key: {{apiKey}}
X-Request-ID: {{$guid}}1.6.3 Body 请求体设置
请求体是 POST/PUT/PATCH 等方法的核心内容，Postman 支持多种请求体格式：
1. none（无请求体）
用于 GET、DELETE 等不需要请求体的方法。
2. form-data（表单数据）
用于上传文件或提交表单数据，支持 multipart/form-data 格式：
# 表单字段
KEY VALUE TYPE
username zhangsan Text
password 123456 Text
avatar [选择文件] File
# 生成的请求体
--boundary123
Content-Disposition: form-data; name="username"
zhangsan
--boundary123
Content-Disposition: form-data; name="password"
123456
--boundary123
Content-Disposition: form-data; name="avatar"; filename="photo.jpg"
Content-Type: image/jpeg
[二进制文件内容]
--boundary123--3. x-www-form-urlencoded（URL 编码表单）
用于提交简单的表单数据，数据以 key=value 格式编码：
# 输入
username=zhangsan&password=123456
# 实际发送
POST /login HTTP/1.1
Content-Type: application/x-www-form-urlencoded
username=zhangsan&password=1234564. raw（原始数据）
支持多种格式的原始数据：
json
// JSON 格式
{
"username": "zhangsan",
"password": "123456",
"remember": true
}
xml
<!-- XML 格式 -->
<user>
<username>zhangsan</username>
<password>123456</password>
</user>
text
# Text 格式
Hello, this is plain text content.5. binary（二进制数据）
用于发送二进制文件，如图片、视频、压缩包等。
6. GraphQL
用于发送 GraphQL 查询：
graphql
query GetUser($id: ID!) {
user(id: $id) {
id
name
email
posts {
title
content
}
}
}
# 变量
{
"id": "1"
}1.7 响应数据结构分析
1.7.1 响应区域组成
Postman 的响应区域分为四个标签页：
响应区域
Body 响应体
Headers 响应头
Cookies
Headers 信息摘要
Pretty 格式化
Raw 原始
Preview 预览
Visualize 可视化
1.7.2 响应状态码解析
HTTP 状态码是服务器返回的响应状态标识，分为五类：
| 状态码范围 | 类别 | 说明 |
|---|---|---|
| 1xx | 信息响应 | 请求已接收，继续处理 |
| 2xx | 成功 | 请求已成功接收、理解、接受 |
| 3xx | 重定向 | 需要进一步操作以完成请求 |
| 4xx | 客户端错误 | 请求包含语法错误或无法完成 |
| 5xx | 服务器错误 | 服务器无法完成有效请求 |
常见状态码详解：
json
// 200 OK - 请求成功
{
"status": "success",
"data": { ... }
}
// 201 Created - 资源创建成功
{
"status": "success",
"data": {
"id": 123,
"name": "新创建的资源"
}
}
// 400 Bad Request - 请求参数错误
{
"status": "error",
"message": "参数验证失败",
"errors": [
{
"field": "email",
"message": "邮箱格式不正确"
}
]
}
// 401 Unauthorized - 未认证
{
"status": "error",
"message": "未登录或登录已过期"
}
// 403 Forbidden - 无权限
{
"status": "error",
"message": "无权访问该资源"
}
// 404 Not Found - 资源不存在
{
"status": "error",
"message": "请求的资源不存在"
}
// 500 Internal Server Error - 服务器错误
{
"status": "error",
"message": "服务器内部错误",
"traceId": "abc123xyz"
}1.7.3 响应头信息
响应头包含服务器返回的元数据信息：
http
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 1234
Date: Mon, 15 Jan 2024 10:30:00 GMT
Server: nginx/1.20.1
X-Request-ID: req-abc123
X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 999
Cache-Control: max-age=3600
ETag: "abc123xyz"重要响应头说明：
| 响应头 | 说明 |
|---|---|
| Content-Type | 响应体类型和编码 |
| Content-Length | 响应体大小（字节） |
| Date | 响应生成时间 |
| Server | 服务器软件信息 |
| X-Request-ID | 请求追踪 ID |
| X-RateLimit-* | 速率限制信息 |
| Cache-Control | 缓存策略 |
| ETag | 资源版本标识 |
1.7.4 响应时间与大小
Postman 在响应区域顶部显示关键性能指标：
Status: 200 OK Time: 256ms Size: 1.2 KB响应时间分析：
总响应时间
DNS 解析
TCP 连接
SSL 握手
请求发送
等待响应
内容下载
响应大小组成：
总大小 = Headers 大小 + Body 大小
示例：
Headers: 456 bytes
Body: 1,234 bytes
Total: 1,690 bytes1.8 请求历史与代码片段生成
1.8.1 History 历史记录
Postman 自动保存所有发送过的请求，方便快速访问历史请求。
历史记录功能：
History 面板
按时间排序
搜索过滤
清除历史
保存到集合
今天
昨天
更早
按 URL 搜索
按方法搜索
按状态码搜索
历史记录操作：
1. 点击历史记录项 - 在新标签页打开请求
2. 右键菜单操作：
- Save to Collection - 保存到集合
- Rename - 重命名
- Delete - 删除
- Clear All - 清除所有历史1.8.2 代码片段生成
Postman 可以将请求转换为多种编程语言的代码片段，方便开发集成。
支持的语言和框架：
| 语言 | 框架/库 |
|---|---|
| JavaScript | Fetch, Axios, jQuery, XHR |
| Python | requests, http.client |
| Java | OkHttp, Unirest, HttpClient |
| PHP | cURL, Guzzle, HTTP_Request2 |
| Ruby | Net::HTTP |
| Go | net/http |
| C# | RestSharp, HttpClient |
| Swift | URLSession |
| Kotlin | OkHttp |
| cURL | cURL |
生成代码示例：
JavaScript - Fetch:
javascript
// Postman 生成的 Fetch 代码
const url = 'https://api.example.com/v1/users';
const options = {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': 'Bearer token123'
},
body: JSON.stringify({
name: '张三',
email: 'zhangsan@example.com'
})
};
fetch(url, options)
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));Python - requests:
python
# Postman 生成的 Python requests 代码
import requests
import json
url = 'https://api.example.com/v1/users'
payload = json.dumps({
'name': '张三',
'email': 'zhangsan@example.com'
})
headers = {
'Content-Type': 'application/json',
'Authorization': 'Bearer token123'
}
response = requests.post(url, headers=headers, data=payload)
print(response.json())cURL:
bash
# Postman 生成的 cURL 命令
curl --location 'https://api.example.com/v1/users' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer token123' \
--data '{
"name": "张三",
"email": "zhangsan@example.com"
}'1.9 批量编辑与全局查找替换
1.9.1 批量编辑功能
批量编辑功能允许同时修改多个请求的属性，提高工作效率。
使用场景：
批量编辑场景
修改基础URL
更新认证信息
添加公共请求头
修改超时设置
测试环境切换到生产环境
Token 过期后批量更新
添加追踪ID请求头
调整超时时间
批量编辑操作步骤：
- 在集合或文件夹上右键
- 选择 "Edit"
- 切换到 "Authorization" 或其他标签
- 修改配置后选择 "Apply to all requests in collection"
批量编辑脚本示例：
javascript
// 在 Collection 级别设置公共请求头
// 此脚本将应用于集合中的所有请求
// 在 Pre-request Script 中添加
pm.request.headers.add({
key: 'X-Request-ID',
value: '{{$guid}}'
});
pm.request.headers.add({
key: 'X-Client-Version',
value: '1.0.0'
});1.9.2 全局查找替换
全局查找替换功能可以在整个工作区内搜索和替换内容。
查找范围：
| 范围 | 说明 |
|---|---|
| All | 整个工作区 |
| Collections | 所有集合 |
| Environments | 所有环境变量 |
| Current Collection | 当前集合 |
查找内容类型：
1. URL 中的内容
2. 请求头
3. 请求体
4. 脚本代码
5. 变量引用
6. 描述文本使用示例：
查找：http://dev-api.example.com
替换为：http://prod-api.example.com
操作步骤：
1. 按 Ctrl+Shift+F (Windows) 或 Cmd+Shift+F (macOS)
2. 输入查找内容
3. 输入替换内容
4. 选择查找范围
5. 点击 "Replace All"1.10 请求描述与响应示例保存
1.10.1 请求描述
请求描述用于记录 API 的用途、参数说明、注意事项等信息，是 API 文档的重要组成部分。
添加请求描述：
- 打开请求
- 点击请求名称旁边的描述图标
- 输入描述内容（支持 Markdown 格式）
描述模板示例：
markdown
## 接口说明
用户登录接口，用于获取访问令牌。
## 请求参数
| 参数名 | 类型 | 必填 | 说明 |
|--------|------|------|------|
| username | string | 是 | 用户名 |
| password | string | 是 | 密码（MD5加密） |
| remember | boolean | 否 | 是否记住登录 |
## 响应示例
```json
{
"code": 200,
"message": "登录成功",
"data": {
"token": "eyJhbGciOiJIUzI1NiIs...",
"expireTime": 1705312800000
}
}注意事项
- 密码需进行 MD5 加密后传输
- Token 有效期为 24 小时
- 连续失败 5 次将锁定账户 30 分钟
1.10.2 响应示例保存
保存响应示例可以用于：
- API 文档展示：在文档中显示响应示例
- Mock Server：作为 Mock 响应的数据源
- 团队共享：分享预期的响应格式
保存响应示例步骤：
- 发送请求获取响应
- 点击响应区域右上角的 "Save Response"
- 选择 "Save as example"
- 输入示例名称和描述
响应示例管理：
响应示例
创建示例
编辑示例
删除示例
设置默认示例
从当前响应保存
手动创建
文档中显示
Mock Server 使用
1.11 断点调试功能
1.11.1 断点调试概述
Postman 的断点调试功能允许在请求发送前或响应返回后暂停执行，检查和修改数据。
断点类型：
断点类型
请求断点
响应断点
发送前暂停
修改请求参数
添加调试信息
接收后暂停
检查响应数据
修改响应内容
1.11.2 启用断点调试
方式一：全局断点
1. 点击菜单 View -> Show Postman Console
2. 在 Console 面板中点击断点图标
3. 选择断点类型：
- Break on requests：请求断点
- Break on responses：响应断点方式二：脚本断点
javascript
// 在 Pre-request Script 中设置断点
// 使用 debugger 语句（需要在 DevTools 中打开）
// 方式1：使用 console.log 调试
console.log('当前请求URL:', pm.request.url.toString());
console.log('当前请求Headers:', pm.request.headers);
// 方式2：使用条件断点
if (pm.variables.get('debug') === 'true') {
console.log('调试模式已启用');
console.log('请求体:', pm.request.body);
}
// 方式3：检查变量值
const token = pm.environment.get('token');
console.log('当前Token:', token);
console.log('Token长度:', token ? token.length : 0);1.11.3 断点调试实战案例
案例：调试登录接口
javascript
// Pre-request Script - 请求前断点
// 获取并验证用户输入
const username = pm.variables.get('username');
const password = pm.variables.get('password');
// 调试输出
console.log('=== 请求前调试信息 ===');
console.log('用户名:', username);
console.log('密码长度:', password ? password.length : 0);
console.log('环境:', pm.environment.name);
console.log('请求URL:', pm.request.url.toString());
// 动态修改请求体
const requestBody = {
username: username,
password: password,
timestamp: Date.now(),
deviceId: 'debug-device-001'
};
// 更新请求体
pm.request.body.raw = JSON.stringify(requestBody);
console.log('更新后的请求体:', pm.request.body.raw);
javascript
// Tests Script - 响应后断点
// 获取响应数据
const response = pm.response.json();
// 调试输出
console.log('=== 响应后调试信息 ===');
console.log('状态码:', pm.response.code);
console.log('响应时间:', pm.response.responseTime, 'ms');
console.log('响应大小:', pm.response.size(), 'bytes');
console.log('响应体:', JSON.stringify(response, null, 2));
// 检查响应结构
if (response.code === 200) {
console.log('登录成功');
console.log('Token:', response.data.token);
// 保存 Token 到环境变量
pm.environment.set('token', response.data.token);
console.log('Token 已保存到环境变量');
} else {
console.log('登录失败:', response.message);
}调试流程图：
Console Tests Script API服务器 Pre-request Script 用户 Console Tests Script API服务器 Pre-request Script 用户 发送请求 输出请求前调试信息 暂停等待检查 继续执行 发送请求 返回响应 输出响应后调试信息 暂停等待检查 继续执行 显示结果
第二章：请求参数全面解析
2.1 路径参数与查询参数
2.1.1 路径参数（Path Parameters）
路径参数是 URL 路径的一部分，用于标识特定资源。在 RESTful API 设计中，路径参数通常用于指定要操作的具体资源。
URL 结构：
https://api.example.com/v1/users/{userId}/orders/{orderId}
↑ ↑
路径参数1 路径参数2Postman 中使用路径参数：
# URL 输入
https://api.example.com/v1/users/:userId/orders/:orderId
# Params 面板配置
KEY VALUE DESCRIPTION
userId 123 用户ID
orderId 456 订单ID
# 实际请求 URL
https://api.example.com/v1/users/123/orders/456路径参数特点：
| 特点 | 说明 |
|---|---|
| 必需性 | 通常为必需参数，缺失会导致 404 |
| 位置 | 位于 URL 路径中 |
| 编码 | 通常不需要编码（但特殊字符需要） |
| 可见性 | 在 URL 中可见 |
代码示例：
javascript
// 在脚本中动态设置路径参数
const userId = pm.environment.get('currentUserId');
const orderId = pm.variables.get('currentOrderId');
// 更新请求 URL
pm.request.url.path = ['v1', 'users', userId, 'orders', orderId];
console.log('更新后的路径:', pm.request.url.path);2.1.2 查询参数（Query Parameters）
查询参数位于 URL 的 ? 之后，用于过滤、排序、分页等操作。
URL 结构：
https://api.example.com/v1/users?page=1&size=10&status=active&sort=createdAt
↑───────────────────────────────────────────↑
查询参数部分查询参数格式：
?key1=value1&key2=value2&key3=value3Postman 中配置查询参数：
# Params 面板配置
KEY VALUE DESCRIPTION
page 1 页码
size 10 每页数量
status active 用户状态
sort createdAt 排序字段
order desc 排序方向
# 生成的 URL
https://api.example.com/v1/users?page=1&size=10&status=active&sort=createdAt&order=desc查询参数常见用途：
查询参数用途
分页
过滤
排序
搜索
字段选择
page, size, limit, offset
status, category, type
sort, order, sortBy
q, keyword, search
fields, select, include
多值参数处理：
# 数组参数 - 方式1：重复键名
https://api.example.com/v1/users?ids=1&ids=2&ids=3
# 数组参数 - 方式2：方括号语法
https://api.example.com/v1/users?ids[]=1&ids[]=2&ids[]=3
# 数组参数 - 方式3：逗号分隔
https://api.example.com/v1/users?ids=1,2,3查询参数编码：
javascript
// 特殊字符需要 URL 编码
// 原始值：hello world&test=123
// 编码后
const keyword = encodeURIComponent('hello world&test=123');
// 结果：hello%20world%26test%3D123
// 在 Postman 中自动处理
// Params 面板输入原始值，Postman 自动编码2.2 请求头参数详解
2.2.1 请求头的作用与分类
请求头（Request Headers）是 HTTP 请求的元数据，用于传递请求的附加信息。
请求头分类
通用头
请求头
实体头
自定义头
Cache-Control
Connection
Date
Authorization
User-Agent
Accept
Host
Cookie
Content-Type
Content-Length
Content-Encoding
X-API-Key
X-Request-ID
X-Client-Version
2.2.2 常用请求头详解
1. Content-Type（内容类型）
指定请求体的数据格式：
| Content-Type | 说明 | 使用场景 |
|---|---|---|
| application/json | JSON 格式 | REST API 最常用 |
| application/xml | XML 格式 | 传统 Web Service |
| application/x-www-form-urlencoded | URL 编码表单 | 简单表单提交 |
| multipart/form-data | 多部分表单 | 文件上传 |
| text/plain | 纯文本 | 简单文本数据 |
| text/html | HTML 格式 | 网页内容 |
| application/octet-stream | 二进制流 | 文件下载 |
2. Accept（接受类型）
指定客户端期望的响应格式：
Accept: application/json
Accept: application/json, text/plain, */*
Accept: application/json; q=1.0, application/xml; q=0.83. Authorization（认证信息）
传递认证凭据：
# Basic Auth
Authorization: Basic base64(username:password)
# Bearer Token
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...
# Digest Auth
Authorization: Digest username="admin", realm="...", nonce="..."
# API Key
X-API-Key: your-api-key-here4. User-Agent（用户代理）
标识客户端信息：
User-Agent: PostmanRuntime/7.32.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.362.2.3 自定义请求头
自定义请求头以 X- 为前缀（虽然现代 HTTP 规范已不再强制要求）：
X-API-Key: abc123xyz
X-Request-ID: {{$guid}}
X-Client-Version: 1.0.0
X-Platform: web
X-Device-ID: device-001
X-Trace-ID: trace-{{$timestamp}}在脚本中动态添加请求头：
javascript
// Pre-request Script 中添加请求头
// 方式1：add 方法 - 添加新请求头
pm.request.headers.add({
key: 'X-Request-ID',
value: '{{$guid}}'
});
// 方式2：upsert 方法 - 添加或更新请求头
pm.request.headers.upsert({
key: 'X-Timestamp',
value: Date.now().toString()
});
// 方式3：remove 方法 - 删除请求头
pm.request.headers.remove('X-Debug-Mode');
// 批量添加请求头
const customHeaders = {
'X-Client-Version': '1.0.0',
'X-Platform': 'web',
'X-Device-ID': 'device-001'
};
Object.entries(customHeaders).forEach(([key, value]) => {
pm.request.headers.add({ key, value });
});
console.log('当前所有请求头:', pm.request.headers);2.3 请求体类型
2.3.1 请求体类型概览
请求体类型
none
form-data
x-www-form-urlencoded
raw
binary
GraphQL
JSON
XML
Text
JavaScript
HTML
2.3.2 form-data（多部分表单）
form-data 使用 multipart/form-data 格式，适用于文件上传和复杂表单。
配置示例：
KEY VALUE TYPE
username zhangsan Text
password 123456 Text
avatar [选择文件] File
resume [选择文件] File
preferences {"theme":"dark"} Text生成的请求体：
http
POST /api/upload HTTP/1.1
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW
------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="username"
zhangsan
------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="password"
123456
------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="avatar"; filename="photo.jpg"
Content-Type: image/jpeg
[二进制文件内容]
------WebKitFormBoundary7MA4YWxkTrZu0gW--脚本中构建 form-data：
javascript
// 注意：Postman 脚本中无法直接修改 form-data
// 需要在请求配置中预设
// 但可以读取 form-data 内容
const formData = pm.request.body.formdata;
console.log('表单数据:', formData);
// 遍历表单字段
formData.each(field => {
console.log(`字段: ${field.key}, 值: ${field.value}, 类型: ${field.type}`);
});2.3.3 x-www-form-urlencoded（URL 编码表单）
适用于简单的键值对提交，数据会被编码为 key1=value1&key2=value2 格式。
配置示例：
KEY VALUE
username zhangsan
password 123456
remember_me true生成的请求体：
http
POST /api/login HTTP/1.1
Content-Type: application/x-www-form-urlencoded
username=zhangsan&password=123456&remember_me=true特殊字符编码：
| 字符 | 编码后 |
|---|---|
| 空格 | + 或 %20 |
| & | %26 |
| = | %3D |
| + | %2B |
| % | %25 |
2.3.4 raw（原始数据）
JSON 格式（最常用）：
json
{
"username": "zhangsan",
"password": "123456",
"profile": {
"nickname": "张三",
"avatar": "https://example.com/avatar.jpg",
"bio": "这是一段个人简介"
},
"roles": ["user", "admin"],
"settings": {
"theme": "dark",
"language": "zh-CN",
"notifications": {
"email": true,
"sms": false,
"push": true
}
}
}XML 格式：
xml
<?xml version="1.0" encoding="UTF-8"?>
<user>
<username>zhangsan</username>
<password>123456</password>
<profile>
<nickname>张三</nickname>
<avatar>https://example.com/avatar.jpg</avatar>
</profile>
<roles>
<role>user</role>
<role>admin</role>
</roles>
</user>在脚本中动态构建 JSON 请求体：
javascript
// Pre-request Script 中动态构建请求体
// 获取环境变量
const username = pm.environment.get('username');
const userId = pm.environment.get('userId');
// 构建请求体对象
const requestBody = {
username: username,
userId: userId,
timestamp: Date.now(),
deviceId: 'device-001',
metadata: {
platform: 'web',
version: '1.0.0',
timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
}
};
// 设置请求体
pm.request.body.raw = JSON.stringify(requestBody, null, 2);
console.log('请求体已更新:', pm.request.body.raw);2.4 动态变量完整列表
2.4.1 动态变量概述
Postman 提供了丰富的动态变量，可以在请求中自动生成随机数据或系统值。动态变量使用 {``{$variableName}} 语法。
动态变量
时间类
标识类
随机数据类
颜色类
网络类
图片类
timestamp
isoTimestamp
randomDateFuture
guid
randomUUID
randomInt
randomFirstName
randomEmail
$randomPhoneNumber
2.4.2 时间类动态变量
| 变量名 | 说明 | 示例输出 |
|---|---|---|
{``{$timestamp}} |
当前 Unix 时间戳（秒） | 1705312800 |
{``{$isoTimestamp}} |
ISO 8601 格式时间戳 | 2024-01-15T10:30:00.000Z |
{``{$randomDateFuture}} |
未来随机日期 | 2025-06-20 |
{``{$randomDatePast}} |
过去随机日期 | 2022-03-15 |
{``{$randomDateRecent}} |
最近随机日期 | 2024-01-10 |
使用示例：
json
{
"createdAt": "{{$isoTimestamp}}",
"expireAt": "{{$randomDateFuture}}",
"timestamp": {{$timestamp}}
}2.4.3 标识类动态变量
| 变量名 | 说明 | 示例输出 |
|---|---|---|
{``{$guid}} |
GUID/UUID | 550e8400-e29b-41d4-a716-446655440000 |
{``{$randomUUID}} |
随机 UUID | 550e8400-e29b-41d4-a716-446655440000 |
{``{$randomInt}} |
随机整数（0-1000） | 42 |
{``{$randomAlphaNumeric}} |
随机字母数字 | a1B2c3D4 |
使用示例：
json
{
"requestId": "{{$guid}}",
"traceId": "{{$randomUUID}}",
"sequence": {{$randomInt}}
}2.4.4 随机数据类动态变量
个人信息类：
| 变量名 | 说明 | 示例输出 |
|---|---|---|
{``{$randomFirstName}} |
随机名 | John |
{``{$randomLastName}} |
随机姓 | Doe |
{``{$randomFullName}} |
随机全名 | John Doe |
{``{$randomEmail}} |
随机邮箱 | john.doe@example.com |
{``{$randomUsername}} |
随机用户名 | john.doe123 |
{``{$randomPassword}} |
随机密码 | aB1!xY2@ |
{``{$randomPhoneNumber}} |
随机电话 | 555-123-4567 |
{``{$randomPhoneNumberExt}} |
随机电话（带分机） | 555-123-4567x123 |
地址类：
| 变量名 | 说明 | 示例输出 |
|---|---|---|
{``{$randomCity}} |
随机城市 | New York |
{``{$randomStreetAddress}} |
随机街道地址 | 123 Main St |
{``{$randomCountry}} |
随机国家 | United States |
{``{$randomZipCode}} |
随机邮编 | 10001 |
{``{$randomLatitude}} |
随机纬度 | 40.7128 |
{``{$randomLongitude}} |
随机经度 | -74.0060 |
公司类：
| 变量名 | 说明 | 示例输出 |
|---|---|---|
{``{$randomCompanyName}} |
随机公司名 | Acme Corp |
{``{$randomJobTitle}} |
随机职位 | Software Engineer |
{``{$randomJobArea}} |
随机工作领域 | IT |
{``{$randomJobType}} |
随机工作类型 | Full-time |
网络类：
| 变量名 | 说明 | 示例输出 |
|---|---|---|
{``{$randomIP}} |
随机 IPv4 | 192.168.1.1 |
{``{$randomIPV6}} |
随机 IPv6 | 2001:0db8:85a3::0000 |
{``{$randomMACAddress}} |
随机 MAC 地址 | 00:1A:2B:3C:4D:5E |
{``{$randomDomainName}} |
随机域名 | example.com |
{``{$randomUrl}} |
随机 URL | https://example.com/page |
颜色类：
| 变量名 | 说明 | 示例输出 |
|---|---|---|
{``{$randomColor}} |
随机颜色名 | red |
{``{$randomHexColor}} |
随机十六进制颜色 | #FF5733 |
{``{$randomRGBColor}} |
随机 RGB 颜色 | rgb(255,87,51) |
图片类：
| 变量名 | 说明 | 示例输出 |
|---|---|---|
{``{$randomImageUrl}} |
随机图片 URL | https://picsum.photos/200/300 |
{``{$randomAvatarImage}} |
随机头像 | https://avatars.example.com/user1.jpg |
{``{$randomAbstractImage}} |
随机抽象图片 | https://images.example.com/abstract.jpg |
商业类：
| 变量名 | 说明 | 示例输出 |
|---|---|---|
{``{$randomPrice}} |
随机价格 | 99.99 |
{``{$randomProduct}} |
随机产品 | Smartphone |
{``{$randomProductAdjective}} |
随机产品形容词 | Premium |
{``{$randomProductMaterial}} |
随机产品材质 | Leather |
{``{$randomProductName}} |
随机产品名 | Premium Leather Wallet |
2.4.5 动态变量使用示例
完整的用户注册请求体：
json
{
"requestId": "{{$guid}}",
"timestamp": "{{$isoTimestamp}}",
"user": {
"firstName": "{{$randomFirstName}}",
"lastName": "{{$randomLastName}}",
"email": "{{$randomEmail}}",
"username": "{{$randomUsername}}",
"password": "{{$randomPassword}}",
"phone": "{{$randomPhoneNumber}}"
},
"address": {
"street": "{{$randomStreetAddress}}",
"city": "{{$randomCity}}",
"country": "{{$randomCountry}}",
"zipCode": "{{$randomZipCode}}"
},
"company": {
"name": "{{$randomCompanyName}}",
"jobTitle": "{{$randomJobTitle}}"
},
"preferences": {
"theme": "{{$randomColor}}",
"avatar": "{{$randomAvatarImage}}"
}
}在脚本中使用动态变量：
javascript
// 注意：动态变量只在请求中生效，脚本中需要手动实现
// 生成 UUID
function generateUUID() {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
const r = Math.random() * 16 | 0;
const v = c === 'x' ? r : (r & 0x3 | 0x8);
return v.toString(16);
});
}
// 生成时间戳
const timestamp = Date.now();
const isoTimestamp = new Date().toISOString();
// 生成随机邮箱
function generateRandomEmail() {
const domains = ['gmail.com', 'yahoo.com', 'outlook.com', 'example.com'];
const username = 'user' + Math.floor(Math.random() * 10000);
const domain = domains[Math.floor(Math.random() * domains.length)];
return `${username}@${domain}`;
}
// 设置变量
pm.variables.set('requestId', generateUUID());
pm.variables.set('timestamp', timestamp);
pm.variables.set('randomEmail', generateRandomEmail());
console.log('生成的变量:', {
requestId: pm.variables.get('requestId'),
timestamp: pm.variables.get('timestamp'),
randomEmail: pm.variables.get('randomEmail')
});2.5 请求配置参数
2.5.1 超时设置
Postman 允许配置请求的超时时间，防止请求长时间挂起。
配置位置：
Settings -> General -> Request timeout in ms
默认值：0（无限制）
建议值：30000（30秒）在脚本中设置超时：
javascript
// 注意：脚本中无法直接修改请求超时
// 但可以通过 sendRequest 设置超时
pm.sendRequest({
url: 'https://api.example.com/long-running',
method: 'GET',
timeout: 5000 // 5秒超时
}, (error, response) => {
if (error) {
console.log('请求超时或失败:', error);
} else {
console.log('响应:', response.json());
}
});2.5.2 SSL 证书配置
对于需要客户端证书的 HTTPS 请求，可以配置 SSL 证书。
配置步骤：
Settings -> Certificates -> Add Certificate
配置项：
- Host: api.example.com
- CRT file: /path/to/client.crt
- KEY file: /path/to/client.key
- PFX file: /path/to/certificate.pfx
- Passphrase: 证书密码（如有）证书配置示例：
json
{
"certificates": [
{
"host": "api.example.com",
"crt": "/path/to/client.crt",
"key": "/path/to/client.key",
"passphrase": "your-passphrase"
},
{
"host": "secure.api.com",
"pfx": "/path/to/certificate.pfx",
"passphrase": "your-passphrase"
}
]
}2.5.3 代理配置
Postman 支持配置代理服务器，用于网络调试或访问受限网络。
配置位置：
Settings -> Proxy
配置项：
- Use system proxy: 使用系统代理
- Custom proxy configuration: 自定义代理
- Proxy server: proxy.example.com:8080
- Proxy authentication: 用户名/密码
- Proxy bypass: 不走代理的地址列表代理配置示例：
json
{
"proxy": {
"enabled": true,
"host": "proxy.example.com",
"port": 8080,
"username": "proxyuser",
"password": "proxypass",
"bypass": [
"localhost",
"127.0.0.1",
"*.internal.com"
]
}
}2.5.4 请求头预设
可以为常用请求头创建预设，快速应用到请求中。
创建预设：
Headers 面板 -> Presets -> Manage Presets -> Add
预设名称：API Common Headers
内容：
X-API-Key: {{apiKey}}
X-Client-Version: 1.0.0
X-Platform: web
Accept: application/json使用预设：
Headers 面板 -> Presets -> 选择预设名称
预设中的所有请求头将被添加到当前请求2.5.5 重定向设置
控制请求如何处理 HTTP 重定向。
配置选项：
Settings -> General
- Automatically follow redirects: 自动跟随重定向（默认开启）
- Maximum redirect count: 最大重定向次数（默认20）重定向处理流程：
服务器 Postman 服务器 Postman 自动跟随重定向 或手动处理 手动处理重定向 GET /old-path 301 Redirect /new-path GET /new-path 200 OK GET /old-path (禁用自动重定向) 301 Redirect /new-path
在 Newman 中禁用重定向：
bash
newman run collection.json --ignore-redirects2.6 大文件上传与下载处理
2.6.1 大文件上传
使用 form-data 上传文件：
# 请求配置
方法：POST
URL：https://api.example.com/upload
# Body 配置（form-data）
KEY VALUE TYPE
file [选择文件] File
chunkIndex 1 Text
totalChunks 10 Text
fileId {{$guid}} Text分片上传实现：
javascript
// Pre-request Script - 分片上传逻辑
// 获取文件信息（需要在环境变量中预设）
const fileId = pm.environment.get('fileId') || '{{$guid}}';
const totalChunks = pm.environment.get('totalChunks') || 10;
const currentChunk = pm.environment.get('currentChunk') || 1;
// 设置当前分片信息
pm.environment.set('fileId', fileId);
pm.environment.set('currentChunk', currentChunk);
console.log(`上传分片 ${currentChunk}/${totalChunks}`);
// Tests Script - 处理上传响应
const response = pm.response.json();
if (response.success) {
if (currentChunk < totalChunks) {
// 继续上传下一个分片
pm.environment.set('currentChunk', currentChunk + 1);
console.log(`准备上传下一分片: ${currentChunk + 1}`);
} else {
// 所有分片上传完成，通知服务器合并
console.log('所有分片上传完成');
pm.environment.set('currentChunk', 1); // 重置
// 可以在这里调用合并接口
}
}2.6.2 大文件下载
下载文件并保存：
javascript
// Tests Script - 处理文件下载
// 获取响应内容
const responseBuffer = pm.response.stream;
// 计算文件大小
const sizeInBytes = responseBuffer.length;
const sizeInMB = (sizeInBytes / (1024 * 1024)).toFixed(2);
console.log(`下载完成，文件大小: ${sizeInMB} MB`);
// 获取文件名（从 Content-Disposition 头）
const contentDisposition = pm.response.headers.get('Content-Disposition');
let filename = 'downloaded_file';
if (contentDisposition) {
const match = contentDisposition.match(/filename="?(.+?)"?$/);
if (match) {
filename = match[1];
}
}
console.log(`文件名: ${filename}`);
// 注意：Postman 无法直接保存文件到本地
// 需要手动点击 "Save Response" -> "Save to a file"断点续传实现：
javascript
// Pre-request Script - 断点续传
// 获取已下载的字节数
let downloadedBytes = pm.environment.get('downloadedBytes') || 0;
// 设置 Range 请求头
if (downloadedBytes > 0) {
pm.request.headers.add({
key: 'Range',
value: `bytes=${downloadedBytes}-`
});
console.log(`断点续传，从 ${downloadedBytes} 字节开始`);
}
// Tests Script - 记录已下载字节数
const contentRange = pm.response.headers.get('Content-Range');
const contentLength = pm.response.headers.get('Content-Length');
if (contentRange) {
const match = contentRange.match(/bytes (\d+)-(\d+)\/(\d+)/);
if (match) {
const start = parseInt(match[1]);
const end = parseInt(match[2]);
const total = parseInt(match[3]);
console.log(`已下载: ${end + 1}/${total} 字节`);
if (end + 1 < total) {
// 还有未下载的部分
pm.environment.set('downloadedBytes', end + 1);
} else {
// 下载完成
console.log('文件下载完成');
pm.environment.set('downloadedBytes', 0);
}
}
}第三章：HTTP 方法深度解析
3.1 GET 方法：数据查询与过滤
3.1.1 GET 方法特性
GET 方法用于请求获取资源，是 HTTP 中最常用的方法。
核心特性：
GET 方法特性
幂等性
安全性
可缓存
无请求体
多次请求结果相同
不修改服务器资源
响应可被缓存
参数通过URL传递
GET 请求结构：
http
GET /api/v1/users?page=1&size=10&status=active HTTP/1.1
Host: api.example.com
Accept: application/json
Authorization: Bearer token1233.1.2 GET 请求参数设计
分页参数：
# 方式1：page + size
GET /api/users?page=1&size=10
# 方式2：offset + limit
GET /api/users?offset=0&limit=10
# 方式3：cursor（游标）
GET /api/users?cursor=eyJpZCI6MTAwfQ&limit=10过滤参数：
# 单条件过滤
GET /api/users?status=active
# 多条件过滤
GET /api/users?status=active&role=admin&department=IT
# 范围过滤
GET /api/products?price_min=100&price_max=500
# 时间范围过滤
GET /api/orders?start_date=2024-01-01&end_date=2024-01-31排序参数：
# 单字段排序
GET /api/users?sort=created_at
# 多字段排序
GET /api/users?sort=created_at:desc,name:asc
# 指定排序方向
GET /api/users?sort=created_at&order=desc字段选择：
# 只返回指定字段
GET /api/users?fields=id,name,email
# 排除某些字段
GET /api/users?exclude=password,token3.1.3 GET 请求最佳实践
Postman 配置示例：
方法：GET
URL：{{baseUrl}}/api/v1/users
# Query Parameters
KEY VALUE DESCRIPTION
page {{page}} 当前页码
size {{size}} 每页数量
status {{status}} 用户状态
keyword {{keyword}} 搜索关键词
sort {{sortField}} 排序字段
order {{sortOrder}} 排序方向测试脚本示例：
javascript
// Tests Script - GET 请求测试
// 1. 验证状态码
pm.test('状态码应为 200', function() {
pm.response.to.have.status(200);
});
// 2. 验证响应结构
pm.test('响应应包含 data 和 pagination 字段', function() {
const response = pm.response.json();
pm.expect(response).to.have.property('data');
pm.expect(response).to.have.property('pagination');
});
// 3. 验证分页信息
pm.test('分页信息应正确', function() {
const response = pm.response.json();
const pagination = response.pagination;
pm.expect(pagination.page).to.equal(parseInt(pm.variables.get('page')));
pm.expect(pagination.size).to.equal(parseInt(pm.variables.get('size')));
pm.expect(pagination.total).to.be.a('number');
pm.expect(pagination.totalPages).to.be.a('number');
});
// 4. 验证数据格式
pm.test('用户数据格式应正确', function() {
const response = pm.response.json();
const users = response.data;
pm.expect(users).to.be.an('array');
if (users.length > 0) {
const user = users[0];
pm.expect(user).to.have.property('id');
pm.expect(user).to.have.property('name');
pm.expect(user).to.have.property('email');
}
});
// 5. 验证响应时间
pm.test('响应时间应小于 500ms', function() {
pm.expect(pm.response.responseTime).to.be.below(500);
});
// 6. 保存分页信息供后续使用
const response = pm.response.json();
pm.environment.set('totalPages', response.pagination.totalPages);
pm.environment.set('totalCount', response.pagination.total);3.2 POST 方法：数据创建与表单提交
3.2.1 POST 方法特性
POST 方法用于向服务器提交数据，创建新资源。
核心特性：
POST 方法特性
非幂等
非安全
可缓存-需配置
有请求体
多次请求可能创建多个资源
会修改服务器资源
需要合适的响应头
数据在请求体中传递
3.2.2 POST 请求类型
1. 创建资源（JSON）：
http
POST /api/v1/users HTTP/1.1
Host: api.example.com
Content-Type: application/json
Authorization: Bearer token123
{
"username": "zhangsan",
"email": "zhangsan@example.com",
"password": "hashed_password",
"role": "user"
}2. 表单提交：
http
POST /api/v1/login HTTP/1.1
Host: api.example.com
Content-Type: application/x-www-form-urlencoded
username=zhangsan&password=123456&remember=true3. 文件上传：
http
POST /api/v1/upload HTTP/1.1
Host: api.example.com
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary
------WebKitFormBoundary
Content-Disposition: form-data; name="file"; filename="document.pdf"
Content-Type: application/pdf
[二进制文件内容]
------WebKitFormBoundary--3.2.3 POST 请求最佳实践
请求配置：
javascript
// Pre-request Script - 准备请求数据
// 生成唯一标识
const requestId = '{{$guid}}';
const timestamp = new Date().toISOString();
// 构建请求体
const requestBody = {
requestId: requestId,
timestamp: timestamp,
data: {
username: pm.environment.get('newUsername'),
email: pm.environment.get('newEmail'),
password: pm.environment.get('newPassword'),
profile: {
nickname: pm.environment.get('nickname'),
avatar: pm.environment.get('avatarUrl')
}
}
};
// 设置请求体
pm.request.body.raw = JSON.stringify(requestBody, null, 2);
console.log('请求体:', pm.request.body.raw);响应验证：
javascript
// Tests Script - POST 请求测试
// 1. 验证状态码
pm.test('创建成功应返回 201', function() {
pm.response.to.have.status(201);
});
// 2. 验证响应体结构
pm.test('响应应包含创建的资源', function() {
const response = pm.response.json();
pm.expect(response).to.have.property('id');
pm.expect(response).to.have.property('username');
pm.expect(response).to.have.property('email');
});
// 3. 验证创建的数据
pm.test('创建的数据应与请求一致', function() {
const response = pm.response.json();
const requestBody = JSON.parse(pm.request.body.raw);
pm.expect(response.username).to.equal(requestBody.data.username);
pm.expect(response.email).to.equal(requestBody.data.email);
});
// 4. 验证 Location 头（REST 最佳实践）
pm.test('响应应包含 Location 头', function() {
pm.response.to.have.header('Location');
const location = pm.response.headers.get('Location');
console.log('资源位置:', location);
});
// 5. 保存创建的资源 ID
const response = pm.response.json();
pm.environment.set('createdUserId', response.id);
console.log('创建的用户 ID:', response.id);3.3 PUT/PATCH 方法：数据更新策略
3.3.1 PUT vs PATCH 对比
更新方法对比
PUT
PATCH
完整更新
替换整个资源
幂等
需提供所有字段
部分更新
只更新指定字段
非幂等-可能
只需提供修改字段
对比表格：
| 特性 | PUT | PATCH |
|---|---|---|
| 更新方式 | 完整替换 | 部分更新 |
| 幂等性 | 是 | 可能不是 |
| 请求体 | 完整资源 | 只包含修改字段 |
| 使用场景 | 全量更新 | 增量更新 |
3.3.2 PUT 请求示例
完整更新用户信息：
http
PUT /api/v1/users/123 HTTP/1.1
Host: api.example.com
Content-Type: application/json
Authorization: Bearer token123
{
"username": "zhangsan_updated",
"email": "zhangsan_new@example.com",
"password": "new_hashed_password",
"role": "admin",
"status": "active",
"profile": {
"nickname": "张三",
"avatar": "https://example.com/new_avatar.jpg",
"bio": "更新后的个人简介"
}
}测试脚本：
javascript
// Tests Script - PUT 请求测试
pm.test('更新成功应返回 200', function() {
pm.response.to.have.status(200);
});
pm.test('所有字段应被更新', function() {
const response = pm.response.json();
const requestBody = JSON.parse(pm.request.body.raw);
// 验证所有字段都已更新
pm.expect(response.username).to.equal(requestBody.username);
pm.expect(response.email).to.equal(requestBody.email);
pm.expect(response.role).to.equal(requestBody.role);
});3.3.3 PATCH 请求示例
部分更新用户信息：
http
PATCH /api/v1/users/123 HTTP/1.1
Host: api.example.com
Content-Type: application/json
Authorization: Bearer token123
{
"email": "newemail@example.com",
"profile": {
"nickname": "新昵称"
}
}测试脚本：
javascript
// Tests Script - PATCH 请求测试
pm.test('更新成功应返回 200', function() {
pm.response.to.have.status(200);
});
pm.test('只有指定字段应被更新', function() {
const response = pm.response.json();
const requestBody = JSON.parse(pm.request.body.raw);
// 验证指定字段已更新
pm.expect(response.email).to.equal(requestBody.email);
pm.expect(response.profile.nickname).to.equal(requestBody.profile.nickname);
// 验证其他字段保持不变
pm.expect(response).to.have.property('username');
pm.expect(response).to.have.property('role');
});3.4 DELETE 方法：资源删除
3.4.1 DELETE 方法特性
DELETE 方法用于删除指定的资源。
核心特性：
DELETE 方法特性
幂等性
非安全
可缓存-需配置
多次删除同一资源结果相同
会删除服务器资源
成功响应可被缓存
3.4.2 DELETE 请求示例
删除单个资源：
http
DELETE /api/v1/users/123 HTTP/1.1
Host: api.example.com
Authorization: Bearer token123批量删除资源：
http
DELETE /api/v1/users HTTP/1.1
Host: api.example.com
Content-Type: application/json
Authorization: Bearer token123
{
"ids": [1, 2, 3, 4, 5]
}测试脚本：
javascript
// Tests Script - DELETE 请求测试
// 1. 验证状态码
pm.test('删除成功应返回 204 或 200', function() {
pm.expect([200, 204]).to.include(pm.response.code);
});
// 2. 验证资源已删除（发送 GET 请求验证）
pm.test('资源应已被删除', function() {
// 保存删除的资源 ID
const deletedId = pm.request.url.path.pop();
pm.environment.set('deletedResourceId', deletedId);
});
// 3. 在后续请求中验证资源不存在
// 可以添加一个 GET 请求，期望返回 4043.5 其他方法：HEAD、OPTIONS
3.5.1 HEAD 方法
HEAD 方法与 GET 类似，但服务器只返回响应头，不返回响应体。
使用场景：
HEAD 方法使用场景
检查资源是否存在
获取资源元信息
检查资源更新时间
验证链接有效性
请求示例：
http
HEAD /api/v1/documents/report.pdf HTTP/1.1
Host: api.example.com
Authorization: Bearer token123测试脚本：
javascript
// Tests Script - HEAD 请求测试
pm.test('状态码应为 200', function() {
pm.response.to.have.status(200);
});
pm.test('响应应无 body', function() {
pm.expect(pm.response.body).to.be.empty;
});
pm.test('应包含 Content-Length 头', function() {
const contentLength = pm.response.headers.get('Content-Length');
console.log('文件大小:', contentLength, 'bytes');
});
pm.test('应包含 Last-Modified 头', function() {
const lastModified = pm.response.headers.get('Last-Modified');
console.log('最后修改时间:', lastModified);
});3.5.2 OPTIONS 方法
OPTIONS 方法用于获取服务器支持的 HTTP 方法列表。
请求示例：
http
OPTIONS /api/v1/users HTTP/1.1
Host: api.example.com响应示例：
http
HTTP/1.1 200 OK
Allow: GET, POST, PUT, DELETE, OPTIONS
Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS
Access-Control-Allow-Headers: Content-Type, Authorization
Access-Control-Allow-Origin: *测试脚本：
javascript
// Tests Script - OPTIONS 请求测试
pm.test('状态码应为 200', function() {
pm.response.to.have.status(200);
});
pm.test('应包含 Allow 头', function() {
pm.response.to.have.header('Allow');
const allowedMethods = pm.response.headers.get('Allow');
console.log('支持的方法:', allowedMethods);
});
pm.test('应包含 CORS 相关头', function() {
const allowOrigin = pm.response.headers.get('Access-Control-Allow-Origin');
const allowMethods = pm.response.headers.get('Access-Control-Allow-Methods');
const allowHeaders = pm.response.headers.get('Access-Control-Allow-Headers');
console.log('允许的源:', allowOrigin);
console.log('允许的方法:', allowMethods);
console.log('允许的头:', allowHeaders);
});3.6 RESTful API 设计规范
3.6.1 RESTful 架构原则
REST（Representational State Transfer）是一种软件架构风格，遵循以下核心原则：
RESTful 原则
客户端-服务器分离
无状态
可缓存
统一接口
分层系统
资源标识
通过表述操作资源
自描述消息
超媒体作为应用状态引擎
3.6.2 URL 设计规范
资源命名规则：
# 推荐：使用名词复数
GET /api/v1/users # 获取用户列表
GET /api/v1/users/123 # 获取单个用户
POST /api/v1/users # 创建用户
PUT /api/v1/users/123 # 更新用户
DELETE /api/v1/users/123 # 删除用户
# 不推荐：使用动词
GET /api/v1/getUsers
POST /api/v1/createUser
DELETE /api/v1/deleteUser/123资源层级关系：
# 一对多关系
GET /api/v1/users/123/orders # 获取用户的所有订单
GET /api/v1/users/123/orders/456 # 获取用户的特定订单
# 多对多关系
GET /api/v1/students/1/courses # 获取学生的课程
GET /api/v1/courses/1/students # 获取课程的学生操作与URL映射：
| 操作 | HTTP 方法 | URL | 说明 |
|---|---|---|---|
| 获取列表 | GET | /resources | 获取资源列表 |
| 获取单个 | GET | /resources/:id | 获取单个资源 |
| 创建 | POST | /resources | 创建新资源 |
| 完整更新 | PUT | /resources/:id | 完整替换资源 |
| 部分更新 | PATCH | /resources/:id | 部分更新资源 |
| 删除 | DELETE | /resources/:id | 删除资源 |
3.6.3 状态码使用规范
HTTP 状态码
2xx 成功
3xx 重定向
4xx 客户端错误
5xx 服务器错误
200 OK - 请求成功
201 Created - 资源创建成功
204 No Content - 成功但无返回体
400 Bad Request - 请求参数错误
401 Unauthorized - 未认证
403 Forbidden - 无权限
404 Not Found - 资源不存在
422 Unprocessable Entity - 验证失败
429 Too Many Requests - 请求过多
500 Internal Server Error - 服务器错误
502 Bad Gateway - 网关错误
503 Service Unavailable - 服务不可用
3.6.4 响应格式规范
成功响应格式：
json
{
"code": 200,
"message": "操作成功",
"data": {
"id": 123,
"name": "张三",
"email": "zhangsan@example.com"
},
"timestamp": 1705312800000
}分页响应格式：
json
{
"code": 200,
"message": "查询成功",
"data": [
{"id": 1, "name": "用户1"},
{"id": 2, "name": "用户2"}
],
"pagination": {
"page": 1,
"size": 10,
"total": 100,
"totalPages": 10
},
"timestamp": 1705312800000
}错误响应格式：
json
{
"code": 400,
"message": "参数验证失败",
"errors": [
{
"field": "email",
"message": "邮箱格式不正确"
},
{
"field": "password",
"message": "密码长度至少8位"
}
],
"timestamp": 1705312800000,
"traceId": "abc123xyz"
}第四章：变量与环境管理
4.1 变量类型与作用域
4.1.1 变量类型概览
Postman 提供了多种变量类型，每种类型有不同的作用域和生命周期：
Postman 变量类型
Global 全局变量
Environment 环境变量
Collection 集合变量
Local 局部变量
Data 数据变量
作用域最广
所有请求可访问
环境级别
切换环境切换变量
集合级别
集合内请求可访问
脚本级别
仅在当前脚本有效
数据文件级别
数据驱动测试使用
4.1.2 变量作用域优先级
当多个作用域存在同名变量时，Postman 按照以下优先级解析变量：
优先级从高到低：
Local > Data > Environment > Collection > Global变量解析流程：
渲染错误: Mermaid 渲染失败: Parse error on line 2: graph TD A[引用变量 {{varName}}] --> B{L -------------------^ Expecting 'SQE', 'DOUBLECIRCLEEND', 'PE', '-)', 'STADIUMEND', 'SUBROUTINEEND', 'PIPE', 'CYLINDEREND', 'DIAMOND_STOP', 'TAGEND', 'TRAPEND', 'INVTRAPEND', 'UNICODE_TEXT', 'TEXT', 'TAGSTART', got 'DIAMOND_START'
4.1.3 各类型变量详解
1. Global 全局变量
全局变量在整个 Postman 应用中都可访问，适用于存储跨环境共享的数据。
javascript
// 在脚本中操作全局变量
// 设置全局变量
pm.globals.set('apiVersion', 'v1');
pm.globals.set('defaultTimeout', 30000);
// 获取全局变量
const apiVersion = pm.globals.get('apiVersion');
console.log('API版本:', apiVersion);
// 检查全局变量是否存在
if (pm.globals.has('apiVersion')) {
console.log('apiVersion 变量存在');
}
// 删除全局变量
pm.globals.unset('apiVersion');
// 清空所有全局变量
pm.globals.clear();
// 获取所有全局变量
const allGlobals = pm.globals.toObject();
console.log('所有全局变量:', JSON.stringify(allGlobals, null, 2));2. Environment 环境变量
环境变量与特定环境绑定，切换环境时自动切换变量值。
javascript
// 在脚本中操作环境变量
// 设置环境变量
pm.environment.set('baseUrl', 'https://dev-api.example.com');
pm.environment.set('token', 'eyJhbGciOiJIUzI1NiIs...');
// 获取环境变量
const baseUrl = pm.environment.get('baseUrl');
console.log('基础URL:', baseUrl);
// 检查环境变量是否存在
if (pm.environment.has('token')) {
console.log('Token 已设置');
}
// 删除环境变量
pm.environment.unset('tempVar');
// 清空当前环境的所有变量
pm.environment.clear();
// 获取当前环境所有变量
const allEnvVars = pm.environment.toObject();
console.log('所有环境变量:', JSON.stringify(allEnvVars, null, 2));3. Collection 集合变量
集合变量属于特定集合，适合存储集合级别的配置。
javascript
// 在脚本中操作集合变量
// 设置集合变量
pm.collectionVariables.set('collectionName', '用户管理API');
pm.collectionVariables.set('retryCount', 3);
// 获取集合变量
const name = pm.collectionVariables.get('collectionName');
console.log('集合名称:', name);
// 其他操作与 Global/Environment 类似
pm.collectionVariables.has('retryCount');
pm.collectionVariables.unset('collectionName');
pm.collectionVariables.clear();
pm.collectionVariables.toObject();4. Local 局部变量
局部变量仅在当前脚本执行期间有效，脚本执行完毕后自动销毁。
javascript
// 局部变量使用示例
// 设置局部变量
pm.variables.set('tempResult', '临时数据');
pm.variables.set('iterationIndex', pm.info.iteration);
// 获取局部变量
const temp = pm.variables.get('tempResult');
console.log('临时变量:', temp);
// 注意：pm.variables 是统一接口
// 它会按照优先级依次查找 Local -> Data -> Environment -> Collection -> Global
const value = pm.variables.get('someVar');5. Data 数据变量
数据变量来自数据驱动测试的数据文件（CSV/JSON），在 Collection Runner 中使用。
javascript
// 使用数据变量
// 获取当前迭代的数据变量
const username = pm.iterationData.get('username');
const password = pm.iterationData.get('password');
console.log('当前测试数据:', {
username: username,
password: password
});
// 获取所有数据变量
const allData = pm.iterationData.toObject();
console.log('所有数据变量:', JSON.stringify(allData, null, 2));4.2 变量的定义、引用与作用范围
4.2.1 变量定义方式
方式一：GUI 界面定义
# 定义全局变量
Manage Environments -> Globals -> Add
# 定义环境变量
Manage Environments -> 选择环境 -> Add Variable
# 定义集合变量
Collection -> Edit -> Variables方式二：脚本动态定义
javascript
// 动态定义变量示例
// 从响应中提取 Token 并保存
const response = pm.response.json();
if (response.data && response.data.token) {
pm.environment.set('token', response.data.token);
pm.environment.set('tokenExpireTime', response.data.expireTime);
console.log('Token 已保存');
}
// 动态生成并保存请求ID
const requestId = 'req_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
pm.variables.set('requestId', requestId);4.2.2 变量引用语法
在请求中引用变量：
# URL 中引用
{{baseUrl}}/api/{{apiVersion}}/users
# Headers 中引用
Authorization: Bearer {{token}}
X-Request-ID: {{$guid}}
# Body 中引用
{
"username": "{{username}}",
"password": "{{password}}",
"timestamp": {{$timestamp}}
}
# 路径参数引用
/api/users/:userId
# 在 Params 面板设置 userId = {{currentUserId}}在脚本中引用变量：
javascript
// 使用 pm.variables.get() 方法
const baseUrl = pm.variables.get('baseUrl');
const token = pm.variables.get('token');
// 构建完整 URL
const fullUrl = `${baseUrl}/api/v1/users`;
console.log('完整URL:', fullUrl);
// 在请求中使用
pm.sendRequest({
url: `${baseUrl}/api/v1/validate`,
method: 'POST',
header: {
'Authorization': `Bearer ${token}`
}
}, (error, response) => {
console.log(response.json());
});4.2.3 变量作用范围示例
Request 请求
使用 baseUrl
使用 token
使用 apiVersion
Collection 集合变量
retryCount: 3
defaultHeaders
Environment 环境变量
baseUrl: https://dev-api.com
token: dev-token-xxx
Global 全局变量
apiVersion: v1
defaultTimeout: 30000
4.3 敏感变量与加密存储
4.3.1 Secret 类型变量
Postman 支持将敏感变量设置为 Secret 类型，值会被加密存储且在界面上隐藏显示。
配置 Secret 变量：
1. 打开环境变量管理界面
2. 添加变量时，将 Type 设置为 "secret"
3. 输入变量值（显示为掩码）
4. 保存后，变量值在界面上显示为 ******Secret 变量特点：
| 特点 | 说明 |
|---|---|
| 加密存储 | 值在本地加密存储 |
| 界面隐藏 | 在 GUI 中显示为掩码 |
| 日志隐藏 | Console 输出时自动脱敏 |
| 导出保护 | 导出集合时不包含 Secret 值 |
4.3.2 敏感数据处理最佳实践
javascript
// 敏感数据处理示例
// 1. 使用 Secret 类型存储敏感信息
// 在环境变量中设置：
// password (secret): 实际密码
// apiKey (secret): API密钥
// 2. 在脚本中安全使用敏感变量
const password = pm.environment.get('password');
const apiKey = pm.environment.get('apiKey');
// 不要在日志中输出敏感信息
// 错误做法：
// console.log('密码:', password);
// 正确做法：
console.log('密码已获取，长度:', password ? password.length : 0);
// 3. 请求完成后清除临时敏感数据
pm.environment.unset('tempPassword');
pm.variables.unset('tempKey');
// 4. 使用环境变量而非硬编码
// 错误做法：
// const apiKey = 'sk-xxxxx';
// 正确做法：
const apiKey = pm.environment.get('apiKey');4.4 多环境配置
4.4.1 环境配置结构
环境配置
开发环境 Dev
测试环境 Test
预发布环境 Staging
生产环境 Production
baseUrl: http://dev-api.com
debug: true
baseUrl: http://test-api.com
debug: true
baseUrl: http://staging-api.com
debug: false
baseUrl: https://api.com
debug: false
4.4.2 创建多环境配置
开发环境（Dev）：
json
{
"name": "Dev",
"values": [
{"key": "baseUrl", "value": "http://localhost:8080", "enabled": true},
{"key": "apiVersion", "value": "v1", "enabled": true},
{"key": "debug", "value": "true", "enabled": true},
{"key": "timeout", "value": "30000", "enabled": true},
{"key": "dbHost", "value": "localhost", "enabled": true},
{"key": "dbPort", "value": "3306", "enabled": true}
]
}测试环境（Test）：
json
{
"name": "Test",
"values": [
{"key": "baseUrl", "value": "http://test-api.example.com", "enabled": true},
{"key": "apiVersion", "value": "v1", "enabled": true},
{"key": "debug", "value": "true", "enabled": true},
{"key": "timeout", "value": "30000", "enabled": true},
{"key": "dbHost", "value": "test-db.example.com", "enabled": true},
{"key": "dbPort", "value": "3306", "enabled": true}
]
}生产环境（Production）：
json
{
"name": "Production",
"values": [
{"key": "baseUrl", "value": "https://api.example.com", "enabled": true},
{"key": "apiVersion", "value": "v1", "enabled": true},
{"key": "debug", "value": "false", "enabled": true},
{"key": "timeout", "value": "10000", "enabled": true},
{"key": "dbHost", "value": "prod-db.example.com", "enabled": true},
{"key": "dbPort", "value": "3306", "enabled": true}
]
}4.4.3 环境切换操作
javascript
// 在脚本中检测当前环境
const currentEnv = pm.environment.name;
console.log('当前环境:', currentEnv);
// 根据环境执行不同逻辑
if (currentEnv === 'Production') {
// 生产环境：禁用调试日志
pm.variables.set('logLevel', 'error');
} else {
// 非生产环境：启用详细日志
pm.variables.set('logLevel', 'debug');
}
// 检查是否在正确的环境
const requiredEnv = pm.collectionVariables.get('requiredEnv');
if (requiredEnv && currentEnv !== requiredEnv) {
console.warn(`警告: 当前环境 ${currentEnv} 与要求环境 ${requiredEnv} 不匹配`);
}4.5 环境切换与变量优先级规则
4.5.1 变量优先级实战示例
javascript
// 变量优先级演示
// 1. 设置各级变量（同名变量）
pm.globals.set('serverUrl', 'https://global.example.com');
pm.environment.set('serverUrl', 'https://env.example.com');
pm.collectionVariables.set('serverUrl', 'https://collection.example.com');
pm.variables.set('serverUrl', 'https://local.example.com');
// 2. 获取变量值（按优先级）
const url = pm.variables.get('serverUrl');
console.log('实际获取的URL:', url);
// 输出: https://local.example.com (Local 优先级最高)
// 3. 删除局部变量后
pm.variables.unset('serverUrl');
const url2 = pm.variables.get('serverUrl');
console.log('删除Local后的URL:', url2);
// 输出: https://env.example.com (Environment 次之)
// 4. 查看变量来源
function getVariableSource(varName) {
if (pm.variables.get(varName) !== undefined) {
// 检查各级变量是否存在
const sources = [];
if (pm.globals.has(varName)) sources.push('Global');
if (pm.environment.has(varName)) sources.push('Environment');
if (pm.collectionVariables.has(varName)) sources.push('Collection');
return sources;
}
return ['Not Found'];
}
console.log('serverUrl 变量存在于:', getVariableSource('serverUrl'));4.5.2 变量覆盖策略
临时覆盖
环境切换
集合共享
全局共享
需要覆盖变量
覆盖类型
使用 Local 变量
使用 Environment 变量
使用 Collection 变量
使用 Global 变量
脚本结束自动清除
切换环境自动切换
集合内所有请求共享
所有请求可访问
4.6 Cookie 与 Session 管理
4.6.1 Cookie 管理界面
Postman 提供了专门的 Cookie 管理功能：
位置：Settings -> Cookies
功能：
1. 查看所有域名的 Cookie
2. 添加/编辑/删除 Cookie
3. 清除特定域名的 Cookie
4. 导入/导出 Cookie4.6.2 在脚本中操作 Cookie
javascript
// Cookie 操作示例
// 获取 Cookie
const sessionId = pm.cookies.get('sessionId');
console.log('Session ID:', sessionId);
// 获取特定域名的 Cookie
const domain = 'api.example.com';
const cookies = pm.cookies.jar();
cookies.get(domain, 'token', (error, value) => {
if (!error) {
console.log('Token Cookie:', value);
}
});
// 设置 Cookie
cookies.set(domain, {
name: 'customCookie',
value: 'customValue',
expires: Date.now() + 86400000, // 24小时后过期
httpOnly: false,
secure: true
}, (error) => {
if (!error) {
console.log('Cookie 设置成功');
}
});
// 删除 Cookie
cookies.unset(domain, 'customCookie', (error) => {
if (!error) {
console.log('Cookie 删除成功');
}
});
// 获取所有 Cookie
pm.cookies.jar().getAll(domain, (error, cookies) => {
if (!error) {
console.log('所有 Cookie:', cookies);
}
});4.6.3 Session 管理策略
javascript
// Session 管理示例
// 1. 登录后保存 Session
const response = pm.response.json();
if (response.code === 200) {
// 保存 Session 相关信息
pm.environment.set('sessionId', response.data.sessionId);
pm.environment.set('userId', response.data.userId);
pm.environment.set('loginTime', Date.now());
// 设置 Cookie（如果服务器返回）
const setCookie = pm.response.headers.get('Set-Cookie');
if (setCookie) {
console.log('服务器设置的 Cookie:', setCookie);
}
}
// 2. 检查 Session 是否过期
const loginTime = parseInt(pm.environment.get('loginTime') || '0');
const sessionTimeout = 24 * 60 * 60 * 1000; // 24小时
if (Date.now() - loginTime > sessionTimeout) {
console.warn('Session 可能已过期，建议重新登录');
// 可以在这里自动触发重新登录
}
// 3. 登出后清除 Session
function logout() {
pm.environment.unset('sessionId');
pm.environment.unset('userId');
pm.environment.unset('loginTime');
pm.cookies.clear();
console.log('已清除所有 Session 信息');
}4.7 测试环境隔离策略
4.7.1 环境隔离原则
环境隔离策略
数据隔离
配置隔离
用户隔离
资源隔离
独立测试数据库
测试数据互不影响
独立配置文件
环境变量分离
独立测试账号
权限隔离
独立服务器资源
独立缓存/队列
4.7.2 实现环境隔离
javascript
// 环境隔离实现示例
// 1. 使用环境前缀隔离数据
const envPrefix = pm.environment.name.toLowerCase() + '_';
const testUserId = envPrefix + 'user_001';
pm.environment.set('testUserId', testUserId);
// 2. 数据库隔离配置
const dbConfig = {
host: pm.environment.get('dbHost'),
port: pm.environment.get('dbPort'),
database: `test_db_${pm.environment.name.toLowerCase()}`
};
pm.environment.set('dbConfig', JSON.stringify(dbConfig));
// 3. 测试账号隔离
const testAccounts = {
Dev: {
admin: 'dev_admin@example.com',
user: 'dev_user@example.com'
},
Test: {
admin: 'test_admin@example.com',
user: 'test_user@example.com'
},
Production: {
admin: 'admin@example.com',
user: 'user@example.com'
}
};
const currentEnv = pm.environment.name;
const account = testAccounts[currentEnv] || testAccounts['Dev'];
pm.environment.set('adminAccount', account.admin);
pm.environment.set('userAccount', account.user);
// 4. 清理测试数据
function cleanupTestData() {
const prefix = pm.environment.get('testDataPrefix');
// 调用清理接口
pm.sendRequest({
url: `${pm.environment.get('baseUrl')}/api/test/cleanup`,
method: 'POST',
header: {
'Authorization': `Bearer ${pm.environment.get('token')}`,
'Content-Type': 'application/json'
},
body: {
mode: 'raw',
raw: JSON.stringify({ prefix: prefix })
}
}, (error, response) => {
if (!error) {
console.log('测试数据清理完成');
}
});
}