【Golang课程项目速成核弹】：72小时构建带JWT鉴权+Swagger+单元测试的完整RESTful服务

第一章：Golang课程项目速成核弹：72小时构建带JWT鉴权+Swagger+单元测试的完整RESTful服务

72小时并非极限压榨，而是聚焦核心路径的高效工程实践——从零启动一个生产就绪的 Go RESTful 服务，集成 JWT 身份验证、自动生成 API 文档的 Swagger（via swag CLI）、以及覆盖率可观的单元测试。

初始化项目结构

mkdir go-rest-api && cd go-rest-api  
go mod init go-rest-api  
go get -u github.com/gin-gonic/gin \
       github.com/golang-jwt/jwt/v5 \
       github.com/swaggo/swag/cmd/swag@v1.16.5 \
       github.com/stretchr/testify/assert

执行 swag init --parseDependency --parseInternal 后，项目根目录将生成 docs/ 文件夹，供 Gin 中间件挂载 Swagger UI。

实现 JWT 鉴权中间件

func JWTAuth() gin.HandlerFunc {
    return func(c *gin.Context) {
        authHeader := c.GetHeader("Authorization")
        if authHeader == "" {
            c.AbortWithStatusJSON(401, gin.H{"error": "missing authorization header"})
            return
        }
        tokenString := strings.TrimPrefix(authHeader, "Bearer ")
        token, err := jwt.Parse(tokenString, func(t *jwt.Token) (interface{}, error) {
            return []byte("your-secret-key"), nil // 生产环境请使用环境变量或密钥管理服务
        })
        if err != nil || !token.Valid {
            c.AbortWithStatusJSON(401, gin.H{"error": "invalid or expired token"})
            return
        }
        c.Next()
    }
}

编写可测试的 Handler 示例

定义 /api/v1/users 端点后，用 testify/assert 编写测试：

• 创建内存 Gin router（gin.New() + gin.SetMode(gin.TestMode)）
• 模拟 POST 请求并断言状态码与 JSON 响应字段
• 使用 assert.JSONEq(t, expected, actual) 避免字段顺序敏感问题

关键依赖与职责对齐表

组件	用途	是否需手动配置
Gin	HTTP 路由与中间件编排	是
jwt/v5	Token 解析与签发	是（密钥/算法）
swag CLI	从 Go 注释生成 OpenAPI 3.0 JSON	是（注释规范）
testify/assert	断言响应结构与行为	否（开箱即用）

所有代码均遵循 Clean Architecture 分层原则：handler → service → repository，确保单元测试可隔离 stub 依赖。

第二章：Go Web服务基础架构与工程化实践

2.1 Go Modules依赖管理与多环境配置设计

Go Modules 是 Go 官方推荐的依赖管理机制，取代了 GOPATH 时代的手动管理。启用后，go.mod 文件自动记录精确版本与校验和，保障构建可重现性。

多环境配置策略

采用 --tags 构建标签 + 环境变量驱动配置加载：

• dev、staging、prod 对应不同 config/ 下的 YAML 文件
• 启动时通过 GO_ENV=prod go run -tags=prod main.go 触发条件编译

// build_tags.go
//go:build prod
package main

import _ "github.com/go-sql-driver/mysql" // 仅 prod 环境链接 MySQL 驱动

此代码块启用构建标签 prod，使 mysql 驱动仅在 prod 构建中被链接，减小 dev 环境二进制体积；//go:build 指令替代旧式 +build，需配合 go mod tidy 自动同步依赖。

环境感知配置加载流程

graph TD
    A[读取 GO_ENV] --> B{GO_ENV == dev?}
    B -->|是| C[加载 config/dev.yaml]
    B -->|否| D[加载 config/prod.yaml]
    C & D --> E[解析为 Config struct]

环境	依赖差异	配置热重载
dev	sqlite3, zap-dev logger	✅
prod	postgres, prometheus	❌

2.2 RESTful路由设计原则与Gin/Echo框架选型实战

RESTful路由应遵循资源导向、动词中立、状态无感三大核心原则：以名词（/users, /orders）表达资源，用HTTP方法（GET/POST/PUT/DELETE）表达意图，避免在路径中嵌入动作（如/getUserById）。

框架对比关键维度

维度	Gin	Echo
中间件链	基于切片，顺序执行	支持分组中间件与条件跳过
路由性能	静态前缀树（radix），微秒级	同为radix，实测高并发略优
路由声明语法	r.GET("/api/v1/users", h)	e.GET("/api/v1/users", h)

// Gin中标准RESTful路由注册示例
r := gin.Default()
r.GET("/api/v1/users", listUsers)        // GET /users → 批量查询
r.POST("/api/v1/users", createUser)      // POST /users → 创建资源
r.GET("/api/v1/users/:id", getUser)      // GET /users/{id} → 单体获取
r.PUT("/api/v1/users/:id", updateUser)   // PUT /users/{id} → 全量更新

逻辑分析：:id 是Gin的路径参数占位符，框架自动解析并注入c.Param("id")；所有路由均以/api/v1/统一版本前缀，符合语义化演进规范；动词严格绑定HTTP方法，不依赖query或body字段模拟操作类型。

路由设计决策流程

graph TD
    A[识别资源实体] --> B[定义标准CRUD端点]
    B --> C[添加版本与命名空间]
    C --> D[按权限/场景分组路由]

2.3 分层架构（Handler-Service-Repository）落地与接口契约定义

分层解耦的核心在于职责隔离与契约先行。各层通过明确的接口定义交互，而非具体实现。

接口契约示例（Spring Boot）

// UserRepository.java —— 仅声明数据访问语义
public interface UserRepository {
    /**
     * 根据ID查询用户，返回Optional避免null风险
     * @param id 非空UUID字符串
     * @return 用户实体封装（可能为空）
     */
    Optional<User> findById(String id);

    User save(User user); // 幂等性由调用方保证
}

该接口约束了Repository层必须提供可预测的输入/输出：String id为不可变标识，Optional<User>显式表达存在性语义，消除了空指针歧义。

层间协作契约表

层级	输入约束	输出承诺	调用频次上限
Handler	JSON有效且符合DTO校验规则	HTTP状态码+标准化错误体	≤5000 QPS
Service	领域对象完整、状态合法	事务一致性保障 + 领域事件发布	≤1000 TPS
Repository	主键非空、字段长度合规	ACID事务内执行，不抛Checked异常	数据库连接池上限

数据流图

graph TD
    A[HTTP Request] --> B[UserHandler]
    B --> C{Validation}
    C -->|Valid| D[UserService]
    C -->|Invalid| E[400 Bad Request]
    D --> F[UserRepository]
    F --> G[(MySQL)]
    G --> F --> D --> B --> A

2.4 数据库连接池管理与GORM高级映射技巧

连接池核心参数调优

GORM v2 默认复用 sql.DB，需显式配置连接池：

db, _ := gorm.Open(mysql.Open(dsn), &gorm.Config{})
sqlDB, _ := db.DB()

sqlDB.SetMaxOpenConns(100)   // 最大打开连接数（含空闲+正在使用）
sqlDB.SetMaxIdleConns(20)    // 最大空闲连接数（复用关键）
sqlDB.SetConnMaxLifetime(time.Hour) // 连接最大存活时间，防长连接僵死

SetMaxOpenConns 过高易耗尽数据库资源；SetMaxIdleConns 应 ≤ 前者，避免空闲连接堆积；SetConnMaxLifetime 推荐设为30m–1h，配合数据库端 wait_timeout。

GORM 高级字段映射

结构体标签	作用	示例
gorm:"primaryKey"	指定主键（支持复合）	ID uintgorm:”primaryKey”`
gorm:"foreignKey"	显式声明外键字段名	UserID uintgorm:”foreignKey:UserID”`
gorm:"embedded"	嵌入结构体自动展开字段	EmbeddedTimegorm:”embedded”`

关联预加载策略

// 一次性加载用户及其角色（JOIN优化）
var users []User
db.Preload("Role", func(db *gorm.DB) *gorm.DB {
    return db.Select("id, name") // 只查必要字段
}).Find(&users)

Preload 默认发N+1查询，加 Select 限制字段 + Joins 可转为单JOIN；嵌套预加载如 Preload("Orders.Items") 支持深度关联。

2.5 中间件链式编排机制与自定义日志/恢复中间件实现

Express/Koa 等框架的中间件本质是函数式管道（Function Pipeline），请求与响应在 next() 调用中逐层透传，形成可插拔、可复用的处理链。

日志中间件：轻量可观测性入口

const logger = (req, res, next) => {
  const start = Date.now();
  console.log(`[LOG] ${new Date().toISOString()} ${req.method} ${req.url}`);
  res.on('finish', () => {
    const duration = Date.now() - start;
    console.log(`[METRIC] ${req.method} ${req.url} → ${res.statusCode} (${duration}ms)`);
  });
  next(); // 继续传递控制权
};

逻辑分析：该中间件在请求进入时打点计时、记录方法与路径；利用 res.on('finish') 监听响应结束事件，避免因异常中断导致耗时丢失。next() 是链式调度的核心枢纽，缺失将阻断后续中间件执行。

恢复中间件：错误兜底与状态还原

能力	实现要点
异常捕获	try/catch 包裹 next() 调用
响应标准化	统一返回 { error: true, message }
上下文清理	清除临时缓存或挂载的资源引用

graph TD
  A[请求进入] --> B[日志中间件]
  B --> C[认证中间件]
  C --> D{业务逻辑}
  D -->|成功| E[响应发送]
  D -->|异常| F[恢复中间件]
  F --> G[返回500+错误体]
  G --> E

第三章：安全认证与API标准化体系建设

3.1 JWT原理剖析与Go标准库/jwt-go/v5签名验签全流程实现

JWT（JSON Web Token）由Header、Payload、Signature三部分Base64Url编码拼接而成，依赖密钥或公私钥对保障完整性与身份可信性。

核心结构解析

• Header：声明算法（alg）和令牌类型（typ: JWT）
• Payload：含标准声明（exp, iss, sub）与自定义字段
• Signature：HMACSHA256(base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)

签名与验签流程（jwt-go/v5）

// 创建带HS256签名的Token
token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
    "user_id": 123,
    "exp":     time.Now().Add(time.Hour).Unix(),
})
signedString, err := token.SignedString([]byte("my-secret"))
// → 输出形如: ey...<header>.ey...<payload>.ey...<signature>

逻辑分析：SignedString 内部调用 SigningMethodHS256.Sign()，将 header+payload 拼接后使用 hmac.New(sha256.New, key) 计算摘要，并 Base64Url 编码生成 signature 段。

// 验签并解析
parsedToken, err := jwt.Parse(signedString, func(token *jwt.Token) (interface{}, error) {
    return []byte("my-secret"), nil // 必须返回与签名时相同的key
})

参数说明：Parse 自动校验 exp、nbf 等时间声明；回调函数返回的密钥用于重建 signature 并比对原始 third segment。

阶段	关键操作
签名	HMAC-SHA256(header.payload, secret)
验签	重新计算 signature 并字节级比对

graph TD
    A[构建Header/Payload] --> B[Base64Url编码拼接]
    B --> C[用密钥计算HMAC签名]
    C --> D[三段拼接为JWT字符串]
    D --> E[传输至客户端]
    E --> F[服务端解析并重算签名]
    F --> G[比对signature段是否一致]

3.2 基于RBAC的权限模型设计与Token上下文注入实践

核心角色与资源映射关系

RBAC模型聚焦三类实体：User（用户）、Role（角色）、Permission（权限），通过中间表建立多对多关联。典型关系如下：

角色名称	允许操作	作用域
admin	*:*	全系统
editor	post:read,write	/api/v1/posts
viewer	post:read	/api/v1/posts

Token上下文注入实现

在认证中间件中，将角色与权限集合注入JWT Claims：

// 构建带RBAC上下文的token
claims := jwt.MapClaims{
    "uid":  user.ID,
    "roles": []string{"editor"},
    "perms": []string{"post:read", "post:write"}, // 预计算权限，避免运行时查库
    "exp":  time.Now().Add(24 * time.Hour).Unix(),
}

逻辑分析：perms 字段为预加载权限列表，规避每次请求触发数据库JOIN查询；roles 保留用于审计与动态策略扩展。exp 严格控制时效，配合短生命周期Token提升安全性。

权限校验流程

graph TD
    A[HTTP Request] --> B{JWT Valid?}
    B -->|Yes| C[Extract perms from Claims]
    B -->|No| D[401 Unauthorized]
    C --> E[Match route+method against perms]
    E -->|Match| F[Proceed]
    E -->|No Match| G[403 Forbidden]

3.3 Swagger 2.0/OpenAPI 3.1文档自动生成与注解驱动开发规范

OpenAPI 已成为 RESTful API 文档事实标准，从 Swagger 2.0 到 OpenAPI 3.1 的演进强化了语义表达与扩展能力。

注解驱动的核心契约

Springdoc OpenAPI（v2+）通过 @Operation、@Parameter、@Schema 等注解将接口语义直接嵌入代码：

@Operation(summary = "创建用户", description = "返回新创建用户的完整信息")
@PostMapping("/users")
public ResponseEntity<User> createUser(
    @io.swagger.v3.oas.annotations.parameters.RequestBody(
        description = "用户注册请求体",
        required = true
    ) @Valid @RequestBody UserCreateRequest request) {
    return ResponseEntity.ok(userService.create(request));
}

逻辑分析：@Operation 定义端点元信息；@RequestBody 注解替代旧版 @ApiParam，支持 OpenAPI 3.1 的 required: true 和描述字段；@Valid 触发 Bean Validation，自动映射为 schema.required 与 schema.properties.*.nullable。

版本关键差异对比

特性	Swagger 2.0	OpenAPI 3.1
请求体多类型支持	❌（仅 body）	✅（requestBody.content）
枚举值语义化	字符串数组	支持 enum + x-enum-descriptions 扩展
安全方案定义	securityDefinitions	components.securitySchemes

文档生成流程

graph TD
    A[源码扫描] --> B[注解解析引擎]
    B --> C{OpenAPI 3.1 AST}
    C --> D[JSON/YAML 序列化]
    D --> E[/GET /v3/api-docs/]

第四章：质量保障与可维护性工程实践

4.1 Go单元测试金字塔：HTTP Handler层Mock与Table-Driven测试编写

在Go的测试金字塔中，HTTP Handler层测试处于中间关键位置——既要避免真实网络调用，又需验证路由、状态码、JSON序列化等端到端逻辑。

为何选择Table-Driven测试？

• 高可维护性：单个函数覆盖多种请求路径、方法、参数组合
• 清晰边界：每个测试用例显式声明输入/期望输出
• 易于扩展：新增场景仅需追加结构体条目

Mock HTTP依赖的核心技巧

使用 httptest.NewRecorder() 模拟响应，配合自定义 http.Handler 或直接调用 handler 函数（跳过服务器启动）：

func TestUserHandler(t *testing.T) {
    tests := []struct {
        name     string
        method   string
        path     string
        wantCode int
    }{
        {"GET user", "GET", "/api/users/123", http.StatusOK},
        {"POST invalid", "POST", "/api/users", http.StatusBadRequest},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            req := httptest.NewRequest(tt.method, tt.path, nil)
            w := httptest.NewRecorder()
            userHandler(w, req) // 直接调用，无net.Listen
            if w.Code != tt.wantCode {
                t.Errorf("expected %d, got %d", tt.wantCode, w.Code)
            }
        })
    }
}

逻辑分析：httptest.NewRequest 构造轻量请求对象，httptest.NewRecorder 捕获响应头/状态码/正文；userHandler(w, req) 绕过http.ServeMux，实现零依赖、高隔离的单元测试。参数 tt.method 和 tt.path 驱动不同路由分支，tt.wantCode 是契约式断言依据。

测试维度	真实HTTP Server	httptest模拟	推荐层级
启动开销	高（端口绑定）	零	✅ 单元
中间件验证	完整	需手动注入	⚠️ 集成
并发安全	受限	自由并发执行	✅ 单元

graph TD
    A[HTTP Handler] --> B[httptest.NewRequest]
    A --> C[httptest.NewRecorder]
    B & C --> D[直接函数调用]
    D --> E[状态码/响应体断言]

4.2 Service层依赖注入与接口隔离测试（gomock/testify组合实践）

Service 层应仅关注业务逻辑，其外部依赖（如 Repository、第三方客户端）必须通过接口抽象并注入。

接口定义与依赖注入

type UserRepository interface {
    FindByID(ctx context.Context, id int64) (*User, error)
}

type UserService struct {
    repo UserRepository // 依赖声明为接口，便于替换
}

UserRepository 是契约抽象；UserService 不持有具体实现，符合依赖倒置原则。构造时由 DI 容器或工厂注入真实/模拟实现。

gomock + testify 测试流程

• 使用 mockgen 生成 UserRepositoryMock
• testify/assert 验证返回值与调用次数
• testify/require 处理 setup 失败

依赖注入测试对比表

场景	真实 Repo	Mock Repo	适用阶段
集成测试	✅	❌	E2E / CI
单元测试	❌	✅	开发自测
边界异常覆盖	困难	精准可控	错误路径验证

模拟行为设置示例

mockRepo := NewMockUserRepository(ctrl)
mockRepo.EXPECT().
    FindByID(gomock.Any(), int64(123)).
    Return(&User{Name: "Alice"}, nil).
    Times(1)

gomock.Any() 忽略上下文参数细节；Times(1) 断言方法被精确调用一次；返回值可定制，支持 nil error 或特定错误类型。

4.3 集成测试策略：内存数据库（sqlite）与TestMain生命周期管理

在 Go 集成测试中，TestMain 是统一管控测试环境生命周期的关键入口。通过它可集中初始化内存 SQLite 实例，并确保所有测试用例共享同一事务上下文，避免文件 I/O 开销与状态污染。

初始化内存数据库

func TestMain(m *testing.M) {
    db, err := sql.Open("sqlite3", "file::memory:?_loc=auto")
    if err != nil {
        log.Fatal(err)
    }
    // 执行 schema 迁移
    migrateDB(db)
    os.Exit(m.Run()) // 所有测试结束后自动释放
}

file::memory: 创建隔离内存实例；_loc=auto 启用时区支持；m.Run() 确保 defer db.Close() 不被提前触发。

测试生命周期关键点

• ✅ TestMain 前：全局 DB 实例创建
• ✅ 每个 TestXxx：复用连接，事务级隔离（需显式 BEGIN/ROLLBACK）
• ❌ TestMain 后：进程退出，内存 DB 自动销毁

阶段	资源状态	是否可跨测试共享
TestMain 开始	DB 连接池就绪	✅
单个测试内	事务独立	❌（需手动控制）
TestMain 结束	内存完全释放	—

graph TD
    A[TestMain] --> B[Open :memory: DB]
    B --> C[Run migrations]
    C --> D[m.Run()]
    D --> E[All tests complete]
    E --> F[Process exit → DB gone]

4.4 CI/CD流水线搭建：GitHub Actions自动化测试+Swagger验证+Go Report Card集成

核心工作流设计

使用单一流水线串联三大质量门禁，避免环境漂移与上下文切换开销。

关键步骤集成

• 运行 go test -v ./... 并生成覆盖率报告（-coverprofile=coverage.out）
• 调用 swag validate ./docs/swagger.yaml 验证 OpenAPI 规范合规性
• 通过 curl -s "https://goreportcard.com/badge/github.com/your/repo" 获取评分快照

示例 GitHub Actions 配置节选

- name: Run Go Report Card Analysis
  run: |
    # Fetch grade as JSON; fail if score < 85%
    GRADE=$(curl -s "https://goreportcard.com/badge/github.com/your/repo" | \
      grep -o '"grade":"[A-Z]","score":[0-9]\+' | cut -d',' -f2 | cut -d':' -f2)
    [ "$GRADE" -ge 85 ] || { echo "Go Report Card score $GRADE < 85"; exit 1; }

该脚本解析 Go Report Card 返回的 JSON 片段，提取 score 字段并强制阈值校验，确保代码健康度达标。

工具	触发时机	输出物
go test	构建后	coverage.out
swag validate	文档提交后	YAML 语法/语义错误
Go Report Card	每次 push	A-F 等级 + 分项得分

graph TD
  A[Push to main] --> B[Run go test]
  B --> C{Coverage ≥ 80%?}
  C -->|Yes| D[Validate Swagger]
  D --> E{Valid OpenAPI?}
  E -->|Yes| F[Fetch Go Report Card]
  F --> G[Score ≥ 85?]
  G -->|No| H[Fail Pipeline]

第五章：结语：从课程项目到生产级Go服务的跃迁路径

工程化落地的真实断层

在课程项目中，main.go 通常是一个单文件、无配置、硬编码端口（:8080）的简易 HTTP 服务；而某电商订单中心的 Go 微服务上线前，其启动流程需加载 YAML 配置、连接 etcd 实现动态配置热更新、通过 go.uber.org/zap 初始化结构化日志、并注册至 Consul 健康检查端点 /healthz。二者差异不在语法，而在可观测性、容错机制与部署契约的完备性。

关键能力跃迁对照表

能力维度	课程项目典型表现	生产级服务强制要求
配置管理	const port = ":8080"	支持环境变量 + 文件 + 远程配置中心三级覆盖
错误处理	log.Fatal(err) 全局崩溃	errors.Join() 构建可追溯链路，http.Error 分级响应
并发安全	全局 map[string]int 直接读写	sync.Map 或 RWMutex 保护状态，配合 atomic 计数器
测试覆盖	手动 curl http://localhost:8080/ping	go test -race -coverprofile=cover.out + GitHub Actions 自动化覆盖率门禁（≥85%）

真实故障驱动的演进案例

2023年Q3，某支付网关因未实现 context.WithTimeout 导致下游超时后 goroutine 泄漏，12小时内累积 17 万个阻塞协程。修复方案不仅添加超时控制，还引入 pprof 实时分析入口：

// 启动时注册 pprof
import _ "net/http/pprof"
go func() {
    log.Println(http.ListenAndServe("localhost:6060", nil))
}()

并通过 Grafana 展示 goroutines 指标趋势，设置告警阈值为 5000。

可观测性不是锦上添花

生产服务必须默认暴露 /metrics（Prometheus 格式），例如订单服务的关键指标：

• order_processed_total{status="success",region="sh"}
• order_processing_duration_seconds_bucket{le="0.1"}
• http_request_duration_seconds_sum{handler="CreateOrder"}

这些指标直接关联 SLO（如“99% 订单创建请求 P99

技术债的量化偿还路径

某团队将课程项目升级为生产服务时，采用分阶段验证策略：

1. 第一周：接入 golang.org/x/exp/slog 替换 fmt.Printf，统一日志格式；
2. 第二周：用 testify/mock 替换硬编码 DB，注入 sqlmock 实现单元测试覆盖率提升至 72%；
3. 第三周：通过 k6 对 /v1/orders 接口压测，定位 JSON 序列化瓶颈，改用 github.com/json-iterator/go；
4. 第四周：CI 流程中嵌入 gosec -fmt sarif -out results.sarif ./...，拦截硬编码密钥风险。

文档即契约

生产服务的 README.md 必须包含：

• curl -X POST http://localhost:8080/v1/orders -H "Content-Type: application/json" -d '{"product_id":"p_123"}' 的完整调用示例；
• make build、make docker-build、make test-e2e 的可执行命令链；
• OpenAPI 3.0 规范链接（自动生成于 /openapi.json）；
• 故障应急手册：当 redis_latency_ms{job="order-service"} > 500 时，立即切换至降级缓存策略。

持续交付流水线不可绕过

某金融风控服务的 GitOps 流程图如下：

flowchart LR
    A[Push to main branch] --> B[Run go vet + staticcheck]
    B --> C{Coverage ≥ 85%?}
    C -->|Yes| D[Build Docker image with multi-stage]
    C -->|No| E[Fail CI]
    D --> F[Scan image with Trivy]
    F --> G[Push to private registry]
    G --> H[ArgoCD sync to staging namespace]
    H --> I[Automated canary analysis via Prometheus metrics]

从“能跑”到“敢上”的心理建设

课程项目重启一次损失为零；生产服务每次 git push 都可能触发资损。某团队要求所有 PR 必须标注 impact: high 或 impact: low，前者需至少两名 Senior Engineer 交叉评审，并附带 ./scripts/load-test.sh --scenario=create_order 的压测报告截图。

服务生命周期始于第一行代码

go mod init github.com/your-org/order-service 不仅声明模块路径，更意味着：

• 该路径将出现在所有错误堆栈、日志 traceID 前缀、监控指标标签中；
• go.sum 文件需随每次依赖变更提交，确保构建可重现；
• go version go1.21.6 linux/amd64 必须写入 .tool-versions 并被 CI 验证。

没有“临时方案”，只有“当前最优解”的持续迭代。