如何用Golang编写可扩展的微服务API 分享Gin框架最佳实践

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

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

func main() {
    router := gin.Default()

    // 获取用户信息
    router.GET("/users/:id", func(c *gin.Context) {
        id := c.Param("id")
        // 实际场景中，这里应该从数据库或其他服务中获取用户信息
        user := User{ID: id, Name: "Example User"}
        c.JSON(http.StatusOK, user)
    })

    // 创建用户
    router.POST("/users", func(c *gin.Context) {
        var user User
        if err := c.BindJSON(&user); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        // 实际场景中，这里应该将用户信息保存到数据库或其他服务中
        c.JSON(http.StatusCreated, user)
    })

    router.Run(":8080")
}

func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("Authorization")
        if token == "" {
            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Missing authorization token"})
            return
        }

        // 实际场景中，这里应该验证 token 的有效性
        if token != "valid_token" {
            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Invalid authorization token"})
            return
        }

        c.Next()
    }
}

router.GET("/protected", AuthMiddleware(), func(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{"message": "Protected resource"})
})

package main

import (
    "context"
    "fmt"
    "log"
    "net"
    "time"

    "google.golang.org/grpc"
    "google.golang.org/grpc/resolver"
    "google.golang.org/grpc/resolver/manual"

    pb "your_package/proto" // 替换为你的 protobuf 包
)

const (
    port = ":50051"
)

// 定义服务
type server struct {
    pb.UnimplementedGreeterServer
}

// 实现 SayHello 方法
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
    log.Printf("Received: %v", in.GetName())
    return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
}

func main() {
    lis, err := net.Listen("tcp", port)
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{})
    log.Printf("server listening at %v", lis.Addr())
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

// 客户端代码 (简化版，需要结合 Consul 或其他服务发现工具)
func mainClient() {
    // 创建一个 manual resolver
    r := manual.NewBuilder()
    conn, err := grpc.Dial("manual://authority/greeter", grpc.WithResolvers(r), grpc.WithInsecure())
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    client := pb.NewGreeterClient(conn)

    // 手动更新服务地址 (实际应用中，Consul 或其他服务发现工具会动态更新)
    r.UpdateState(resolver.State{Addresses: []resolver.Address{{Addr: "localhost:50051"}}})

    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    res, err := client.SayHello(ctx, &pb.HelloRequest{Name: "world"})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("Greeting: %s", res.GetMessage())
}

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"

    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/jaeger"
    "go.opentelemetry.io/otel/propagation"
    "go.opentelemetry.io/otel/sdk/resource"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
    semconv "go.opentemetry.io/otel/semconv/v1.17.0"

    "github.com/gin-gonic/gin"
    "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
)

// 初始化 Jaeger tracer
func newJaegerTracerProvider(url string) (*sdktrace.TracerProvider, error) {
    // 创建 Jaeger exporter
    exp, err := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint(url)))
    if err != nil {
        return nil, err
    }
    tp := sdktrace.NewTracerProvider(
        sdktrace.WithBatcher(exp),
        sdktrace.WithResource(resource.NewWithAttributes(
            semconv.SchemaURL,
            semconv.ServiceName("my-gin-app"), // 服务名
            semconv.ServiceVersion("v1.0.0"),  // 服务版本
        )),
    )
    return tp, nil
}

func main() {
    jaegerEndpoint := os.Getenv("JAEGER_ENDPOINT") // 建议通过环境变量配置
    if jaegerEndpoint == "" {
        jaegerEndpoint = "http://localhost:14268/api/traces" // 默认 Jaeger 地址
        log.Println("JAEGER_ENDPOINT not set, using default:", jaegerEndpoint)
    }

    tp, err := newJaegerTracerProvider(jaegerEndpoint)
    if err != nil {
        log.Fatal(err)
    }

    // 设置全局 TracerProvider 和 TextMapPropagator
    otel.SetTracerProvider(tp)
    otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}))

    defer func() {
        if err := tp.Shutdown(context.Background()); err != nil {
            log.Printf("Error shutting down tracer provider: %v", err)
        }
    }()

    router := gin.Default()

    // 使用 otelgin 中间件
    router.Use(otelgin.Middleware("my-gin-app")) // 链路名称

    router.GET("/hello/:name", func(c *gin.Context) {
        name := c.Param("name")
        ctx := c.Request.Context()
        span := otel.Tracer("my-gin-app").StartSpan(ctx, "hello-handler") // 自定义 span

        defer span.End()

        greeting := fmt.Sprintf("Hello, %s!", name)
        c.String(http.StatusOK, greeting)
    })

    router.Run(":8080")
}