Go context、工程化、框架与压测

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // 步骤1：创建根context，所有context树的起点
    // Background返回一个永远不会取消、没有值、没有截止时间的空context
    rootCtx := context.Background()

    // 步骤2：创建可手动取消的context
    // 返回ctx和cancel函数，调用cancel()会向所有子context发送取消信号
    cancelCtx, cancelFunc := context.WithCancel(rootCtx)
    defer cancelFunc() // 步骤3：defer调用cancel，防止goroutine泄漏

    // 步骤4：创建带超时的context
    // 超过指定时长后自动取消，效果等同于手动调用cancel
    timeoutCtx, timeoutCancel := context.WithTimeout(rootCtx, 3*time.Second)
    defer timeoutCancel()

    // 步骤5：创建带截止时刻的context
    // 与WithTimeout类似，但指定的是绝对时间点而非相对时长
    deadline := time.Now().Add(5 * time.Second)
    deadlineCtx, deadlineCancel := context.WithDeadline(rootCtx, deadline)
    defer deadlineCancel()

    // 步骤6：创建携带请求级数据的context
    // 用于在调用链中传递traceID等元信息
    type ctxKey string
    valueCtx := context.WithValue(rootCtx, ctxKey("traceID"), "req-abc-123")

    // 步骤7：在goroutine中监听取消信号
    go func(ctx context.Context) {
        select {
        case <-ctx.Done():
            // 步骤8：收到取消信号，退出goroutine
            fmt.Println("goroutine收到取消信号:", ctx.Err())
            return
        case <-time.After(10 * time.Second):
            fmt.Println("goroutine正常完成")
        }
    }(cancelCtx)

    // 步骤9：模拟1秒后手动取消
    time.Sleep(1 * time.Second)
    cancelFunc()

    // 步骤10：验证WithValue的值
    traceID := valueCtx.Value(ctxKey("traceID"))
    fmt.Println("traceID:", traceID)

    // 步骤11：等待deadline context超时
    select {
    case <-deadlineCtx.Done():
        fmt.Println("deadline context已超时:", deadlineCtx.Err())
    }

    _ = timeoutCtx
}

package main

import (
    "context"
    "fmt"
    "net/http"
    "time"

    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()

    // 步骤1：中间件中为每个请求设置超时context
    r.Use(func(c *gin.Context) {
        // 步骤2：基于请求创建5秒超时的context
        ctx, cancel := context.WithTimeout(c.Request.Context(), 5*time.Second)
        defer cancel()

        // 步骤3：将新context放回request，后续Handler通过c.Request.Context()获取
        c.Request = c.Request.WithContext(ctx)
        c.Next()
    })

    r.GET("/api/user/:id", func(c *gin.Context) {
        // 步骤4：从request中获取带超时的context
        ctx := c.Request.Context()

        // 步骤5：用这个context查询数据库
        user, err := queryUserWithTimeout(ctx, c.Param("id"))
        if err != nil {
            // 步骤6：检查是否是context超时导致的错误
            if ctx.Err() == context.DeadlineExceeded {
                c.JSON(http.StatusGatewayTimeout, gin.H{"error": "请求超时"})
                return
            }
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }
        c.JSON(http.StatusOK, gin.H{"user": user})
    })

    r.Run(":8080")
}

// queryUserWithTimeout 模拟带context的数据库查询
func queryUserWithTimeout(ctx context.Context, userID string) (string, error) {
    // 步骤7：select监听context取消和数据库查询完成
    resultCh := make(chan string, 1)

    go func() {
        // 步骤8：模拟数据库查询耗时
        time.Sleep(2 * time.Second)
        resultCh <- fmt.Sprintf("user-%s", userID)
    }()

    select {
    case <-ctx.Done():
        // 步骤9：context超时或取消，查询goroutine会被丢弃
        return "", ctx.Err()
    case result := <-resultCh:
        return result, nil
    }
}

package main

import (
    "context"
    "database/sql"
    "time"
)

// QueryUserByID 带超时的数据库查询
func QueryUserByID(ctx context.Context, db *sql.DB, userID int) (*User, error) {
    // 步骤1：为这次查询单独设置2秒超时
    queryCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
    defer cancel()

    // 步骤2：将context传给db.QueryContext
    row := db.QueryRowContext(queryCtx,
        "SELECT id, name FROM users WHERE id = ?", userID)

    var user User
    // 步骤3：如果查询超时，Scan会返回context错误
    err := row.Scan(&user.ID, &user.Name)
    if err != nil {
        return nil, err
    }
    return &user, nil
}

type User struct {
    ID   int
    Name string
}

package main

import (
    "context"
    "fmt"
    "time"
)

func worker(ctx context.Context, id int) {
    for {
        select {
        // 步骤1：监听context取消信号
        case <-ctx.Done():
            fmt.Printf("worker %d 收到退出信号，停止工作\n", id)
            return
        default:
            // 步骤2：执行正常工作
            fmt.Printf("worker %d 正在工作...\n", id)
            time.Sleep(500 * time.Millisecond)
        }
    }
}

func main() {
    // 步骤3：创建可取消的context
    ctx, cancel := context.WithCancel(context.Background())

    // 步骤4：启动3个worker goroutine
    for i := 1; i <= 3; i++ {
        go worker(ctx, i)
    }

    // 步骤5：运行3秒后取消所有worker
    time.Sleep(3 * time.Second)
    cancel()

    // 步骤6：等待worker退出
    time.Sleep(1 * time.Second)
    fmt.Println("所有worker已退出")
}

// 步骤1：定义自定义key类型，避免冲突
type ctxKey string

const (
    keyTraceID   ctxKey = "traceID"
    keyUserID    ctxKey = "userID"
    keyRequestID ctxKey = "requestID"
)

// 步骤2：使用自定义key存值
ctx := context.WithValue(parent, keyTraceID, "abc-123")

// 步骤3：使用自定义key取值，务必做类型断言
traceID, ok := ctx.Value(keyTraceID).(string)
if !ok {
    // 步骤4：处理key不存在或类型不匹配的情况
    traceID = "unknown"
}

# 步骤1：安装swag命令行工具
go install github.com/swaggo/swag/cmd/swag@latest

# 步骤2：安装Go依赖包
go get -u github.com/swaggo/gin-swagger
go get -u github.com/swaggo/files

package main

import (
    "net/http"
    "strconv"

    "github.com/gin-gonic/gin"
    swaggerFiles "github.com/swaggo/files"
    ginSwagger "github.com/swaggo/gin-swagger"

    // 步骤1：导入swag生成的docs包，下划线导入仅执行init()注册文档
    _ "myproject/docs"
)

// User 用户数据模型
type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

// ErrorResponse 错误响应模型
type ErrorResponse struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
}

// @Summary      获取用户列表
// @Description  分页获取用户列表
// @Tags         用户管理
// @Accept       json
// @Produce      json
// @Param        page   query    int  false  "页码"   default(1)
// @Param        size   query    int  false  "每页数量" default(10)
// @Success      200    {array}  User
// @Failure      500    {object} ErrorResponse
// @Router       /api/users [get]
func GetUsers(c *gin.Context) {
    // 步骤2：获取分页参数
    page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
    size, _ := strconv.Atoi(c.DefaultQuery("size", "10"))

    // 步骤3：模拟查询数据库
    users := []User{
        {ID: 1, Name: "张三", Email: "zhangsan@example.com"},
        {ID: 2, Name: "李四", Email: "lisi@example.com"},
    }

    c.JSON(http.StatusOK, gin.H{
        "page":  page,
        "size":  size,
        "data":  users,
    })
}

// @Summary      获取单个用户
// @Description  根据用户ID获取用户详细信息
// @Tags         用户管理
// @Accept       json
// @Produce      json
// @Param        id   path    int  true  "用户ID"
// @Success      200  {object}  User
// @Failure      400  {object}  ErrorResponse
// @Failure      404  {object}  ErrorResponse
// @Router       /api/users/{id} [get]
func GetUserByID(c *gin.Context) {
    // 步骤4：从路径参数获取用户ID
    idStr := c.Param("id")
    id, err := strconv.Atoi(idStr)
    if err != nil {
        c.JSON(http.StatusBadRequest, ErrorResponse{Code: 400, Message: "无效的用户ID"})
        return
    }

    // 步骤5：模拟查询数据库
    if id > 100 {
        c.JSON(http.StatusNotFound, ErrorResponse{Code: 404, Message: "用户不存在"})
        return
    }

    c.JSON(http.StatusOK, User{ID: id, Name: "张三", Email: "zhangsan@example.com"})
}

// @title           Go API 文档
// @version         1.0
// @description     这是一个示例API服务
// @host            localhost:8080
// @BasePath        /api
// @schemes         http
func main() {
    r := gin.Default()

    // 步骤6：挂载Swagger UI路由
    r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))

    // 步骤7：注册业务路由
    api := r.Group("/api")
    {
        api.GET("/users", GetUsers)
        api.GET("/users/:id", GetUserByID)
    }

    // 步骤8：启动服务
    r.Run(":8080")
}

# 步骤1：在项目根目录执行swag init，扫描注解生成docs目录
swag init -g main.go -o docs

# 步骤2：运行项目
go run main.go

# 步骤3：浏览器打开Swagger UI
# http://localhost:8080/swagger/index.html

# 步骤1：macOS安装
brew install wrk

# 步骤2：Ubuntu安装
sudo apt-get install wrk

# 步骤3：从源码编译
git clone https://github.com/wg/wrk.git
cd wrk
make
sudo cp wrk /usr/local/bin/

# 步骤1：基本压测命令
# -t12  使用12条线程
# -c400 维持400个并发连接
# -d30s 持续30秒
wrk -t12 -c400 -d30s http://localhost:8080/api/users

# 步骤2：带header的压测
wrk -t12 -c400 -d30s \
  -H "Authorization: Bearer token123" \
  -H "Content-Type: application/json" \
  http://localhost:8080/api/users

# 步骤3：使用Lua脚本压测POST接口
wrk -t12 -c400 -d30s -s post.lua \
  http://localhost:8080/api/login

-- post.lua: 自定义POST请求压测脚本

-- 步骤1：设置请求方法和请求头
wrk.method = "POST"
wrk.headers["Content-Type"] = "application/json"
wrk.headers["Authorization"] = "Bearer test-token-123"

-- 步骤2：设置请求体
wrk.body = '{"username":"testuser","password":"123456"}'

-- 步骤3（可选）：每次请求前动态修改body
local counter = 0
request = function()
    counter = counter + 1
    -- 步骤4：动态生成不同的用户名
    wrk.body = string.format('{"username":"user%d","password":"123456"}', counter)
    return wrk.format()
end

-- 步骤5（可选）：响应处理，统计状态码
local responses = {}
response = function(status, headers, body)
    responses[status] = (responses[status] or 0) + 1
end

-- 步骤6（可选）：压测结束后输出统计
done = function(summary, latency, requests)
    for status, count in pairs(responses) do
        io.write(string.format("HTTP %d: %d responses\n", status, count))
    end
end

package main

import (
    "strings"
    "testing"
)

// 步骤1：被测函数 - 使用strings.Builder拼接
func concatBuilder(n int) string {
    var sb strings.Builder
    for i := 0; i < n; i++ {
        sb.WriteString("hello")
    }
    return sb.String()
}

// 步骤2：被测函数 - 使用 += 拼接
func concatPlus(n int) string {
    s := ""
    for i := 0; i < n; i++ {
        s += "hello"
    }
    return s
}

// 步骤3：编写Builder方式的benchmark
func BenchmarkConcatBuilder(b *testing.B) {
    // 步骤4：重置计时器，排除初始化开销
    b.ResetTimer()
    // 步骤5：报告内存分配次数和大小
    b.ReportAllocs()

    for i := 0; i < b.N; i++ {
        _ = concatBuilder(100)
    }
}

// 步骤6：编写 += 方式的benchmark
func BenchmarkConcatPlus(b *testing.B) {
    b.ResetTimer()
    b.ReportAllocs()

    for i := 0; i < b.N; i++ {
        _ = concatPlus(100)
    }
}

# 步骤1：运行所有benchmark
go test -bench=.

# 步骤2：运行指定benchmark并显示内存分配
go test -bench=BenchmarkConcatBuilder -benchmem

# 步骤3：运行多次取平均值（更准确）
go test -bench=. -count=5 -benchmem

# 步骤4：生成CPU profile文件
go test -bench=. -cpuprofile=cpu.prof

# 步骤5：生成memory profile文件
go test -bench=. -memprofile=mem.prof

package main

import (
    "log"
    "net/http"
    _ "net/http/pprof" // 步骤1：导入pprof，自动注册/debug/pprof路由
)

func main() {
    // 步骤2：在单独goroutine中启动pprof HTTP服务
    go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil))
    }()

    // 步骤3：业务服务正常启动
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        // 步骤4：模拟业务逻辑
        result := heavyCompute()
        w.Write([]byte(result))
    })

    log.Println("server started on :8080")
    http.ListenAndServe(":8080", nil)
}

func heavyCompute() string {
    s := ""
    for i := 0; i < 100000; i++ {
        s += "x"
    }
    return s
}

# 步骤1：采集CPU profile，持续30秒
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

# 步骤2：采集memory profile
go tool pprof http://localhost:6060/debug/pprof/heap

# 步骤3：采集goroutine profile
go tool pprof http://localhost:6060/debug/pprof/goroutine

# 步骤4：在pprof交互界面常用命令
(pprof) top          # 步骤5：显示CPU耗时最高的10个函数
(pprof) top20        # 步骤6：显示前20
(pprof) list 函数名   # 步骤7：查看函数源码级耗时
(pprof) web          # 步骤8：在浏览器中打开调用图

# 步骤9：生成火焰图（需要安装graphviz）
go tool pprof -http=:8081 http://localhost:6060/debug/pprof/profile?seconds=30

// 步骤1：原生 testing 包，函数名必须以 Test 开头、签名固定为 (t *testing.T)
func TestAdd_Native(t *testing.T) {
    got := Add(1, 2)
    // 步骤2：手动 if 判断，失败用 t.Errorf 记录
    if got != 3 {
        t.Errorf("Add(1,2)=%d, want 3", got)
    }
}

# 步骤1：拉取 goconvey 包（注意前面的点号是包导入，不是命令）
go get github.com/smartystreets/goconvey/convey

# 步骤2：安装 goconvey 命令行工具，用于启动 Web UI 与文件监听
go install github.com/smartystreets/goconvey@latest

package main

import (
    "testing"

    // 步骤1：用点号导入，让 Convey/So 像本地函数一样调用（也可不用点号）
    . "github.com/smartystreets/goconvey/convey"
)

// Add 被测试的目标函数
func Add(a, b int) int { return a + b }

func TestAdd(t *testing.T) {
    // 步骤2：最外层 Convey 描述"测试对象"，传入 *testing.T 和测试体
    Convey("测试 Add 函数", t, func() {
        // 步骤3：嵌套 Convey 描述不同子场景，像 BDD 一样分层
        Convey("两个正数相加", func() {
            // 步骤4：So 携带"标准量勺"断言：实际值 ShouldEqual 期望值
            So(Add(1, 2), ShouldEqual, 3)
        })
        Convey("加零不变", func() {
            So(Add(5, 0), ShouldEqual, 5)
        })
        Convey("负数相加", func() {
            So(Add(-1, -2), ShouldEqual, -3)
        })
    })
}

# 步骤1：当作普通测试跑，和 go test 一样，结果输出到终端
go test -v ./...

# 步骤2：启动 goconvey 服务，打开浏览器 http://localhost:8080
# 它会监听当前目录文件变更，保存即自动重跑，并在 Web UI 上展示结果
goconvey

// testify 写法：单函数断言，风格接近原生但更简洁
import "github.com/stretchr/testify/assert"

func TestAdd_Testify(t *testing.T) {
    // 一行一个断言，失败自动格式化报错
    assert.Equal(t, 3, Add(1, 2))
    assert.NoError(t, nil)
}