Golang中如何选择REST和gRPC进行API开发

再次强调，这只是其中一种实现方式。在这个特定项目中，有一个内部的 api 包和另一个 storage 包，api 实现会调用这些包来创建和消费数据（例如数据验证、执行必要查询等）。项目结构有很多种方式，论坛里也讨论过几次（可以搜索项目布局或类似关键词）。

在本论坛搜索"项目布局 grpc"只返回了1个结果。这个问题 🙂

但我有点只见树木不见森林。所以我尝试从宏观视角来理解。以下是我的理解：

根据我的解读，这需要3个服务器？Web服务器、网关服务器，最后是gRPC服务器。对吗？

浏览器（Web服务器）

1. GET users

网关服务器（负责JSON和二进制格式之间的转换）？

6. 将结果解析为JSON并返回给浏览器

gRPC服务器

2. 连接到Postgresql
3. 监听并服务（启动服务器）
4. 路由到端点
5. 存储SQL和获取SQL数据

我猜想网关和gRPC服务器使用的是相同的结构体？（通过proto之类的工具神秘生成的）

我的理解正确吗？如果有误请指正！

在Go语言中同时使用REST和gRPC进行API开发是完全可行的，而且这种架构在现代微服务系统中很常见。让我通过具体示例来说明如何实现。

架构实现方案

1. 定义gRPC服务

首先定义protobuf文件 user_service.proto：

syntax = "proto3";

package user;

service UserService {
  rpc GetUser(GetUserRequest) returns (UserResponse);
  rpc CreateUser(CreateUserRequest) returns (UserResponse);
}

message GetUserRequest {
  string user_id = 1;
}

message CreateUserRequest {
  string name = 1;
  string email = 2;
}

message UserResponse {
  string id = 1;
  string name = 2;
  string email = 3;
}

生成Go代码：

protoc --go_out=. --go-grpc_out=. user_service.proto

2. 实现gRPC服务端

package main

import (
	"context"
	"log"
	"net"

	"google.golang.org/grpc"
	pb "path/to/your/proto"
)

type userServer struct {
	pb.UnimplementedUserServiceServer
}

func (s *userServer) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.UserResponse, error) {
	// 数据库查询逻辑
	return &pb.UserResponse{
		Id:    req.UserId,
		Name:  "John Doe",
		Email: "john@example.com",
	}, nil
}

func (s *userServer) CreateUser(ctx context.Context, req *pb.CreateUserRequest) (*pb.UserResponse, error) {
	// 数据库插入逻辑
	return &pb.UserResponse{
		Id:    "123",
		Name:  req.Name,
		Email: req.Email,
	}, nil
}

func main() {
	lis, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	
	grpcServer := grpc.NewServer()
	pb.RegisterUserServiceServer(grpcServer, &userServer{})
	
	log.Println("gRPC server listening on :50051")
	if err := grpcServer.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

3. 实现REST网关

使用grpc-gateway创建REST到gRPC的转换：

package main

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

	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"

	pb "path/to/your/proto"
)

func runRESTGateway() {
	ctx := context.Background()
	ctx, cancel := context.WithCancel(ctx)
	defer cancel()

	mux := runtime.NewServeMux()
	opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
	
	err := pb.RegisterUserServiceHandlerFromEndpoint(ctx, mux, "localhost:50051", opts)
	if err != nil {
		log.Fatalf("failed to register gateway: %v", err)
	}

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

func main() {
	go runRESTGateway()
	
	// 同时运行gRPC服务
	runGRPCServer()
}

4. 前端调用示例

前端可以通过REST API调用：

// 获取用户
fetch('http://localhost:8080/v1/users/123')
  .then(response => response.json())
  .then(data => console.log(data));

// 创建用户
fetch('http://localhost:8080/v1/users', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    name: 'Jane Doe',
    email: 'jane@example.com'
  })
})
.then(response => response.json())
.then(data => console.log(data));

5. 数据库集成

集成PostgreSQL的示例：

import (
	"database/sql"
	_ "github.com/lib/pq"
)

type UserRepository struct {
	db *sql.DB
}

func (r *UserRepository) GetUserByID(ctx context.Context, id string) (*pb.UserResponse, error) {
	var user pb.UserResponse
	err := r.db.QueryRowContext(ctx, 
		"SELECT id, name, email FROM users WHERE id = $1", id).
		Scan(&user.Id, &user.Name, &user.Email)
	if err != nil {
		return nil, err
	}
	return &user, nil
}

部署方案

使用Nginx作为反向代理

http {
    upstream grpc_servers {
        server localhost:50051;
    }
    
    upstream rest_gateway {
        server localhost:8080;
    }
    
    server {
        listen 80;
        
        location /api/ {
            proxy_pass http://rest_gateway/;
        }
        
        location / {
            # 静态文件服务
            root /var/www/html;
        }
    }
    
    server {
        listen 50052 http2;
        
        location / {
            grpc_pass grpc://grpc_servers;
        }
    }
}

这种架构的优势在于：

• 内部服务间使用高效的gRPC通信
• 外部客户端使用熟悉的REST API
• 单一代码库维护两种接口
• 自动生成API文档和客户端代码

整个方案不需要Docker，可以直接在服务器上部署运行。