1
2
3
4
5
6
7
8
9

// 一个能跑起来的 Web 服务器，就是这么朴实无华
package main

import "fmt"

func main() {
    fmt.Println("我是一个 Web 服务器！我在 8080 端口等待请求...")
    fmt.Println("但等等，我好像什么都没做——别急，net/http 帮我包揽了所有脏活累活")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// 这个例子演示了 net/http 的核心工作流程
// 1. 创建 ServeMux（路由器）
// 2. 注册 Handler（处理器）
// 3. 启动服务器
package main

import (
    "fmt"
    "net/http"
)

// HelloHandler 处理 /hello 路径的请求
func HelloHandler(w http.ResponseWriter, r *http.Request) {
    // ResponseWriter 用来写响应
    // *Request 包含请求的所有信息
    fmt.Fprint(w, "你好，HTTP 世界！")
}

func main() {
    // 创建路由器（ ServeMux 是 Go 内置的 HTTP 多路复用器）
    mux := http.NewServeMux()
    
    // 注册处理器：当有人访问 /hello 时，调用 HelloHandler
    mux.HandleFunc("/hello", HelloHandler)
    
    // 启动服务器，监听 8080 端口
    fmt.Println("服务器启动在 http://localhost:8080")
    fmt.Println("访问 http://localhost:8080/hello 看看效果")
    
    // ListenAndServe 是阻塞的，会一直运行直到服务器关闭
    http.ListenAndServe(":8080", mux)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

package main

import "net/http"

// 这就是传说中的 Handler 函数签名
// w = ResponseWriter，用来写响应
// r = *Request，包含请求的所有信息
func handler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Hello, Go HTTP Server!"))
}

func main() {
    // http.HandleFunc 注册一个函数作为 Handler
    // 第一个参数是路径，第二个是处理函数
    http.HandleFunc("/", handler)
    
    // 启动服务器，监听 8080 端口
    // 第二个参数 nil 表示使用默认的 ServeMux
    http.ListenAndServe(":8080", nil)
}

1
2

// 输出结果示例（浏览器访问 http://localhost:8080/）
// Hello, Go HTTP Server!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package main

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

func timeHandler(w http.ResponseWriter, r *http.Request) {
    // 写入当前时间
    fmt.Fprintf(w, "当前时间：%s", time.Now().Format("2006-01-02 15:04:05"))
}

func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "欢迎来到 Go HTTP 服务器！")
}

func aboutHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "这是一个关于页面，关于什么呢？关于 Go 的 net/http 有趣之处！")
}

func main() {
    // 注册多个路径的处理函数
    http.HandleFunc("/", homeHandler)       // 首页
    http.HandleFunc("/time", timeHandler)   // 当前时间
    http.HandleFunc("/about", aboutHandler) // 关于页

    fmt.Println("服务器启动：http://localhost:8080")
    fmt.Println("试试访问：/time 和 /about")
    
    // 启动服务器
    http.ListenAndServe(":8080", nil)
}

1
2
3
4

// 输出示例
// 访问 http://localhost:8080/      → 欢迎来到 Go HTTP 服务器！
// 访问 http://localhost:8080/time  → 当前时间：2024-03-15 14:30:45
// 访问 http://localhost:8080/about → 这是一个关于页面，关于什么呢？关于 Go 的 net/http 有趣之处！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// HandleFunc 的签名是这样的：
// func HandleFunc(pattern string, handler func(ResponseWriter, *Request))

// 内部等价于：
// func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
//     Handle(pattern, HandlerFunc(handler))
// }

// HandlerFunc(handler) 把普通函数转型为 http.HandlerFunc
// HandlerFunc 实现了 http.Handler 接口

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

package main

import (
    "fmt"
    "net/http"
)

// Counter 是一个状态管理器，统计访问次数
type Counter struct {
    count int
}

// ServeHTTP 方法让 Counter 成为一个 Handler
// 这是 http.Handler 接口的唯一方法
func (c *Counter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    c.count++
    fmt.Fprintf(w, "你是第 %d 位访客！", c.count)
}

// PageHandler 演示另一种写法——可以携带配置
type PageHandler struct {
    Title   string
    Content string
}

func (p *PageHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "<h1>%s</h1><p>%s</p>", p.Title, p.Content)
}

func main() {
    // 使用 http.Handle 注册实现了 http.Handler 的对象
    http.Handle("/counter", &Counter{})          // 计数器
    http.Handle("/page", &PageHandler{
        Title:   "动态页面",
        Content: "这是一个通过 Handler 对象生成的页面，可以携带配置！",
    })

    fmt.Println("服务器启动：http://localhost:8080")
    fmt.Println("访问 /counter 看看计数效果，访问 /page 看看配置效果")
    
    http.ListenAndServe(":8080", nil)
}

1
2
3
4
5
6
7
8

// 输出示例
// 访问 http://localhost:8080/counter
// 第一次访问 → 你是第 1 位访客！
// 第二次访问 → 你是第 2 位访客！
// 第三次访问 → 你是第 3 位访客！

// 访问 http://localhost:8080/page
// → <h1>动态页面</h1><p>这是一个通过 Handler 对象生成的页面，可以携带配置！</p>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package main

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

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello from ListenAndServe!")
}

func main() {
    // 注册处理器
    http.HandleFunc("/hello", helloHandler)

    fmt.Println("=== 启动 HTTP 服务器 ===")
    fmt.Println("监听地址：:8080")
    fmt.Println("按 Ctrl+C 停止服务器")

    // ListenAndServe 返回一个 error
    // 如果出错（比如端口被占用），会打印出来
    // 如果正常关闭（比如调用了 Shutdown），返回 nil
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatalf("服务器启动失败：%v", err)
    }
}

1
2
3
4
5

// 运行后终端输出：
// === 启动 HTTP 服务器 ===
// 监听地址：:8080
// 按 Ctrl+C 停止服务器
// [浏览器访问后] 127.0.0.1:59834: GET /hello HTTP/1.1 → 200

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 标准启动（使用默认 ServeMux）
http.ListenAndServe(":8080", nil)

// 指定自定义 ServeMux
mux := http.NewServeMux()
http.ListenAndServe(":8080", mux)

// 使用自定义 Server 结构体（更多配置，见 21.22 节）
srv := &http.Server{
    Addr:         ":8080",
    Handler:      mux,
    ReadTimeout:  10 * time.Second,
    WriteTimeout: 10 * time.Second,
}
srv.ListenAndServe()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

package main

import (
    "fmt"
    "net/http"
)

// 不同的处理器
func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "首页 - 这里是 Go HTTP 服务器！")
}

func productsHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "产品列表 - 我们有超棒的 Go 课程！")
}

func contactHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "联系我们 - 发邮件到 hi@example.com")
}

func main() {
    // 创建一个新的 ServeMux（路由器）
    mux := http.NewServeMux()

    // 注册路由规则
    mux.HandleFunc("/", homeHandler)           // 根路径
    mux.HandleFunc("/products", productsHandler) // /products
    mux.HandleFunc("/contact", contactHandler)  // /contact

    fmt.Println("ServeMux 路由演示服务器启动：http://localhost:8080")
    fmt.Println("可访问路径：/, /products, /contact")

    // 启动服务器，传入自定义的 mux
    http.ListenAndServe(":8080", mux)
}

1
2
3
4

// 输出示例
// 访问 http://localhost:8080/        → 首页 - 这里是 Go HTTP 服务器！
// 访问 http://localhost:8080/products → 产品列表 - 我们有超棒的 Go 课程！
// 访问 http://localhost:8080/contact → 联系我们 - 发邮件到 hi@example.com

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

package main

import (
    "fmt"
    "net/http"
)

func rootHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Handler: /  (根路径)")
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Handler: /hello  (hello路径)")
}

func helloNameHandler(w http.ResponseWriter, r *http.Request) {
    // 从 URL 中提取名字
    name := r.URL.Path[len("/hello/"):]
    fmt.Fprintf(w, "Handler: /hello/%s  (具体名字路径)", name)
}

func main() {
    mux := http.NewServeMux()

    // 关键点：注册顺序不影响匹配结果
    // ServeMux 总是选择最长匹配的路径
    mux.HandleFunc("/", rootHandler)
    mux.HandleFunc("/hello", helloHandler)        // 匹配 /hello
    mux.HandleFunc("/hello/", helloNameHandler)   // 匹配 /hello/*

    fmt.Println("路由匹配规则演示：http://localhost:8080")
    fmt.Println("最长路径优先匹配！")

    http.ListenAndServe(":8080", mux)
}

1
2
3
4
5

// 输出示例
// 访问 http://localhost:8080/         → Handler: /  (根路径)
// 访问 http://localhost:8080/hello    → Handler: /hello  (hello路径)
// 访问 http://localhost:8080/hello/Alice → Handler: /hello/Alice  (具体名字路径)
// 访问 http://localhost:8080/hello/Bob   → Handler: /hello/Bob  (具体名字路径)

1
2
3
4

// 源码（net/http 包定义）
type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

package main

import (
    "fmt"
    "net/http"
    "strings"
    "time"
)

// UppercaseHandler 将请求体转换为大写
type UppercaseHandler struct{}

func (h *UppercaseHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 从请求体读取内容
    body := r.PostFormValue("text")
    if body != "" {
        fmt.Fprint(w, strings.ToUpper(body))
    } else {
        fmt.Fprint(w, "请在 POST 请求的 form 中提交 text 参数")
    }
}

// TimeStampHandler 返回当前时间戳
type TimeStampHandler struct{}

func (h *TimeStampHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "服务器当前时间戳：%d", time.Now().Unix())
}

// 演示：普通函数如何适配 Handler 接口
type StatusHandler struct {
    statusCode int
    message    string
}

func (h *StatusHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(h.statusCode)
    fmt.Fprint(w, h.message)
}

func main() {
    mux := http.NewServeMux()

    // 注册实现 Handler 接口的类型
    mux.Handle("/uppercase", &UppercaseHandler{})
    mux.Handle("/timestamp", &TimeStampHandler{})
    mux.Handle("/notfound", &StatusHandler{404, "哎呀，页面走丢了！"})
    mux.Handle("/teapot", &StatusHandler{418, "我是一个茶壶 🫖"})

    fmt.Println("Handler 接口演示：http://localhost:8080")
    fmt.Println("/uppercase - POST 提交 text，返回大写")
    fmt.Println("/timestamp - 返回当前时间戳")
    fmt.Println("/notfound  - 返回 404")
    fmt.Println("/teapot    - 返回 418")

    http.ListenAndServe(":8080", mux)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 测试方式
// curl -X POST -d "text=hello world" http://localhost:8080/uppercase
// → HELLO WORLD

// curl http://localhost:8080/timestamp
// → 服务器当前时间戳：1710000000

// curl -i http://localhost:8080/notfound
// → HTTP/1.1 404
// → 哎呀，页面走丢了！

// curl -i http://localhost:8080/teapot
// → HTTP/1.1 418
// → 我是一个茶壶 🫖

1
2
3
4
5
6
7

// 源码本质（简化的理解）
type HandlerFunc func(ResponseWriter, *Request)

// HandlerFunc 实现了 Handler 接口！
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r)  // 调用的就是函数自身
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package main

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

func main() {
    mux := http.NewServeMux()

    // 方法一：直接传入普通函数（HandleFunc 内部会转为 HandlerFunc）
    mux.HandleFunc("/greet", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "你好，陌生人！")
    })

    // 方法二：显式使用 HandlerFunc 转型（等价，但更显式）
    // 这在需要把函数作为参数传递时很有用
    greetFunc := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "显式 HandlerFunc 版本：你好啊！")
    })
    mux.Handle("/greet-explicit", greetFunc)

    // 方法三：把已定义的函数赋值给 HandlerFunc 类型
    uppercase := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        text := r.URL.Query().Get("text")
        fmt.Fprint(w, strings.ToUpper(text))
    })
    mux.Handle("/uppercase", uppercase)

    fmt.Println("HandlerFunc 演示：http://localhost:8080")
    http.ListenAndServe(":8080", mux)
}

1
2
3
4

// 输出示例
// 访问 http://localhost:8080/greet           → 你好，陌生人！
// 访问 http://localhost:8080/greet-explicit  → 显式 HandlerFunc 版本：你好啊！
// 访问 http://localhost:8080/uppercase?text=hello → HELLO

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

package main

import (
    "fmt"
    "net/http"
)

func main() {
    mux := http.NewServeMux()

    // NotFoundHandler：返回 404 Not Found
    // 相当于 w.WriteHeader(404) + 写一个默认的 404 页面
    mux.Handle("/missing", http.NotFoundHandler())

    // RedirectHandler：重定向到另一个 URL
    // 参数：目标 URL，重定向状态码（301/302/303/307/308）
    mux.Handle("/old-page", http.RedirectHandler("http://localhost:8080/new-page", 302))
    mux.Handle("/new-page", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "欢迎来到新页面！你被重定向了。")
    }))

    // RedirectFunc：更简洁的函数式写法
    mux.HandleFunc("/home", func(w http.ResponseWriter, r *http.Request) {
        http.Redirect(w, r, "/new-page", 301)
    })

    fmt.Println("常用 Handler 演示：http://localhost:8080")
    fmt.Println("/missing   → 404 Not Found")
    fmt.Println("/old-page  → 302 重定向到 /new-page")
    fmt.Println("/home      → 301 重定向到 /new-page")

    http.ListenAndServe(":8080", mux)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 输出示例
// curl -i http://localhost:8080/missing
// → HTTP/1.1 404 Not Found
// → Content-Type: text/plain; charset=utf-8
// → 404 page not found

// curl -i http://localhost:8080/old-page
// → HTTP/1.1 302 Found
// → Location: http://localhost:8080/new-page
// → (跟随重定向后) → 欢迎来到新页面！你被重定向了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package main

import (
    "fmt"
    "net/http"
)

func main() {
    mux := http.NewServeMux()

    // 假设请求 /static/css/style.css
    // StripPrefix("/static", handler) 会：
    // 1. 把 "/static" 前缀去掉
    // 2. 把剩余路径 "/css/style.css" 交给 handler 处理
    // 3. handler 会去它的 root 目录（当前目录）下找 /css/style.css

    // 这里用一个简单的 Handler 演示（实际应该用 FileServer，见 21.14）
    mux.Handle("/static/", http.StripPrefix("/static/",
        http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            fmt.Fprintf(w, "你请求的文件路径（去除 /static 前缀后）: %s", r.URL.Path)
        }),
    ))

    fmt.Println("StripPrefix 演示：http://localhost:8080")
    fmt.Println("/static/css/style.css → 剥去 /static → 你请求的文件路径（去除 /static 前缀后）: /css/style.css")

    http.ListenAndServe(":8080", mux)
}

1
2
3

// 输出示例
// 访问 http://localhost:8080/static/css/style.css
// → 你请求的文件路径（去除 /static 前缀后）: /css/style.css

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

package main

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

func slowHandler(w http.ResponseWriter, r *http.Request) {
    duration := r.URL.Query().Get("wait")
    if duration == "" {
        duration = "5s"
    }
    d, _ := time.ParseDuration(duration)
    fmt.Printf("慢请求开始，要等 %s...\n", d)
    time.Sleep(d)
    fmt.Fprintf(w, "终于等到你了！等了 %s 才返回。", d)
}

func fastHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "快到没朋友！毫秒级响应！")
}

func main() {
    mux := http.NewServeMux()

    // 包装：最多只给 slowHandler 2 秒时间
    // 超时后返回 503 Service Unavailable
    mux.Handle("/slow",
        http.TimeoutHandler(
            http.HandlerFunc(slowHandler),
            2*time.Second,
            "请求超时了，老兄！503 Service Unavailable",
        ))

    // 这个不会超时
    mux.HandleFunc("/fast", fastHandler)

    fmt.Println("TimeoutHandler 演示：http://localhost:8080")
    fmt.Println("/slow?wait=5s → 等 5 秒 → 超时（最多 2 秒）→ 503")
    fmt.Println("/slow?wait=1s → 等 1 秒 → 成功返回")
    fmt.Println("/fast         → 立即返回")

    http.ListenAndServe(":8080", mux)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 输出示例
// curl http://localhost:8080/slow?wait=5s
// → 请求超时了，老兄！503 Service Unavailable
// （约 2 秒后返回）

// curl http://localhost:8080/slow?wait=1s
// → 终于等到你了！等了 1s 才返回。

// curl http://localhost:8080/fast
// → 快到没朋友！毫秒级响应！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package main

import (
    "fmt"
    "net/http"
)

func main() {
    mux := http.NewServeMux()

    // FileServer 接收一个 http.Dir 类型参数（就是文件系统路径）
    // 它会托管该目录下的所有文件
    // 当前目录下的 static/ 目录作为静态文件根目录
    mux.Handle("/static/",
        http.StripPrefix("/static/",
            http.FileServer(http.Dir("."))))

    fmt.Println("FileServer 演示服务器启动：http://localhost:8080")
    fmt.Println("访问 /static/<filename> 查看文件")
    fmt.Println("例如：http://localhost:8080/static/index.html")
    fmt.Println("(确保当前目录下有 static 目录和文件)")

    http.ListenAndServe(":8080", mux)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 输出示例
// 目录结构：
// .
// ├── main.go
// └── static/
//     ├── index.html
//     └── css/
//         └── style.css

// curl http://localhost:8080/static/index.html
// → (返回 index.html 的内容)

// curl http://localhost:8080/static/css/style.css
// → (返回 style.css 的内容)

// curl http://localhost:8080/static/nonexistent.txt
// → 404 page not found

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

package main

import (
    "fmt"
    "net/http"
)

func main() {
    mux := http.NewServeMux()

    mux.HandleFunc("/text", func(w http.ResponseWriter, r *http.Request) {
        // Write 接收 []byte，可以是文本也可以是二进制
        w.Write([]byte("这是一段纯文本响应"))
    })

    mux.HandleFunc("/html", func(w http.ResponseWriter, r *http.Request) {
        // 默认 Content-Type 是 text/plain
        // 如果返回 HTML，最好设置一下 Content-Type
        w.Header().Set("Content-Type", "text/html; charset=utf-8")
        w.Write([]byte("<h1>HTML 响应</h1><p>这是一个 HTML 页面</p>"))
    })

    mux.HandleFunc("/json", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        w.Write([]byte(`{"message": "你好，世界！", "code": 200}`))
    })

    mux.HandleFunc("/bytes", func(w http.ResponseWriter, r *http.Request) {
        // Write 可以写入任意字节数据
        data := []byte{0x48, 0x65, 0x6C, 0x6C, 0x6F} // "Hello" 的字节
        w.Write(data)
    })

    fmt.Println("ResponseWriter.Write 演示：http://localhost:8080")
    http.ListenAndServe(":8080", mux)
}

1
2
3
4
5
6
7
8
9

// 输出示例
// curl http://localhost:8080/text
// → 这是一段纯文本响应

// curl http://localhost:8080/html
// → <h1>HTML 响应</h1><p>这是一个 HTML 页面</p>

// curl -H "Accept: application/json" http://localhost:8080/json
// → {"message": "你好，世界！", "code": 200}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

package main

import (
    "fmt"
    "net/http"
)

func main() {
    mux := http.NewServeMux()

    mux.HandleFunc("/ok", func(w http.ResponseWriter, r *http.Request) {
        // 默认 200 OK，不需要显式调用
        fmt.Fprint(w, "一切正常！")
    })

    mux.HandleFunc("/not-found", func(w http.ResponseWriter, r *http.Request) {
        // 必须先 WriteHeader，再 Write
        w.WriteHeader(http.StatusNotFound) // 404
        fmt.Fprint(w, "404 - 页面走丢了！")
    })

    mux.HandleFunc("/server-error", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusInternalServerError) // 500
        fmt.Fprint(w, "500 - 服务器爆炸了！💥")
    })

    mux.HandleFunc("/custom", func(w http.ResponseWriter, r *http.Request) {
        // 429 = Too Many Requests
        w.WriteHeader(429)
        fmt.Fprint(w, "慢点慢点，你请求太快了！")
    })

    fmt.Println("WriteHeader 演示：http://localhost:8080")
    http.ListenAndServe(":8080", mux)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 输出示例
// curl -i http://localhost:8080/not-found
// → HTTP/1.1 404 Not Found
// → Content-Type: text/plain; charset=utf-8
// → 404 - 页面走丢了！

// curl -i http://localhost:8080/custom
// → HTTP/1.1 429 Unknown Status
// → Content-Type: text/plain; charset=utf-8
// → 慢点慢点，你请求太快了！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

package main

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

func main() {
    mux := http.NewServeMux()

    mux.HandleFunc("/headers", func(w http.ResponseWriter, r *http.Request) {
        h := w.Header()

        // 设置各种响应头
        h.Set("Content-Type", "text/plain; charset=utf-8")
        h.Set("X-Custom-Header", "Hello from Go!")
        h.Set("X-Server-Name", "Go-HTTP-Server/1.0")

        // 设置缓存头
        h.Set("Cache-Control", "max-age=3600")
        h.Set("Expires", time.Now().Add(time.Hour).Format(http.TimeFormat))

        // 设置 CORS 头
        h.Set("Access-Control-Allow-Origin", "*")
        h.Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE")

        // 追加多个值的响应头（同一 key 可以有多个 value）
        h.Add("X-Debug", "handler=headers")
        h.Add("X-Debug", "timestamp="+time.Now().Format(time.RFC3339))

        fmt.Fprint(w, "响应头已设置，用 curl -i 查看")
    })

    mux.HandleFunc("/read-headers", func(w http.ResponseWriter, r *http.Request) {
        // 读取请求头
        userAgent := r.Header.Get("User-Agent")
        accept := r.Header.Get("Accept")

        w.Header().Set("Content-Type", "text/plain")
        fmt.Fprintf(w, "User-Agent: %s\nAccept: %s\n", userAgent, accept)

        // 遍历所有请求头
        fmt.Fprintln(w, "\n--- 所有请求头 ---")
        for key, values := range r.Header {
            fmt.Fprintf(w, "%s: %s\n", key, values)
        }
    })

    fmt.Println("Header 演示：http://localhost:8080")
    http.ListenAndServe(":8080", mux)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 输出示例
// curl -i http://localhost:8080/headers
// → HTTP/1.1 200 OK
// → Content-Type: text/plain; charset=utf-8
// → X-Custom-Header: Hello from Go!
// → X-Server-Name: Go-HTTP-Server/1.0
// → Cache-Control: max-age=3600
// → Access-Control-Allow-Origin: *
// → X-Debug: handler=headers
// → X-Debug: timestamp=2024-03-15T10:30:00+08:00
// →
// → 响应头已设置，用 curl -i 查看

// curl -i -H "User-Agent: MyClient/1.0" http://localhost:8080/read-headers
// → User-Agent: MyClient/1.0
// → Accept: */*

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

package main

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

func main() {
    mux := http.NewServeMux()

    mux.HandleFunc("/info", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/plain; charset=utf-8")

        // Method: GET, POST, PUT, DELETE, etc.
        fmt.Fprintf(w, "Method: %s\n", r.Method)

        // URL: 请求的 URL 路径和查询参数
        fmt.Fprintf(w, "URL: %s\n", r.URL.String())
        fmt.Fprintf(w, "Path: %s\n", r.URL.Path)
        fmt.Fprintf(w, "RawQuery: %s\n", r.URL.RawQuery)

        // Proto: HTTP 协议版本
        fmt.Fprintf(w, "Proto: %s\n", r.Proto)

        // Host: 目标主机
        fmt.Fprintf(w, "Host: %s\n", r.Host)

        // RemoteAddr: 客户端 IP 地址
        fmt.Fprintf(w, "RemoteAddr: %s\n", r.RemoteAddr)

        fmt.Fprintln(w, "\n--- 请求头 ---")
        for key, values := range r.Header {
            fmt.Fprintf(w, "%s: %s\n", key, values)
        }
    })

    mux.HandleFunc("/body", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/plain")

        // Body: 请求体（io.ReadCloser，需要自己读取）
        // 记得读取后关闭
        defer r.Body.Close()

        body, err := io.ReadAll(r.Body)
        if err != nil {
            w.WriteHeader(http.StatusBadRequest)
            fmt.Fprint(w, "读取请求体失败")
            return
        }

        fmt.Fprintf(w, "Body 长度: %d 字节\n", len(body))
        fmt.Fprintf(w, "Body 内容: %s\n", string(body))
    })

    fmt.Println("Request 信息解析演示：http://localhost:8080")
    fmt.Println("访问 /info 查看请求信息，/body 读取 POST 请求体")
    http.ListenAndServe(":8080", mux)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 输出示例
// curl -X POST -H "Content-Type: text/plain" \
//      -d "Hello, Go!" http://localhost:8080/info
// → Method: POST
// → URL: /info
// → Path: /info
// → Proto: HTTP/1.1
// → Host: localhost:8080
// → RemoteAddr: 127.0.0.1:54321
// →
// --- 请求头 ---
// Content-Type: text/plain
// User-Agent: curl/8.1.2
// Accept: */*

// curl -X POST -d "Hello, Go!" http://localhost:8080/body
// → Body 长度: 10 字节
// → Body 内容: Hello, Go!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

package main

import (
    "fmt"
    "net/http"
)

func main() {
    mux := http.NewServeMux()

    mux.HandleFunc("/search", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/plain; charset=utf-8")

        // ParseForm() 会解析 URL 查询参数和 POST 表单数据
        // 如果不调用，直接访问 Form 会返回空值
        if err := r.ParseForm(); err != nil {
            fmt.Fprintf(w, "解析失败：%v", err)
            return
        }

        fmt.Fprintln(w, "=== Form（查询参数 + POST 表单）===")
        fmt.Fprintf(w, "q: %v\n", r.Form["q"])
        fmt.Fprintf(w, "category: %v\n", r.Form["category"])

        // PostForm 只包含 POST 表单数据（不包含 URL 查询参数）
        fmt.Fprintln(w, "\n=== PostForm（仅 POST 表单）===")
        fmt.Fprintf(w, "username: %v\n", r.PostForm["username"])
        fmt.Fprintf(w, "password: %v\n", r.PostForm["password"])

        // 单值快捷方式
        fmt.Fprintln(w, "\n=== 快捷取值 ===")
        fmt.Fprintf(w, "q (第一个): %s\n", r.FormValue("q"))
        fmt.Fprintf(w, "username (第一个): %s\n", r.PostFormValue("username"))
    })

    fmt.Println("Form 演示：http://localhost:8080")
    fmt.Println("GET /search?q=golang&category=tech     → 查询参数")
    fmt.Println("POST /search q=golang category=tech    → 表单数据")
    http.ListenAndServe(":8080", mux)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// 输出示例
// GET 请求
// curl "http://localhost:8080/search?q=golang&category=tech"
// → === Form（查询参数 + POST 表单）===
// → q: [golang]
// → category: [tech]
// → === PostForm（仅 POST 表单）===
// → username: []
// → password: []
// → === 快捷取值 ===
// → q (第一个): golang

// POST 表单请求
// curl -X POST -d "q=golang&category=tech&username=alice" http://localhost:8080/search
// → === Form ===
// → q: [golang]
// → category: [tech]
// → username: [alice]
// → === PostForm ===
// → username: [alice]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

package main

import (
    "fmt"
    "net/http"
)

func main() {
    mux := http.NewServeMux()

    mux.HandleFunc("/read-cookies", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/plain; charset=utf-8")

        // 读取指定名称的 Cookie
        username, err := r.Cookie("username")
        if err != nil {
            fmt.Fprintf(w, "username Cookie 不存在: %v\n", err)
        } else {
            fmt.Fprintf(w, "username Cookie: %s\n", username.Value)
        }

        sessionID, err := r.Cookie("session_id")
        if err != nil {
            fmt.Fprintf(w, "session_id Cookie 不存在: %v\n", err)
        } else {
            fmt.Fprintf(w, "session_id Cookie: %s\n", sessionID.Value)
        }

        // 读取所有 Cookie
        fmt.Fprintln(w, "\n--- 所有 Cookies ---")
        for _, c := range r.Cookies() {
            fmt.Fprintf(w, "%s = %s\n", c.Name, c.Value)
        }
    })

    mux.HandleFunc("/set-cookie", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/plain; charset=utf-8")

        // 设置 Cookie（通过 Set-Cookie 响应头）
        cookie := &http.Cookie{
            Name:     "username",
            Value:    "alice",
            Path:     "/",
            HttpOnly: true, // 不允许 JavaScript 访问（防 XSS）
            SameSite: http.SameSiteLaxMode,
            MaxAge:   3600, // 1 小时
        }
        http.SetCookie(w, cookie)

        fmt.Fprintln(w, "Cookie 已设置！")
        fmt.Fprintln(w, "请访问 /read-cookies 查看")
    })

    fmt.Println("Cookie 演示：http://localhost:8080")
    fmt.Println("1. 访问 /set-cookie 设置 Cookie")
    fmt.Println("2. 访问 /read-cookies 读取 Cookie")
    http.ListenAndServe(":8080", mux)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 输出示例
// 第一步：设置 Cookie
// curl -i http://localhost:8080/set-cookie
// → HTTP/1.1 200 OK
// → Set-Cookie: username=alice; Path=/; HttpOnly; Max-Age=3600
// → Cookie 已设置！

// 第二步：读取 Cookie（带上刚才的 Cookie）
// curl -i --cookie "username=alice;session_id=abc123" http://localhost:8080/read-cookies
// → username Cookie: alice
// → session_id Cookie: abc123
// → --- 所有 Cookies ---
// → username = alice
// → session_id = abc123

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

package main

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

func main() {
    mux := http.NewServeMux()

    mux.HandleFunc("/normal", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/plain")
        fmt.Fprintf(w, "普通请求，Context: %v", r.Context())
    })

    mux.HandleFunc("/with-timeout", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/plain")

        // 创建 2 秒超时的 Context
        ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
        defer cancel() // 很重要：防止内存泄漏

        // 创建带新 Context 的请求副本
        newReq := r.WithContext(ctx)

        // 模拟处理（使用新 Context）
        select {
        case <-newReq.Context().Done():
            fmt.Fprintf(w, "超时了！错误: %v", newReq.Context().Err())
        case <-time.After(1 * time.Second):
            fmt.Fprintf(w, "1秒后完成，使用了带超时的 Context: %v", newReq.Context())
        }
    })

    mux.HandleFunc("/with-value", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/plain")

        // 创建带值的 Context（用于传递请求级别数据）
        ctx := context.WithValue(r.Context(), "user_id", "alice123")
        ctx = context.WithValue(ctx, "trace_id", "trace-xyz-789")
        newReq := r.WithContext(ctx)

        // 在 Handler 的其他地方可以通过 newReq.Context() 获取
        userID := newReq.Context().Value("user_id")
        traceID := newReq.Context().Value("trace_id")

        fmt.Fprintf(w, "user_id=%v, trace_id=%v", userID, traceID)
    })

    fmt.Println("WithContext 演示：http://localhost:8080")
    http.ListenAndServe(":8080", mux)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 输出示例
// curl http://localhost:8080/normal
// → 普通请求，Context: context.Background

// curl http://localhost:8080/with-timeout
// → 1秒后完成，使用了带超时的 Context: context.Background

// curl "http://localhost:8080/with-timeout?wait=3"
// (等待 2 秒后)
// → 超时了！错误: context deadline exceeded

// curl http://localhost:8080/with-value
// → user_id=alice123, trace_id=trace-xyz-789

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

package main

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

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "你好！")
    })

    mux.HandleFunc("/slow", func(w http.ResponseWriter, r *http.Request) {
        time.Sleep(5 * time.Second)
        fmt.Fprint(w, "终于醒了！")
    })

    // 创建 Server 实例，配置各种参数
    srv := &http.Server{
        Addr:         ":8080", // 监听地址

        Handler:      mux,     // 路由器（如果为 nil，使用 DefaultServeMux）

        // 读取超时：从客户端读取请求头的最大时间
        // 如果客户端在这段时间内没有发送完请求头，连接被关闭
        ReadTimeout:  10 * time.Second,

        // 写入超时：向客户端写入响应的最大时间
        // 如果响应在这段时间内没写完，连接被关闭
        WriteTimeout: 10 * time.Second,

        // Idle 超时：keep-alive 连接在空闲时保持多久
        // Go 1.8+ 支持
        IdleTimeout:  120 * time.Second,

        // 最大请求头字节数
        MaxHeaderBytes: 1 << 20, // 1MB

        // ErrorLog：自定义错误日志（默认是标准 logger）
        // ErrorLog: log.New(os.Stderr, "http: ", log.LstdFlags),
    }

    fmt.Println("自定义 Server 配置演示：http://localhost:8080")
    fmt.Println("ReadTimeout:  10s")
    fmt.Println("WriteTimeout: 10s")

    // ListenAndServe 是阻塞的
    // 我们可以配合 context 做优雅关闭（见 21.23）
    if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
        log.Fatalf("服务器错误：%v", err)
    }
}