中篇：Go语言进阶核心（学时10天）

Day 8：面向对象编程

8.1 结构体与方法

// 银行账户案例
type Account struct {
    owner   string
    balance float64
}

// 指针接收器方法（修改结构体内容）
func (a *Account) Deposit(amount float64) {
    a.balance += amount
}

// 值接收器方法（不修改原结构体）
func (a Account) Display() string {
    return fmt.Sprintf("%s的余额：%.2f元", a.owner, a.balance)
}

func main() {
    acc := Account{"张三", 1000}
    acc.Deposit(500)
    fmt.Println(acc.Display()) // "张三的余额：1500.00元"
}

8.2 接口与鸭子类型

// 通用日志接口
type Logger interface {
    Log(content string) error
}

// 文件日志实现
type FileLogger struct{ filename string }

func (f FileLogger) Log(content string) error {
    return os.WriteFile(f.filename, []byte(content), 0644)
}

// 控制台日志实现
type ConsoleLogger struct{}

func (c ConsoleLogger) Log(content string) error {
    fmt.Println("[LOG]", content)
    return nil
}

// 使用接口的函数
func ProcessOrder(logger Logger) {
    logger.Log("订单开始处理")
    // 业务逻辑...
}

func main() {
    ProcessOrder(ConsoleLogger{})
    ProcessOrder(FileLogger{"app.log"})
}

Day 9：错误处理艺术

9.1 错误处理机制

// 自定义错误类型
type APIError struct {
    Code    int
    Message string
}

func (e APIError) Error() string {
    return fmt.Sprintf("API错误 %d: %s", e.Code, e.Message)
}

// 错误处理实战
func GetUser(id int) (User, error) {
    if id <= 0 {
        return User{}, APIError{400, "无效用户ID"}
    }
    // 数据库查询...
    return User{Name: "张三"}, nil
}

func main() {
    if user, err := GetUser(-1); err != nil {
        var apiErr APIError
        if errors.As(err, &apiErr) {
            fmt.Println("业务错误:", apiErr.Message)
        } else {
            fmt.Println("系统错误:", err)
        }
    }
}

9.2 defer深度解析

// 文件操作正确姿势
func ReadFile(filename string) (string, error) {
    file, err := os.Open(filename)
    if err != nil {
        return "", err
    }
    defer file.Close() // 确保资源释放

    content, err := io.ReadAll(file)
    return string(content), err
}

// defer执行顺序实验
func main() {
    defer fmt.Println("第一个defer")
    defer fmt.Println("第二个defer")
    fmt.Println("主函数执行")
}
// 输出：
// 主函数执行
// 第二个defer
// 第一个defer

Day 10-12：并发编程基础

10.1 goroutine原理

// 并发素数筛案例
func Generate(ch chan<- int) {
    for i := 2; ; i++ {
        ch <- i
    }
}

func Filter(in <-chan int, out chan<- int, prime int) {
    for {
        num := <-in
        if num%prime != 0 {
            out <- num
        }
    }
}

func main() {
    ch := make(chan int)
    go Generate(ch)
    for i := 0; i < 10; i++ {
        prime := <-ch
        fmt.Printf("第%d个素数: %d\n", i+1, prime)
        chNext := make(chan int)
        go Filter(ch, chNext, prime)
        ch = chNext
    }
}

10.2 channel高级用法

// 工作池模式
func Worker(id int, jobs <-chan int, results chan<- int) {
    for job := range jobs {
        fmt.Printf("Worker %d 开始处理任务 %d\n", id, job)
        time.Sleep(time.Second) // 模拟耗时操作
        results <- job * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    // 启动3个worker
    for w := 1; w <= 3; w++ {
        go Worker(w, jobs, results)
    }

    // 发送9个任务
    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)

    // 收集结果
    for a := 1; a <= 9; a++ {
        fmt.Println("处理结果:", <-results)
    }
}

10.3 sync包使用

// 并发安全计数器
type SafeCounter struct {
    mu    sync.Mutex
    count int
}

func (c *SafeCounter) Inc() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}

func (c *SafeCounter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

func main() {
    counter := SafeCounter{}
    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            counter.Inc()
            wg.Done()
        }()
    }
    wg.Wait()
    fmt.Println(counter.Value()) // 1000
}

Day 13-14：包与依赖管理

13.1 模块化开发

myproject/
├── go.mod
├── main.go
└── pkg/
    └── utils/
        ├── math.go
        └── string.go

math.go示例：

package utils

func Sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

main.go调用：

import "myproject/pkg/utils"

func main() {
    fmt.Println(utils.Sum(1,2,3)) // 6
}

13.2 Go Module进阶

# 设置私有仓库配置
go env -w GOPRIVATE="gitlab.mycompany.com"
# 带认证的依赖拉取
git config --global url."https://user:token@gitlab.mycompany.com".insteadOf "https://gitlab.mycompany.com"

13.3 标准库实战

// HTTP服务器+文件服务
func main() {
    // 静态文件服务
    fs := http.FileServer(http.Dir("./static"))
    http.Handle("/static/", http.StripPrefix("/static/", fs))

    // API路由
    http.HandleFunc("/api/time", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, `{"timestamp": %d}`, time.Now().Unix())
    })

    // 启动服务器
    fmt.Println("服务启动在 :8080")
    http.ListenAndServe(":8080", nil)
}

综合实战：并发HTTP代理服务器

package main

import (
    "io"
    "log"
    "net"
    "net/http"
)

func handleRequest(w http.ResponseWriter, r *http.Request) {
    // 创建目标连接
    destConn, err := net.Dial("tcp", r.Host)
    if err != nil {
        http.Error(w, err.Error(), http.StatusServiceUnavailable)
        return
    }
    defer destConn.Close()

    // 劫持客户端连接
    hijacker, ok := w.(http.Hijacker)
    if !ok {
        http.Error(w, "Hijacking not supported", http.StatusInternalServerError)
        return
    }
    clientConn, _, err := hijacker.Hijack()
    if err != nil {
        http.Error(w, err.Error(), http.StatusServiceUnavailable)
        return
    }
    defer clientConn.Close()

    // 双向数据转发
    go io.Copy(destConn, clientConn)
    io.Copy(clientConn, destConn)
}

func main() {
    server := &http.Server{
        Addr: ":8888",
        Handler: http.HandlerFunc(handleRequest),
    }
    log.Fatal(server.ListenAndServe())
}

并发编程核心要点

1. Goroutine泄漏检测：使用runtime.NumGoroutine()监控协程数量
2. Channel选择机制：select实现超时控制

   select {
   case res := <-ch:
       fmt.Println(res)
   case <-time.After(3 * time.Second):
       fmt.Println("请求超时")
   }

3. 竞争检测：编译时添加-race参数

   go run -race main.go

性能调优技巧

1. 并发瓶颈分析：

   // 查看调度器信息
   go tool trace trace.out

2. 内存优化：

   // 对象池复用
   var bufferPool = sync.Pool{
       New: func() interface{} {
           return bytes.NewBuffer(make([]byte, 1024))
       },
   }