基于gRpc-web的Golang微服务Web应用服务器开发

这是一个非常出色的项目！基于gRPC-Web构建的Golang微服务框架确实能够提供高性能的通信能力，特别是在Web应用中。Globular项目整合了多种数据存储和通信协议，展现了Go语言在微服务架构中的强大能力。

让我通过一些代码示例来说明如何使用类似的gRPC-Web技术栈构建Go微服务：

首先，定义gRPC服务原型：

syntax = "proto3";

package globular;

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

message UserRequest {
  string user_id = 1;
}

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

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

Go服务端实现：

package main

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

    "github.com/improbable-eng/grpc-web/go/grpcweb"
    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
)

type userService struct {
    // 集成MongoDB等存储
}

func (s *userService) GetUser(ctx context.Context, req *UserRequest) (*UserResponse, error) {
    // MongoDB查询示例
    // user, err := s.mongoCollection.FindOne(ctx, bson.M{"_id": req.UserId})
    if req.UserId == "" {
        return nil, status.Error(codes.InvalidArgument, "user_id is required")
    }
    
    return &UserResponse{
        UserId: req.UserId,
        Name:   "John Doe",
        Email:  "john@example.com",
    }, nil
}

func (s *userService) CreateUser(ctx context.Context, req *CreateUserRequest) (*UserResponse, error) {
    // MongoDB插入示例
    // result, err := s.mongoCollection.InsertOne(ctx, bson.M{
    //     "name":  req.Name,
    //     "email": req.Email,
    // })
    
    return &UserResponse{
        UserId: "generated_id",
        Name:   req.Name,
        Email:  req.Email,
    }, nil
}

func main() {
    grpcServer := grpc.NewServer()
    RegisterUserServiceServer(grpcServer, &userService{})
    
    // 包装gRPC服务器以支持Web
    wrappedServer := grpcweb.WrapServer(grpcServer)
    
    httpServer := &http.Server{
        Addr: ":8080",
        Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            if wrappedServer.IsGrpcWebRequest(r) {
                wrappedServer.ServeHTTP(w, r)
                return
            }
            // 处理其他HTTP请求
            http.DefaultServeMux.ServeHTTP(w, r)
        }),
    }
    
    log.Println("Server starting on :8080")
    if err := httpServer.ListenAndServe(); err != nil {
        log.Fatal("Server failed:", err)
    }
}

客户端JavaScript示例：

// 使用gRPC-Web客户端
const {UserServiceClient} = require('./user_service_grpc_web_pb');
const {UserRequest, CreateUserRequest} = require('./user_service_pb');

const client = new UserServiceClient('http://localhost:8080');

// 获取用户
const request = new UserRequest();
request.setUserId('123');

client.getUser(request, {}, (err, response) => {
    if (err) {
        console.error('Error:', err);
        return;
    }
    console.log('User:', response.toObject());
});

// 创建用户
const createRequest = new CreateUserRequest();
createRequest.setName('Alice');
createRequest.setEmail('alice@example.com');

client.createUser(createRequest, {}, (err, response) => {
    if (err) {
        console.error('Error:', err);
        return;
    }
    console.log('Created user:', response.toObject());
});

MySQL集成示例：

package storage

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)

type MySQLStorage struct {
    db *sql.DB
}

func NewMySQLStorage(dsn string) (*MySQLStorage, error) {
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        return nil, fmt.Errorf("failed to connect to MySQL: %w", err)
    }
    
    if err := db.Ping(); err != nil {
        return nil, fmt.Errorf("failed to ping MySQL: %w", err)
    }
    
    return &MySQLStorage{db: db}, nil
}

func (s *MySQLStorage) CreateUser(name, email string) error {
    query := "INSERT INTO users (name, email) VALUES (?, ?)"
    _, err := s.db.Exec(query, name, email)
    return err
}

func (s *MySQLStorage) GetUser(userID string) (string, string, error) {
    var name, email string
    query := "SELECT name, email FROM users WHERE id = ?"
    err := s.db.QueryRow(query, userID).Scan(&name, &email)
    return name, email, err
}

这个项目架构展示了Go语言在构建高性能微服务方面的优势，特别是结合gRPC-Web技术，能够为Web应用提供高效的通信机制。多种存储引擎的集成也体现了Go语言在系统编程方面的灵活性。