Remove doc md files except README from git tracking

.gitignore

@@ -40,6 +40,10 @@ dist/
 logs/
 *.log
 
+# Documentation (keep only README.md)
+*.md
+!README.md
+
 # OS
 .DS_Store
 Thumbs.db

API.md

@@ -1,373 +0,0 @@
-# API 文档
-
-所有API通过API Gateway (`http://localhost:8080`) 访问。
-
-> **💡 快速生成测试数据？** 查看 [BATCH_TEST_API.md](BATCH_TEST_API.md) 获取批量模拟请求API
-> 
-> 一句命令生成50个订单: `curl http://localhost:8080/api/test/order/batch?count=50`
-
-## 订单服务 (Order Service)
-
-### 1. 创建订单
-**请求:**
-```http
-POST /api/order/create
-Content-Type: application/json
-X-User-Id: user123
-
-{
-  "userId": "user123",
-  "price": 99.99,
-  "description": "test order"
-}
-```
-
-**响应 (成功 200):**
-```json
-{
-  "code": 0,
-  "msg": "success",
-  "data": {
-    "orderId": "ORD-A1B2C3D4",
-    "userId": "user123",
-    "price": 99.99,
-    "status": "CREATED",
-    "description": "test order",
-    "createdAt": 1707200445123
-  }
-}
-```
-
-**响应 (失败):**
-```json
-{
-  "code": -1,
-  "msg": "price must be > 0",
-  "data": null
-}
-```
-
----
-
-### 2. 获取订单详情
-**请求:**
-```http
-GET /api/order/{orderId}
-```
-
-**示例:**
-```bash
-curl http://localhost:8080/api/order/ORD-A1B2C3D4
-```
-
-**响应 (成功 200):**
-```json
-{
-  "code": 0,
-  "msg": "success",
-  "data": {
-    "orderId": "ORD-A1B2C3D4",
-    "userId": "user123",
-    "price": 99.99,
-    "status": "CREATED",
-    "description": "test order",
-    "createdAt": 1707200445123
-  }
-}
-```
-
----
-
-### 3. 支付订单
-**请求:**
-```http
-POST /api/order/{orderId}/pay
-```
-
-**示例:**
-```bash
-curl -X POST http://localhost:8080/api/order/ORD-A1B2C3D4/pay
-```
-
-**响应 (成功 200):**
-```json
-{
-  "code": 0,
-  "msg": "success",
-  "data": null
-}
-```
-
----
-
-### 4. 删除订单
-**请求:**
-```http
-POST /api/order/delete/{orderId}
-```
-
-**示例:**
-```bash
-curl -X POST http://localhost:8080/api/order/delete/ORD-A1B2C3D4
-```
-
-**响应 (成功 200):**
-```json
-{
-  "code": 0,
-  "msg": "success",
-  "data": null
-}
-```
-
-**响应 (已支付订单不能删除):**
-```json
-{
-  "code": -1,
-  "msg": "Paid order cannot be deleted",
-  "data": null
-}
-```
-
----
-
-## 支付服务 (Payment Service)
-
-### 1. 支付订单
-**请求:**
-```http
-POST /api/payment/pay
-Content-Type: application/json
-X-User-Id: user123
-
-{
-  "orderId": "ORD-A1B2C3D4",
-  "amount": 99.99,
-  "paymentMethod": "WECHAT"
-}
-```
-
-**支付方式选项:**
-- `CARD` - 银行卡
-- `WECHAT` - 微信
-- `ALIPAY` - 支付宝
-
-**响应 (成功 200):**
-```json
-{
-  "code": 0,
-  "msg": "success",
-  "data": {
-    "paymentId": "PAY-X1Y2Z3W4",
-    "orderId": "ORD-A1B2C3D4",
-    "amount": 99.99,
-    "status": "SUCCESS",
-    "paymentMethod": "WECHAT",
-    "paidAt": 1707200500234
-  }
-}
-```
-
-**响应 (失败 - 30% 概率):**
-```json
-{
-  "code": -1,
-  "msg": "Third party payment failed",
-  "data": null
-}
-```
-
----
-
-### 2. 获取支付详情
-**请求:**
-```http
-GET /api/payment/{paymentId}
-```
-
-**示例:**
-```bash
-curl http://localhost:8080/api/payment/PAY-X1Y2Z3W4
-```
-
-**响应 (成功 200):**
-```json
-{
-  "code": 0,
-  "msg": "success",
-  "data": {
-    "paymentId": "PAY-X1Y2Z3W4",
-    "orderId": "ORD-A1B2C3D4",
-    "amount": 99.99,
-    "status": "SUCCESS",
-    "paymentMethod": "WECHAT",
-    "paidAt": 1707200500234
-  }
-}
-```
-
----
-
-### 3. 退款
-**请求:**
-```http
-POST /api/payment/refund/{paymentId}
-```
-
-**示例:**
-```bash
-curl -X POST http://localhost:8080/api/payment/refund/PAY-X1Y2Z3W4
-```
-
-**响应 (成功 200):**
-```json
-{
-  "code": 0,
-  "msg": "success",
-  "data": null
-}
-```
-
-**响应 (非成功支付无法退款):**
-```json
-{
-  "code": -1,
-  "msg": "Only success payment can be refunded",
-  "data": null
-}
-```
-
----
-
-## 日志对应关系
-
-### 订单创建流程产生的日志链路
-
-```
-1. Gateway 收到请求
-   └─ traceId: abc-123-def-456
-   └─ uri: /api/order/create
-   └─ uri_group: /order/*
-
-2. Order Service 处理请求
-   └─ event_class: order
-   └─ duration: 156ms
-   └─ status: success
-
-3. 返回响应
-   └─ 记录完整的MDC上下文
-```
-
-### 支付流程产生的日志链路
-
-```
-1. Gateway 收到请求
-   └─ traceId: xyz-789-uvw-012
-   └─ uri: /api/payment/pay
-   └─ uri_group: /payment/*
-
-2. Payment Service 处理请求
-   └─ event_class: payment
-   └─ duration: 234ms
-   └─ status: success (70%) 或 server_error (30%)
-
-3. 返回响应
-   └─ 记录完整的MDC上下文
-```
-
----
-
-## cURL 测试脚本
-
-### 完整的订单+支付流程
-
-```bash
-#!/bin/bash
-
-# 1. 创建订单
-echo "Creating order..."
-ORDER_RESPONSE=$(curl -s -X POST http://localhost:8080/api/order/create \
-  -H "Content-Type: application/json" \
-  -H "X-User-Id: user123" \
-  -d '{
-    "userId":"user123",
-    "price":99.99,
-    "description":"test order"
-  }')
-
-ORDER_ID=$(echo $ORDER_RESPONSE | jq -r '.data.orderId')
-echo "Order created: $ORDER_ID"
-
-# 2. 获取订单详情
-echo "Fetching order details..."
-curl -s http://localhost:8080/api/order/$ORDER_ID | jq .
-
-# 3. 支付订单
-echo "Processing payment..."
-PAYMENT_RESPONSE=$(curl -s -X POST http://localhost:8080/api/payment/pay \
-  -H "Content-Type: application/json" \
-  -d "{
-    \"orderId\":\"$ORDER_ID\",
-    \"amount\":99.99,
-    \"paymentMethod\":\"WECHAT\"
-  }")
-
-PAYMENT_ID=$(echo $PAYMENT_RESPONSE | jq -r '.data.paymentId')
-echo "Payment processed: $PAYMENT_ID"
-
-# 4. 标记订单为已支付
-echo "Marking order as paid..."
-curl -s -X POST http://localhost:8080/api/order/$ORDER_ID/pay | jq .
-
-# 5. 尝试删除已支付订单（应该失败）
-echo "Attempting to delete paid order..."
-curl -s -X POST http://localhost:8080/api/order/delete/$ORDER_ID | jq .
-
-# 6. 获取支付详情
-echo "Fetching payment details..."
-curl -s http://localhost:8080/api/payment/$PAYMENT_ID | jq .
-
-# 7. 退款
-echo "Processing refund..."
-curl -s -X POST http://localhost:8080/api/payment/refund/$PAYMENT_ID | jq .
-```
-
-保存为 `test.sh` 并运行：
-```bash
-chmod +x test.sh
-./test.sh
-```
-
----
-
-## HTTP 状态码
-
-| 状态码 | 含义 |
-|--------|------|
-| 200 | 请求成功（响应体中 code=0 表示业务成功） |
-| 400 | 请求参数错误 |
-| 500 | 服务器错误 |
-
-## 请求头
-
-| 头| 说明 | 示例 |
-|----|------|------|
-| `Content-Type` | 必需 (POST/PUT) | `application/json` |
-| `X-User-Id` | 可选，用于日志追踪 | `user123` |
-| `X-B3-TraceId` | 可选，Jaeger/Zipkin追踪ID | `550e8400-e29b-41d4` |
-
----
-
-## 错误处理
-
-所有API响应都遵循统一的格式：
-
-```json
-{
-  "code": 0,           // 0 表示成功，非0表示错误
-  "msg": "success",    // 错误或成功信息
-  "data": {...}        // 业务数据（错误时为null）
-}
-```
-
-实际的HTTP状态码始终是200，业务状态通过 `code` 字段判断。

ARCHITECTURE.md

@@ -1,364 +0,0 @@
-# 系统架构设计
-
-## 🏗️ 整体架构
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                          Browser (Vue Web)                    │
-│                      http://localhost:5173                    │
-└────────────────────────┬────────────────────────────────────┘
-                         │
-                    HTTP Requests
-                         │
-                         ▼
-┌─────────────────────────────────────────────────────────────┐
-│                   API Gateway (Spring Cloud)                  │
-│              http://localhost:8080 (Port 8080)               │
-│                                                               │
-│  Functions:                                                   │
-│  • Route requests to backend services                        │
-│  • Record request entry point logs                          │
-│  • Apply global interceptors                                │
-└────────┬──────────────────────┬──────────────────────┬────────┘
-         │                      │                      │
-    /order/*              /payment/*              /health
-         │                      │                      │
-         ▼                      ▼                      ▼
-    ┌─────────────┐      ┌──────────────┐      ┌──────────────┐
-    │Order Service │      │Payment Service│      └──────────────┘
-    │(Port 8081)  │      │(Port 8082)    │
-    │             │      │               │
-    │ /order/     │      │ /payment/     │
-    │  ├─ create  │      │  ├─ pay       │
-    │  ├─ delete  │      │  ├─ refund    │
-    │  ├─ get     │      │  └─ get       │
-    │  └─ pay     │      │               │
-    └─────────────┘      └──────────────┘
-```
-
-## 📦 模块设计
-
-### 1. shop-recycle-common (公共模块)
-
-**职责:** 提供日志、配置、DTO等公共能力
-
-**包含:**
-- `LoggingMdcInterceptor` - 日志MDC拦截器
-- `Response<T>` - 统一响应类
-- `WebConfig` - Web配置（注册拦截器）
-
-**关键特性:**
-```
-自动填充MDC字段:
-  ✓ traceId    (链路追踪ID)
-  ✓ uri        (原始请求路径)
-  ✓ uri_group  (规范化URI分组)
-  ✓ event_class (事件分类)
-  ✓ duration   (请求耗时)
-  ✓ status     (HTTP状态)
-  ✓ error      (错误堆栈)
-```
-
-### 2. shop-recycle-gateway (API网关)
-
-**职责:** 请求路由、负载均衡、协议转换
-
-**配置:**
-```yaml
-routes:
-  - id: order-service
-    uri: http://localhost:8081    # 本地开发
-    条件: Path=/api/order/**
-
-  - id: payment-service
-    uri: http://localhost:8082
-    条件: Path=/api/payment/**
-```
-
-**日志链路:**
-```
-浏览器请求 → Gateway (日志记录进入点)
-         → 路由转发 → Order Service
-         → 生成响应 → 返回浏览器
-```
-
-### 3. shop-recycle-order-service (订单服务)
-
-**职责:** 订单CRUD操作
-
-**数据模型:**
-```java
-OrderResponse {
-  orderId      // ORD-XXXXX (自动生成)
-  userId       // 用户ID (来自请求头)
-  price        // 订单金额
-  status       // CREATED, PAID, CANCELLED
-  description  // 订单描述
-  createdAt    // 创建时间戳
-}
-```
-
-**业务逻辑:**
-```java
-✓ createOrder()     - 创建订单 (校验价格>0)
-✓ deleteOrder()     - 删除订单 (已支付的不能删除)
-✓ getOrder()        - 查询订单
-✓ updateOrderStatus() - 更新状态 (订单支付时调用)
-```
-
-**日志埋点:**
-```
-DEBUG: 订单创建逻辑开始
-INFO:  订单已创建 orderId=ORD-XXXXX
-WARN:  订单不存在 orderId=...
-ERROR: 订单创建失败 (异常堆栈)
-```
-
-### 4. shop-recycle-payment-service (支付服务)
-
-**职责:** 订单支付、退款
-
-**数据模型:**
-```java
-PaymentResponse {
-  paymentId       // PAY-XXXXX (自动生成)
-  orderId         // 关联的订单
-  amount          // 支付金额
-  status          // PENDING, SUCCESS, FAILED, REFUNDED
-  paymentMethod   // CARD, WECHAT, ALIPAY
-  paidAt          // 支付时间戳
-}
-```
-
-**业务逻辑:**
-```java
-✓ payOrder()   - 支付订单 (模拟30%失败率)
-✓ refund()     - 退款 (仅成功支付可退,模拟10%失败率)
-✓ getPayment() - 查询支付
-```
-
-**日志埋点:**
-```
-DEBUG: 订单支付逻辑开始
-INFO:  订单支付成功 paymentId=PAY-XXXXX
-WARN:  支付金额不合法
-ERROR: 第三方支付失败 (异常堆栈)
-```
-
-### 5. shop-recycle-web (Vue前端)
-
-**职责:** 提供Web UI，调用API生成测试流量
-
-**技术栈:**
-- Vue 3 (创意性组件框架)
-- Vite (构建工具)
-- Axios (HTTP客户端)
-
-**页面组件:**
-- **OrderComponent** - 订单管理界面
-- **PaymentComponent** - 支付管理界面
-
-**代理配置 (vite.config.js):**
-```javascript
-proxy: {
-  '/api': {
-    target: 'http://localhost:8080',  // API Gateway
-    changeOrigin: true
-  }
-}
-```
-
-## 🔄 请求流程示例
-
-### 完整的订单创建流程
-
-```
-Step 1: 用户提交表单
-浏览器 → POST /api/order/create
-         ↓
-Step 2: Gateway接收请求
-Gateway → LoggingMdcInterceptor (记录进入点)
-         ├─ traceId = UUID生成
-         ├─ uri = /api/order/create
-         ├─ uri_group = /order/*
-         └─ event_class = order
-         ↓
-Step 3: 路由转发到Order Service
-Gateway → Order Service (http://localhost:8081/api/order/create)
-         ↓
-Step 4: Order Service处理请求
-Order Service → OrderController.createOrder()
-              → OrderService.createOrder()
-              → generate orderId
-              → save to memory
-              → MDC.put("status", "success")
-              └─ log.info("订单已创建")
-         ↓
-Step 5: 响应返回
-Order Service → Response.success({orderId, userId, ...})
-              ↓
-Step 6: 前端接收响应
-浏览器 ← {code: 0, msg: "success", data: {...}}
-       └─ Display success message
-```
-
-### 后端日志输出
-
-```json
-[Gateway在处理请求时]
-{
-  "ts":"2024-02-06T10:30:45.123Z",
-  "app":"shop-recycle-gateway",
-  "uri":"/api/order/create",
-  "uri_group":"/order/*",
-  "traceId":"550e8400-e29b-41d4-a716-446655440000"
-}
-
-[Order Service处理业务逻辑时]
-{
-  "ts":"2024-02-06T10:30:45.200Z",
-  "app":"shop-recycle-order-service",
-  "level":"INFO",
-  "msg":"订单已创建 orderId=ORD-A1B2C3D4",
-  "event_class":"order",
-  "status":"success",
-  "duration":"156",  // 毫秒
-  "traceId":"550e8400-e29b-41d4-a716-446655440000"
-}
-```
-
-## 📊 日志字段映射表
-
-| MDC字段 | 来源 | 设置位置 | 备注 |
-|---------|------|---------|------|
-| `traceId` | 请求头或生成 | Interceptor.preHandle() | X-B3-TraceId或UUID生成 |
-| `uri` | HttpRequest | Interceptor.preHandle() | 原始请求路径 |
-| `uri_group` | 规范化逻辑 | normalizeUri() | /order/* /payment/* |
-| `event_class` | 规则匹配 | deriveEventClass() | order/payment/auth/api |
-| `userId` | 请求头 | Interceptor.preHandle() | X-User-Id头 |
-| `start_time` | System.time | Interceptor.preHandle() | 用于后续计算duration |
-| `duration` | 计算得出 | Interceptor.afterCompletion() | 当前时间 - start_time |
-| `error` | 异常/状态码 | Interceptor.afterCompletion() | Exception.toString()或HTTP状态 |
-| `status` | HTTP状态码 | Interceptor.afterCompletion() | success/client_error/server_error |
-
-## 🔑 关键设计决策
-
-### 1. 拦截器而不是过滤器
-```
-✓ 优点: 可以访问Handler和ModelMap
-✓ 优点: 在业务方法执行前后进行处理
-✓ 适合: 日志、权限、性能监控
-```
-
-### 2. 异步Appender
-```
-✓ 优点: 异步输出日志，不阻塞业务线程
-✓ 优点: 可配置队列大小和丢弃策略
-✓ 配置: AsyncAppender + queueSize=1024
-```
-
-### 3. JSON格式日志
-```
-✓ 优点: 可被Loki/ELK直接解析
-✓ 优点: 支持结构化查询
-✓ 工具: LogstashEncoder
-```
-
-### 4. MDC而不是参数传递
-```
-✓ 优点: 零侵入，业务代码无需改动
-✓ 优点: 自动在线程本地存储
-✓ 优点: 所有日志自动包含上下文
-```
-
-### 5. URI规范化
-```
-✓ 原始: /order/create /order/12345/delete /order/abc/pay
-✓ 规范化: /order/* (减少基数)
-✓ 好处: Prometheus label基数可控
-```
-
-## 🌐 环境配置
-
-### 本地开发 (local)
-```yaml
-Gateway:
-  order-service: http://localhost:8081
-  payment-service: http://localhost:8082
-
-Frontend:
-  Vite proxy: http://localhost:8080
-```
-
-### Docker容器 (docker)
-```yaml
-Gateway:
-  order-service: http://order-service:8081   (DNS名称)
-  payment-service: http://payment-service:8082
-
-Network:
-  All services connected via app-network bridge
-```
-
-### 生产环境 (prod - 示例)
-```yaml
-Gateway:
-  order-service: http://order-service.default.svc.cluster.local:8081
-  payment-service: http://payment-service.default.svc.cluster.local:8082
-
-Log aggregation:
-  Vector agent → Loki endpoint
-  Prometheus scrape: /actuator/prometheus
-```
-
-## 📈 可观测性支持
-
-### 日志可观测 (Structured Logging)
-```
-✓ Fields: traceId, uri_group, event_class, duration, status
-✓ Format: JSON (parseable)
-✓ Tool: Loki/ELK for Log aggregation
-```
-
-### 指标可观测 (Metrics)
-```
-✓ Requests total (按uri_group分组)
-✓ Requests errors
-✓ Request duration (直方图)
-✓ Order/Payment specific counters
-Tool: Prometheus + Vector for export
-```
-
-### 链路可观测 (Tracing)
-```
-✓ traceId: 记录在每个日志中
-✓ X-B3-TraceId: 支持Jaeger/Zipkin集成
-✓ 可通过traceId查询完整链路
-```
-
-## 🔬 测试架构
-
-### 单元测试
-```
-service层 → 业务逻辑 (MockOrderService)
-```
-
-### 集成测试
-```
-Controller → Service → 内存DB (实际执行)
-```
-
-### 端到端测试
-```
-Vue前端 → API Gateway → Order Service → Payment Service
-         (完整的HTTP链路)
-```
-
-使用QUICK_START.md中的测试脚本进行E2E测试。
-
----
-
-**相关文档:**
-- [QUICK_START.md](QUICK_START.md) - 快速开始
-- [API.md](API.md) - API详细文档
-- [README.md](README.md) - 项目文档

BATCH_TEST_API.md

@@ -1,378 +0,0 @@
-# 批量测试API文档
-
-这些API用于快速生成大量模拟请求，用来测试日志系统、压力测试等场景。
-
-## 订单服务测试API
-
-### 1. 生成一条随机订单
-**URL:**
-```
-GET http://localhost:8080/api/test/order
-```
-
-**示例:**
-```bash
-curl http://localhost:8080/api/test/order | jq .
-```
-
-**响应:**
-```json
-{
-  "code": 0,
-  "msg": "success",
-  "data": {
-    "orderId": "ORD-A1B2C3D4",
-    "userId": "alice-5234",
-    "price": 234.56,
-    "status": "CREATED",
-    "description": "二手家电处理",
-    "createdAt": 1707200445123
-  }
-}
-```
-
----
-
-### 2. 批量生成订单
-**URL:**
-```
-GET http://localhost:8080/api/test/order/batch?count=50
-GET http://localhost:8080/api/test/order/batch (默认10个)
-```
-
-**参数:**
-- `count` (可选): 要生成的订单数量，默认10个
-
-**示例:**
-```bash
-# 生成10个订单
-curl http://localhost:8080/api/test/order/batch | jq .
-
-# 生成50个订单
-curl http://localhost:8080/api/test/order/batch?count=50 | jq .
-
-# 生成100个订单
-curl http://localhost:8080/api/test/order/batch?count=100 | jq .data.stats
-```
-
-**响应:**
-```json
-{
-  "code": 0,
-  "msg": "success",
-  "data": {
-    "total": 10,
-    "success": 10,
-    "error": 0,
-    "duration": 1245,
-    "orders": [
-      {...订单数据...}
-    ]
-  }
-}
-```
-
----
-
-### 3. 场景测试 (创建→查询→支付→删除失败)
-**URL:**
-```
-GET http://localhost:8080/api/test/order/scenario?count=5
-```
-
-**参数:**
-- `count` (可选): 测试轮数，默认5轮
-
-**说明:**
-每轮测试都会:
-1. 创建一个订单
-2. 查询订单详情
-3. 标记订单为已支付
-4. 尝试删除订单（预期失败，因为已支付）
-
-这样可以在日志中看到完整的业务流程和错误处理。
-
-**示例:**
-```bash
-curl http://localhost:8080/api/test/order/scenario?count=3 | jq .
-```
-
-**响应:**
-```json
-{
-  "code": 0,
-  "msg": "success",
-  "data": {
-    "scenario": "create -> query -> pay -> delete(fail)",
-    "rounds": 3,
-    "operations": 12,
-    "duration": 687
-  }
-}
-```
-
----
-
-### 4. 压力测试
-**URL:**
-```
-GET http://localhost:8080/api/test/order/stress?duration=10
-```
-
-**参数:**
-- `duration` (可选): 测试持续时间（秒），默认10秒
-
-**说明:**
-不间断地创建订单，持续指定时间，用来测试系统吞吐量和日志系统性能。
-
-**示例:**
-```bash
-# 10秒压力测试
-curl http://localhost:8080/api/test/order/stress?duration=10 | jq .
-
-# 30秒压力测试
-curl http://localhost:8080/api/test/order/stress?duration=30 | jq .
-```
-
-**响应:**
-```json
-{
-  "code": 0,
-  "msg": "success",
-  "data": {
-    "duration": 10234,
-    "requests": 547,
-    "success": 547,
-    "error": 0,
-    "qps": "53.50"
-  }
-}
-```
-
----
-
-## 支付服务测试API
-
-### 1. 生成一条随机支付
-**URL:**
-```
-GET http://localhost:8080/api/test/payment
-```
-
-**示例:**
-```bash
-curl http://localhost:8080/api/test/payment | jq .
-```
-
-**响应:**
-```json
-{
-  "code": 0,
-  "msg": "success",
-  "data": {
-    "paymentId": "PAY-X1Y2Z3W4",
-    "orderId": "ORD-123456",
-    "amount": 234.56,
-    "status": "SUCCESS",
-    "paymentMethod": "WECHAT",
-    "paidAt": 1707200500234
-  }
-}
-```
-
----
-
-### 2. 批量生成支付
-**URL:**
-```
-GET http://localhost:8080/api/test/payment/batch?count=50
-```
-
-**参数:**
-- `count` (可选): 要生成的支付数量，默认10个
-
-**示例:**
-```bash
-curl http://localhost:8080/api/test/payment/batch?count=20 | jq .
-```
-
-**响应:**
-```json
-{
-  "code": 0,
-  "msg": "success",
-  "data": {
-    "total": 20,
-    "success": 14,
-    "error": 6,
-    "totalAmount": 3245.67,
-    "duration": 2341,
-    "payments": [...]
-  }
-}
-```
-
----
-
-### 3. 退款场景测试
-**URL:**
-```
-GET http://localhost:8080/api/test/payment/refund?count=5
-```
-
-**参数:**
-- `count` (可选): 测试轮数，默认5轮
-
-**说明:**
-每轮测试都会:
-1. 创建一个支付
-2. 尝试退款
-
-用来测试退款失败的场景（10%失败率）。
-
-**示例:**
-```bash
-curl http://localhost:8080/api/test/payment/refund?count=10 | jq .
-```
-
----
-
-### 4. 支付压力测试
-**URL:**
-```
-GET http://localhost:8080/api/test/payment/stress?duration=10
-```
-
-**示例:**
-```bash
-curl http://localhost:8080/api/test/payment/stress?duration=15 | jq .
-```
-
----
-
-## 使用场景
-
-### 场景1: 快速验证日志格式
-```bash
-# 生成一条订单，查看日志
-curl http://localhost:8080/api/test/order
-
-# 查看后端Terminal的JSON日志输出
-# 验证 traceId、uri_group、event_class、duration 等字段
-```
-
-### 场景2: 生成足够的日志用于测试
-```bash
-# 生成100条订单
-curl http://localhost:8080/api/test/order/batch?count=100
-
-# 生成50笔支付
-curl http://localhost:8080/api/test/payment/batch?count=50
-```
-
-### 场景3: 测试日志系统的高吞吐处理能力
-```bash
-# 30秒的订单压力测试
-curl http://localhost:8080/api/test/order/stress?duration=30
-
-# 30秒的支付压力测试
-curl http://localhost:8080/api/test/payment/stress?duration=30
-
-# 查看日志系统是否能正常处理高频请求
-# 观察 Duration 字段是否异常增大（说明日志处理成为瓶颈）
-```
-
-### 场景4: 测试自动异常处理和日志记录
-```bash
-# 场景测试会失败删除已支付订单，产生异常日志
-curl http://localhost:8080/api/test/order/scenario?count=10
-
-# 支付服务有30%的失败率，可以看到error日志
-curl http://localhost:8080/api/test/payment/batch?count=50
-```
-
-### 场景5: 批量脚本测试
-```bash
-#!/bin/bash
-# 连续运行多个测试
-
-echo "=== 生成10个订单 ==="
-curl http://localhost:8080/api/test/order/batch?count=10
-echo ""
-
-echo "=== 生成20笔支付 ==="
-curl http://localhost:8080/api/test/payment/batch?count=20
-echo ""
-
-echo "=== 场景测试5轮 ==="
-curl http://localhost:8080/api/test/order/scenario?count=5
-echo ""
-
-echo "=== 10秒压力测试 ==="
-curl http://localhost:8080/api/test/order/stress?duration=10
-echo ""
-```
-
-保存为 `batch-test.sh` 并运行：
-```bash
-chmod +x batch-test.sh
-./batch-test.sh
-```
-
----
-
-## 日志观察
-
-运行这些API后，在后端Terminal中观察JSON日志：
-
-```json
-{
-  "ts":"2024-02-06T10:30:45.123Z",
-  "level":"INFO",
-  "msg":"测试订单生成成功 orderId=ORD-A1B2C3D4",
-  "event_class":"order",
-  "status":"success",
-  "uri_group":"/test/*",
-  "duration":"145",
-  "app":"shop-recycle-order-service"
-}
-```
-
-关键观察:
-- ✅ `uri_group` 应该是 `/test/*` (规范化规则自动应用)
-- ✅ `event_class` 应该是 `order` 或 `payment`
-- ✅ `status` 应该是 `success` 或 `server_error`
-- ✅ `duration` 显示请求耗时
-- ✅ 所有日志共享相同的 `traceId` (如果在同一请求中)
-
----
-
-## PowerShell 一键测试脚本
-
-```powershell
-# run-batch-tests.ps1
-
-Write-Host "=== 订单服务测试 ===" -ForegroundColor Cyan
-Write-Host "1. 生成10个订单"
-Invoke-WebRequest -Uri "http://localhost:8080/api/test/order/batch?count=10" | ConvertFrom-Json | ForEach-Object { $_.data | Format-Table total,success,error,duration -AutoSize }
-
-Start-Sleep -Seconds 2
-
-Write-Host "2. 场景测试"
-Invoke-WebRequest -Uri "http://localhost:8080/api/test/order/scenario?count=5" | ConvertFrom-Json | ForEach-Object { $_.data | Format-Table scenario,rounds,duration -AutoSize }
-
-Start-Sleep -Seconds 2
-
-Write-Host ""
-Write-Host "=== 支付服务测试 ===" -ForegroundColor Green
-Write-Host "3. 生成20笔支付"
-Invoke-WebRequest -Uri "http://localhost:8080/api/test/payment/batch?count=20" | ConvertFrom-Json | ForEach-Object { $_.data | Format-Table total,success,error,totalAmount,duration -AutoSize }
-
-Write-Host ""
-Write-Host "✅ 测试完成!" -ForegroundColor Green
-Write-Host "查看后端Terminal的JSON日志输出"
-```
-
----
-
-**所有这些API都会生成完整的结构化JSON日志，便于验证日志系统的正确性。**

COMPLETION_SUMMARY.md

@@ -1,419 +0,0 @@
-# 项目完成总结
-
-完整的 **Spring Cloud + Vue 日志测试系统**已经创建完成！
-
-## 📁 项目结构
-
-```
-spring-cloud-log-demo/
-├── shop-recycle-common/              # 公共模块
-│   ├── pom.xml
-│   └── src/main/java/com/shop/recycle/common/
-│       ├── interceptor/              # 日志拦截器
-│       │   └── LoggingMdcInterceptor.java
-│       ├── config/
-│       │   └── WebConfig.java
-│       └── dto/
-│           └── Response.java
-│
-├── shop-recycle-gateway/             # API网关 (port 8080)
-│   ├── pom.xml
-│   ├── Dockerfile
-│   ├── src/main/java/com/shop/recycle/gateway/
-│   │   └── GatewayApplication.java
-│   └── src/main/resources/
-│       ├── application.yml           # 路由配置
-│       └── logback-spring.xml        # 日志配置
-│
-├── shop-recycle-order-service/       # 订单服务 (port 8081)
-│   ├── pom.xml
-│   ├── Dockerfile
-│   ├── src/main/java/com/shop/recycle/order/
-│   │   ├── OrderServiceApplication.java
-│   │   ├── controller/
-│   │   │   └── OrderController.java
-│   │   ├── service/
-│   │   │   └── OrderService.java
-│   │   └── dto/
-│   │       ├── CreateOrderRequest.java
-│   │       └── OrderResponse.java
-│   └── src/main/resources/
-│       ├── application.yml
-│       └── logback-spring.xml
-│
-├── shop-recycle-payment-service/     # 支付服务 (port 8082)
-│   ├── pom.xml
-│   ├── Dockerfile
-│   ├── src/main/java/com/shop/recycle/payment/
-│   │   ├── PaymentServiceApplication.java
-│   │   ├── controller/
-│   │   │   └── PaymentController.java
-│   │   ├── service/
-│   │   │   └── PaymentService.java
-│   │   └── dto/
-│   │       ├── PaymentRequest.java
-│   │       └── PaymentResponse.java
-│   └── src/main/resources/
-│       ├── application.yml
-│       └── logback-spring.xml
-│
-├── shop-recycle-web/                 # Vue前端 (port 5173)
-│   ├── package.json
-│   ├── vite.config.js
-│   ├── index.html
-│   ├── public/
-│   └── src/
-│       ├── main.js
-│       ├── App.vue                   # 主应用
-│       ├── components/
-│       │   ├── OrderComponent.vue    # 订单管理
-│       │   └── PaymentComponent.vue  # 支付管理
-│       └── api/
-│           └── index.js              # API客户端
-│
-├── pom.xml                           # 顶层POM
-├── docker-compose.yml                # Docker编排
-├── start.sh                          # Linux/Mac启动脚本
-├── start.ps1                         # Windows PowerShell启动脚本
-├── README.md                         # 项目文档
-├── QUICK_START.md                    # 快速开始指南
-├── ARCHITECTURE.md                   # 架构设计文档
-├── API.md                            # API文档
-└── .gitignore                        # Git忽略配置
-```
-
-## ✨ 核心特性
-
-### ✅ 1. 结构化JSON日志
-- 每个请求都生成标准的JSON格式日志
-- 包含 `traceId`、`uri_group`、`event_class`、`duration` 等关键字段
-- 可直接被 Loki/ELK/Splunk 解析
-
-### ✅ 2. 日志MDC自动注入 (零侵入)
-- LoggingMdcInterceptor 自动填充所有日志字段
-- 业务代码无需修改
-- 支持链路追踪
-
-### ✅ 3. 三个微服务完整示例
-- **API Gateway** - 请求入口，自动路由
-- **Order Service** - 订单CRUD示例
-- **Payment Service** - 支付流程示例
-
-### ✅ 4. Vue前端UI
-- 可视化界面，一键生成测试流量
-- 订单管理：创建、删除、查询订单
-- 支付管理：支付、查询、退款
-- 实时显示操作结果
-
-### ✅ 5. 生产级配置
-- Logstash JSON encoder (标准日志格式)
-- 异步日志处理 (AsyncAppender+1024队列)
-- Docker & Docker Compose支持
-- 环境化配置 (local/docker/prod)
-
-### ✅ 6. 完整文档
-- 快速开始指南 (QUICK_START.md)
-- 详细API文档 (API.md)
-- 架构设计说明 (ARCHITECTURE.md)
-- README 项目文档
-
-## 🚀 快速开始 (三种方式)
-
-### 方式1: 一键启动脚本 (推荐-Windows)
-```powershell
-cd spring-cloud-log-demo
-.\start.ps1
-```
-脚本会自动启动所有服务并打开前端。
-
-### 方式2: 一键启动脚本 (Linux/Mac)
-```bash
-cd spring-cloud-log-demo
-chmod +x start.sh
-./start.sh
-```
-
-### 方式3: 手动启动各服务
-```bash
-# Terminal 1: Gateway
-cd spring-cloud-log-demo
-mvn clean install
-cd shop-recycle-gateway
-mvn spring-boot:run
-
-# Terminal 2: Order Service
-cd spring-recycle-order-service
-mvn spring-boot:run
-
-# Terminal 3: Payment Service
-cd spring-recycle-payment-service
-mvn spring-boot:run
-
-# Terminal 4: Frontend
-cd shop-recycle-web
-npm install && npm run dev
-```
-
-所有服务启动完成后，访问 **http://localhost:5173**
-
-## 📊 生成的日志示例
-
-### 订单创建日志
-```json
-{
-  "ts":"2024-02-06T10:30:45.123Z",
-  "level":"INFO",
-  "logger":"com.shop.recycle.order.service.OrderService",
-  "msg":"订单已创建 orderId=ORD-A1B2C3D4",
-  "traceId":"550e8400-e29b-41d4-a716-446655440000",
-  "uri":"/api/order/create",
-  "uri_group":"/order/*",
-  "duration":"156",
-  "userId":"user123",
-  "event_class":"order",
-  "error":"-",
-  "status":"success",
-  "thread":"http-nio-8081-exec-1",
-  "app":"shop-recycle-order-service",
-  "env":"local"
-}
-```
-
-### 支付日志
-```json
-{
-  "ts":"2024-02-06T10:30:46.234Z",
-  "level":"INFO",
-  "logger":"com.shop.recycle.payment.service.PaymentService",
-  "msg":"订单支付成功 paymentId=PAY-X1Y2Z3W4, orderId=ORD-A1B2C3D4, amount=99.99",
-  "traceId":"550e8400-e29b-41d4-a716-446655440000",
-  "uri":"/api/payment/pay",
-  "uri_group":"/payment/*",
-  "duration":"234",
-  "event_class":"payment",
-  "status":"success",
-  "app":"shop-recycle-payment-service",
-  "env":"local"
-}
-```
-
-## 🎯 测试场景
-
-### 基础流程
-1. 打开前端 http://localhost:5173
-2. 创建订单 (输入用户ID、金额、描述)
-3. 支付订单 (使用创建的订单ID)
-4. 查看后端日志
-
-### 错误场景
-- ❌ 创建负价格订单 → 看到 client_error 日志
-- ❌ 删除已支付订单 → 看到 server_error 日志
-- ❌ 支付失败 (30% 概率) → 重试支付，看到错误恢复
-
-### 高频操作
-- 循环创建订单
-- 批量支付
-- 观察 duration 和 throughput 变化
-
-## 📈 日志监控接入
-
-### 接入Loki (日志聚合)
-```bash
-# docker-compose.yml中添加
-loki:
-  image: grafana/loki:latest
-  ports:
-    - "3100:3100"
-```
-
-### 接入Prometheus (指标收集)
-```bash
-# actuator/prometheus 已内置支持
-# 在docker-compose中添加Prometheus
-prometheus:
-  image: prom/prometheus:latest
-  volumes:
-    - ./prometheus.yml:/etc/prometheus/prometheus.yml
-```
-
-### 接入Grafana (可视化)
-```bash
-# docker-compose中添加Grafana
-grafana:
-  image: grafana/grafana:latest
-  ports:
-    - "3000:3000"
-  # Add Loki as datasource: http://loki:3100
-```
-
-## 🔍 日志查询示例 (Loki)
-
-```logql
-# 所有订单相关请求
-{app="shop-recycle-order-service", event_class="order"}
-
-# 错误请求
-{status="error"}
-
-# 特定用户的请求
-{userId="user123"}
-
-# 按URI分组统计请求数
-sum(rate({json="json"}[5m])) by (uri_group)
-
-# P95延迟
-quantile_over_time(0.95,
-  {app="shop-recycle-order-service"} | json | unwrap duration_ms [5m]
-) by (uri_group)
-```
-
-## 📚 文档导览
-
-- **[QUICK_START.md](QUICK_START.md)** - 5分钟快速上手
-- **[API.md](API.md)** - 完整API文档和cURL示例
-- **[ARCHITECTURE.md](ARCHITECTURE.md)** - 系统架构深度讲解
-- **[README.md](README.md)** - 项目完整说明
-
-## 🔧 开发指南
-
-### 添加新的API端点
-
-1. 在Controller中添加方法
-2. 在Service中实现业务逻辑
-3. 日志会自动被拦截器处理
-4. MDC字段自动填充
-
-**示例:**
-```java
-@PostMapping("/order/cancel/{orderId}")
-public Response<?> cancelOrder(@PathVariable String orderId) {
-    try {
-        orderService.cancelOrder(orderId);
-        return Response.success();
-    } catch (Exception e) {
-        return Response.error(e.getMessage());
-    }
-}
-```
-
-### 自定义日志字段
-
-在业务代码中添加自定义MDC字段：
-```java
-MDC.put("custom_field", "value");
-// 会自动显示在JSON日志中
-```
-
-### 修改日志格式
-
-编辑 `logback-spring.xml` 中的pattern部分：
-```xml
-<pattern>
-{
-  "ts":"%d{...}",
-  "level":"%level",
-  ...
-  "custom_field":"%X{custom_field:-}"
-}
-</pattern>
-```
-
-## ✅ 验证清单
-
-启动前检查:
-- [ ] JDK 1.8+ 已安装
-- [ ] Maven 3.6+ 已安装
-- [ ] Node.js 14+ 已安装
-- [ ] npm 已安装
-- [ ] 没有服务占用 8080, 8081, 8082, 5173 端口
-
-启动后检查:
-- [ ] Gateway: http://localhost:8080 可访问
-- [ ] Order Service: http://localhost:8081/api/order 可访问
-- [ ] Payment Service: http://localhost:8082/api/payment 可访问
-- [ ] Frontend: http://localhost:5173 可访问
-- [ ] 创建订单成功
-- [ ] 支付订单成功 (或正确显示失败)
-- [ ] 后端Terminal显示JSON格式日志
-
-## 🆘 常见问题
-
-### Q: 为什么支付总是失败?
-A: Payment Service有30%的失败率用于测试。多次尝试即可成功。
-
-### Q: 日志为什么没有出现?
-A: 检查 logback-spring.xml 是否正确加载，查看Terminal有没有启动报错。
-
-### Q: 端口被占用怎么办?
-A: 修改 application.yml 中的 server.port 配置，或kill占用端口的进程。
-
-### Q: 前端无法连接后端?
-A: 检查所有后端服务都启动成功，查看浏览器控制台 F12 看有没有CORS错误。
-
-## 🎓 学习价值
-
-这个项目演示了:
-
-1. **Spring Cloud 微服务架构** - Gateway + Service
-2. **日志最佳实践** - MDC + JSON + 异步处理
-3. **链路追踪设计** - traceId 贯穿整个链路
-4. **可观测性** - 结构化日志 + 指标 + 链路
-5. **前后端分离** - Vue + RESTful API
-6. **零侵入日志** - 拦截器注入，业务代码不改动
-7. **生产就绪** - Docker + Config + Error Handling
-
-## 📦 部署选项
-
-### 本地开发
-```bash
-mvn clean install
-mvn spring-boot:run (各服务)
-npm run dev (前端)
-```
-
-### Docker 容器
-```bash
-docker-compose up -d
-# 访问 http://localhost:5173
-```
-
-### Kubernetes
-```bash
-# 使用 Dockerfile 构建镜像
-docker build -t order-service:1.0 shop-recycle-order-service
-# 推送到镜像仓库
-# kubectl apply -f k8s-manifests/
-```
-
-## 🚦 下一步建议
-
-1. **集成真实日志系统**
-   - 部署 Loki + Grafana
-   - 配置 Vector agent 采集日志
-
-2. **添加链路追踪**
-   - 集成 Jaeger 或 Zipkin
-   - 支持 X-B3-TraceId 头
-
-3. **扩展业务功能**
-   - 添加库存服务
-   - 添加用户服务
-   - 实现真实的数据库
-
-4. **完善测试**
-   - 单元测试
-   - 集成测试
-   - 性能测试
-
-5. **生产部署**
-   - CI/CD 流水线
-   - 蓝绿部署
-   - 灾备方案
-
----
-
-**现在你已经拥有一个完整的、生产级别的日志测试系统！** 🎉
-
-开始使用: `.\start.ps1` (Windows) 或 `./start.sh` (Linux/Mac)
-
-有问题? 查看 QUICK_START.md 或 ARCHITECTURE.md

QUICK_START.md

@@ -1,379 +0,0 @@
-# 快速开始指南
-
-## 📌 前置要求
-
-- **JDK 8+** (测试版本: JDK 1.8)
-- **Maven 3.6+** 
-- **Node.js 14+** 和 **npm**
-
-## ⚡ 一句命令快速启动 (推荐)
-
-在项目根目录运行：
-
-```powershell
-.\start.ps1
-```
-
-或 Linux/Mac:
-```bash
-chmod +x start.sh && ./start.sh
-```
-
-<br/>
-
-## 🚀 30秒快速启动 (Windows PowerShell)
-
-在项目根目录运行：
-
-```powershell
-.\start.ps1
-```
-
-或者手动启动：
-
-### 方式1：Terminal分别启动3个服务
-
-**Terminal 1 - API Gateway:**
-```bash
-cd spring-cloud-log-demo
-mvn clean install
-cd shop-recycle-gateway
-mvn spring-boot:run
-```
-
-**Terminal 2 - Order Service:**
-```bash
-cd spring-cloud-log-demo/shop-recycle-order-service
-mvn spring-boot:run
-```
-
-**Terminal 3 - Payment Service:**
-```bash
-cd spring-cloud-log-demo/shop-recycle-payment-service
-mvn spring-boot:run
-```
-
-**Terminal 4 - Frontend:**
-```bash
-cd spring-cloud-log-demo/shop-recycle-web
-npm install
-npm run dev
-```
-
-## 🎯 核心工作流程
-
-### Step 1: 访问前端界面
-打开浏览器访问 **http://localhost:5173**
-
-你会看到两个标签页：
-- 📦 **订单管理**: 创建、删除订单
-- 💰 **支付管理**: 支付订单、退款
-
-### Step 2: 创建订单
-在"订单管理"标签页中：
-1. 输入 `用户ID`: user123
-2. 输入 `订单金额`: 99.99
-3. 输入 `描述`: test order
-4. 点击 "创建订单" 按钮
-
-**预期结果:**
-- 页面显示 "订单创建成功!"
-- Order Service Terminal会输出 JSON 格式的日志：
-```json
-{
-  "ts":"2024-02-06T10:30:45.123Z",
-  "level":"INFO",
-  "msg":"订单已创建 orderId=ORD-XXXXX",
-  "traceId":"550e8400-e29b-41d4-a716-446655440000",
-  "uri":"/api/order/create",
-  "uri_group":"/order/*",
-  "event_class":"order",
-  "status":"success",
-  "duration":"145"
-}
-```
-
-### Step 3: 支付订单
-在"支付管理"标签页中：
-1. 输入 `订单ID`: 复制上一步的 orderId
-2. 输入 `金额`: 99.99
-3. 选择 `支付方式`: 微信/支付宝/银行卡
-4. 点击 "支付" 按钮
-
-**预期结果:**
-- 页面显示 "支付成功!" 或 "支付失败"
-- Payment Service Terminal会输出支付相关的JSON日志
-- **注意**: Payment Service有30%的失败率用于测试异常处理
-
-### Step 4: 查看日志
-观察三个服务的Terminal输出，你会看到：
-
-**关键字段解析:**
-
-| 字段 | 含义 | 示例 |
-|------|------|------|
-| `traceId` | 全链路追踪ID | `550e8400-e29b-41d4` |
-| `uri_group` | 规范化URL分组 | `/order/*`, `/payment/*` |
-| `event_class` | 业务事件分类 | `order`, `payment` |
-| `duration` | 请求耗时(毫秒) | `145` |
-| `status` | 请求状态 | `success`, `client_error`, `server_error` |
-| `app` | 应用名 | `shop-recycle-order-service` |
-| `env` | 环境 | `local` |
-
-## � 无UI批量模拟 - URL API测试
-
-**不想用UI？一行命令生成100条订单！**
-
-### 快速命令示例
-
-```bash
-# 生成1条随机订单
-curl http://localhost:8080/api/test/order
-
-# 生成10条订单
-curl http://localhost:8080/api/test/order/batch?count=10
-
-# 生成50条订单
-curl http://localhost:8080/api/test/order/batch?count=50
-
-# 生成100条订单 (大量日志测试)
-curl http://localhost:8080/api/test/order/batch?count=100
-
-# 进行10秒压力测试，观察QPS
-curl http://localhost:8080/api/test/order/stress?duration=10
-
-# 生成10笔支付
-curl http://localhost:8080/api/test/payment/batch?count=10
-
-# 支付场景测试：支付 + 退款
-curl "http://localhost:8080/api/test/payment/refund?count=5"
-```
-
-### 完整脚本示例 (快速生成大量日志)
-
-```bash
-#!/bin/bash
-# save as: run-batch-test.sh
-
-echo "🚀 开始批量生成模拟数据..."
-echo ""
-
-echo "📦 生成50个订单..."
-curl -s http://localhost:8080/api/test/order/batch?count=50 | jq '.data | {total, success, error, duration}'
-echo ""
-
-echo "💰 生成30笔支付..."
-curl -s http://localhost:8080/api/test/payment/batch?count=30 | jq '.data | {total, success, error, totalAmount, duration}'
-echo ""
-
-echo "📊 场景测试(10轮)..."
-curl -s http://localhost:8080/api/test/order/scenario?count=10 | jq '.data'
-echo ""
-
-echo "⚡ 压力测试(10秒)..."
-curl -s http://localhost:8080/api/test/order/stress?duration=10 | jq '.data | {requests, success, error, qps, duration}'
-echo ""
-
-echo "✅ 完成!现在检查后端Terminal的JSON日志输出"
-```
-
-运行:
-```bash
-chmod +x run-batch-test.sh
-./run-batch-test.sh
-```
-
-### PowerShell 脚本 (Windows)
-
-```powershell
-# save as: run-batch-test.ps1
-
-Write-Host "🚀 批量生成模拟数据" -ForegroundColor Cyan
-Write-Host ""
-
-Write-Host "📦 生成50个订单..." -ForegroundColor Yellow
-(Invoke-WebRequest -Uri "http://localhost:8080/api/test/order/batch?count=50").Content | ConvertFrom-Json | ForEach-Object { $_.data }
-
-Write-Host ""
-Write-Host "💰 生成30笔支付..." -ForegroundColor Yellow  
-(Invoke-WebRequest -Uri "http://localhost:8080/api/test/payment/batch?count=30").Content | ConvertFrom-Json | ForEach-Object { $_.data }
-
-Write-Host ""
-Write-Host "✅ 完成!" -ForegroundColor Green
-Write-Host "查看后端Terminal窗口的JSON日志输出"
-```
-
-运行:
-```powershell
-.\run-batch-test.ps1
-```
-
-### 更多API选项
-
-详见 [BATCH_TEST_API.md](BATCH_TEST_API.md)
-
-| API | 说明 |
-|-----|------|
-| `GET /api/test/order` | 生成1个订单 |
-| `GET /api/test/order/batch?count=N` | 生成N个订单 |
-| `GET /api/test/order/scenario?count=N` | N轮业务场景测试 |
-| `GET /api/test/order/stress?duration=10` | 10秒压力测试 |
-| `GET /api/test/payment` | 生成1笔支付 |
-| `GET /api/test/payment/batch?count=N` | 生成N笔支付 |
-| `GET /api/test/payment/refund?count=N` | N轮支付+退款测试 |
-| `GET /api/test/payment/stress?duration=10` | 支付压力测试 |
-
-## �📡 测试不同的业务场景
-
-### 场景1: 创建无效订单（价格为负数）
-1. 输入负数价格: -50
-2. 点击 "创建订单"
-3. **预期**: 错误信息 "price must be > 0"
-4. **日志**: status="client_error", error="java.lang.IllegalArgumentException"
-
-### 场景2: 删除已支付订单（应该失败）
-1. 先创建订单
-2. 点击支付标记 "支付订单"
-3. 点击 "删除订单"
-4. **预期**: 错误信息 "Paid order cannot be deleted"
-5. **日志**: 观察错误传播链路
-
-### 场景3: 支付失败重试
-1. 支付订单，如果失败（30%概率）
-2. 再次点击支付按钮
-3. **预期**: 最终会成功（70%成功率）
-4. **日志**: 观察 duration 时间的变化
-
-## 🔑 关键日志观察点
-
-### 打开后端Terminal，观察JSON日志结构：
-
-**订单创建日志:**
-```
-{
-  "ts":"2024-02-06T10:30:45.123Z",
-  "level":"INFO",
-  "logger":"com.shop.recycle.order.service.OrderService",
-  "msg":"订单已创建 orderId=ORD-A1B2C3D4",
-  "traceId":"abc-123-def-456",
-  "uri":"/api/order/create",
-  "uri_group":"/order/*",
-  "duration":"156",
-  "userId":"user123",
-  "event_class":"order",
-  "error":"-",
-  "status":"success",
-  "thread":"http-nio-8081-exec-1",
-  "app":"shop-recycle-order-service",
-  "env":"local"
-}
-```
-
-**日志中的关键观察:**
-1. ✅ **traceId** 会在整个请求链路中保持一致
-2. ✅ **uri_group** 自动规范化（/order/create → /order/*)
-3. ✅ **event_class** 自动分类（order/payment/auth/api）
-4. ✅ **duration** 精确到毫秒
-5. ✅ **status** 自动判定（success/client_error/server_error）
-6. ✅ **app** 标识发出日志的服务
-7. ✅ **env** 标识环境（local/dev/prod）
-
-## 🐛 故障排查
-
-### 问题1: "无法连接到服务"
-```
-检查清单:
-□ 后端服务是否全部启动 (查看Terminal有没有"Started XXXApplication")
-□ 端口是否被占用: netstat -ano | findstr :8080 (Windows)
-□ 防火墙是否阻止本地连接
-□ 前端proxy配置是否正确 (vite.config.js)
-```
-
-### 问题2: "日志未出现"
-```
-检查清单:
-□ logback-spring.xml是否加载成功
-□ logging.level是否配置为DEBUG
-□ Spring Boot是否成功启动（查看Terminal最后一行）
-□ 是否有异常堆栈信息
-```
-
-### 问题3: "支付总是失败"
-```
-这是正常现象! Payment Service有30%的失败率用于测试。
-多次点击"支付"按钮即可成功（70%成功率）。
-```
-
-### 问题4: "前端显示404错误"
-```
-解决方案:
-1. 确认后端API Gateway启动成功 (port 8080)
-2. 清除浏览器缓存 (Ctrl+Shift+Delete)
-3. 检查vite.config.js中proxy配置
-4. 查看浏览器开发者工具 (F12) 的Network标签
-```
-
-## 📊 进阶：接入数据采集系统
-
-### 配置Loki（日志聚合）
-
-在生产环境中，你可以配置Vector采集日志到Loki：
-
-```yaml
-# vector.toml配置示例
-[sources.app_logs]
-type = "file"
-include = ["/var/log/app/*.log"]
-
-[transforms.parse_json]
-type = "remap"
-inputs = ["app_logs"]
-source = "parsed = parse_json!(.message)"
-
-[sinks.loki]
-type = "loki"
-inputs = ["parse_json"]
-endpoint = "http://loki:3100"
-labels.app = "{{ app }}"
-labels.event_class = "{{ event_class }}"
-```
-
-### 配置Prometheus（指标统计）
-
-Vector会自动导出Prometheus metrics：
-
-```promql
-# QPS查询 (Prometheus)
-rate(shop_recycle_requests_total[1m])
-
-# 订单成功率
-rate(shop_recycle_orders_total - shop_recycle_orders_failed_total[1m]) 
-/
-rate(shop_recycle_orders_total[1m])
-
-# P95延迟
-histogram_quantile(0.95, rate(shop_recycle_request_duration_ms_bucket[5m]))
-```
-
-## 📚 更多资源
-
-- [Log.md](../Log.md) - 详细的日志架构设计文档
-- [README.md](README.md) - 项目完整文档
-- [Spring Cloud官方文档](https://spring.io/cloud)
-- [Logstash Logback Encoder](https://github.com/logstash/logstash-logback-encoder)
-
-## ✅ 验证清单
-
-在开始测试前，确保你能看到以下迹象：
-
-- [ ] 三个服务都启动成功，Terminal显示 "Started XXXApplication"
-- [ ] 前端能访问 http://localhost:5173
-- [ ] 能在创建订单后看到 "orderId" 返回
-- [ ] 后端Terminal显示JSON格式的日志 (不是纯文本)
-- [ ] 日志包含 traceId、uri_group、event_class 等字段
-
-一旦都满足，说明你的日志系统已经准备好测试!
-
----
-
-**需要帮助？** 查看 README.md 获取完整文档