🖥️ 后端技术 - GOLANG

What is Go language? What are its main features and advantages?

考察点：Go语言基础概念。

答案：

Go语言（Golang）是由Google开发的一种开源的编程语言，于2009年首次发布。Go语言被设计为一种简洁、高效、并发友好的系统级编程语言，主要用于构建可靠和高效的软件系统。它结合了静态类型语言的安全性和动态语言的开发效率。

主要特点：

1. 简洁的语法：Go语言的语法简单明了，学习成本低
2. 高效的编译：快速编译到机器码，无需虚拟机
3. 内置并发支持：原生支持goroutine和channel
4. 垃圾回收：自动内存管理，减少内存泄漏风险
5. 静态类型：编译时类型检查，提高代码安全性

主要优势：

• 编译速度快，运行效率高
• 并发编程模型简单易用
• 跨平台支持，部署方便
• 丰富的标准库，生态系统完善
• 代码可读性强，维护成本低

适用场景：

• 云原生应用开发
• 微服务架构
• 网络编程和API服务
• 分布式系统开发
• DevOps工具链

What is Go’s concurrency model? How to use goroutine and channel?

考察点：Go并发编程基础。

答案：

Go语言采用CSP（Communicating Sequential Processes）并发模型，通过goroutine和channel实现轻量级并发编程。这种模型强调"不要通过共享内存来通信，而要通过通信来共享内存"的理念。

Goroutine：
Goroutine是Go语言的轻量级线程，由Go运行时管理。创建和切换开销极小，一个程序可以同时运行数千个goroutine。

// 创建goroutine
go func() {
    fmt.Println("Hello from goroutine!")
}()

// 带参数的goroutine
go processData(data)

Channel：
Channel是goroutine之间通信的管道，提供类型安全的数据传递机制。

// 创建channel
ch := make(chan int)
ch := make(chan int, 10) // 带缓冲的channel

// 发送和接收数据
ch <- 42        // 发送
value := <-ch   // 接收

// 关闭channel
close(ch)

实际应用示例：

func worker(id int, jobs <-chan int, results chan<- int) {
    for job := range jobs {
        results <- job * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)
    
    // 启动3个worker goroutine
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }
    
    // 发送任务
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)
    
    // 收集结果
    for a := 1; a <= 5; a++ {
        <-results
    }
}

最佳实践：

• 避免过度创建goroutine，合理控制并发数量
• 使用select语句处理多个channel操作
• 及时关闭不再使用的channel
• 使用context包管理goroutine生命周期

What is Go’s package management and module system? How to use go mod?

考察点：包管理和模块化。

答案：

Go模块（Module）是Go语言官方的依赖管理解决方案，从Go 1.11版本开始引入，Go 1.16版本后成为默认模式。模块是相关Go包的集合，通过go.mod文件定义模块的依赖关系和版本信息。

核心概念：

• 模块（Module）：一个或多个相关包的集合
• go.mod文件：定义模块路径和依赖关系
• go.sum文件：记录依赖模块的校验和，确保依赖完整性
• 语义化版本：使用v主版本.次版本.修订版本格式

常用go mod命令：

# 初始化模块
go mod init example.com/myproject

# 添加依赖
go get github.com/gin-gonic/gin

# 添加特定版本依赖
go get github.com/gin-gonic/[email protected]

# 更新依赖到最新版本
go get -u github.com/gin-gonic/gin

# 下载依赖到本地缓存
go mod download

# 清理未使用的依赖
go mod tidy

# 查看依赖图
go mod graph

# 验证依赖完整性
go mod verify

go.mod文件示例：

module example.com/myproject

go 1.19

require (
    github.com/gin-gonic/gin v1.8.1
    github.com/go-sql-driver/mysql v1.6.0
)

require (
    github.com/bytedance/sonic v1.5.0 // indirect
    github.com/gin-contrib/sse v0.1.0 // indirect
)

版本管理策略：

• 使用语义化版本号进行版本控制
• 主版本兼容性原则（v1.x.x与v2.x.x不兼容）
• 使用go.sum文件确保依赖完整性
• 定期执行go mod tidy清理依赖

最佳实践：

• 及时提交go.mod和go.sum文件到版本控制
• 使用replace指令处理本地开发依赖
• 定期更新依赖版本，关注安全漏洞
• 使用vendor目录锁定依赖版本

How to create a basic HTTP server in Go?

考察点：HTTP服务基础。

答案：

Go语言的标准库net/http提供了强大的HTTP服务器功能，可以轻松创建高性能的web服务。Go的HTTP服务器基于Handler接口，通过注册路由处理不同的HTTP请求。

基本HTTP服务器：

package main

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

func main() {
    // 注册路由处理函数
    http.HandleFunc("/", homeHandler)
    http.HandleFunc("/api/users", usersHandler)
    
    // 启动服务器
    log.Println("Server starting on :8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        log.Fatal("Server failed to start:", err)
    }
}

func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to Go HTTP Server!")
}

func usersHandler(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case "GET":
        fmt.Fprintf(w, "Get users")
    case "POST":
        fmt.Fprintf(w, "Create user")
    default:
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
}

使用自定义ServeMux：

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/api/health", healthCheck)
    mux.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("./static/"))))
    
    server := &http.Server{
        Addr:         ":8080",
        Handler:      mux,
        ReadTimeout:  15 * time.Second,
        WriteTimeout: 15 * time.Second,
    }
    
    log.Fatal(server.ListenAndServe())
}

处理不同HTTP方法：

func apiHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    
    switch r.Method {
    case http.MethodGet:
        handleGet(w, r)
    case http.MethodPost:
        handlePost(w, r)
    case http.MethodPut:
        handlePut(w, r)
    case http.MethodDelete:
        handleDelete(w, r)
    default:
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
}

添加中间件：

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Printf("%s %s %v", r.Method, r.URL.Path, time.Since(start))
    })
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/api/", apiHandler)
    
    // 应用中间件
    handler := loggingMiddleware(mux)
    log.Fatal(http.ListenAndServe(":8080", handler))
}

最佳实践：

• 合理设置服务器超时参数
• 使用中间件处理通用逻辑（日志、认证等）
• 正确设置HTTP状态码和响应头
• 处理静态文件服务
• 实现优雅关闭机制

How to handle JSON data in Go? How to implement serialization and deserialization?

考察点：JSON数据处理。

答案：

Go语言通过标准库encoding/json包提供了强大的JSON处理功能。通过结构体标签（struct tags）和反射机制，可以方便地实现Go数据结构与JSON格式之间的转换。

基本序列化和反序列化：

package main

import (
    "encoding/json"
    "fmt"
    "log"
)

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email,omitempty"`
    Age   int    `json:"age"`
}

func main() {
    // 序列化（Marshal）
    user := User{
        ID:    1,
        Name:  "张三",
        Email: "[email protected]",
        Age:   25,
    }
    
    jsonData, err := json.Marshal(user)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(jsonData))
    // 输出：{"id":1,"name":"张三","email":"[email protected]","age":25}
    
    // 反序列化（Unmarshal）
    jsonStr := `{"id":2,"name":"李四","age":30}`
    var newUser User
    err = json.Unmarshal([]byte(jsonStr), &newUser)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%+v\n", newUser)
    // 输出：{ID:2 Name:李四 Email: Age:30}
}

常用结构体标签：

type Product struct {
    ID          int     `json:"id"`
    Name        string  `json:"product_name"`        // 自定义字段名
    Price       float64 `json:"price,omitempty"`     // 零值时省略
    Description string  `json:"-"`                   // 忽略字段
    CreatedAt   string  `json:"created_at,string"`   // 强制转换为字符串
    IsActive    bool    `json:"is_active,omitempty"`
}

处理嵌套结构和数组：

type Address struct {
    Street  string `json:"street"`
    City    string `json:"city"`
    Country string `json:"country"`
}

type Person struct {
    Name      string    `json:"name"`
    Addresses []Address `json:"addresses"`
    Metadata  map[string]interface{} `json:"metadata"`
}

// 序列化嵌套结构
person := Person{
    Name: "王五",
    Addresses: []Address{
        {Street: "北京路1号", City: "北京", Country: "中国"},
        {Street: "上海路2号", City: "上海", Country: "中国"},
    },
    Metadata: map[string]interface{}{
        "level": "VIP",
        "score": 95.5,
    },
}

流式处理大型JSON：

// 使用Encoder和Decoder进行流式处理
func streamProcessing() {
    // 编码到Writer
    var buf bytes.Buffer
    encoder := json.NewEncoder(&buf)
    encoder.Encode(user)
    
    // 从Reader解码
    decoder := json.NewDecoder(&buf)
    var decoded User
    decoder.Decode(&decoded)
}

处理动态JSON：

// 使用interface{}处理未知结构的JSON
func handleDynamicJSON(jsonData []byte) {
    var result map[string]interface{}
    json.Unmarshal(jsonData, &result)
    
    // 类型断言访问数据
    if name, ok := result["name"].(string); ok {
        fmt.Println("Name:", name)
    }
    
    if age, ok := result["age"].(float64); ok {
        fmt.Println("Age:", int(age))
    }
}

自定义JSON序列化：

type Time struct {
    time.Time
}

// 实现json.Marshaler接口
func (t Time) MarshalJSON() ([]byte, error) {
    return json.Marshal(t.Format("2006-01-02 15:04:05"))
}

// 实现json.Unmarshaler接口
func (t *Time) UnmarshalJSON(data []byte) error {
    var str string
    if err := json.Unmarshal(data, &str); err != nil {
        return err
    }
    parsed, err := time.Parse("2006-01-02 15:04:05", str)
    if err != nil {
        return err
    }
    t.Time = parsed
    return nil
}

最佳实践：

• 使用omitempty标签避免输出零值字段
• 为公开API定义清晰的JSON结构体
• 处理JSON解析错误，避免程序崩溃
• 使用验证库验证JSON数据完整性
• 对敏感字段使用"-"标签避免序列化

What is Go’s error handling mechanism? How to handle errors gracefully?

考察点：错误处理机制。

答案：

Go语言采用显式错误处理机制，通过内置的error接口类型来表示错误状态。这种设计哲学强调错误处理的明确性和可预测性，避免了异常机制可能带来的隐藏控制流。

error接口定义：

type error interface {
    Error() string
}

基本错误处理模式：

package main

import (
    "errors"
    "fmt"
    "log"
    "strconv"
)

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        log.Printf("Error: %v", err)
        return
    }
    fmt.Printf("Result: %.2f", result)
}

创建错误的方式：

// 1. 使用errors.New()
err1 := errors.New("something went wrong")

// 2. 使用fmt.Errorf()格式化错误
err2 := fmt.Errorf("user %s not found", username)

// 3. 自定义错误类型
type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation failed for %s: %s", e.Field, e.Message)
}

// 4. 使用fmt.Errorf包装错误（Go 1.13+）
originalErr := errors.New("original error")
wrappedErr := fmt.Errorf("operation failed: %w", originalErr)

错误包装和解包：

import (
    "errors"
    "fmt"
)

func processFile(filename string) error {
    err := readFile(filename)
    if err != nil {
        return fmt.Errorf("failed to process file %s: %w", filename, err)
    }
    return nil
}

func main() {
    err := processFile("config.txt")
    if err != nil {
        // 检查是否包含特定错误
        if errors.Is(err, os.ErrNotExist) {
            fmt.Println("File not found")
        }
        
        // 解包错误
        var pathError *os.PathError
        if errors.As(err, &pathError) {
            fmt.Printf("Path error: %s\n", pathError.Path)
        }
        
        // 获取根本原因
        fmt.Printf("Root cause: %v\n", errors.Unwrap(err))
    }
}

自定义错误类型：

// 错误码枚举
type ErrorCode int

const (
    ErrorCodeInvalidInput ErrorCode = iota + 1
    ErrorCodeNotFound
    ErrorCodeUnauthorized
    ErrorCodeInternalError
)

// 自定义错误结构
type APIError struct {
    Code    ErrorCode `json:"code"`
    Message string    `json:"message"`
    Details string    `json:"details,omitempty"`
}

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

// 创建特定错误的辅助函数
func NewNotFoundError(resource string) *APIError {
    return &APIError{
        Code:    ErrorCodeNotFound,
        Message: fmt.Sprintf("%s not found", resource),
    }
}

优雅的错误处理策略：

// 1. 早期返回模式
func validateUser(user *User) error {
    if user == nil {
        return errors.New("user cannot be nil")
    }
    if user.Name == "" {
        return errors.New("user name is required")
    }
    if user.Email == "" {
        return errors.New("user email is required")
    }
    return nil
}

// 2. 错误聚合
func validateUserComplete(user *User) error {
    var errs []string
    
    if user.Name == "" {
        errs = append(errs, "name is required")
    }
    if user.Email == "" {
        errs = append(errs, "email is required")
    }
    if user.Age < 0 {
        errs = append(errs, "age must be positive")
    }
    
    if len(errs) > 0 {
        return fmt.Errorf("validation errors: %s", strings.Join(errs, ", "))
    }
    return nil
}

// 3. 使用defer进行清理
func processData(filename string) (err error) {
    file, err := os.Open(filename)
    if err != nil {
        return fmt.Errorf("failed to open file: %w", err)
    }
    defer func() {
        if closeErr := file.Close(); closeErr != nil {
            if err == nil {
                err = closeErr
            }
        }
    }()
    
    // 处理文件数据...
    return nil
}

错误处理最佳实践：

• 总是检查和处理错误，不要忽略
• 在适当的层级处理错误，避免过度传播
• 使用有意义的错误信息，便于调试
• 对于库函数，返回包装过的错误以提供上下文
• 使用自定义错误类型为调用者提供更多信息
• 在HTTP API中，将错误转换为适当的HTTP状态码
• 记录错误日志，但避免重复记录同一个错误

What are interfaces and structs in Go? How to define and use them?

考察点：接口和结构体基础。

答案：

Go语言中的结构体（struct）和接口（interface）是面向对象编程的核心概念。结构体用于定义数据结构，接口用于定义行为规范。Go通过组合而非继承的方式实现面向对象设计。

结构体定义和使用：

// 定义结构体
type Person struct {
    Name    string
    Age     int
    Email   string
    address Address // 嵌入其他结构体
}

type Address struct {
    Street  string
    City    string
    ZipCode string
}

// 结构体方法
func (p Person) GetFullInfo() string {
    return fmt.Sprintf("Name: %s, Age: %d, Email: %s", p.Name, p.Age, p.Email)
}

// 指针接收者方法（可以修改结构体）
func (p *Person) SetAge(age int) {
    p.Age = age
}

// 使用结构体
func main() {
    // 创建结构体实例
    person1 := Person{
        Name:  "张三",
        Age:   25,
        Email: "[email protected]",
        address: Address{
            Street:  "北京路1号",
            City:    "北京",
            ZipCode: "100000",
        },
    }
    
    // 通过字段赋值
    person2 := Person{}
    person2.Name = "李四"
    person2.Age = 30
    
    // 使用new创建指针
    person3 := new(Person)
    person3.Name = "王五"
}

接口定义和实现：

// 定义接口
type Writer interface {
    Write([]byte) (int, error)
}

type Reader interface {
    Read([]byte) (int, error)
}

// 组合接口
type ReadWriter interface {
    Reader
    Writer
}

// 实现接口（隐式实现）
type FileLogger struct {
    filename string
}

func (f *FileLogger) Write(data []byte) (int, error) {
    // 实现写入文件逻辑
    return len(data), nil
}

type ConsoleLogger struct{}

func (c *ConsoleLogger) Write(data []byte) (int, error) {
    fmt.Print(string(data))
    return len(data), nil
}

// 使用接口
func LogMessage(w Writer, message string) {
    w.Write([]byte(message))
}

func main() {
    fileLogger := &FileLogger{filename: "app.log"}
    consoleLogger := &ConsoleLogger{}
    
    LogMessage(fileLogger, "Log to file")
    LogMessage(consoleLogger, "Log to console")
}

嵌入和组合：

// 结构体嵌入
type Animal struct {
    Name string
    Age  int
}

func (a Animal) Speak() string {
    return "Some sound"
}

type Dog struct {
    Animal    // 嵌入Animal结构体
    Breed string
}

func (d Dog) Speak() string {
    return "Woof!"
}

func main() {
    dog := Dog{
        Animal: Animal{Name: "Buddy", Age: 3},
        Breed:  "Golden Retriever",
    }
    
    fmt.Println(dog.Name)    // 可以直接访问嵌入字段
    fmt.Println(dog.Speak()) // "Woof!" - 重写了方法
}

接口的高级特性：

// 空接口
func PrintAnything(v interface{}) {
    fmt.Printf("Value: %v, Type: %T\n", v, v)
}

// 类型断言
func ProcessValue(v interface{}) {
    switch val := v.(type) {
    case string:
        fmt.Printf("String: %s\n", val)
    case int:
        fmt.Printf("Integer: %d\n", val)
    case Person:
        fmt.Printf("Person: %s\n", val.Name)
    default:
        fmt.Printf("Unknown type: %T\n", val)
    }
}

// 检查接口实现
func CheckImplementation(v interface{}) {
    if writer, ok := v.(Writer); ok {
        writer.Write([]byte("Hello"))
    }
}

实际应用示例：

// 定义数据库接口
type Database interface {
    Connect() error
    Close() error
    Query(sql string) ([]map[string]interface{}, error)
}

// MySQL实现
type MySQL struct {
    connectionString string
}

func (m *MySQL) Connect() error {
    // MySQL连接逻辑
    return nil
}

func (m *MySQL) Close() error {
    // MySQL关闭逻辑
    return nil
}

func (m *MySQL) Query(sql string) ([]map[string]interface{}, error) {
    // MySQL查询逻辑
    return nil, nil
}

// PostgreSQL实现
type PostgreSQL struct {
    connectionString string
}

func (p *PostgreSQL) Connect() error {
    // PostgreSQL连接逻辑
    return nil
}

func (p *PostgreSQL) Close() error {
    // PostgreSQL关闭逻辑
    return nil
}

func (p *PostgreSQL) Query(sql string) ([]map[string]interface{}, error) {
    // PostgreSQL查询逻辑
    return nil, nil
}

// 服务层使用接口
type UserService struct {
    db Database
}

func NewUserService(db Database) *UserService {
    return &UserService{db: db}
}

func (s *UserService) GetUsers() ([]map[string]interface{}, error) {
    return s.db.Query("SELECT * FROM users")
}

最佳实践：

• 接口应该小而专注，遵循单一职责原则
• 使用组合而非继承来构建复杂类型
• 接收者类型选择：值接收者用于不修改状态的方法，指针接收者用于修改状态或大型结构体
• 定义接口时考虑调用者的需求，而非实现者
• 使用嵌入来实现"is-a"关系
• 通过接口实现依赖注入和测试替换

How to connect and operate databases in Go? What are the commonly used database drivers?

考察点：数据库连接基础。

答案：

Go语言通过标准库database/sql包提供了统一的数据库接口，支持多种数据库驱动。通过导入相应的驱动包，可以操作不同类型的数据库，如MySQL、PostgreSQL、SQLite等。

常用数据库驱动：

// MySQL
import _ "github.com/go-sql-driver/mysql"

// PostgreSQL  
import _ "github.com/lib/pq"

// SQLite
import _ "github.com/mattn/go-sqlite3"

// SQL Server
import _ "github.com/denisenkom/go-mssqldb"

// Oracle
import _ "github.com/godror/godror"

基本数据库操作：

package main

import (
    "database/sql"
    "fmt"
    "log"
    _ "github.com/go-sql-driver/mysql"
)

type User struct {
    ID    int    `db:"id"`
    Name  string `db:"name"`
    Email string `db:"email"`
    Age   int    `db:"age"`
}

func main() {
    // 连接数据库
    dsn := "username:password@tcp(localhost:3306)/database_name?parseTime=true"
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        log.Fatal("Failed to connect to database:", err)
    }
    defer db.Close()
    
    // 测试连接
    if err := db.Ping(); err != nil {
        log.Fatal("Database ping failed:", err)
    }
    
    // 设置连接池参数
    db.SetMaxOpenConns(25)
    db.SetMaxIdleConns(5)
    db.SetConnMaxLifetime(time.Minute * 5)
    
    fmt.Println("Database connected successfully!")
}

CRUD操作实现：

// Create - 插入数据
func CreateUser(db *sql.DB, user User) (int64, error) {
    query := `INSERT INTO users (name, email, age) VALUES (?, ?, ?)`
    result, err := db.Exec(query, user.Name, user.Email, user.Age)
    if err != nil {
        return 0, err
    }
    
    id, err := result.LastInsertId()
    if err != nil {
        return 0, err
    }
    return id, nil
}

// Read - 查询单个用户
func GetUser(db *sql.DB, id int) (*User, error) {
    query := `SELECT id, name, email, age FROM users WHERE id = ?`
    row := db.QueryRow(query, id)
    
    var user User
    err := row.Scan(&user.ID, &user.Name, &user.Email, &user.Age)
    if err != nil {
        if err == sql.ErrNoRows {
            return nil, fmt.Errorf("user with id %d not found", id)
        }
        return nil, err
    }
    return &user, nil
}

// Read - 查询多个用户
func GetUsers(db *sql.DB) ([]User, error) {
    query := `SELECT id, name, email, age FROM users`
    rows, err := db.Query(query)
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    var users []User
    for rows.Next() {
        var user User
        err := rows.Scan(&user.ID, &user.Name, &user.Email, &user.Age)
        if err != nil {
            return nil, err
        }
        users = append(users, user)
    }
    
    if err = rows.Err(); err != nil {
        return nil, err
    }
    return users, nil
}

// Update - 更新用户
func UpdateUser(db *sql.DB, user User) error {
    query := `UPDATE users SET name = ?, email = ?, age = ? WHERE id = ?`
    result, err := db.Exec(query, user.Name, user.Email, user.Age, user.ID)
    if err != nil {
        return err
    }
    
    rowsAffected, err := result.RowsAffected()
    if err != nil {
        return err
    }
    
    if rowsAffected == 0 {
        return fmt.Errorf("user with id %d not found", user.ID)
    }
    return nil
}

// Delete - 删除用户
func DeleteUser(db *sql.DB, id int) error {
    query := `DELETE FROM users WHERE id = ?`
    result, err := db.Exec(query, id)
    if err != nil {
        return err
    }
    
    rowsAffected, err := result.RowsAffected()
    if err != nil {
        return err
    }
    
    if rowsAffected == 0 {
        return fmt.Errorf("user with id %d not found", id)
    }
    return nil
}

事务处理：

func TransferFunds(db *sql.DB, fromID, toID int, amount float64) error {
    // 开始事务
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    
    // 确保事务回滚（如果没有提交）
    defer func() {
        if err != nil {
            tx.Rollback()
        }
    }()
    
    // 扣减源账户余额
    _, err = tx.Exec("UPDATE accounts SET balance = balance - ? WHERE id = ?", amount, fromID)
    if err != nil {
        return err
    }
    
    // 增加目标账户余额
    _, err = tx.Exec("UPDATE accounts SET balance = balance + ? WHERE id = ?", amount, toID)
    if err != nil {
        return err
    }
    
    // 插入转账记录
    _, err = tx.Exec("INSERT INTO transfers (from_id, to_id, amount) VALUES (?, ?, ?)", 
        fromID, toID, amount)
    if err != nil {
        return err
    }
    
    // 提交事务
    return tx.Commit()
}

预处理语句：

func BulkInsertUsers(db *sql.DB, users []User) error {
    // 准备预处理语句
    stmt, err := db.Prepare("INSERT INTO users (name, email, age) VALUES (?, ?, ?)")
    if err != nil {
        return err
    }
    defer stmt.Close()
    
    // 批量插入
    for _, user := range users {
        _, err := stmt.Exec(user.Name, user.Email, user.Age)
        if err != nil {
            return err
        }
    }
    return nil
}

连接池配置和最佳实践：

func ConfigureDatabase(dsn string) (*sql.DB, error) {
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        return nil, err
    }
    
    // 连接池配置
    db.SetMaxOpenConns(25)                 // 最大打开连接数
    db.SetMaxIdleConns(5)                  // 最大空闲连接数
    db.SetConnMaxLifetime(time.Minute * 5) // 连接最大生存时间
    db.SetConnMaxIdleTime(time.Minute * 2) // 空闲连接最大时间
    
    // 测试连接
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()
    
    if err := db.PingContext(ctx); err != nil {
        db.Close()
        return nil, err
    }
    
    return db, nil
}

使用Context进行超时控制：

func GetUserWithTimeout(db *sql.DB, id int, timeout time.Duration) (*User, error) {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()
    
    query := `SELECT id, name, email, age FROM users WHERE id = ?`
    row := db.QueryRowContext(ctx, query, id)
    
    var user User
    err := row.Scan(&user.ID, &user.Name, &user.Email, &user.Age)
    if err != nil {
        return nil, err
    }
    return &user, nil
}

最佳实践：

• 总是使用预处理语句防止SQL注入
• 合理配置连接池参数，避免连接泄漏
• 使用事务保证数据一致性
• 在查询中使用Context进行超时控制
• 正确处理sql.ErrNoRows错误
• 及时关闭rows对象释放资源
• 使用数据库迁移工具管理schema变更
• 考虑使用ORM库（如GORM）简化开发

How to design and implement RESTful APIs in Go? What are the best practices?

考察点：RESTful API设计。

答案：

RESTful API是基于REST（Representational State Transfer）架构风格设计的Web API。在Go中，可以使用标准库net/http或第三方框架（如Gin、Echo）来实现RESTful API，遵循HTTP协议和REST设计原则。

RESTful API设计原则：

1. 资源导向：URL表示资源，使用名词而非动词
2. HTTP方法：使用GET、POST、PUT、DELETE等方法表示操作
3. 状态码：使用标准HTTP状态码表示响应状态
4. 无状态：每个请求独立，不依赖服务器状态
5. 统一接口：保持API接口的一致性

基本API实现：

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "strconv"
    "strings"
)

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

type APIResponse struct {
    Success bool        `json:"success"`
    Data    interface{} `json:"data,omitempty"`
    Error   string      `json:"error,omitempty"`
}

var users = []User{
    {ID: 1, Name: "张三", Email: "[email protected]"},
    {ID: 2, Name: "李四", Email: "[email protected]"},
}

func main() {
    http.HandleFunc("/api/users", usersHandler)
    http.HandleFunc("/api/users/", userHandler)
    
    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

// 用户集合处理器
func usersHandler(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case http.MethodGet:
        getUsers(w, r)
    case http.MethodPost:
        createUser(w, r)
    default:
        sendErrorResponse(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
}

// 单个用户处理器
func userHandler(w http.ResponseWriter, r *http.Request) {
    idStr := strings.TrimPrefix(r.URL.Path, "/api/users/")
    id, err := strconv.Atoi(idStr)
    if err != nil {
        sendErrorResponse(w, "Invalid user ID", http.StatusBadRequest)
        return
    }
    
    switch r.Method {
    case http.MethodGet:
        getUser(w, r, id)
    case http.MethodPut:
        updateUser(w, r, id)
    case http.MethodDelete:
        deleteUser(w, r, id)
    default:
        sendErrorResponse(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
}

CRUD操作实现：

// GET /api/users - 获取所有用户
func getUsers(w http.ResponseWriter, r *http.Request) {
    sendSuccessResponse(w, users, http.StatusOK)
}

// GET /api/users/{id} - 获取特定用户
func getUser(w http.ResponseWriter, r *http.Request, id int) {
    for _, user := range users {
        if user.ID == id {
            sendSuccessResponse(w, user, http.StatusOK)
            return
        }
    }
    sendErrorResponse(w, "User not found", http.StatusNotFound)
}

// POST /api/users - 创建用户
func createUser(w http.ResponseWriter, r *http.Request) {
    var newUser User
    if err := json.NewDecoder(r.Body).Decode(&newUser); err != nil {
        sendErrorResponse(w, "Invalid JSON", http.StatusBadRequest)
        return
    }
    
    // 验证必填字段
    if newUser.Name == "" || newUser.Email == "" {
        sendErrorResponse(w, "Name and email are required", http.StatusBadRequest)
        return
    }
    
    // 生成新ID
    newUser.ID = len(users) + 1
    users = append(users, newUser)
    
    sendSuccessResponse(w, newUser, http.StatusCreated)
}

// PUT /api/users/{id} - 更新用户
func updateUser(w http.ResponseWriter, r *http.Request, id int) {
    var updatedUser User
    if err := json.NewDecoder(r.Body).Decode(&updatedUser); err != nil {
        sendErrorResponse(w, "Invalid JSON", http.StatusBadRequest)
        return
    }
    
    for i, user := range users {
        if user.ID == id {
            updatedUser.ID = id
            users[i] = updatedUser
            sendSuccessResponse(w, updatedUser, http.StatusOK)
            return
        }
    }
    sendErrorResponse(w, "User not found", http.StatusNotFound)
}

// DELETE /api/users/{id} - 删除用户
func deleteUser(w http.ResponseWriter, r *http.Request, id int) {
    for i, user := range users {
        if user.ID == id {
            users = append(users[:i], users[i+1:]...)
            sendSuccessResponse(w, map[string]string{"message": "User deleted"}, http.StatusOK)
            return
        }
    }
    sendErrorResponse(w, "User not found", http.StatusNotFound)
}

响应处理辅助函数：

func sendSuccessResponse(w http.ResponseWriter, data interface{}, statusCode int) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(statusCode)
    
    response := APIResponse{
        Success: true,
        Data:    data,
    }
    
    json.NewEncoder(w).Encode(response)
}

func sendErrorResponse(w http.ResponseWriter, message string, statusCode int) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(statusCode)
    
    response := APIResponse{
        Success: false,
        Error:   message,
    }
    
    json.NewEncoder(w).Encode(response)
}

使用Gin框架的简化实现：

package main

import (
    "net/http"
    "strconv"
    
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    
    // API路由组
    api := r.Group("/api/v1")
    {
        api.GET("/users", getUsers)
        api.GET("/users/:id", getUser)
        api.POST("/users", createUser)
        api.PUT("/users/:id", updateUser)
        api.DELETE("/users/:id", deleteUser)
    }
    
    r.Run(":8080")
}

func getUsers(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{
        "success": true,
        "data":    users,
    })
}

func getUser(c *gin.Context) {
    id, err := strconv.Atoi(c.Param("id"))
    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{
            "success": false,
            "error":   "Invalid user ID",
        })
        return
    }
    
    for _, user := range users {
        if user.ID == id {
            c.JSON(http.StatusOK, gin.H{
                "success": true,
                "data":    user,
            })
            return
        }
    }
    
    c.JSON(http.StatusNotFound, gin.H{
        "success": false,
        "error":   "User not found",
    })
}

API版本管理：

// 路径版本控制
r.Group("/api/v1")
r.Group("/api/v2")

// 请求头版本控制
func VersionMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        version := c.GetHeader("API-Version")
        if version == "" {
            version = "v1"
        }
        c.Set("version", version)
        c.Next()
    }
}

输入验证和错误处理：

type CreateUserRequest struct {
    Name  string `json:"name" binding:"required,min=2"`
    Email string `json:"email" binding:"required,email"`
}

func createUser(c *gin.Context) {
    var req CreateUserRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{
            "success": false,
            "error":   err.Error(),
        })
        return
    }
    
    // 创建用户逻辑...
}

RESTful API最佳实践：

1. URL设计：使用复数名词，遵循层级结构
2. HTTP状态码：正确使用2xx、4xx、5xx状态码
3. 响应格式：统一JSON响应格式，包含成功状态和数据
4. 错误处理：提供详细的错误信息和错误码
5. 版本控制：通过URL路径或请求头管理API版本
6. 分页处理：对列表接口实现分页、排序、过滤
7. 安全性：实现认证、授权、输入验证、CORS
8. 文档化：提供清晰的API文档和使用示例
9. 幂等性：确保PUT和DELETE操作的幂等性
10. 缓存策略：合理使用HTTP缓存头提高性能

What is middleware in Go web development? How to develop and use middleware?

考察点：中间件开发和使用。

答案：

中间件是在HTTP请求处理流程中插入的函数，用于处理横切关注点（如认证、日志、CORS等）。中间件按照洋葱模型执行，可以在请求处理前后执行特定逻辑，实现代码复用和关注点分离。

标准库中间件实现：

// 中间件类型定义
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()
        
        // 创建响应记录器
        rec := &responseRecorder{
            ResponseWriter: w,
            statusCode:     http.StatusOK,
        }
        
        // 执行下一个处理器
        next.ServeHTTP(rec, r)
        
        // 记录日志
        log.Printf("%s %s %d %v", 
            r.Method, r.URL.Path, rec.statusCode, time.Since(start))
    })
}

// 响应记录器，用于捕获状态码
type responseRecorder struct {
    http.ResponseWriter
    statusCode int
}

func (rec *responseRecorder) WriteHeader(code int) {
    rec.statusCode = code
    rec.ResponseWriter.WriteHeader(code)
}

// 认证中间件
func AuthMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token == "" {
            http.Error(w, "Missing authorization token", http.StatusUnauthorized)
            return
        }
        
        // 验证token逻辑
        if !validateToken(token) {
            http.Error(w, "Invalid token", http.StatusUnauthorized)
            return
        }
        
        // 将用户信息添加到context
        ctx := context.WithValue(r.Context(), "userID", extractUserID(token))
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

// 使用中间件
func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/api/public", publicHandler)
    mux.HandleFunc("/api/private", privateHandler)
    
    // 链式应用中间件
    handler := LoggingMiddleware(AuthMiddleware(mux))
    
    log.Fatal(http.ListenAndServe(":8080", handler))
}

中间件链管理：

// 中间件链构建器
type MiddlewareChain struct {
    middlewares []Middleware
}

func NewMiddlewareChain() *MiddlewareChain {
    return &MiddlewareChain{
        middlewares: make([]Middleware, 0),
    }
}

func (mc *MiddlewareChain) Use(middleware Middleware) *MiddlewareChain {
    mc.middlewares = append(mc.middlewares, middleware)
    return mc
}

func (mc *MiddlewareChain) Then(handler http.Handler) http.Handler {
    if len(mc.middlewares) == 0 {
        return handler
    }
    
    // 从右到左包装中间件
    wrapped := handler
    for i := len(mc.middlewares) - 1; i >= 0; i-- {
        wrapped = mc.middlewares[i](wrapped)
    }
    
    return wrapped
}

// 使用中间件链
func main() {
    chain := NewMiddlewareChain().
        Use(LoggingMiddleware).
        Use(CORSMiddleware).
        Use(AuthMiddleware)
    
    handler := chain.Then(http.HandlerFunc(apiHandler))
    
    http.ListenAndServe(":8080", handler)
}

Gin框架中间件：

package main

import (
    "net/http"
    "time"
    
    "github.com/gin-gonic/gin"
)

// 自定义日志中间件
func CustomLogger() gin.HandlerFunc {
    return gin.LoggerWithFormatter(func(param gin.LogFormatterParams) string {
        return fmt.Sprintf("%s - [%s] \"%s %s %s %d %s \"%s\" %s\"\n",
            param.ClientIP,
            param.TimeStamp.Format(time.RFC1123),
            param.Method,
            param.Path,
            param.Request.Proto,
            param.StatusCode,
            param.Latency,
            param.Request.UserAgent(),
            param.ErrorMessage,
        )
    })
}

// JWT认证中间件
func JWTAuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("Authorization")
        if token == "" {
            c.JSON(http.StatusUnauthorized, gin.H{
                "error": "Missing authorization token",
            })
            c.Abort()
            return
        }
        
        // 验证JWT token
        userID, err := validateJWT(token)
        if err != nil {
            c.JSON(http.StatusUnauthorized, gin.H{
                "error": "Invalid token",
            })
            c.Abort()
            return
        }
        
        // 将用户ID存储到上下文
        c.Set("userID", userID)
        c.Next()
    }
}

// 限流中间件
func RateLimitMiddleware(maxRequests int, windowSize time.Duration) gin.HandlerFunc {
    // 使用内存存储，生产环境建议使用Redis
    store := make(map[string][]time.Time)
    var mu sync.Mutex
    
    return func(c *gin.Context) {
        mu.Lock()
        defer mu.Unlock()
        
        clientIP := c.ClientIP()
        now := time.Now()
        
        // 清理过期记录
        if requests, exists := store[clientIP]; exists {
            var validRequests []time.Time
            for _, reqTime := range requests {
                if now.Sub(reqTime) <= windowSize {
                    validRequests = append(validRequests, reqTime)
                }
            }
            store[clientIP] = validRequests
        }
        
        // 检查请求数量
        if len(store[clientIP]) >= maxRequests {
            c.JSON(http.StatusTooManyRequests, gin.H{
                "error": "Rate limit exceeded",
            })
            c.Abort()
            return
        }
        
        // 记录当前请求
        store[clientIP] = append(store[clientIP], now)
        c.Next()
    }
}

func main() {
    r := gin.New()
    
    // 全局中间件
    r.Use(CustomLogger())
    r.Use(gin.Recovery())
    r.Use(CORSMiddleware())
    
    // 公开路由
    public := r.Group("/api/public")
    {
        public.GET("/health", healthCheck)
        public.POST("/login", login)
    }
    
    // 需要认证的路由
    private := r.Group("/api/private")
    private.Use(JWTAuthMiddleware())
    private.Use(RateLimitMiddleware(100, time.Minute))
    {
        private.GET("/profile", getUserProfile)
        private.PUT("/profile", updateUserProfile)
    }
    
    r.Run(":8080")
}

常用中间件实现：

// CORS中间件
func CORSMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Header("Access-Control-Allow-Origin", "*")
        c.Header("Access-Control-Allow-Credentials", "true")
        c.Header("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With")
        c.Header("Access-Control-Allow-Methods", "POST, OPTIONS, GET, PUT, DELETE")
        
        if c.Request.Method == "OPTIONS" {
            c.AbortWithStatus(204)
            return
        }
        
        c.Next()
    }
}

// 错误处理中间件
func ErrorHandlerMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Next()
        
        // 检查是否有错误
        if len(c.Errors) > 0 {
            err := c.Errors.Last()
            
            switch err.Type {
            case gin.ErrorTypeBind:
                c.JSON(http.StatusBadRequest, gin.H{
                    "error": "Invalid request format",
                })
            case gin.ErrorTypePublic:
                c.JSON(http.StatusInternalServerError, gin.H{
                    "error": err.Error(),
                })
            default:
                c.JSON(http.StatusInternalServerError, gin.H{
                    "error": "Internal server error",
                })
            }
        }
    }
}

// 响应时间中间件
func ResponseTimeMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        c.Next()
        duration := time.Since(start)
        c.Header("X-Response-Time", duration.String())
    }
}

中间件测试：

func TestLoggingMiddleware(t *testing.T) {
    // 创建测试路由
    router := gin.New()
    router.Use(LoggingMiddleware())
    router.GET("/test", func(c *gin.Context) {
        c.JSON(200, gin.H{"message": "success"})
    })
    
    // 创建测试请求
    req, _ := http.NewRequest("GET", "/test", nil)
    w := httptest.NewRecorder()
    
    // 执行请求
    router.ServeHTTP(w, req)
    
    // 验证结果
    assert.Equal(t, 200, w.Code)
}

最佳实践：

• 中间件应该职责单一，专注处理一个关注点
• 在中间件中合理使用c.Abort()和c.Next()控制执行流
• 将共享数据通过Context传递给后续处理器
• 为中间件提供配置选项，增强灵活性
• 编写单元测试验证中间件功能
• 注意中间件的执行顺序，合理安排依赖关系
• 在生产环境中监控中间件性能影响

How to handle CORS cross-origin issues in Go APIs? What are the solutions?

考察点：CORS跨域处理。

答案：

CORS（Cross-Origin Resource Sharing）是一种允许Web页面从不同域名访问资源的机制。在Go API开发中，需要正确配置CORS头部来解决浏览器的跨域限制问题。

CORS基本概念：

• 简单请求：GET、POST（特定Content-Type）、HEAD请求
• 预检请求：复杂请求前的OPTIONS请求，用于验证是否允许跨域
• 凭证请求：包含Cookie或Authorization头的请求

标准库CORS实现：

package main

import (
    "log"
    "net/http"
)

// CORS中间件
func enableCORS(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 设置CORS头部
        w.Header().Set("Access-Control-Allow-Origin", "*")
        w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With")
        w.Header().Set("Access-Control-Allow-Credentials", "true")
        w.Header().Set("Access-Control-Max-Age", "86400") // 24小时
        
        // 处理预检请求
        if r.Method == "OPTIONS" {
            w.WriteHeader(http.StatusOK)
            return
        }
        
        next.ServeHTTP(w, r)
    })
}

func apiHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.Write([]byte(`{"message": "Hello CORS!"}`))
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/api/data", apiHandler)
    
    // 应用CORS中间件
    handler := enableCORS(mux)
    
    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", handler))
}

高级CORS配置：

type CORSConfig struct {
    AllowedOrigins     []string
    AllowedMethods     []string
    AllowedHeaders     []string
    ExposedHeaders     []string
    AllowCredentials   bool
    MaxAge             int
    AllowPrivateNetwork bool
}

func NewCORSMiddleware(config CORSConfig) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            origin := r.Header.Get("Origin")
            
            // 检查允许的域名
            if len(config.AllowedOrigins) > 0 {
                allowed := false
                for _, allowedOrigin := range config.AllowedOrigins {
                    if allowedOrigin == "*" || allowedOrigin == origin {
                        allowed = true
                        break
                    }
                }
                if !allowed {
                    http.Error(w, "CORS: origin not allowed", http.StatusForbidden)
                    return
                }
            }
            
            // 设置CORS头部
            if origin != "" {
                if contains(config.AllowedOrigins, "*") {
                    w.Header().Set("Access-Control-Allow-Origin", "*")
                } else {
                    w.Header().Set("Access-Control-Allow-Origin", origin)
                }
            }
            
            if len(config.AllowedMethods) > 0 {
                w.Header().Set("Access-Control-Allow-Methods", 
                    strings.Join(config.AllowedMethods, ", "))
            }
            
            if len(config.AllowedHeaders) > 0 {
                w.Header().Set("Access-Control-Allow-Headers", 
                    strings.Join(config.AllowedHeaders, ", "))
            }
            
            if len(config.ExposedHeaders) > 0 {
                w.Header().Set("Access-Control-Expose-Headers", 
                    strings.Join(config.ExposedHeaders, ", "))
            }
            
            if config.AllowCredentials {
                w.Header().Set("Access-Control-Allow-Credentials", "true")
            }
            
            if config.MaxAge > 0 {
                w.Header().Set("Access-Control-Max-Age", strconv.Itoa(config.MaxAge))
            }
            
            if config.AllowPrivateNetwork {
                w.Header().Set("Access-Control-Allow-Private-Network", "true")
            }
            
            // 处理预检请求
            if r.Method == "OPTIONS" {
                w.WriteHeader(http.StatusNoContent)
                return
            }
            
            next.ServeHTTP(w, r)
        })
    }
}

// 使用高级CORS配置
func main() {
    corsConfig := CORSConfig{
        AllowedOrigins:   []string{"http://localhost:3000", "https://example.com"},
        AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
        AllowedHeaders:   []string{"Content-Type", "Authorization", "X-API-Key"},
        ExposedHeaders:   []string{"X-Total-Count", "X-Page-Count"},
        AllowCredentials: true,
        MaxAge:          86400,
    }
    
    corsMiddleware := NewCORSMiddleware(corsConfig)
    
    mux := http.NewServeMux()
    mux.HandleFunc("/api/", apiHandler)
    
    handler := corsMiddleware(mux)
    log.Fatal(http.ListenAndServe(":8080", handler))
}

Gin框架CORS实现：

package main

import (
    "net/http"
    "time"
    
    "github.com/gin-contrib/cors"
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    
    // 使用gin-contrib/cors包
    r.Use(cors.New(cors.Config{
        AllowOrigins:     []string{"http://localhost:3000"},
        AllowMethods:     []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
        AllowHeaders:     []string{"Origin", "Content-Type", "Authorization"},
        ExposeHeaders:    []string{"Content-Length"},
        AllowCredentials: true,
        MaxAge:          12 * time.Hour,
    }))
    
    // 或者使用默认配置（允许所有域名）
    // r.Use(cors.Default())
    
    r.GET("/api/data", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{
            "message": "Hello CORS with Gin!",
        })
    })
    
    r.Run(":8080")
}

// 自定义CORS中间件（Gin版本）
func CORSMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        origin := c.Request.Header.Get("Origin")
        
        // 动态设置允许的域名
        allowedOrigins := []string{
            "http://localhost:3000",
            "https://yourdomain.com",
        }
        
        for _, allowedOrigin := range allowedOrigins {
            if origin == allowedOrigin {
                c.Header("Access-Control-Allow-Origin", origin)
                break
            }
        }
        
        c.Header("Access-Control-Allow-Credentials", "true")
        c.Header("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With")
        c.Header("Access-Control-Allow-Methods", "POST, OPTIONS, GET, PUT, DELETE")
        
        if c.Request.Method == "OPTIONS" {
            c.AbortWithStatus(204)
            return
        }
        
        c.Next()
    }
}

处理复杂CORS场景：

// 根据环境动态配置CORS
func getCORSConfig() CORSConfig {
    if os.Getenv("ENV") == "production" {
        return CORSConfig{
            AllowedOrigins: []string{
                "https://yourdomain.com",
                "https://app.yourdomain.com",
            },
            AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE"},
            AllowedHeaders:   []string{"Content-Type", "Authorization"},
            AllowCredentials: true,
            MaxAge:          86400,
        }
    }
    
    // 开发环境
    return CORSConfig{
        AllowedOrigins:   []string{"*"},
        AllowedMethods:   []string{"*"},
        AllowedHeaders:   []string{"*"},
        AllowCredentials: false,
        MaxAge:          86400,
    }
}

// 处理子域名
func isSubdomain(origin, domain string) bool {
    return strings.HasSuffix(origin, "."+domain) || origin == domain
}

// 支持通配符域名
func matchOrigin(origin string, allowedOrigins []string) bool {
    for _, allowed := range allowedOrigins {
        if allowed == "*" {
            return true
        }
        if matched, _ := filepath.Match(allowed, origin); matched {
            return true
        }
    }
    return false
}

CORS安全最佳实践：

// 安全的CORS配置
func secureCORSMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        origin := c.Request.Header.Get("Origin")
        
        // 白名单验证
        allowedOrigins := []string{
            "https://yourdomain.com",
            "https://app.yourdomain.com",
        }
        
        allowed := false
        for _, allowedOrigin := range allowedOrigins {
            if origin == allowedOrigin {
                allowed = true
                c.Header("Access-Control-Allow-Origin", origin)
                break
            }
        }
        
        if !allowed && origin != "" {
            c.JSON(http.StatusForbidden, gin.H{
                "error": "CORS: origin not allowed",
            })
            c.Abort()
            return
        }
        
        // 严格的头部控制
        c.Header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE")
        c.Header("Access-Control-Allow-Headers", "Content-Type, Authorization")
        c.Header("Access-Control-Allow-Credentials", "true")
        c.Header("Access-Control-Max-Age", "3600") // 1小时
        
        if c.Request.Method == "OPTIONS" {
            c.AbortWithStatus(http.StatusNoContent)
            return
        }
        
        c.Next()
    }
}

不同解决方案对比：

1. 通配符（*）：简单但不安全，不支持凭证
2. 白名单：安全但需要维护域名列表
3. 反向代理：通过Nginx等代理服务器处理CORS
4. JSONP：仅支持GET请求的传统跨域方案

最佳实践：

• 生产环境避免使用通配符，明确指定允许的域名
• 合理设置MaxAge减少预检请求频率
• 只暴露必要的HTTP头部
• 根据API需求决定是否允许凭证
• 记录和监控CORS相关的错误请求
• 在开发和生产环境使用不同的CORS配置

How to implement JWT authentication in Go? What are the security considerations?

考察点：JWT认证实现。

答案：

JWT（JSON Web Token）是一种开放标准，用于在各方之间安全地传输信息。它由Header、Payload和Signature三部分组成，广泛用于Web应用的身份验证和授权。

基本JWT实现：

package main

import (
    "time"
    "github.com/golang-jwt/jwt/v5"
)

type Claims struct {
    UserID   string `json:"user_id"`
    Username string `json:"username"`
    Role     string `json:"role"`
    jwt.RegisteredClaims
}

var jwtKey = []byte("your-secret-key")

// 生成JWT token
func GenerateJWT(userID, username, role string) (string, error) {
    expirationTime := time.Now().Add(24 * time.Hour)
    
    claims := &Claims{
        UserID:   userID,
        Username: username,
        Role:     role,
        RegisteredClaims: jwt.RegisteredClaims{
            ExpiresAt: jwt.NewNumericDate(expirationTime),
            IssuedAt:  jwt.NewNumericDate(time.Now()),
            Issuer:    "your-app",
            Subject:   userID,
        },
    }
    
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    return token.SignedString(jwtKey)
}

// 验证JWT token
func ValidateJWT(tokenString string) (*Claims, error) {
    claims := &Claims{}
    
    token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
        return jwtKey, nil
    })
    
    if err != nil || !token.Valid {
        return nil, err
    }
    
    return claims, nil
}

// JWT中间件
func JWTMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        tokenString := r.Header.Get("Authorization")
        if tokenString == "" {
            http.Error(w, "Missing authorization token", http.StatusUnauthorized)
            return
        }
        
        // 移除 "Bearer " 前缀
        if len(tokenString) > 7 && tokenString[:7] == "Bearer " {
            tokenString = tokenString[7:]
        }
        
        claims, err := ValidateJWT(tokenString)
        if err != nil {
            http.Error(w, "Invalid token", http.StatusUnauthorized)
            return
        }
        
        // 将用户信息添加到context
        ctx := context.WithValue(r.Context(), "userID", claims.UserID)
        ctx = context.WithValue(ctx, "role", claims.Role)
        
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

安全注意事项：

• 使用强密钥并定期轮换
• 设置合理的过期时间
• 实现token刷新机制
• 在HTTPS下传输token
• 实现token黑名单机制
• 避免在JWT中存储敏感信息

Go web framework selection: differences and use cases of Gin, Echo, Fiber?

考察点：Web框架选择。

答案：

Go有多种优秀的Web框架，Gin、Echo、Fiber是最受欢迎的三个框架，各有特点和适用场景。

框架对比：

Gin框架：

// Gin - 简洁高效
func main() {
    r := gin.Default()
    
    // 中间件
    r.Use(gin.Logger())
    r.Use(gin.Recovery())
    
    // 路由组
    v1 := r.Group("/api/v1")
    {
        v1.GET("/users", getUsers)
        v1.POST("/users", createUser)
    }
    
    r.Run(":8080")
}

Echo框架：

// Echo - 功能丰富
func main() {
    e := echo.New()
    
    // 中间件
    e.Use(middleware.Logger())
    e.Use(middleware.Recover())
    
    // 路由
    e.GET("/users", getUsers)
    e.POST("/users", createUser)
    
    e.Start(":8080")
}

Fiber框架：

// Fiber - Express.js风格
func main() {
    app := fiber.New()
    
    // 中间件
    app.Use(logger.New())
    app.Use(recover.New())
    
    // 路由
    app.Get("/users", getUsers)
    app.Post("/users", createUser)
    
    app.Listen(":8080")
}

适用场景：

• Gin：微服务、API开发、快速原型
• Echo：企业级应用、复杂路由、WebSocket
• Fiber：高性能应用、实时应用、Node.js迁移

How to use ORM in Go? Basic usage and best practices of GORM?

考察点：ORM使用。

答案：

GORM是Go语言最受欢迎的ORM库，提供了友好的API来操作数据库。它支持多种数据库，具有自动迁移、关联查询、钩子函数等强大功能。

基本使用：

import (
    "gorm.io/gorm"
    "gorm.io/driver/mysql"
)

type User struct {
    ID        uint      `gorm:"primaryKey"`
    Name      string    `gorm:"size:100;not null"`
    Email     string    `gorm:"uniqueIndex"`
    Age       int
    CreatedAt time.Time
    UpdatedAt time.Time
}

// 连接数据库
func initDB() *gorm.DB {
    dsn := "user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }
    
    // 自动迁移
    db.AutoMigrate(&User{})
    return db
}

// CRUD操作
func userOperations(db *gorm.DB) {
    // 创建
    user := User{Name: "张三", Email: "[email protected]", Age: 25}
    db.Create(&user)
    
    // 查询
    var users []User
    db.Find(&users)
    
    var user User
    db.First(&user, 1) // 根据ID查询
    db.Where("name = ?", "张三").First(&user)
    
    // 更新
    db.Model(&user).Update("Age", 26)
    db.Model(&user).Updates(User{Name: "李四", Age: 27})
    
    // 删除
    db.Delete(&user, 1)
}

关联关系：

type User struct {
    ID      uint
    Name    string
    Profile Profile `gorm:"constraint:OnUpdate:CASCADE,OnDelete:SET NULL;"`
    Orders  []Order
}

type Profile struct {
    ID     uint
    UserID uint
    Bio    string
}

type Order struct {
    ID     uint
    UserID uint
    Amount float64
}

// 预加载关联
db.Preload("Profile").Preload("Orders").Find(&users)

最佳实践：

• 使用事务处理复杂操作
• 合理使用索引和约束
• 避免N+1查询问题
• 使用批量操作提高性能
• 定期进行数据库优化

How to generate documentation for Go APIs? What are the version management strategies?

考察点：API文档和版本管理。

答案：

API文档是开发和维护的重要环节。Go生态系统提供了多种工具来生成和管理API文档，同时需要合理的版本管理策略。

Swagger文档生成：

// 使用swaggo/swag生成Swagger文档
package main

// @title           Go API 文档
// @version         1.0
// @description     这是一个示例API服务器
// @host           localhost:8080
// @BasePath       /api/v1

import (
    "github.com/gin-gonic/gin"
    "github.com/swaggo/gin-swagger"
    "github.com/swaggo/files"
)

// GetUsers godoc
// @Summary      获取用户列表
// @Description  获取所有用户信息
// @Tags         users
// @Accept       json
// @Produce      json
// @Param        page    query     int  false  "页码"
// @Param        limit   query     int  false  "每页数量"
// @Success      200  {array}   User
// @Failure      400  {object}  ErrorResponse
// @Router       /users [get]
func GetUsers(c *gin.Context) {
    // 实现逻辑
}

func main() {
    r := gin.Default()
    
    // Swagger文档路由
    r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))
    
    r.Run()
}

版本管理策略：

// 1. URL路径版本控制
v1 := r.Group("/api/v1")
v2 := r.Group("/api/v2")

// 2. 请求头版本控制
func VersionMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        version := c.GetHeader("Accept-Version")
        if version == "" {
            version = "v1"
        }
        c.Set("api_version", version)
        c.Next()
    }
}

// 3. 参数版本控制
func GetUsers(c *gin.Context) {
    version := c.Query("version")
    switch version {
    case "v2":
        // v2 logic
    default:
        // v1 logic
    }
}

文档生成工具：

• Swagger/OpenAPI：标准化API文档
• godoc：Go标准文档工具
• Postman：API测试和文档平台

最佳实践：

• 保持文档与代码同步
• 提供完整的示例和错误码
• 使用语义化版本控制
• 维护向后兼容性
• 及时废弃旧版本API

What is the testing strategy for Go applications? How to perform unit testing and integration testing?

考察点：测试和调试策略。

答案：

Go内置了强大的测试框架，支持单元测试、集成测试、基准测试等。合理的测试策略能够保证代码质量和系统稳定性。

单元测试：

// user.go
type UserService struct {
    db *sql.DB
}

func (s *UserService) GetUser(id int) (*User, error) {
    user := &User{}
    err := s.db.QueryRow("SELECT id, name FROM users WHERE id = ?", id).
        Scan(&user.ID, &user.Name)
    if err != nil {
        return nil, err
    }
    return user, nil
}

// user_test.go
import (
    "testing"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
)

func TestUserService_GetUser(t *testing.T) {
    // 表格驱动测试
    tests := []struct {
        name    string
        userID  int
        want    *User
        wantErr bool
    }{
        {"valid user", 1, &User{ID: 1, Name: "张三"}, false},
        {"user not found", 999, nil, true},
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            // 测试逻辑
            service := &UserService{db: mockDB}
            user, err := service.GetUser(tt.userID)
            
            if tt.wantErr {
                assert.Error(t, err)
                assert.Nil(t, user)
            } else {
                assert.NoError(t, err)
                assert.Equal(t, tt.want, user)
            }
        })
    }
}

集成测试：

func TestAPIIntegration(t *testing.T) {
    // 设置测试环境
    testDB := setupTestDB(t)
    defer cleanupTestDB(testDB)
    
    router := setupRouter(testDB)
    
    // 测试用例
    t.Run("Create and Get User", func(t *testing.T) {
        // 创建用户
        createReq := `{"name":"测试用户","email":"[email protected]"}`
        w := httptest.NewRecorder()
        req, _ := http.NewRequest("POST", "/api/users", strings.NewReader(createReq))
        req.Header.Set("Content-Type", "application/json")
        router.ServeHTTP(w, req)
        
        assert.Equal(t, 201, w.Code)
        
        // 获取用户
        w2 := httptest.NewRecorder()
        req2, _ := http.NewRequest("GET", "/api/users/1", nil)
        router.ServeHTTP(w2, req2)
        
        assert.Equal(t, 200, w2.Code)
    })
}

测试工具和框架：

• testify：断言和模拟框架
• GoMock：自动生成mock对象
• Ginkgo：BDD测试框架
• httptest：HTTP测试工具

测试最佳实践：

• 遵循AAA模式（Arrange, Act, Assert）
• 使用表格驱动测试
• 保持测试独立性
• 合理使用测试替身（Mock, Stub）
• 维护高测试覆盖率
• 编写可读性强的测试用例

How to design Go microservices architecture? How to implement inter-service communication?

考察点：微服务架构设计。

答案：

微服务架构将应用拆分为多个独立的服务，每个服务专注于特定的业务功能。在Go中实现微服务需要考虑服务发现、通信协议、数据一致性等关键问题。

微服务设计原则：

• 单一职责：每个服务负责一个业务领域
• 去中心化：服务自治，独立部署和扩展
• 面向失败设计：容错和降级机制
• 可观测性：日志、监控、链路追踪

服务间通信实现：

// 1. HTTP/REST通信
type UserServiceClient struct {
    baseURL string
    client  *http.Client
}

func (c *UserServiceClient) GetUser(ctx context.Context, userID string) (*User, error) {
    url := fmt.Sprintf("%s/users/%s", c.baseURL, userID)
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return nil, err
    }
    
    resp, err := c.client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    var user User
    return &user, json.NewDecoder(resp.Body).Decode(&user)
}

// 2. gRPC通信
service UserService {
    rpc GetUser(GetUserRequest) returns (User);
    rpc CreateUser(CreateUserRequest) returns (User);
}

// gRPC客户端
conn, err := grpc.Dial("user-service:50051", grpc.WithInsecure())
client := pb.NewUserServiceClient(conn)
user, err := client.GetUser(ctx, &pb.GetUserRequest{Id: "123"})

// 3. 消息队列异步通信
type EventBus struct {
    conn *amqp.Connection
}

func (eb *EventBus) PublishEvent(event Event) error {
    ch, err := eb.conn.Channel()
    if err != nil {
        return err
    }
    defer ch.Close()
    
    body, _ := json.Marshal(event)
    return ch.Publish("events", event.Type, false, false, amqp.Publishing{
        ContentType: "application/json",
        Body:        body,
    })
}

服务发现机制：

// 使用Consul进行服务注册和发现
type ServiceRegistry struct {
    client *consul.Client
}

func (sr *ServiceRegistry) RegisterService(service *consul.AgentServiceRegistration) error {
    return sr.client.Agent().ServiceRegister(service)
}

func (sr *ServiceRegistry) DiscoverService(serviceName string) ([]*consul.ServiceEntry, error) {
    return sr.client.Health().Service(serviceName, "", true, nil)
}

微服务模式：

• API网关：统一入口和路由
• 服务注册发现：动态服务管理
• 断路器：防止级联失败
• 配置中心：集中配置管理
• 分布式追踪：请求链路监控

How to implement API gateway and service governance in Go applications?

考察点：API网关和服务治理。

答案：

API网关是微服务架构的统一入口，负责请求路由、认证授权、限流熔断等功能。服务治理则确保服务的稳定性、可用性和可观测性。

API网关实现：

// 基本网关路由
type Gateway struct {
    services map[string]string // 服务映射
    lb       LoadBalancer      // 负载均衡器
}

func (g *Gateway) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 1. 认证授权
    if !g.authenticate(r) {
        http.Error(w, "Unauthorized", http.StatusUnauthorized)
        return
    }
    
    // 2. 限流检查
    if !g.rateLimiter.Allow() {
        http.Error(w, "Rate limit exceeded", http.StatusTooManyRequests)
        return
    }
    
    // 3. 路由转发
    service := g.extractService(r.URL.Path)
    target := g.lb.GetTarget(service)
    g.proxyRequest(w, r, target)
}

// 负载均衡
type LoadBalancer struct {
    targets map[string][]string
    current map[string]int
}

func (lb *LoadBalancer) GetTarget(service string) string {
    targets := lb.targets[service]
    if len(targets) == 0 {
        return ""
    }
    
    // 轮询算法
    idx := lb.current[service] % len(targets)
    lb.current[service]++
    return targets[idx]
}

服务治理组件：

// 1. 断路器模式
type CircuitBreaker struct {
    maxFailures int
    timeout     time.Duration
    state       State
    failures    int
    lastFailure time.Time
}

func (cb *CircuitBreaker) Call(fn func() error) error {
    if cb.state == Open {
        if time.Since(cb.lastFailure) > cb.timeout {
            cb.state = HalfOpen
        } else {
            return errors.New("circuit breaker is open")
        }
    }
    
    err := fn()
    if err != nil {
        cb.failures++
        cb.lastFailure = time.Now()
        if cb.failures >= cb.maxFailures {
            cb.state = Open
        }
    } else {
        cb.failures = 0
        cb.state = Closed
    }
    
    return err
}

// 2. 健康检查
type HealthChecker struct {
    services []string
    client   *http.Client
}

func (hc *HealthChecker) CheckHealth() map[string]bool {
    results := make(map[string]bool)
    for _, service := range hc.services {
        resp, err := hc.client.Get(service + "/health")
        results[service] = err == nil && resp.StatusCode == 200
    }
    return results
}

服务治理最佳实践：

• 实现服务熔断和降级机制
• 配置合理的超时和重试策略
• 建立服务监控和告警体系
• 使用分布式配置管理
• 实现优雅的服务上下线

What are the performance optimization strategies for Go applications? How to handle high concurrency scenarios?

考察点：性能优化和并发处理。

答案：

Go应用性能优化涉及内存管理、并发控制、I/O优化等多个层面。合理的优化策略能显著提升应用性能和并发处理能力。

性能优化策略：

// 1. 对象池减少GC压力
var bufferPool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 1024)
    },
}

func processData(data []byte) {
    buf := bufferPool.Get().([]byte)
    defer bufferPool.Put(buf)
    // 处理逻辑
}

// 2. 并发控制
type WorkerPool struct {
    workerNum int
    jobQueue  chan Job
    wg        sync.WaitGroup
}

func (wp *WorkerPool) Start() {
    for i := 0; i < wp.workerNum; i++ {
        wp.wg.Add(1)
        go wp.worker()
    }
}

func (wp *WorkerPool) worker() {
    defer wp.wg.Done()
    for job := range wp.jobQueue {
        job.Process()
    }
}

// 3. 连接池优化
type ConnectionPool struct {
    pool chan *Connection
    max  int
}

func (cp *ConnectionPool) Get() *Connection {
    select {
    case conn := <-cp.pool:
        return conn
    default:
        return cp.createConnection()
    }
}

// 4. 缓存策略
type Cache struct {
    data   map[string]interface{}
    mutex  sync.RWMutex
    expire time.Duration
}

func (c *Cache) Get(key string) (interface{}, bool) {
    c.mutex.RLock()
    defer c.mutex.RUnlock()
    value, exists := c.data[key]
    return value, exists
}

高并发处理：

• 使用goroutine池控制并发数
• 实现背压机制防止系统过载
• 合理使用channel缓冲
• 优化锁的粒度和使用
• 使用无锁数据结构

性能监控工具：

• pprof：性能分析工具
• go tool trace：执行追踪
• benchmarks：基准测试

How to design containerized deployment and CI/CD pipeline for Go applications?

考察点：容器化部署和CI/CD。

答案：

容器化部署使Go应用具备更好的可移植性和一致性。结合CI/CD流程可以实现自动化的构建、测试和部署。

Docker化：

# 多阶段构建
FROM golang:1.19-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 .

# 运行时镜像
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/

COPY --from=builder /app/main .
EXPOSE 8080
CMD ["./main"]

CI/CD Pipeline（GitHub Actions）：

name: CI/CD Pipeline

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - uses: actions/setup-go@v3
      with:
        go-version: 1.19
    - run: go test ./...
    
  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Build Docker image
      run: docker build -t myapp:${{ github.sha }} .
    - name: Push to registry
      run: |
        docker tag myapp:${{ github.sha }} registry.com/myapp:${{ github.sha }}
        docker push registry.com/myapp:${{ github.sha }}
        
  deploy:
    needs: build
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
    - name: Deploy to Kubernetes
      run: |
        kubectl set image deployment/myapp myapp=registry.com/myapp:${{ github.sha }}

Kubernetes部署：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: go-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: go-app
  template:
    metadata:
      labels:
        app: go-app
    spec:
      containers:
      - name: go-app
        image: myapp:latest
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "64Mi"
            cpu: "250m"
          limits:
            memory: "128Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10

How to implement monitoring and logging systems for Go applications?

考察点：监控和日志系统。

答案：

完善的监控和日志系统是保障Go应用稳定运行的关键。通过指标采集、日志聚合和告警机制，可以及时发现和解决问题。

指标监控（Prometheus）：

import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

var (
    httpRequestsTotal = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "http_requests_total",
            Help: "Total number of HTTP requests",
        },
        []string{"method", "endpoint", "status"},
    )
    
    httpDuration = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name: "http_request_duration_seconds",
            Help: "HTTP request duration in seconds",
        },
        []string{"method", "endpoint"},
    )
)

func init() {
    prometheus.MustRegister(httpRequestsTotal)
    prometheus.MustRegister(httpDuration)
}

// 监控中间件
func MetricsMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        
        rw := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
        next.ServeHTTP(rw, r)
        
        duration := time.Since(start)
        
        httpRequestsTotal.WithLabelValues(
            r.Method, 
            r.URL.Path, 
            strconv.Itoa(rw.statusCode),
        ).Inc()
        
        httpDuration.WithLabelValues(r.Method, r.URL.Path).Observe(duration.Seconds())
    })
}

结构化日志：

import (
    "github.com/sirupsen/logrus"
    "github.com/gin-gonic/gin"
)

// 配置日志
func setupLogger() {
    logrus.SetFormatter(&logrus.JSONFormatter{})
    logrus.SetLevel(logrus.InfoLevel)
    
    // 输出到文件
    file, err := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err == nil {
        logrus.SetOutput(file)
    }
}

// 日志中间件
func LoggerMiddleware() gin.HandlerFunc {
    return gin.LoggerWithFormatter(func(param gin.LogFormatterParams) string {
        logrus.WithFields(logrus.Fields{
            "timestamp":   param.TimeStamp.Format(time.RFC3339),
            "status":      param.StatusCode,
            "latency":     param.Latency,
            "client_ip":   param.ClientIP,
            "method":      param.Method,
            "path":        param.Path,
            "user_agent":  param.Request.UserAgent(),
        }).Info("HTTP Request")
        
        return ""
    })
}

分布式追踪：

import (
    "github.com/opentracing/opentracing-go"
    "github.com/jaegertracing/jaeger-client-go"
)

func initTracing() {
    tracer, closer, err := jaeger.NewTracer(
        "go-service",
        jaeger.NewConstSampler(true),
        jaeger.NewRemoteReporter(/* ... */),
    )
    if err != nil {
        log.Fatal(err)
    }
    
    opentracing.SetGlobalTracer(tracer)
}

func TracingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        span := opentracing.StartSpan("http_request")
        defer span.Finish()
        
        ctx := opentracing.ContextWithSpan(r.Context(), span)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

监控最佳实践：

• 定义核心业务指标
• 设置合理的告警阈值
• 建立监控大盘和可视化
• 实现健康检查端点
• 监控系统资源使用情况

What are the security protection measures for Go applications? How to prevent common security vulnerabilities?

考察点：安全防护和漏洞防范。

答案：

Go应用安全防护需要从多个层面考虑，包括输入验证、认证授权、数据加密等。预防常见的Web安全漏洞是构建安全应用的基础。

输入验证和防护：

// 1. SQL注入防护
func getUserByID(db *sql.DB, userID string) (*User, error) {
    // 使用参数化查询
    query := "SELECT id, name, email FROM users WHERE id = ?"
    row := db.QueryRow(query, userID)
    
    var user User
    err := row.Scan(&user.ID, &user.Name, &user.Email)
    return &user, err
}

// 2. XSS防护
import "html/template"

func renderTemplate(w http.ResponseWriter, data interface{}) {
    tmpl := template.Must(template.New("page").Parse(`
        <h1>{{.Title}}</h1>
        <p>{{.Content}}</p>
    `))
    tmpl.Execute(w, data)
}

// 3. CSRF防护
func CSRFMiddleware(next http.Handler) http.Handler {
    return csrf.Protect(
        []byte("32-byte-long-auth-key"),
        csrf.Secure(false), // 开发环境设为false
    )(next)
}

认证和授权：

// JWT令牌验证
func validateJWT(tokenString string) (*Claims, error) {
    token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
            return nil, fmt.Errorf("unexpected signing method")
        }
        return jwtSecret, nil
    })
    
    if claims, ok := token.Claims.(*Claims); ok && token.Valid {
        return claims, nil
    }
    return nil, err
}

// 基于角色的访问控制
func RequireRole(role string) gin.HandlerFunc {
    return func(c *gin.Context) {
        userRole := c.GetString("role")
        if userRole != role {
            c.JSON(http.StatusForbidden, gin.H{"error": "Insufficient permissions"})
            c.Abort()
            return
        }
        c.Next()
    }
}

数据加密和安全存储：

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "golang.org/x/crypto/bcrypt"
)

// 密码哈希
func hashPassword(password string) (string, error) {
    bytes, err := bcrypt.GenerateFromPassword([]byte(password), 14)
    return string(bytes), err
}

func checkPasswordHash(password, hash string) bool {
    err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
    return err == nil
}

// AES加密
func encrypt(plaintext []byte, key []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }
    
    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }
    
    nonce := make([]byte, gcm.NonceSize())
    if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
        return nil, err
    }
    
    ciphertext := gcm.Seal(nonce, nonce, plaintext, nil)
    return ciphertext, nil
}

安全最佳实践：

• 使用HTTPS加密传输
• 实施输入验证和输出编码
• 定期更新依赖库
• 实现访问日志和审计
• 使用安全的默认配置
• 定期进行安全测试和代码审查

How to design Go distributed systems? How to implement distributed locks and transactions?

考察点：分布式系统设计。

答案：

分布式系统设计需要解决数据一致性、可用性和分区容错性问题。分布式锁和事务是保证数据一致性的重要机制。

分布式锁实现：

// 基于Redis的分布式锁
type RedisLock struct {
    client *redis.Client
    key    string
    value  string
    ttl    time.Duration
}

func NewRedisLock(client *redis.Client, key string, ttl time.Duration) *RedisLock {
    return &RedisLock{
        client: client,
        key:    key,
        value:  generateUUID(),
        ttl:    ttl,
    }
}

func (rl *RedisLock) TryLock(ctx context.Context) (bool, error) {
    result := rl.client.SetNX(ctx, rl.key, rl.value, rl.ttl)
    return result.Val(), result.Err()
}

func (rl *RedisLock) Unlock(ctx context.Context) error {
    script := `
        if redis.call("GET", KEYS[1]) == ARGV[1] then
            return redis.call("DEL", KEYS[1])
        else
            return 0
        end
    `
    return rl.client.Eval(ctx, script, []string{rl.key}, rl.value).Err()
}

// 使用分布式锁
func processWithLock(ctx context.Context, resourceID string) error {
    lock := NewRedisLock(redisClient, "lock:"+resourceID, 30*time.Second)
    
    acquired, err := lock.TryLock(ctx)
    if err != nil {
        return err
    }
    if !acquired {
        return errors.New("failed to acquire lock")
    }
    defer lock.Unlock(ctx)
    
    // 执行业务逻辑
    return processResource(resourceID)
}

分布式事务（Saga模式）：

type SagaStep struct {
    Action     func(ctx context.Context) error
    Compensate func(ctx context.Context) error
}

type Saga struct {
    steps     []SagaStep
    completed int
}

func (s *Saga) Execute(ctx context.Context) error {
    for i, step := range s.steps {
        if err := step.Action(ctx); err != nil {
            // 回滚已执行的步骤
            for j := i - 1; j >= 0; j-- {
                s.steps[j].Compensate(ctx)
            }
            return err
        }
        s.completed = i + 1
    }
    return nil
}

// 订单处理Saga示例
func CreateOrderSaga(orderID string) *Saga {
    return &Saga{
        steps: []SagaStep{
            {
                Action:     func(ctx context.Context) error { return reserveInventory(orderID) },
                Compensate: func(ctx context.Context) error { return releaseInventory(orderID) },
            },
            {
                Action:     func(ctx context.Context) error { return processPayment(orderID) },
                Compensate: func(ctx context.Context) error { return refundPayment(orderID) },
            },
            {
                Action:     func(ctx context.Context) error { return createOrder(orderID) },
                Compensate: func(ctx context.Context) error { return cancelOrder(orderID) },
            },
        },
    }
}

分布式系统模式：

• 服务网格：微服务间通信管理
• 事件溯源：通过事件重建状态
• CQRS：命令查询责任分离
• 最终一致性：异步数据同步

分布式系统设计原则：

• 容错性和降级策略
• 数据分片和负载均衡
• 监控和可观测性
• 一致性哈希和服务发现

How to deeply integrate Go backend services with modern frontend frameworks? What are the best practices?

考察点：与前端框架深度集成。

答案：

Go后端与现代前端框架集成需要考虑API设计、实时通信、状态同步等多个方面。良好的集成能够提供流畅的用户体验和高效的开发流程。

RESTful API集成：

// 统一的API响应格式
type APIResponse struct {
    Success   bool        `json:"success"`
    Data      interface{} `json:"data,omitempty"`
    Error     string      `json:"error,omitempty"`
    Meta      *Meta       `json:"meta,omitempty"`
}

type Meta struct {
    Total     int `json:"total"`
    Page      int `json:"page"`
    PerPage   int `json:"per_page"`
    PageCount int `json:"page_count"`
}

// 分页查询
func GetUsers(c *gin.Context) {
    page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
    perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "10"))
    
    users, total, err := userService.GetUsersPaginated(page, perPage)
    if err != nil {
        c.JSON(http.StatusInternalServerError, APIResponse{
            Success: false,
            Error:   err.Error(),
        })
        return
    }
    
    c.JSON(http.StatusOK, APIResponse{
        Success: true,
        Data:    users,
        Meta: &Meta{
            Total:     total,
            Page:      page,
            PerPage:   perPage,
            PageCount: (total + perPage - 1) / perPage,
        },
    })
}

WebSocket实时通信：

import (
    "github.com/gorilla/websocket"
)

type Hub struct {
    clients    map[*Client]bool
    broadcast  chan []byte
    register   chan *Client
    unregister chan *Client
}

type Client struct {
    hub  *Hub
    conn *websocket.Conn
    send chan []byte
}

func (h *Hub) Run() {
    for {
        select {
        case client := <-h.register:
            h.clients[client] = true
            
        case client := <-h.unregister:
            if _, ok := h.clients[client]; ok {
                delete(h.clients, client)
                close(client.send)
            }
            
        case message := <-h.broadcast:
            for client := range h.clients {
                select {
                case client.send <- message:
                default:
                    close(client.send)
                    delete(h.clients, client)
                }
            }
        }
    }
}

// WebSocket处理器
func handleWebSocket(hub *Hub, w http.ResponseWriter, r *http.Request) {
    upgrader := websocket.Upgrader{
        CheckOrigin: func(r *http.Request) bool { return true },
    }
    
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        return
    }
    
    client := &Client{
        hub:  hub,
        conn: conn,
        send: make(chan []byte, 256),
    }
    
    client.hub.register <- client
    
    go client.writePump()
    go client.readPump()
}

GraphQL集成：

import (
    "github.com/graphql-go/graphql"
    "github.com/graphql-go/handler"
)

// GraphQL Schema定义
var userType = graphql.NewObject(graphql.ObjectConfig{
    Name: "User",
    Fields: graphql.Fields{
        "id":    &graphql.Field{Type: graphql.String},
        "name":  &graphql.Field{Type: graphql.String},
        "email": &graphql.Field{Type: graphql.String},
    },
})

var queryType = graphql.NewObject(graphql.ObjectConfig{
    Name: "Query",
    Fields: graphql.Fields{
        "user": &graphql.Field{
            Type: userType,
            Args: graphql.FieldConfigArgument{
                "id": &graphql.ArgumentConfig{Type: graphql.String},
            },
            Resolve: func(params graphql.ResolveParams) (interface{}, error) {
                id := params.Args["id"].(string)
                return userService.GetUserByID(id)
            },
        },
    },
})

func setupGraphQL() {
    schema, _ := graphql.NewSchema(graphql.SchemaConfig{
        Query: queryType,
    })
    
    h := handler.New(&handler.Config{
        Schema:   &schema,
        Pretty:   true,
        GraphiQL: true,
    })
    
    http.Handle("/graphql", h)
}

服务端渲染（SSR）支持：

// 为Next.js提供API路由
func handleAPIRoute(w http.ResponseWriter, r *http.Request) {
    // 设置CORS头
    w.Header().Set("Access-Control-Allow-Origin", "http://localhost:3000")
    w.Header().Set("Access-Control-Allow-Credentials", "true")
    
    // 处理预检请求
    if r.Method == "OPTIONS" {
        w.WriteHeader(http.StatusOK)
        return
    }
    
    // API逻辑处理
    switch r.URL.Path {
    case "/api/data":
        handleDataAPI(w, r)
    default:
        http.NotFound(w, r)
    }
}

前后端集成最佳实践：

1. API设计原则：

   • 统一的响应格式和错误处理
   • RESTful URL设计和HTTP状态码
   • 版本管理和向后兼容性
   • 完整的API文档

2. 性能优化：

   • 实现数据缓存策略
   • 支持字段选择和数据预加载
   • 使用CDN加速静态资源
   • 实现接口防抖和节流

3. 安全考虑：

   • JWT认证和权限控制
   • CORS正确配置
   • 输入验证和SQL注入防护
   • HTTPS强制使用

4. 开发体验：

   • 热重载和自动重启
   • 统一的错误处理和日志
   • 接口mock和测试支持
   • 自动化部署流程

现代前端框架集成示例：

• React/Next.js：提供SSR API支持
• Vue/Nuxt.js：实现实时数据同步
• Angular：支持响应式数据流
• 移动端：提供统一的数据接口