原生 HTTP 服务 net/http

package main

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

// 普通函数，签名与 HandlerFunc 一致
func hello(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello, %s!\n", r.URL.Path)
}

func main() {
	// http.HandleFunc 内部把函数转成 HandlerFunc，再注册进默认的 DefaultServeMux
	http.HandleFunc("/hello", hello)

	log.Println("listening on :8080")
	log.Fatal(http.ListenAndServe(":8080", nil)) // nil = 使用 DefaultServeMux
}

type Greeter struct {
	Greeting string
}

func (g *Greeter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "%s, %s!\n", g.Greeting, r.URL.Path)
}

// 注册一个带状态的 Handler
g := &Greeter{Greeting: "你好"}
http.Handle("/", g)

package main

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

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

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

	// 路径字面量 + 方法限定
	mux.HandleFunc("GET /api/users", func(w http.ResponseWriter, r *http.Request) {
		json.NewEncoder(w).Encode([]User{{ID: 1, Name: "Tom"}})
	})

	// 路径参数 {id}，运行时用 r.PathValue 取
	mux.HandleFunc("GET /api/users/{id}", func(w http.ResponseWriter, r *http.Request) {
		id := r.PathValue("id")
		json.NewEncoder(w).Encode(User{ID: 1, Name: "用户" + id})
	})

	// POST 也能限定方法（不认识的方法直接 405）
	mux.HandleFunc("POST /api/users", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusCreated)
		json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
	})

	log.Println("listening on :8080")
	log.Fatal(http.ListenAndServe(":8080", mux))
}

package main

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

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("ok"))
	})

	srv := &http.Server{ // 注意是结构体，不是函数
		Addr:         ":8080",
		Handler:      mux,
		ReadTimeout:  5 * time.Second,   // 读取完整请求体的超时
		WriteTimeout: 10 * time.Second,  // 写出响应的超时
		IdleTimeout:  60 * time.Second,  // keep-alive 空闲连接保留时间
		MaxHeaderBytes: 1 << 20,         // 请求头上限 1MB
	}

	log.Printf("server on %s", srv.Addr)
	if err := srv.ListenAndServe(); err != nil {
		log.Fatal(err)
	}
}

package main

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

type Resp struct {
	Code int    `json:"code"`
	Msg  string `json:"msg"`
	Data any    `json:"data"`
}

func ok(w http.ResponseWriter, data any) {
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	json.NewEncoder(w).Encode(Resp{Code: 0, Msg: "ok", Data: data})
}

func fail(w http.ResponseWriter, status int, errMsg string) {
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.WriteHeader(status)
	json.NewEncoder(w).Encode(Resp{Code: status, Msg: errMsg})
}

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

	mux.HandleFunc("GET /api/user", func(w http.ResponseWriter, r *http.Request) {
		ok(w, map[string]string{"name": "Tom", "role": "admin"})
	})

	mux.HandleFunc("GET /api/missing", func(w http.ResponseWriter, r *http.Request) {
		fail(w, http.StatusNotFound, "user not found")
	})

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

package main

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

// 记录日志的中间件：包一层，执行自动记日志
func logging(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 withHeaders(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Server", "go-demo")
		next.ServeHTTP(w, r)
	})
}

// 恐慌恢复：防止单个 panic 挂掉整个进程
func recoverer(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			if err := recover(); err != nil {
				log.Printf("panic: %v", err)
				http.Error(w, "internal error", http.StatusInternalServerError)
			}
		}()
		next.ServeHTTP(w, r)
	})
}

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("home"))
	})

	// 多层包装：执行的顺序是 recoverer → withHeaders → logging → mux
	app := recoverer(withHeaders(logging(mux)))

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

package main

import (
	"context"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"
)

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("hello"))
	})

	srv := &http.Server{Addr: ":8080", Handler: mux}

	// 后台启动
	go func() {
		log.Printf("server on %s", srv.Addr)
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Fatalf("listen: %v", err)
		}
	}()

	// 等待退出信号
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
	log.Println("收到退出信号，开始优雅关闭...")

	// 给在飞请求最多 10s 收尾，然后强制结束
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	if err := srv.Shutdown(ctx); err != nil {
		log.Fatalf("shutdown: %v", err)
	}
	log.Println("server stopped")
}