如何用Golang学习后端开发

从简单的开始。我已经多次给出这个建议，但一个仅供自己使用的简单任务追踪应用程序是一个有趣的入门方式。当我学习一个新的框架或任何东西时，我经常创建一个任务追踪应用（就像我前段时间为了学习Flutter而构建了一个）。试着找出一些听起来有趣的东西来构建，然后就去构建它！在我看来，除了结构化的学习环境之外，这是最好的学习方式。

如何用Golang学习后端开发

1. 从具体项目开始

不要从空白文件开始，先确定一个简单的项目目标。比如创建一个HTTP API服务器：

package main

import (
    "encoding/json"
    "log"
    "net/http"
)

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

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

func usersHandler(w http.ResponseWriter, r *http.Request) {
    users := []User{
        {ID: 1, Name: "Alice"},
        {ID: 2, Name: "Bob"},
    }
    
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(users)
}

2. 理解核心包的实际用法

以net/http为例，先掌握基本模式：

// 路由处理
http.HandleFunc("/api/health", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("OK"))
})

// 中间件模式
func loggingMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        log.Printf("%s %s", r.Method, r.URL.Path)
        next(w, r)
    }
}

// 使用goroutine处理并发
http.HandleFunc("/async", func(w http.ResponseWriter, r *http.Request) {
    go func() {
        // 异步处理任务
        processTask()
    }()
    w.Write([]byte("Task started"))
})

3. 数据库操作示例

使用标准库database/sql：

import (
    "database/sql"
    _ "github.com/lib/pq"
)

func connectDB() *sql.DB {
    db, err := sql.Open("postgres", "host=localhost user=postgres dbname=test sslmode=disable")
    if err != nil {
        log.Fatal(err)
    }
    return db
}

func queryUsers(db *sql.DB) ([]User, error) {
    rows, err := db.Query("SELECT id, name FROM users")
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    var users []User
    for rows.Next() {
        var u User
        if err := rows.Scan(&u.ID, &u.Name); err != nil {
            return nil, err
        }
        users = append(users, u)
    }
    return users, nil
}

4. 文件操作示例

使用bufio和io包：

import (
    "bufio"
    "os"
)

func readFileLines(filename string) ([]string, error) {
    file, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer file.Close()
    
    var lines []string
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        lines = append(lines, scanner.Text())
    }
    return lines, scanner.Err()
}

func writeToFile(filename, content string) error {
    file, err := os.Create(filename)
    if err != nil {
        return err
    }
    defer file.Close()
    
    writer := bufio.NewWriter(file)
    _, err = writer.WriteString(content)
    if err != nil {
        return err
    }
    return writer.Flush()
}

5. 完整的REST API示例

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "strconv"
    "github.com/gorilla/mux"
)

var users = map[int]User{
    1: {ID: 1, Name: "John"},
    2: {ID: 2, Name: "Jane"},
}

func main() {
    r := mux.NewRouter()
    
    r.HandleFunc("/users", getUsers).Methods("GET")
    r.HandleFunc("/users/{id}", getUser).Methods("GET")
    r.HandleFunc("/users", createUser).Methods("POST")
    
    log.Fatal(http.ListenAndServe(":8080", r))
}

func getUsers(w http.ResponseWriter, r *http.Request) {
    json.NewEncoder(w).Encode(users)
}

func getUser(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    id, _ := strconv.Atoi(vars["id"])
    
    if user, exists := users[id]; exists {
        json.NewEncoder(w).Encode(user)
    } else {
        http.Error(w, "User not found", http.StatusNotFound)
    }
}

func createUser(w http.ResponseWriter, r *http.Request) {
    var user User
    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    
    users[user.ID] = user
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}

6. 并发处理示例

func processRequests(requests []string) []string {
    results := make([]string, len(requests))
    var wg sync.WaitGroup
    
    for i, req := range requests {
        wg.Add(1)
        go func(idx int, request string) {
            defer wg.Done()
            results[idx] = handleRequest(request)
        }(i, req)
    }
    
    wg.Wait()
    return results
}

func handleRequest(req string) string {
    // 模拟处理逻辑
    time.Sleep(100 * time.Millisecond)
    return "Processed: " + req
}

从具体功能开始实现，逐步组合成完整应用。每个包都有明确的用途：net/http处理HTTP，database/sql处理数据库，bufio处理缓冲I/O。先实现核心功能，再考虑错误处理、日志、配置等。