REST vs gRPC 选型深度对比：Go 语言微服务通信协议决策指南

syntax = "proto3";
package benchmark;
option go_package = "./pb";

message UserRequest {
  int64 user_id = 1;
}

message UserResponse {
  int64 user_id = 1;
  string name = 2;
  string email = 3;
  int32 age = 4;
  string address = 5;
  repeated string tags = 6;
}

service UserService {
  rpc GetUser(UserRequest) returns (UserResponse);
  rpc ListUsers(UserRequest) returns (stream UserResponse);
}

package main

import (
	"context"
	"log"
	"net"

	"google.golang.org/grpc"
	pb "restvgrpc/pb"
)

type server struct {
	pb.UnimplementedUserServiceServer
}

func (s *server) GetUser(ctx context.Context, req *pb.UserRequest) (*pb.UserResponse, error) {
	return &pb.UserResponse{
		UserId:  req.UserId,
		Name:    "张三",
		Email:   "zhangsan@example.com",
		Age:     28,
		Address: "北京市海淀区中关村",
		Tags:    []string{"golang", "backend", "distributed-systems"},
	}, nil
}

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

package main

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

type UserRequest struct {
	UserID int64 `json:"user_id"`
}

type UserResponse struct {
	UserID  int64    `json:"user_id"`
	Name    string   `json:"name"`
	Email   string   `json:"email"`
	Age     int32    `json:"age"`
	Address string   `json:"address"`
	Tags    []string `json:"tags"`
}

func getUserHandler(w http.ResponseWriter, r *http.Request) {
	var req UserRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	resp := UserResponse{
		UserID:  req.UserID,
		Name:    "张三",
		Email:   "zhangsan@example.com",
		Age:     28,
		Address: "北京市海淀区中关村",
		Tags:    []string{"golang", "backend", "distributed-systems"},
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(resp)
}

func main() {
	http.HandleFunc("/user", getUserHandler)
	log.Println("REST server starting on :8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
	"context"
	"testing"
	"time"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	pb "restvgrpc/pb"
)

func BenchmarkGRPCGetUser(b *testing.B) {
	conn, err := grpc.Dial("localhost:50051",
		grpc.WithTransportCredentials(insecure.NewCredentials()),
		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(1024*1024)),
	)
	if err != nil {
		b.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()

	client := pb.NewUserServiceClient(conn)
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, err := client.GetUser(ctx, &pb.UserRequest{UserId: int64(i)})
		if err != nil {
			b.Fatalf("GetUser failed: %v", err)
		}
	}
}

package main

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

func BenchmarkRESTGetUser(b *testing.B) {
	client := &http.Client{}
	url := "http://localhost:8080/user"

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		reqBody, _ := json.Marshal(map[string]int64{"user_id": int64(i)})
		resp, err := client.Post(url, "application/json", bytes.NewReader(reqBody))
		if err != nil {
			b.Fatalf("request failed: %v", err)
		}
		resp.Body.Close()
	}
}

package main

import (
	"context"
	"fmt"
	"io"
	"log"
	"time"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	pb "restvgrpc/pb"
)

func runBidirectionalStream(client pb.UserServiceClient) {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	stream, err := client.Chat(ctx)
	if err != nil {
		log.Fatalf("Chat failed: %v", err)
	}

	// 发送 goroutine
	go func() {
		for i := 0; i < 5; i++ {
			if err := stream.Send(&pb.ChatMessage{
				UserId:    int64(i),
				Content:   fmt.Sprintf("消息 %d", i),
				Timestamp: time.Now().Unix(),
			}); err != nil {
				log.Printf("Send error: %v", err)
				return
			}
			time.Sleep(500 * time.Millisecond)
		}
		stream.CloseSend()
	}()

	// 接收 goroutine
	for {
		msg, err := stream.Recv()
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatalf("Recv error: %v", err)
		}
		fmt.Printf("收到回复: %s\n", msg.Content)
	}
}

package main

import (
	"context"
	"log"
	"time"

	"google.golang.org/grpc"
)

func loggingInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
	start := time.Now()
	resp, err := handler(ctx, req)
	log.Printf("Method: %s, Duration: %v, Error: %v", info.FullMethod, time.Since(start), err)
	return resp, err
}

func main() {
	s := grpc.NewServer(grpc.UnaryInterceptor(loggingInterceptor))
	// ... 注册服务并启动
}

syntax = "proto3";
package hybrid;
option go_package = "./hybridpb";

import "google/api/annotations.proto";

message GetUserRequest {
  int64 user_id = 1;
}

message User {
  int64 user_id = 1;
  string name = 2;
  string email = 3;
}

service UserService {
  rpc GetUser(GetUserRequest) returns (User) {
    option (google.api.http) = {
      get: "/v1/users/{user_id}"
    };
  }
}

package main

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

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

type server struct {
	hybridpb.UnimplementedUserServiceServer
}

func (s *server) GetUser(ctx context.Context, req *hybridpb.GetUserRequest) (*hybridpb.User, error) {
	return &hybridpb.User{
		UserId: req.UserId,
		Name:   "张三",
		Email:  "zhangsan@example.com",
	}, nil
}

func runGRPCServer() {
	lis, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatal(err)
	}
	s := grpc.NewServer()
	hybridpb.RegisterUserServiceServer(s, &server{})
	log.Println("gRPC server on :50051")
	s.Serve(lis)
}

func runGatewayServer() {
	ctx := context.Background()
	mux := runtime.NewServeMux()
	opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
	err := hybridpb.RegisterUserServiceHandlerFromEndpoint(ctx, mux, "localhost:50051", opts)
	if err != nil {
		log.Fatal(err)
	}
	log.Println("Gateway server on :8080")
	log.Fatal(http.ListenAndServe(":8080", mux))
}

func main() {
	go runGRPCServer()
	runGatewayServer()
}

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

package main

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

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

var users = map[int64]*User{
	1: {ID: 1, Name: "张三", Email: "zhangsan@example.com"},
	2: {ID: 2, Name: "李四", Email: "lisi@example.com"},
}

func jsonMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		next.ServeHTTP(w, r)
	})
}

func loggingMiddleware(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 userHandler(w http.ResponseWriter, r *http.Request) {
	switch r.Method {
	case http.MethodGet:
		path := strings.TrimPrefix(r.URL.Path, "/users/")
		var id int64
		if _, err := fmt.Sscanf(path, "%d", &id); err == nil {
			if user, ok := users[id]; ok {
				json.NewEncoder(w).Encode(user)
				return
			}
		}
		w.WriteHeader(http.StatusNotFound)
		json.NewEncoder(w).Encode(map[string]string{"error": "user not found"})

	case http.MethodPost:
		var user User
		if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
			w.WriteHeader(http.StatusBadRequest)
			json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
			return
		}
		users[user.ID] = &user
		w.WriteHeader(http.StatusCreated)
		json.NewEncoder(w).Encode(user)

	default:
		w.WriteHeader(http.StatusMethodNotAllowed)
	}
}

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/users/", userHandler)

	var handler http.Handler = mux
	handler = jsonMiddleware(handler)
	handler = loggingMiddleware(handler)

	log.Println("REST server on :8080")
	log.Fatal(http.ListenAndServe(":8080", handler))
}

// models.go
package models

type Product struct {
	ID          int64    `json:"id"`
	Name        string   `json:"name"`
	Description string   `json:"description"`
	Price       float64  `json:"price"`
	Category    string   `json:"category"`
	Tags        []string `json:"tags"`
	InStock     bool     `json:"in_stock"`
}

// product.proto
syntax = "proto3";
package product;
option go_package = "./productpb";

message Product {
  int64 id = 1;
  string name = 2;
  string description = 3;
  double price = 4;
  string category = 5;
  repeated string tags = 6;
  bool in_stock = 7;
}

message GetProductRequest {
  int64 id = 1;
}

message CreateProductRequest {
  string name = 1;
  string description = 2;
  double price = 3;
  string category = 4;
  repeated string tags = 5;
  bool in_stock = 6;
}

service ProductService {
  rpc GetProduct(GetProductRequest) returns (Product);
  rpc CreateProduct(CreateProductRequest) returns (Product);
  rpc ListProducts(GetProductRequest) returns (stream Product);
}

// grpc_server.go
package main

import (
	"context"
	"log"
	"net"
	"sync"
	"sync/atomic"

	"google.golang.org/grpc"
	productpb "restvgrpc/productpb"
)

type productServer struct {
	productpb.UnimplementedProductServiceServer
	mu       sync.RWMutex
	products map[int64]*productpb.Product
	nextID   int64
}

func newProductServer() *productServer {
	return &productServer{
		products: make(map[int64]*productpb.Product),
		nextID:   1,
	}
}

func (s *productServer) GetProduct(ctx context.Context, req *productpb.GetProductRequest) (*productpb.Product, error) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	if p, ok := s.products[req.Id]; ok {
		return p, nil
	}
	return nil, grpc.Errorf(codes.NotFound, "product %d not found", req.Id)
}

func (s *productServer) CreateProduct(ctx context.Context, req *productpb.CreateProductRequest) (*productpb.Product, error) {
	s.mu.Lock()
	defer s.mu.Unlock()

	id := atomic.AddInt64(&s.nextID, 1)
	p := &productpb.Product{
		Id:          id,
		Name:        req.Name,
		Description: req.Description,
		Price:       req.Price,
		Category:    req.Category,
		Tags:        req.Tags,
		InStock:     req.InStock,
	}
	s.products[id] = p
	return p, nil
}

func (s *productServer) ListProducts(req *productpb.GetProductRequest, stream productpb.ProductService_ListProductsServer) error {
	s.mu.RLock()
	defer s.mu.RUnlock()
	for _, p := range s.products {
		if err := stream.Send(p); err != nil {
			return err
		}
	}
	return nil
}

func main() {
	lis, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	s := grpc.NewServer()
	productpb.RegisterProductServiceServer(s, newProductServer())
	log.Println("gRPC Product server on :50051")
	if err := s.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

// rest_server.go
package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"strconv"
	"strings"
	"sync"
	"sync/atomic"
)

type Product struct {
	ID          int64    `json:"id"`
	Name        string   `json:"name"`
	Description string   `json:"description"`
	Price       float64  `json:"price"`
	Category    string   `json:"category"`
	Tags        []string `json:"tags"`
	InStock     bool     `json:"in_stock"`
}

type CreateProductRequest struct {
	Name        string   `json:"name"`
	Description string   `json:"description"`
	Price       float64  `json:"price"`
	Category    string   `json:"category"`
	Tags        []string `json:"tags"`
	InStock     bool     `json:"in_stock"`
}

type productStore struct {
	mu       sync.RWMutex
	products map[int64]*Product
	nextID   int64
}

func newProductStore() *productStore {
	return &productStore{
		products: make(map[int64]*Product),
		nextID:   1,
	}
}

func (s *productStore) get(id int64) (*Product, bool) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	p, ok := s.products[id]
	return p, ok
}

func (s *productStore) create(req *CreateProductRequest) *Product {
	s.mu.Lock()
	defer s.mu.Unlock()
	id := atomic.AddInt64(&s.nextID, 1)
	p := &Product{
		ID:          id,
		Name:        req.Name,
		Description: req.Description,
		Price:       req.Price,
		Category:    req.Category,
		Tags:        req.Tags,
		InStock:     req.InStock,
	}
	s.products[id] = p
	return p
}

var store = newProductStore()

func productHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")

	switch r.Method {
	case http.MethodGet:
		path := strings.TrimPrefix(r.URL.Path, "/products/")
		id, err := strconv.ParseInt(path, 10, 64)
		if err != nil {
			w.WriteHeader(http.StatusBadRequest)
			json.NewEncoder(w).Encode(map[string]string{"error": "invalid id"})
			return
		}
		if p, ok := store.get(id); ok {
			json.NewEncoder(w).Encode(p)
			return
		}
		w.WriteHeader(http.StatusNotFound)
		json.NewEncoder(w).Encode(map[string]string{"error": "product not found"})

	case http.MethodPost:
		var req CreateProductRequest
		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
			w.WriteHeader(http.StatusBadRequest)
			json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
			return
		}
		p := store.create(&req)
		w.WriteHeader(http.StatusCreated)
		json.NewEncoder(w).Encode(p)

	default:
		w.WriteHeader(http.StatusMethodNotAllowed)
	}
}

func main() {
	http.HandleFunc("/products/", productHandler)
	log.Println("REST Product server on :8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

// benchmark_test.go
package benchmark

import (
	"bytes"
	"context"
	"encoding/json"
	"net/http"
	"testing"
	"time"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	productpb "restvgrpc/productpb"
)

var grpcClient productpb.ProductServiceClient
var grpcConn *grpc.ClientConn

func initGRPC() {
	var err error
	grpcConn, err = grpc.Dial("localhost:50051",
		grpc.WithTransportCredentials(insecure.NewCredentials()),
	)
	if err != nil {
		panic(err)
	}
	grpcClient = productpb.NewProductServiceClient(grpcConn)
}

func BenchmarkGRPCGetProduct(b *testing.B) {
	if grpcClient == nil {
		initGRPC()
	}
	ctx := context.Background()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, err := grpcClient.GetProduct(ctx, &productpb.GetProductRequest{Id: 1})
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkRESTGetProduct(b *testing.B) {
	client := &http.Client{Timeout: 5 * time.Second}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		resp, err := client.Get("http://localhost:8080/products/1")
		if err != nil {
			b.Fatal(err)
		}
		resp.Body.Close()
	}
}

func BenchmarkGRPCCreateProduct(b *testing.B) {
	if grpcClient == nil {
		initGRPC()
	}
	ctx := context.Background()
	req := &productpb.CreateProductRequest{
		Name:        "测试产品",
		Description: "这是一个用于基准测试的产品",
		Price:       99.99,
		Category:    "测试分类",
		Tags:        []string{"test", "benchmark", "grpc"},
		InStock:     true,
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, err := grpcClient.CreateProduct(ctx, req)
		if err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkRESTCreateProduct(b *testing.B) {
	client := &http.Client{Timeout: 5 * time.Second}
	reqBody, _ := json.Marshal(map[string]interface{}{
		"name":        "测试产品",
		"description": "这是一个用于基准测试的产品",
		"price":       99.99,
		"category":    "测试分类",
		"tags":        []string{"test", "benchmark", "rest"},
		"in_stock":    true,
	})
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		resp, err := client.Post("http://localhost:8080/products/",
			"application/json", bytes.NewReader(reqBody))
		if err != nil {
			b.Fatal(err)
		}
		resp.Body.Close()
	}
}

# 启动 gRPC 服务器
go run grpc_server.go

# 在另一个终端启动 REST 服务器
go run rest_server.go

# 在第三个终端运行基准测试
go test -bench=. -benchmem -benchtime=10s