欢迎访问XServX技术社区|专注Go语言工程化实践

Go语言项目教程|从零构建企业级Go应用

本教程面向希望系统掌握Go语言项目开发全流程的开发者,涵盖从环境搭建、基础语法、工程结构设计、并发模型实战、网络编程、微服务架构到性能调优与工程化工具链的完整知识体系。内容基于企业级项目实践提炼,注重可落地性与工程化思维培养。

为什么选择Go语言?

Go语言自2009年发布以来,已成为云原生、微服务、高并发后端开发的首选语言。其核心优势包括:

  • 编译型性能:静态类型编译为机器码,运行效率接近C/C++
  • 极致并发模型:轻量级goroutine(千级并发无压力)+ CSP通信顺序进程模型
  • 工程化友好:内置依赖管理(go mod)、测试框架(testing)、性能分析工具(pprof)
  • 跨平台构建:一键交叉编译(GOOS/GOARCH),支持Linux/Windows/macOS/ARM/x86等
  • 简洁语法:无继承、无泛型(早期)、无异常机制,学习曲线平缓
  • 生态成熟:Kubernetes、Docker、Prometheus等云原生项目均采用Go构建

一、Go语言核心基础体系

1.1 变量与类型系统

Go采用强类型静态类型系统,变量声明需明确类型或通过类型推导。类型安全是编译时检查的核心保障,避免运行时类型错误。

⚡重要提示:Go不支持隐式类型转换(如int→float),必须显式转换,防止精度丢失风险。

标准类型包括:布尔型(bool)、数值型(int/uint系列、float系列、complex系列)、字符串(string)、错误类型(error)。复合类型包括数组、切片、映射、结构体、指针、函数、接口、通道。

变量声明与初始化

// 方式1:var声明(推荐用于全局变量)
var count int = 100
var name string = "GoTutorial"
// 方式2:短变量声明(推荐用于局部变量,仅函数内)
age := 28
title := "高级工程师"
// 方式3:批量声明
var (
    port     = 8080
    host     = "localhost"
    isDebug  = true
)

类型别名与自定义类型

// 类型别名(完全等价)
type Celsius float64
type Fahrenheit float64
// 自定义类型(新类型,不兼容原类型)
type UserID string
var u1 UserID = "user001"
var s string = u1 // 编译错误!必须显式转换
var s2 string = string(u1) // 正确

1.2 控制结构与流程控制

Go的控制结构简洁而强大,去除了switch的fallthrough默认行为(需显式写fallthrough),for循环替代了其他语言的while/do-while。

// if-else
if score >= 90 {
    fmt.Println("优秀")
} else if score >= 80 {
    fmt.Println("良好")
} else {
    fmt.Println("需努力")
}
// for循环(唯一循环结构)
for i := 0; i < 5; i++ {
    fmt.Printf("第%d次迭代\n", i+1)
}
// 带条件的for(类似while)
sum := 0
n := 1
for n <= 100 {
    sum += n
    n++
}
// range遍历(数组/切片/映射/字符串/通道)
colors := []string{"red", "green", "blue"}
for idx, color := range colors {
    fmt.Printf("[%d] %s\n", idx, color)
}
// switch(无需break,自动break)
day := "Monday"
switch day {
case "Monday", "Tuesday":
    fmt.Println("工作日开始")
case "Friday":
    fmt.Println("周末前最后一天")
default:
    fmt.Println("普通日子")
}

1.3 函数与闭包

Go函数支持多返回值、命名返回值、可变参数,且函数是一等公民(可赋值、作为参数传递)。

// 多返回值(错误处理关键)
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("除数不能为零")
    }
    return a / b, nil
}
// 命名返回值(提升可读性)
func calcArea(radius float64) (area, circumference float64) {
    pi := 3.14159
    area = pi * radius * radius
    circumference = 2 * pi * radius
    return // 自动返回命名值
}
// 闭包(捕获外部变量)
func makeCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}
counter := makeCounter()
fmt.Println(counter()) // 1
fmt.Println(counter()) // 2

1.4 错误处理哲学

Go不使用try-catch异常机制,而是通过返回error类型显式处理错误。这种设计强调错误是业务逻辑的一部分,而非异常路径。

func loadConfig(path string) (*Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("读取配置文件失败: %w", err)
    }
    var cfg Config
    if err := json.Unmarshal(data, &cfg); err != nil {
        return nil, fmt.Errorf("解析JSON失败: %w", err)
    }
    return &cfg, nil
}

使用%w包装错误可保留原始错误链(通过errors.Unwrap()获取),%v仅显示顶层错误信息。

⚙️最佳实践:错误消息应包含上下文(如“读取配置文件失败”),而非仅“文件不存在”;避免过度包装导致堆栈过长。

二、Go语言项目工程化结构设计

2.1 标准项目布局(Go 1.18+推荐)

采用“分层目录+功能分组”原则,避免单层目录混乱。推荐结构如下:

目录 用途 关键说明
cmd/ 可执行入口 每个子目录对应一个main.go,如cmd/server/main.go
internal/ 私有业务逻辑 仅当前项目可导入(防止外部滥用)
pkg/ 可公开组件 如通用工具、第三方封装,可被外部项目导入
api/ API定义 存放gRPC/HTTP接口定义(如OpenAPI规范)
configs/ 配置文件 开发/测试/生产环境配置分离
scripts/ 构建脚本 Docker构建、CI/CD配置脚本
docs/ 文档 API文档、架构图、部署手册

2.2 分层架构设计(Clean Architecture变体)

采用分层解耦思想,确保业务逻辑与技术细节分离:

五层结构

  • interface层:定义外部接口(HTTP Handler、gRPC Server、CLI命令)
  • application层:业务编排层,协调领域对象与基础设施
  • domain层:核心业务逻辑,含实体、值对象、领域服务
  • repository层:数据访问抽象接口
  • infrastructure层:具体实现(数据库、缓存、消息队列)

代码示例:用户注册流程

// domain/user.go
type User struct {
    ID       UserID
    Email    string
    Password string // 加密存储
}
func (u *User) Validate() error {
    if !strings.Contains(u.Email, "@") {
        return errors.New("邮箱格式错误")
    }
    return nil
}
// repository/user_repo.go
type UserRepository interface {
    Save(ctx context.Context, user *User) error
   FindByEmail(ctx context.Context, email string) (*User, error)
}
// application/user_service.go
type UserService struct {
    repo UserRepository
}
func (s *UserService) Register(ctx context.Context, email, password string) error {
    user := &User{Email: email, Password: hashPassword(password)}
    if err := user.Validate(); err != nil {
        return err
    }
    return s.repo.Save(ctx, user)
}

2.3 依赖管理与go mod

使用go mod管理依赖,确保构建可复现性:

# 初始化模块
go mod init github.com/xservx/gotutorial
# 添加依赖(自动写入go.mod)
go get github.com/gin-gonic/gin@v1.9.1
# 生成依赖锁文件
go mod tidy
# 查看依赖树
go mod graph | grep "github.com/gin-gonic/gin"

go.mod示例内容:

module github.com/xservx/gotutorial
go 1.21
require (
    github.com/gin-gonic/gin v1.9.1
    github.com/go-sql-driver/mysql v1.7.1
)
require (
    github.com/valyala/fasttemplate v1.2.2 // indirect
    github.com/go-playground/validator v10.11.2 // indirect
)
⚡重要提示:生产环境构建应使用go mod vendor生成vendor目录,确保依赖可审计且不受外部仓库变更影响。

三、Go语言并发编程实战

3.1 Goroutine与Channel基础

Go并发模型基于CSP(通信顺序进程),通过通道(channel)传递数据而非共享内存,避免竞态条件。

// 启动goroutine
go func() {
    fmt.Println("异步执行任务")
}()
// 无缓冲通道(同步)
ch := make(chan int)
go func() { ch <- 42 }() // 阻塞直到被接收
val := <-ch              // 阻塞直到发送完成
fmt.Println("收到:", val)
// 有缓冲通道(异步)
buffered := make(chan string, 2)
buffered <- "msg1" // 不阻塞(缓冲区未满)
buffered <- "msg2" // 不阻塞
// buffered <- "msg3" // 阻塞(缓冲区满)

3.2 并发模式与最佳实践

Fan-out / Fan-in模式

将任务分发给多个worker处理,再聚合结果,适用于高吞吐量数据处理。

// Fan-out:一个输入通道分发给多个worker
func distribute(jobs <-chan int, workers int) []<-chan int {
    chans := make([]<-chan int, workers)
    for i := 0; i < workers; i++ {
        ch := make(chan int)
        chans[i] = ch
        go func(out chan<- int) {
            for j := range jobs {
                out <- process(j) // 处理任务
            }
            close(out)
        }(ch)
    }
    return chans
}
// Fan-in:合并多个worker输出
func merge(chans ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    wg.Add(len(chans))
    for _, ch := range chans {
        go func(c <-chan int) {
            defer wg.Done()
            for v := range c {
                out <- v
            }
        }(ch)
    }
    go func() {
        wg.Wait()
        close(out)
    }()
    return out
}

Worker Pool模式

预创建固定数量worker,复用goroutine,避免高并发下资源耗尽。

type Job struct {
    ID   int
    Data string
}
func worker(id int, jobs <-chan Job, results chan<- JobResult) {
    for job := range jobs {
        fmt.Printf("Worker %d 处理任务 %d\n", id, job.ID)
        result := JobResult{JobID: job.ID, Output: process(job.Data)}
        results <- result
    }
}
func main() {
    jobs := make(chan Job, 100)
    results := make(chan JobResult, 100)
    // 启动5个worker
    for w := 1; w <= 5; w++ {
        go worker(w, jobs, results)
    }
    // 提交任务
    for i := 1; i <= 10; i++ {
        jobs <- Job{ID: i, Data: fmt.Sprintf("data-%d", i)}
    }
    close(jobs)
    // 收集结果
    for a := 1; a <= 10; a++ {
        result := <-results
        fmt.Printf("任务 %d 完成: %s\n", result.JobID, result.Output)
    }
}

超时控制(context.WithTimeout)

防止并发操作阻塞导致资源泄漏,是生产环境必备。

func fetchUser(ctx context.Context, id int) (*User, error) {
    req, _ := http.NewRequest("GET", "/api/user/"+strconv.Itoa(id), nil)
    // 设置请求超时
    req = req.WithContext(ctx)
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, fmt.Errorf("请求失败: %w", err)
    }
    defer resp.Body.Close()
    var user User
    if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
        return nil, fmt.Errorf("解析响应失败: %w", err)
    }
    return &user, nil
}
// 调用方设置100ms超时
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
user, err := fetchUser(ctx, 123)
if err != nil {
    log.Printf("获取用户失败: %v", err)
}

熔断机制(简化版)

基于计数器的简易熔断器,防止服务雪崩。

type CircuitBreaker struct {
    failureCount int
    threshold    int
    state        string // "close" / "open"
    lastFail     time.Time
}
func (cb *CircuitBreaker) Allow() bool {
    if cb.state == "open" {
        if time.Since(cb.lastFail) > 30*time.Second {
            cb.state = "half-open"
            return true
        }
        return false
    }
    return true
}
func (cb *CircuitBreaker) RecordSuccess() {
    cb.failureCount = 0
    cb.state = "close"
}
func (cb *CircuitBreaker) RecordFailure() {
    cb.failureCount++
    cb.lastFail = time.Now()
    if cb.failureCount >= cb.threshold {
        cb.state = "open"
    }
}
// 使用
cb := &CircuitBreaker{threshold: 3}
if cb.Allow() {
    err := callExternalService()
    if err != nil {
        cb.RecordFailure()
    } else {
        cb.RecordSuccess()
    }
}
⚙️生产建议:使用github.com/sony/gobreaker等成熟库实现熔断;避免在channel操作中阻塞goroutine;使用sync.Pool复用对象减少GC压力。

四、Go网络编程与HTTP服务构建

4.1 标准库net/http深度实践

Go标准库提供强大的HTTP服务端/客户端支持,支持中间件链式处理。

中间件链式设计

type Middleware func(http.Handler) http.Handler
func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        log.Printf("请求: %s %s", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
        log.Printf("耗时: %v", time.Since(start))
    })
}
func AuthMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token == "" || !isValidToken(token) {
            http.Error(w, "未授权", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    })
}
// 组合中间件
func chain(h http.Handler, middlewares ...Middleware) http.Handler {
    for _, m := range middlewares {
        h = m(h)
    }
    return h
}
func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/api/users", handleUsers)
    handler := chain(mux, LoggingMiddleware, AuthMiddleware)
    http.ListenAndServe(":8080", handler)
}

流式响应与大文件传输

// 分块传输大文件
func downloadHandler(w http.ResponseWriter, r *http.Request) {
    file, err := os.Open("/large/data.zip")
    if err != nil {
        http.Error(w, "文件不存在", http.StatusNotFound)
        return
    }
    defer file.Close()
    w.Header().Set("Content-Type", "application/zip")
    w.Header().Set("Content-Disposition", "attachment; filename=data.zip")
    // 使用io.Copy实现流式传输,避免内存溢出
    io.Copy(w, file)
}

4.2 gRPC微服务通信

Protocol Buffers定义服务接口,生成强类型代码,支持双向流式通信。

⚙️安装工具:go install google.golang.org/protobuf/cmd/protoc-gen-go@latest 和 go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
// user.proto
syntax = "proto3";
package user;
service UserService {
    rpc GetUser(GetUserRequest) returns (UserReply) {}
    rpc ListUsers(ListUsersRequest) returns (stream UserReply) {} // 流式
}
message GetUserRequest {
    int32 id = 1;
}
message UserReply {
    int32 id = 1;
    string email = 2;
}
// 服务端实现
type server struct {
    pb.UnimplementedUserServiceServer
    db *sql.DB
}
func (s *server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.UserReply, error) {
    var user User
    err := s.db.QueryRow("SELECT id, email FROM users WHERE id=?", req.Id).Scan(&user.ID, &user.Email)
    if err != nil {
        return nil, status.Errorf(codes.NotFound, "用户不存在")
    }
    return &pb.UserReply{Id: user.ID, Email: user.Email}, nil
}
func (s *server) ListUsers(req *pb.ListUsersRequest, stream pb.UserService_ListUsersServer) error {
    rows, err := s.db.Query("SELECT id, email FROM users LIMIT ?", req.Limit)
    if err != nil {
        return status.Errorf(codes.Internal, "查询失败")
    }
    defer rows.Close()
    for rows.Next() {
        var u User
        rows.Scan(&u.ID, &u.Email)
        if err := stream.Send(&pb.UserReply{Id: u.ID, Email: u.Email}); err != nil {
            return err
        }
    }
    return nil
}

五、Go微服务架构实战

5.1 服务发现与配置中心

推荐使用Consul作为服务注册中心,支持健康检查与多数据中心。

服务注册与发现

type Service struct {
    ID      string
    Name    string
    Address string
    Port    int
}
func (s *Service) Register() error {
    client, _ := api.NewClient(&api.Config{Address: "http://consul:8500"})
    reg := &api.AgentServiceRegistration{
        ID:      s.ID,
        Name:    s.Name,
        Address: s.Address,
        Port:    s.Port,
        Checks: []*api.AgentServiceCheck{
            {
                HTTP:     fmt.Sprintf("http://%s:%d/health", s.Address, s.Port),
                Interval: "10s",
                Timeout:  "5s",
            },
        },
    }
    return client.Agent().ServiceRegister(reg)
}
func DiscoverService(name string) ([]*Service, error) {
    client, _ := api.NewClient(&api.Config{Address: "http://consul:8500"})
    services, _, err := client.Agent().Services()
    if err != nil {
        return nil, err
    }
    var result []*Service
    for _, svc := range services {
        if svc.Service == name {
            result = append(result, &Service{
                ID:      svc.ID,
                Name:    svc.Service,
                Address: svc.Address,
                Port:    svc.Port,
            })
        }
    }
    return result, nil
}

5.2 分布式追踪(OpenTelemetry集成)

使用Jaeger实现全链路追踪,定位性能瓶颈。

import (
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/jaeger"
    "go.opentelemetry.io/otel/sdk/resource"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
)
func initTracer() {
    exporter, _ := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint("http://jaeger:14268/api/traces")))
    tp := sdktrace.NewTracerProvider(
        sdktrace.WithBatcher(exporter),
        sdktrace.WithResource(resource.NewWithAttributes(
            "service.name", "user-service",
        )),
    )
    otel.SetTracerProvider(tp)
}
// 在HTTP中间件中注入trace
func TracingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := context.Background()
        span := otel.Tracer("user-service").Start(ctx, "handle-request")
        defer span.End()
        r = r.WithContext(span.SpanContext().TraceContext())
        next.ServeHTTP(w, r)
    })
}

微服务关键指标监控

  • 请求量:QPS、请求总数
  • 延迟:P50/P95/P99响应时间
  • 错误率:HTTP 4xx/5xx比例
  • 资源使用:CPU、内存、GC频率
  • 业务指标:注册转化率、订单创建量

六、Go性能调优与诊断

6.1 性能分析工具链

使用pprof分析CPU、内存、goroutine、阻塞等瓶颈。

启用性能分析

import _ "net/http/pprof"
func main() {
    go func() {
        log.Println(http.ListenAndServe("0.0.0.0:6060", nil))
    }()
    // 主业务逻辑
    runServer()
}

诊断命令示例

# CPU分析(采样10秒)
go tool pprof http://localhost:6060/debug/pprof/profile
# 内存分析
go tool pprof http://localhost:6060/debug/pprof/heap
# 查看火焰图(需安装graphviz)
go tool pprof -http=:8080 http://localhost:6060/debug/pprof/profile
# 查看goroutine栈
go tool pprof http://localhost:6060/debug/pprof/goroutine

6.2 内存优化技巧

sync.Pool复用对象

适用于高频创建/销毁的小对象(如JSON解码器),减少GC压力。

var jsonDecoderPool = sync.Pool{
    New: func() interface{} {
        return json.NewDecoder(nil)
    },
}
func decode(data []byte) (Result, error) {
    decoder := jsonDecoderPool.Get().(*json.Decoder)
    defer jsonDecoderPool.Put(decoder)
    decoder.Reset(bytes.NewReader(data))
    var r Result
    if err := decoder.Decode(&r); err != nil {
        return Result{}, err
    }
    return r, nil
}

字符串高效拼接

避免+拼接,使用strings.Builder或bytes.Buffer。

// 高效拼接
var sb strings.Builder
for i := 0; i < 1000; i++ {
    sb.WriteString(fmt.Sprintf("item%d", i))
    sb.WriteString(",")
}
result := sb.String()
// ❌ 低效(每次创建新字符串)
result := ""
for i := 0; i < 1000; i++ {
    result += fmt.Sprintf("item%d,", i)
}

切片预分配容量

避免动态扩容导致的内存拷贝。

// 低效:频繁扩容
items := []string{}
for i := 0; i < 10000; i++ {
    items = append(items, fmt.Sprintf("item%d", i))
}
// 高效:预分配容量
items := make([]string, 0, 10000)
for i := 0; i < 10000; i++ {
    items = append(items, fmt.Sprintf("item%d", i))
}
⚙️生产监控:使用go tool trace分析调度延迟;通过GODEBUG=gctrace=1观察GC行为;监控/debug/pprof/heap?debug=1输出。

七、Go工程化工具链

7.1 代码质量工具

# 静态检查
golangci-lint run ./...
# 代码覆盖率
go test -coverprofile=coverage.out ./...
go tool cover -html=coverage.out -o coverage.html
# 格式化
gofmt -w -l .

7.2 CI/CD集成

GitHub Actions示例:

name: Go CI
on: [push]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Set up Go
      uses: actions/setup-go@v3
      with:
        go-version: '1.21'
    - name: Install dependencies
      run: go mod download
    - name: Run tests
      run: go test -v ./...

7.3 Docker构建优化

多阶段构建减少镜像体积:

# Dockerfile
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o main ./cmd/server
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/main .
CMD ["./main"]

八、真实项目案例解析

8.1 高并发订单系统设计

某电商大促场景:每秒处理10万订单请求,要求最终一致性。

核心优化措施

  • 请求排队:RabbitMQ削峰填谷,避免系统过载
  • 库存预减:Redis原子操作预扣库存,失败快速返回
  • 异步处理:订单创建后异步发送通知、更新统计
  • 幂等设计:订单ID+用户ID作为唯一键,防止重复提交
  • 降级方案:库存不足时返回“排队中”,后台排队处理

关键代码片段

func CreateOrder(userID, productID int64) (int64, error) {
    // 1. 预扣库存(Redis)
   库存 := redisClient.Decr(fmt.Sprintf("stock:%d", productID))
    if 库存 < 0 {
        redisClient.Incr(fmt.Sprintf("stock:%d", productID))
        return 0, errors.New("库存不足")
    }
    // 2. 创建订单(MySQL事务)
    tx, _ := db.Begin()
    defer tx.Rollback()
    var orderID int64
    err := tx.QueryRow(
        "INSERT INTO orders (user_id, product_id, status) VALUES ($1,$2,'pending') RETURNING id",
        userID, productID,
    ).Scan(&orderID)
    if err != nil {
        return 0, err
    }
    // 3. 提交事务
    if err := tx.Commit(); err != nil {
        return 0, err
    }
    // 4. 异步处理后续逻辑
    go func() {
        // 发送通知、更新统计等
    }()
    return orderID, nil
}

8.2 日志系统最佳实践

使用zap高性能日志库,结构化日志便于ELK分析。

import "go.uber.org/zap"
var logger *zap.Logger
func init() {
    config := zap.NewProductionConfig()
    config.EncoderConfig.EncodeTime = zap.ISO8601TimeEncoder
    config.OutputPaths = []string{"stdout", "/var/log/app/app.log"}
    logger, _ = config.Build()
}
// 使用
logger.Info("用户登录",
    zap.String("user_id", "u123"),
    zap.String("ip", "192.168.1.1"),
    zap.Int("status", 200),
)

九、开发者高频问题解答

Q1: 为什么Go没有泛型?

Go 1.18起已支持泛型(2022年发布),但设计原则是“渐进式引入”,避免复杂性。典型泛型用法:

func Max[T constraints.Ordered](a, b T) T {
    if a > b {
        return a
    }
    return b
}
// 使用
maxInt := Max(3, 5) // T推导为int
maxStr := Max("a", "b") // T推导为string
Q2: 如何避免goroutine泄漏?

关键措施:① 使用context超时控制;② 通道操作必有接收者;③ 避免无限循环不退出;④ 使用sync.WaitGroup等待完成。推荐使用go test -race检测竞态条件。

Q3: JSON序列化性能优化

① 使用json.RawMessage延迟解析;② 避免map[string]interface{}频繁创建;③ 重用json.Decoder;④ 对固定结构使用encoding/json而非第三方库。实测json-iterator性能提升约20%。

Q4: 为什么HTTP服务启动后不退出?

常见原因:① 未正确关闭HTTP服务;② 阻塞的goroutine未退出;③ 未调用context.WithCancel。正确做法:使用http.Server的Shutdown方法优雅退出。

srv := &http.Server{Addr: ":8080"}
go func() {
    if err := srv.ListenAndServe(); err != http.ErrServerClosed {
        log.Fatal(err)
    }
}()
// 退出时
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
srv.Shutdown(ctx)