1
package main
2

3
import (
4
    "net/http"
5
    "github.com/gin-gonic/gin"
6
)
7

8
func main() {
9
    // 创建默认引擎（自带Logger和Recovery中间件）
10
    r := gin.Default()
11

12
    // 定义一个GET路由
13
    r.GET("/hello", func(c *gin.Context) {
14
        c.JSON(http.StatusOK, gin.H{
15
            "message": "Hello, Gin!",
16
        })
17
    })
18

19
    // 启动服务，默认监听 :8080
20
    r.Run(":8080")
21
}

1
// gin.Default() = gin.New() + Logger() + Recovery()
2
r := gin.Default()
3

4
// gin.New() 不带任何中间件，完全自己控制
5
r := gin.New()
6
r.Use(gin.Logger())   // 手动添加日志
7
r.Use(gin.Recovery()) // 手动添加panic恢复

1
func main() {
2
    r := gin.Default()
3

4
    // 基本路由
5
    r.GET("/users", getUsers)
6
    r.POST("/users", createUser)
7
    r.PUT("/users/:id", updateUser)    // 路径参数
8
    r.DELETE("/users/:id", deleteUser)
9

10
    // 路由分组 —— 管理API版本非常方便
11
    v1 := r.Group("/api/v1")
12
    {
13
        v1.GET("/articles", getArticles)
14
        v1.POST("/articles", createArticle)
15
    }
16

17
    v2 := r.Group("/api/v2")
18
    {
19
        v2.GET("/articles", getArticlesV2)
20
    }
21

22
    r.Run()
23
}

1
// 路径参数：/user/123
2
r.GET("/user/:id", func(c *gin.Context) {
3
    id := c.Param("id") // "123"
4
})
5

6
// 查询参数：/search?keyword=go&page=1
7
r.GET("/search", func(c *gin.Context) {
8
    keyword := c.DefaultQuery("keyword", "")  // 有默认值
9
    page := c.Query("page")                   // 无默认值
10
})

1
// *filepath 会匹配 /assets 下的所有路径
2
// 例如 /assets/css/style.css → filepath = "/css/style.css"
3
r.Static("/assets", "./public")
4

5
// 手动通配符
6
r.GET("/files/*filepath", func(c *gin.Context) {
7
    filepath := c.Param("filepath") // "/docs/readme.md"
8
    c.File("./public" + filepath)
9
})

1
type LoginRequest struct {
2
    Username string `json:"username" binding:"required"`
3
    Password string `json:"password" binding:"required,min=6"`
4
    Email    string `json:"email"    binding:"omitempty,email"`
5
}
6

7
r.POST("/login", func(c *gin.Context) {
8
    var req LoginRequest
9
    // ShouldBindJSON 自动解析JSON请求体并验证
10
    if err := c.ShouldBindJSON(&req); err != nil {
11
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
12
        return
13
    }
14
    // 绑定成功，直接使用 req.Username, req.Password
15
    c.JSON(http.StatusOK, gin.H{"message": "登录成功"})
16
})

1
// JSON请求体
2
c.ShouldBindJSON(&req)
3

4
// URL查询参数
5
c.ShouldBindQuery(&req)
6

7
// 表单数据（application/x-www-form-urlencoded）
8
c.ShouldBind(&req)
9

10
// 路径参数需要手动获取，不支持自动绑定到struct
11
id := c.Param("id")
12

13
// 多数据源绑定（先查query，再查form）
14
c.ShouldBindWith(&req, binding.Query)

1
// 注册自定义验证：检查年龄是否在合理范围内
2
validate := validator.New()
3
validate.RegisterValidation("age", func(fl validator.FieldLevel) bool {
4
    age := fl.Field().Int()
5
    return age >= 0 && age <= 150
6
})
7

8
type User struct {
9
    Age int `json:"age" binding:"required,age"` // 使用自定义验证
10
}

1
// 自定义中间件
2
func AuthMiddleware() gin.HandlerFunc {
3
    return func(c *gin.Context) {
4
        token := c.GetHeader("Authorization")
5
        if token == "" {
6
            c.JSON(http.StatusUnauthorized, gin.H{"error": "未登录"})
7
            c.Abort() // 终止请求链
8
            return
9
        }
10
        // 验证token逻辑...
11
        c.Set("userId", 123) // 把解析出的用户ID放入上下文
12
        c.Next()             // 继续执行下一个处理函数
13
    }
14
}
15

16
func main() {
17
    r := gin.Default()
18

19
    // 全局中间件
20
    r.Use(corsMiddleware())
21

22
    // 路由组使用中间件
23
    auth := r.Group("/api", AuthMiddleware())
24
    {
25
        auth.GET("/profile", getProfile)
26
    }
27
}

1
func CORSMiddleware() gin.HandlerFunc {
2
    return func(c *gin.Context) {
3
        c.Header("Access-Control-Allow-Origin", "*")
4
        c.Header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
5
        c.Header("Access-Control-Allow-Headers", "Content-Type, Authorization")
6

7
        if c.Request.Method == "OPTIONS" {
8
            c.AbortWithStatus(204)
9
            return
10
        }
11

12
        c.Next()
13
    }
14
}

1
import "golang.org/x/time/rate"
2

3
func RateLimitMiddleware(r rate.Limit, b int) gin.HandlerFunc {
4
    limiter := rate.NewLimiter(r, b)
5
    return func(c *gin.Context) {
6
        if !limiter.Allow() {
7
            c.JSON(http.StatusTooManyRequests, gin.H{"error": "请求过于频繁"})
8
            c.Abort()
9
            return
10
        }
11
        c.Next()
12
    }
13
}
14

15
// 使用：每秒10个请求，突发最多20个
16
r.Use(RateLimitMiddleware(10, 20))

1
func handler(c *gin.Context) {
2
    // 获取请求信息
3
    method := c.Request.Method
4
    path := c.Request.URL.Path
5
    ip := c.ClientIP()
6
    ua := c.GetHeader("User-Agent")
7

8
    // 设置/获取上下文值（常用于中间件传值给处理函数）
9
    c.Set("key", "value")
10
    val, exists := c.Get("key")
11

12
    // 响应
13
    c.JSON(200, gin.H{"status": "ok"})     // JSON
14
    c.String(200, "hello")                  // 纯文本
15
    c.HTML(200, "index.html", data)         // HTML模板
16
    c.Redirect(301, "/new-path")            // 重定向
17

18
    // 文件上传
19
    file, _ := c.FormFile("file")
20
    c.SaveUploadedFile(file, "./uploads/"+file.Filename)
21
}

1
type Response struct {
2
    Code    int         `json:"code"`
3
    Message string      `json:"message"`
4
    Data    interface{} `json:"data,omitempty"`
5
}
6

7
func OK(c *gin.Context, data interface{}) {
8
    c.JSON(http.StatusOK, Response{Code: 0, Message: "success", Data: data})
9
}
10

11
func Fail(c *gin.Context, code int, msg string) {
12
    c.JSON(http.StatusOK, Response{Code: code, Message: msg})
13
}
14

15
// 使用
16
r.GET("/user/:id", func(c *gin.Context) {
17
    // 业务逻辑...
18
    OK(c, user)
19
})

1
import (
2
    "context"
3
    "log"
4
    "net/http"
5
    "os"
6
    "os/signal"
7
    "syscall"
8
    "time"
9
)
10

11
func main() {
12
    r := gin.Default()
13
    r.GET("/health", func(c *gin.Context) {
14
        c.JSON(200, gin.H{"status": "ok"})
15
    })
16

17
    srv := &http.Server{
18
        Addr:    ":8080",
19
        Handler: r,
20
    }
21

22
    // 在goroutine中启动服务
23
    go func() {
24
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
25
            log.Fatalf("服务启动失败: %v", err)
26
        }
27
    }()
28

29
    // 等待中断信号
30
    quit := make(chan os.Signal, 1)
31
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
32
    <-quit
33
    log.Println("正在关闭服务...")
34

35
    // 给5秒时间处理剩余请求
36
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
37
    defer cancel()
38

39
    if err := srv.Shutdown(ctx); err != nil {
40
        log.Fatalf("服务关闭异常: %v", err)
41
    }
42
    log.Println("服务已安全关闭")
43
}

1
// 单文件上传
2
r.POST("/upload", func(c *gin.Context) {
3
    file, err := c.FormFile("file")
4
    if err != nil {
5
        c.JSON(400, gin.H{"error": "文件上传失败"})
6
        return
7
    }
8

9
    // 限制文件大小（10MB）
10
    if file.Size > 10<<20 {
11
        c.JSON(400, gin.H{"error": "文件不能超过10MB"})
12
        return
13
    }
14

15
    // 保存文件
16
    dst := fmt.Sprintf("./uploads/%d_%s", time.Now().Unix(), file.Filename)
17
    if err := c.SaveUploadedFile(file, dst); err != nil {
18
        c.JSON(500, gin.H{"error": "保存失败"})
19
        return
20
    }
21
    c.JSON(200, gin.H{"path": dst})
22
})
23

24
// 多文件上传
25
r.POST("/upload/multiple", func(c *gin.Context) {
26
    form, _ := c.MultipartForm()
27
    files := form.File["files"] // 表单字段名
28

29
    for _, file := range files {
30
        dst := fmt.Sprintf("./uploads/%s", file.Filename)
31
        c.SaveUploadedFile(file, dst)
32
    }
33
    c.JSON(200, gin.H{"count": len(files)})
34
})
35

36
// 文件下载
37
r.GET("/download/:filename", func(c *gin.Context) {
38
    filename := c.Param("filename")
39
    filepath := "./uploads/" + filename
40
    c.Header("Content-Disposition", "attachment; filename="+filename)
41
    c.File(filepath)
42
})

1
import (
2
    "net/http"
3
    "net/http/httptest"
4
    "testing"
5
    "github.com/stretchr/testify/assert"
6
)
7

8
func setupRouter() *gin.Engine {
9
    r := gin.Default()
10
    r.GET("/ping", func(c *gin.Context) {
11
        c.JSON(200, gin.H{"message": "pong"})
12
    })
13
    return r
14
}
15

16
func TestPing(t *testing.T) {
17
    router := setupRouter()
18

19
    // 创建测试请求
20
    req, _ := http.NewRequest("GET", "/ping", nil)
21
    w := httptest.NewRecorder()
22

23
    // 执行请求
24
    router.ServeHTTP(w, req)
25

26
    // 断言
27
    assert.Equal(t, 200, w.Code)
28
    assert.Contains(t, w.Body.String(), "pong")
29
}

1
// 指定protobuf版本
2
syntax = "proto3";
3

4
// 生成的Go代码的包路径
5
option go_package = "./pb";
6

7
// 包名（防止不同项目的消息名冲突）
8
package user;
9

10
// 定义消息（类似Go的struct）
11
message User {
12
    int64 id = 1;              // 字段编号1，不是默认值
13
    string name = 2;
14
    string email = 3;
15
    int32 age = 4;
16
    Gender gender = 5;         // 使用枚举类型
17
    repeated string hobbies = 6; // repeated = 列表/切片
18
    map<string, string> metadata = 7; // map类型
19
}
20

21
// 枚举
22
enum Gender {
23
    GENDER_UNSPECIFIED = 0;  // proto3要求第一个值必须是0
24
    GENDER_MALE = 1;
25
    GENDER_FEMALE = 2;
26
}
27

28
// 请求和响应消息（通常用于RPC定义）
29
message GetUserRequest {
30
    int64 id = 1;
31
}
32

33
message GetUserResponse {
34
    User user = 1;
35
}
36

37
message ListUsersRequest {
38
    int32 page = 1;
39
    int32 page_size = 2;
40
}
41

42
message ListUsersResponse {
43
    repeated User users = 1;
44
    int32 total = 2;
45
}
46

47
// 定义服务（用于gRPC）
48
service UserService {
49
    rpc GetUser(GetUserRequest) returns (GetUserResponse);
50
    rpc ListUsers(ListUsersRequest) returns (ListUsersResponse);
51
    rpc CreateUser(User) returns (User);
52
}

1
message Example {
2
    reserved 2, 15, 9 to 11;
3
    reserved "old_field_name";
4
    string new_field = 1;
5
}

1
message Payment {
2
    oneof payment_method {
3
        CreditCard credit_card = 1;
4
        Alipay alipay = 2;
5
        WechatPay wechat = 3;
6
    }
7
}

1
message Outer {
2
    message Inner {
3
        string value = 1;
4
    }
5
    Inner inner = 1;
6
}
7

8
// Go中使用：outer.Inner.Value

1
import "google/protobuf/timestamp.proto";
2

3
message Event {
4
    string name = 1;
5
    google.protobuf.Timestamp created_at = 2;
6
}

1
import "google/protobuf/wrappers.proto";
2
import "google/protobuf/timestamp.proto";
3
import "google/protobuf/duration.proto";
4
import "google/protobuf/empty.proto";
5

6
message Example {
7
    // Wrapper类型：可以区分"未设置"和"零值"
8
    google.protobuf.StringValue name = 1;   // nil表示未设置，""表示空字符串
9
    google.protobuf.Int32Value count = 2;   // nil表示未设置，0表示零
10

11
    // 时间和时长
12
    google.protobuf.Timestamp created_at = 3;
13
    google.protobuf.Duration timeout = 4;
14

15
    // 空消息（用于无参数的RPC方法）
16
    // rpc HealthCheck(google.protobuf.Empty) returns (google.protobuf.Empty);
17
}

1
package main
2

3
import (
4
    "fmt"
5
    "log"
6

7
    pb "your-module/pb"
8
    "google.golang.org/protobuf/proto"
9
)
10

11
func main() {
12
    // 创建消息
13
    user := &pb.User{
14
        Id:      1,
15
        Name:    "张三",
16
        Email:   "zhangsan@example.com",
17
        Age:     25,
18
        Gender:  pb.Gender_GENDER_MALE,
19
        Hobbies: []string{"编程", "游戏"},
20
        Metadata: map[string]string{
21
            "city": "北京",
22
        },
23
    }
24

25
    // 序列化为二进制
26
    data, err := proto.Marshal(user)
27
    if err != nil {
28
        log.Fatal(err)
29
    }
30
    fmt.Printf("序列化后大小: %d bytes\n", len(data))
31

32
    // 反序列化
33
    newUser := &pb.User{}
34
    if err := proto.Unmarshal(data, newUser); err != nil {
35
        log.Fatal(err)
36
    }
37
    fmt.Printf("用户: %+v\n", newUser)
38

39
    // JSON序列化（调试用）
40
    jsonData, _ := protojson.Marshal(user)
41
    fmt.Println(string(jsonData))
42
}

1
rpc GetUser(GetUserRequest) returns (GetUserResponse);

1
// 例如：客户端请求某个时间段的日志，服务端持续推送
2
rpc WatchLogs(WatchLogsRequest) returns (stream LogEntry);

1
// 例如：客户端上传大文件
2
rpc UploadFile(stream FileChunk) returns (UploadResponse);

1
// 例如：实时聊天
2
rpc Chat(stream ChatMessage) returns (stream ChatMessage);

1
package main
2

3
import (
4
    "context"
5
    "log"
6
    "net"
7

8
    pb "your-module/pb"
9
    "google.golang.org/grpc"
10
    "google.golang.org/grpc/codes"
11
    "google.golang.org/grpc/status"
12
)
13

14
// 实现 UserService 接口
15
type server struct {
16
    pb.UnimplementedUserServiceServer // 嵌入这个，保证向前兼容
17
    users map[int64]*pb.User
18
}
19

20
func (s *server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.GetUserResponse, error) {
21
    user, ok := s.users[req.Id]
22
    if !ok {
23
        return nil, status.Errorf(codes.NotFound, "用户 %d 不存在", req.Id)
24
    }
25
    return &pb.GetUserResponse{User: user}, nil
26
}
27

28
func (s *server) CreateUser(ctx context.Context, user *pb.User) (*pb.User, error) {
29
    s.users[user.Id] = user
30
    return user, nil
31
}
32

33
func main() {
34
    lis, err := net.Listen("tcp", ":50051")
35
    if err != nil {
36
        log.Fatalf("监听失败: %v", err)
37
    }
38

39
    grpcServer := grpc.NewServer()
40
    pb.RegisterUserServiceServer(grpcServer, &server{
41
        users: make(map[int64]*pb.User),
42
    })
43

44
    log.Println("gRPC服务启动，监听 :50051")
45
    if err := grpcServer.Serve(lis); err != nil {
46
        log.Fatalf("服务失败: %v", err)
47
    }
48
}

1
package main
2

3
import (
4
    "context"
5
    "log"
6
    "time"
7

8
    pb "your-module/pb"
9
    "google.golang.org/grpc"
10
    "google.golang.org/grpc/credentials/insecure"
11
)
12

13
func main() {
14
    // 建立连接
15
    conn, err := grpc.Dial("localhost:50051",
16
        grpc.WithTransportCredentials(insecure.NewCredentials()),
17
    )
18
    if err != nil {
19
        log.Fatalf("连接失败: %v", err)
20
    }
21
    defer conn.Close()
22

23
    // 创建客户端
24
    client := pb.NewUserServiceClient(conn)
25

26
    // 设置超时
27
    ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
28
    defer cancel()
29

30
    // 调用远程方法——就像调用本地函数一样
31
    resp, err := client.GetUser(ctx, &pb.GetUserRequest{Id: 1})
32
    if err != nil {
33
        log.Printf("调用失败: %v", err)
34
        return
35
    }
36
    log.Printf("用户: %v", resp.User)
37
}

1
// Unary拦截器
2
func loggingInterceptor(
3
    ctx context.Context,
4
    req interface{},
5
    info *grpc.UnaryServerInfo,
6
    handler grpc.UnaryHandler,
7
) (interface{}, error) {
8
    start := time.Now()
9
    log.Printf("调用方法: %s", info.FullMethod)
10

11
    resp, err := handler(ctx, req)
12

13
    log.Printf("方法 %s 耗时: %v", info.FullMethod, time.Since(start))
14
    return resp, err
15
}
16

17
// 注册拦截器
18
grpcServer := grpc.NewServer(
19
    grpc.UnaryInterceptor(loggingInterceptor),
20
)

1
import "google.golang.org/grpc/middleware"
2

3
grpcServer := grpc.NewServer(
4
    grpc.ChainUnaryInterceptor(
5
        loggingInterceptor,    // 日志
6
        authInterceptor,       // 鉴权
7
        recoveryInterceptor,   // panic恢复
8
    ),
9
)

1
func clientInterceptor(
2
    ctx context.Context,
3
    method string,
4
    req, reply interface{},
5
    cc *grpc.ClientConn,
6
    invoker grpc.UnaryInvoker,
7
    opts ...grpc.CallOption,
8
) error {
9
    start := time.Now()
10
    log.Printf("客户端调用: %s", method)
11

12
    err := invoker(ctx, method, req, reply, cc, opts...)
13

14
    log.Printf("方法 %s 耗时: %v", method, time.Since(start))
15
    return err
16
}
17

18
conn, _ := grpc.Dial("localhost:50051",
19
    grpc.WithTransportCredentials(insecure.NewCredentials()),
20
    grpc.WithUnaryInterceptor(clientInterceptor),
21
)

1
import (
2
    "google.golang.org/grpc/codes"
3
    "google.golang.org/grpc/status"
4
)
5

6
// 服务端返回错误
7
func (s *server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.GetUserResponse, error) {
8
    if req.Id <= 0 {
9
        return nil, status.Errorf(codes.InvalidArgument, "ID必须大于0，收到: %d", req.Id)
10
    }
11
    user, ok := s.users[req.Id]
12
    if !ok {
13
        return nil, status.Errorf(codes.NotFound, "用户 %d 不存在", req.Id)
14
    }
15
    return &pb.GetUserResponse{User: user}, nil
16
}
17

18
// 客户端解析错误
19
resp, err := client.GetUser(ctx, req)
20
if err != nil {
21
    st, ok := status.FromError(err)
22
    if ok {
23
        switch st.Code() {
24
        case codes.NotFound:
25
            log.Println("用户不存在")
26
        case codes.InvalidArgument:
27
            log.Println("参数错误:", st.Message())
28
        case codes.Unavailable:
29
            log.Println("服务不可用")
30
        default:
31
            log.Printf("未知错误: %v", st.Err())
32
        }
33
    }
34
}

1
// 服务端实现
2
func (s *server) WatchUsers(req *pb.WatchUsersRequest, stream pb.UserService_WatchUsersServer) error {
3
    for _, user := range s.users {
4
        if err := stream.Send(user); err != nil {
5
            return err
6
        }
7
        time.Sleep(time.Second) // 模拟实时推送
8
    }
9
    return nil
10
}
11

12
// 客户端调用
13
stream, err := client.WatchUsers(ctx, &pb.WatchUsersRequest{})
14
for {
15
    user, err := stream.Recv()
16
    if err == io.EOF {
17
        break // 流结束
18
    }
19
    if err != nil {
20
        log.Fatal(err)
21
    }
22
    fmt.Printf("收到用户: %s\n", user.Name)
23
}

1
// 服务端
2
func (s *server) Chat(stream pb.UserService_ChatServer) error {
3
    for {
4
        msg, err := stream.Recv()
5
        if err == io.EOF {
6
            return nil
7
        }
8
        if err != nil {
9
            return err
10
        }
11
        // 回复消息
12
        reply := &pb.ChatMessage{
13
            From:    "server",
14
            Content: "收到: " + msg.Content,
15
        }
16
        if err := stream.Send(reply); err != nil {
17
            return err
18
        }
19
    }
20
}
21

22
// 客户端
23
stream, _ := client.Chat(ctx)
24

25
// 发送消息的goroutine
26
go func() {
27
    for _, msg := range messages {
28
        stream.Send(msg)
29
    }
30
    stream.CloseSend()
31
}()
32

33
// 接收消息的goroutine
34
for {
35
    reply, err := stream.Recv()
36
    if err == io.EOF {
37
        break
38
    }
39
    fmt.Println(reply.Content)
40
}

1
import "google/api/annotations.proto";
2

3
service UserService {
4
    rpc GetUser(GetUserRequest) returns (GetUserResponse) {
5
        option (google.api.http) = {
6
            get: "/api/v1/users/{id}"
7
        };
8
    }
9
    rpc CreateUser(User) returns (User) {
10
        option (google.api.http) = {
11
            post: "/api/v1/users"
12
            body: "*"
13
        };
14
    }
15
}

1
// 同时启动gRPC和HTTP
2
func main() {
3
    // gRPC服务
4
    grpcServer := grpc.NewServer()
5
    pb.RegisterUserServiceServer(grpcServer, &server{})
6

7
    // HTTP代理
8
    gwMux := runtime.NewServeMux()
9
    pb.RegisterUserServiceHandlerFromEndpoint(ctx, gwMux, ":50051", opts)
10

11
    // HTTP服务器（转发REST请求到gRPC）
12
    httpServer := &http.Server{
13
        Addr:    ":8080",
14
        Handler: gwMux,
15
    }
16

17
    go grpcServer.Serve(lis)
18
    httpServer.ListenAndServe()
19
}