1
package main
2

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

8
func main() {
9
    // Create the default engine (comes with Logger and Recovery middleware)
10
    r := gin.Default()
11

12
    // Define a GET route
13
    r.GET("/hello", func(c *gin.Context) {
14
        c.JSON(http.StatusOK, gin.H{
15
            "message": "Hello, Gin!",
16
        })
17
    })
18

19
    // Start the server, listening on :8080 by default
20
    r.Run(":8080")
21
}

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

4
// gin.New() has no middleware at all; you have full control
5
r := gin.New()
6
r.Use(gin.Logger())   // Add logging manually
7
r.Use(gin.Recovery()) // Add panic recovery manually

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

4
    // Basic routes
5
    r.GET("/users", getUsers)
6
    r.POST("/users", createUser)
7
    r.PUT("/users/:id", updateUser)    // Path parameter
8
    r.DELETE("/users/:id", deleteUser)
9

10
    // Route grouping — very convenient for managing API versions
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
// Path parameter: /user/123
2
r.GET("/user/:id", func(c *gin.Context) {
3
    id := c.Param("id") // "123"
4
})
5

6
// Query parameter: /search?keyword=go&page=1
7
r.GET("/search", func(c *gin.Context) {
8
    keyword := c.DefaultQuery("keyword", "")  // Has a default value
9
    page := c.Query("page")                   // No default value
10
})

1
// *filepath matches all paths under /assets
2
// e.g. /assets/css/style.css → filepath = "/css/style.css"
3
r.Static("/assets", "./public")
4

5
// Manual wildcard
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 automatically parses the JSON request body and validates it
10
    if err := c.ShouldBindJSON(&req); err != nil {
11
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
12
        return
13
    }
14
    // Binding succeeded; use req.Username, req.Password directly
15
    c.JSON(http.StatusOK, gin.H{"message": "Login successful"})
16
})

1
// JSON request body
2
c.ShouldBindJSON(&req)
3

4
// URL query parameters
5
c.ShouldBindQuery(&req)
6

7
// Form data (application/x-www-form-urlencoded)
8
c.ShouldBind(&req)
9

10
// Path parameters must be retrieved manually; automatic binding to struct is not supported
11
id := c.Param("id")
12

13
// Multi-source binding (query first, then form)
14
c.ShouldBindWith(&req, binding.Query)

1
// Register a custom validation: check whether age is within a reasonable range
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"` // Use the custom validation
10
}

1
// Custom middleware
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": "Not logged in"})
7
            c.Abort() // Terminate the request chain
8
            return
9
        }
10
        // Token verification logic...
11
        c.Set("userId", 123) // Put the parsed user ID into the context
12
        c.Next()             // Continue to the next handler
13
    }
14
}
15

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

19
    // Global middleware
20
    r.Use(corsMiddleware())
21

22
    // Middleware on a route group
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": "Too many requests"})
8
            c.Abort()
9
            return
10
        }
11
        c.Next()
12
    }
13
}
14

15
// Usage: 10 requests per second, max burst of 20
16
r.Use(RateLimitMiddleware(10, 20))

1
func handler(c *gin.Context) {
2
    // Get request information
3
    method := c.Request.Method
4
    path := c.Request.URL.Path
5
    ip := c.ClientIP()
6
    ua := c.GetHeader("User-Agent")
7

8
    // Set / get context values (commonly used to pass values from middleware to handlers)
9
    c.Set("key", "value")
10
    val, exists := c.Get("key")
11

12
    // Response
13
    c.JSON(200, gin.H{"status": "ok"})     // JSON
14
    c.String(200, "hello")                  // Plain text
15
    c.HTML(200, "index.html", data)         // HTML template
16
    c.Redirect(301, "/new-path")            // Redirect
17

18
    // File upload
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
// Usage
16
r.GET("/user/:id", func(c *gin.Context) {
17
    // Business logic...
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
    // Start the server in a goroutine
23
    go func() {
24
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
25
            log.Fatalf("Failed to start server: %v", err)
26
        }
27
    }()
28

29
    // Wait for interrupt signal
30
    quit := make(chan os.Signal, 1)
31
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
32
    <-quit
33
    log.Println("Shutting down server...")
34

35
    // Allow 5 seconds to handle remaining requests
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("Server shutdown error: %v", err)
41
    }
42
    log.Println("Server shut down safely")
43
}

1
// Single file upload
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": "File upload failed"})
6
        return
7
    }
8

9
    // Limit file size (10MB)
10
    if file.Size > 10<<20 {
11
        c.JSON(400, gin.H{"error": "File cannot exceed 10MB"})
12
        return
13
    }
14

15
    // Save the file
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": "Save failed"})
19
        return
20
    }
21
    c.JSON(200, gin.H{"path": dst})
22
})
23

24
// Multiple file upload
25
r.POST("/upload/multiple", func(c *gin.Context) {
26
    form, _ := c.MultipartForm()
27
    files := form.File["files"] // Form field name
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
// File download
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
    // Create a test request
20
    req, _ := http.NewRequest("GET", "/ping", nil)
21
    w := httptest.NewRecorder()
22

23
    // Execute the request
24
    router.ServeHTTP(w, req)
25

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

1
// Specify the protobuf version
2
syntax = "proto3";
3

4
// Go package path for the generated code
5
option go_package = "./pb";
6

7
// Package name (prevents message name conflicts across projects)
8
package user;
9

10
// Define a message (similar to a Go struct)
11
message User {
12
    int64 id = 1;              // Field number 1, not a default value
13
    string name = 2;
14
    string email = 3;
15
    int32 age = 4;
16
    Gender gender = 5;         // Use an enum type
17
    repeated string hobbies = 6; // repeated = list / slice
18
    map<string, string> metadata = 7; // map type
19
}
20

21
// Enum
22
enum Gender {
23
    GENDER_UNSPECIFIED = 0;  // proto3 requires the first value to be 0
24
    GENDER_MALE = 1;
25
    GENDER_FEMALE = 2;
26
}
27

28
// Request and response messages (typically used for RPC definitions)
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
// Define a service (for 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
// In 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 types: can distinguish "not set" from "zero value"
8
    google.protobuf.StringValue name = 1;   // nil means not set, "" means empty string
9
    google.protobuf.Int32Value count = 2;   // nil means not set, 0 means zero
10

11
    // Time and duration
12
    google.protobuf.Timestamp created_at = 3;
13
    google.protobuf.Duration timeout = 4;
14

15
    // Empty message (for RPC methods with no parameters)
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
    // Create a message
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
    // Serialize to binary
26
    data, err := proto.Marshal(user)
27
    if err != nil {
28
        log.Fatal(err)
29
    }
30
    fmt.Printf("Serialized size: %d bytes\n", len(data))
31

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

39
    // JSON serialization (for debugging)
40
    jsonData, _ := protojson.Marshal(user)
41
    fmt.Println(string(jsonData))
42
}

1
rpc GetUser(GetUserRequest) returns (GetUserResponse);

1
// e.g.: the client requests logs for a time range, and the server keeps pushing
2
rpc WatchLogs(WatchLogsRequest) returns (stream LogEntry);

1
// e.g.: the client uploads a large file
2
rpc UploadFile(stream FileChunk) returns (UploadResponse);

1
// e.g.: real-time chat
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
// Implement the UserService interface
15
type server struct {
16
    pb.UnimplementedUserServiceServer // Embed this for forward compatibility
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, "User %d does not exist", 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("Failed to listen: %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 service started, listening on :50051")
45
    if err := grpcServer.Serve(lis); err != nil {
46
        log.Fatalf("Service failed: %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
    // Establish a connection
15
    conn, err := grpc.Dial("localhost:50051",
16
        grpc.WithTransportCredentials(insecure.NewCredentials()),
17
    )
18
    if err != nil {
19
        log.Fatalf("Connection failed: %v", err)
20
    }
21
    defer conn.Close()
22

23
    // Create a client
24
    client := pb.NewUserServiceClient(conn)
25

26
    // Set a timeout
27
    ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
28
    defer cancel()
29

30
    // Call the remote method — just like calling a local function
31
    resp, err := client.GetUser(ctx, &pb.GetUserRequest{Id: 1})
32
    if err != nil {
33
        log.Printf("Call failed: %v", err)
34
        return
35
    }
36
    log.Printf("User: %v", resp.User)
37
}

1
// Unary interceptor
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("Calling method: %s", info.FullMethod)
10

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

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

17
// Register the interceptor
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,    // Logging
6
        authInterceptor,       // Authentication
7
        recoveryInterceptor,   // panic recovery
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("Client calling: %s", method)
11

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

14
    log.Printf("Method %s took: %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
// Server returns an error
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 must be greater than 0, received: %d", req.Id)
10
    }
11
    user, ok := s.users[req.Id]
12
    if !ok {
13
        return nil, status.Errorf(codes.NotFound, "User %d does not exist", req.Id)
14
    }
15
    return &pb.GetUserResponse{User: user}, nil
16
}
17

18
// Client parses the error
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("User does not exist")
26
        case codes.InvalidArgument:
27
            log.Println("Invalid argument:", st.Message())
28
        case codes.Unavailable:
29
            log.Println("Service unavailable")
30
        default:
31
            log.Printf("Unknown error: %v", st.Err())
32
        }
33
    }
34
}

1
// Server implementation
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) // Simulate real-time push
8
    }
9
    return nil
10
}
11

12
// Client call
13
stream, err := client.WatchUsers(ctx, &pb.WatchUsersRequest{})
14
for {
15
    user, err := stream.Recv()
16
    if err == io.EOF {
17
        break // Stream ended
18
    }
19
    if err != nil {
20
        log.Fatal(err)
21
    }
22
    fmt.Printf("Received user: %s\n", user.Name)
23
}

1
// Server
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
        // Reply to the message
12
        reply := &pb.ChatMessage{
13
            From:    "server",
14
            Content: "Received: " + msg.Content,
15
        }
16
        if err := stream.Send(reply); err != nil {
17
            return err
18
        }
19
    }
20
}
21

22
// Client
23
stream, _ := client.Chat(ctx)
24

25
// Goroutine that sends messages
26
go func() {
27
    for _, msg := range messages {
28
        stream.Send(msg)
29
    }
30
    stream.CloseSend()
31
}()
32

33
// Goroutine that receives messages
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
// Start both gRPC and HTTP
2
func main() {
3
    // gRPC service
4
    grpcServer := grpc.NewServer()
5
    pb.RegisterUserServiceServer(grpcServer, &server{})
6

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

11
    // HTTP server (forwards REST requests to gRPC)
12
    httpServer := &http.Server{
13
        Addr:    ":8080",
14
        Handler: gwMux,
15
    }
16

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