golang微服务代码怎么写

要编写Golang微服务代码，首先需要了解几个关键点：使用Golang编写服务、采用RESTful API、使用gRPC通信、利用Docker进行容器化、以及集成CI/CD管道。其中，使用RESTful API是最常见且易于理解的方式。使用RESTful API可以使服务具有更好的可读性和可维护性，同时也方便了与其他服务的集成。

一、Golang微服务代码的基本结构

在编写Golang微服务时，项目的基本结构非常重要。通常，一个Golang微服务项目包括以下几个目录和文件：

main.go：主程序文件，包含服务的启动逻辑。
router/：路由配置，管理不同的API端点。
controllers/：控制器，处理业务逻辑。
models/：数据模型，定义数据结构和数据库操作。
config/：配置文件，包含数据库连接、环境变量等配置。
middlewares/：中间件，处理请求和响应的预处理逻辑。
services/：服务层，封装业务逻辑和数据访问。
utils/：工具类，提供通用的辅助函数。

main.go文件通常是程序的入口，负责初始化配置、设置路由和启动服务器。一个简单的main.go文件可能如下所示：

package main
import (
    "log"
    "net/http"
    "github.com/gorilla/mux"
    "myapp/config"
    "myapp/router"
)
func main() {
    config.LoadConfig()
    r := mux.NewRouter()
    router.SetupRoutes(r)
    log.Fatal(http.ListenAndServe(":8080", r))
}

二、路由配置

路由配置是微服务中非常关键的一部分，它负责将不同的HTTP请求映射到相应的处理函数。可以使用第三方路由库，如gorilla/mux。在router/目录下创建一个router.go文件：

package router
import (
    "github.com/gorilla/mux"
    "myapp/controllers"
)
func SetupRoutes(r *mux.Router) {
    r.HandleFunc("/api/v1/resource", controllers.GetResource).Methods("GET")
    r.HandleFunc("/api/v1/resource", controllers.CreateResource).Methods("POST")
    r.HandleFunc("/api/v1/resource/{id}", controllers.GetResourceByID).Methods("GET")
    r.HandleFunc("/api/v1/resource/{id}", controllers.UpdateResource).Methods("PUT")
    r.HandleFunc("/api/v1/resource/{id}", controllers.DeleteResource).Methods("DELETE")
}

三、控制器层

控制器负责处理具体的业务逻辑和响应生成。在controllers/目录下创建一个resource.go文件：

package controllers
import (
    "encoding/json"
    "net/http"
    "github.com/gorilla/mux"
    "myapp/models"
    "myapp/services"
)
func GetResource(w http.ResponseWriter, r *http.Request) {
    resources, err := services.GetAllResources()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    json.NewEncoder(w).Encode(resources)
}
func CreateResource(w http.ResponseWriter, r *http.Request) {
    var resource models.Resource
    if err := json.NewDecoder(r.Body).Decode(&resource); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    if err := services.CreateResource(&resource); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(resource)
}
func GetResourceByID(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    id := vars["id"]
    resource, err := services.GetResourceByID(id)
    if err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        return
    }
    json.NewEncoder(w).Encode(resource)
}
func UpdateResource(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    id := vars["id"]
    var resource models.Resource
    if err := json.NewDecoder(r.Body).Decode(&resource); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    if err := services.UpdateResource(id, &resource); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    json.NewEncoder(w).Encode(resource)
}
func DeleteResource(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    id := vars["id"]
    if err := services.DeleteResource(id); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    w.WriteHeader(http.StatusNoContent)
}

四、数据模型层

数据模型层定义了数据结构和数据库操作。在models/目录下创建一个resource.go文件：

package models
type Resource struct {
    ID   string `json:"id"`
    Name string `json:"name"`
    Data string `json:"data"`
}

五、服务层

服务层封装了具体的业务逻辑和数据访问。在services/目录下创建一个resource.go文件：

package services
import (
    "errors"
    "myapp/models"
)
var resources = make(map[string]models.Resource)
func GetAllResources() ([]models.Resource, error) {
    var result []models.Resource
    for _, resource := range resources {
        result = append(result, resource)
    }
    return result, nil
}
func CreateResource(resource *models.Resource) error {
    if _, exists := resources[resource.ID]; exists {
        return errors.New("resource already exists")
    }
    resources[resource.ID] = *resource
    return nil
}
func GetResourceByID(id string) (*models.Resource, error) {
    resource, exists := resources[id]
    if !exists {
        return nil, errors.New("resource not found")
    }
    return &resource, nil
}
func UpdateResource(id string, resource *models.Resource) error {
    if _, exists := resources[id]; !exists {
        return errors.New("resource not found")
    }
    resources[id] = *resource
    return nil
}
func DeleteResource(id string) error {
    if _, exists := resources[id]; !exists {
        return errors.New("resource not found")
    }
    delete(resources, id)
    return nil
}

六、配置文件

配置文件包含数据库连接、环境变量等配置。在config/目录下创建一个config.go文件：

package config
import (
    "log"
    "os"
)
var (
    DBHost     string
    DBPort     string
    DBUser     string
    DBPassword string
    DBName     string
)
func LoadConfig() {
    DBHost = os.Getenv("DB_HOST")
    DBPort = os.Getenv("DB_PORT")
    DBUser = os.Getenv("DB_USER")
    DBPassword = os.Getenv("DB_PASSWORD")
    DBName = os.Getenv("DB_NAME")
    if DBHost == "" || DBPort == "" || DBUser == "" || DBPassword == "" || DBName == "" {
        log.Fatal("Database configuration is not set properly")
    }
}

七、中间件

中间件用于处理请求和响应的预处理逻辑。在middlewares/目录下创建一个logging.go文件：

package middlewares
import (
    "log"
    "net/http"
    "time"
)
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 %s %v", r.Method, r.RequestURI, r.Host, time.Since(start))
    })
}

在main.go中应用这个中间件：

r.Use(middlewares.LoggingMiddleware)

八、工具类

工具类提供通用的辅助函数。在utils/目录下创建一个utils.go文件：

package utils
import (
    "log"
    "os"
)
func CheckEnvVars(vars ...string) {
    for _, v := range vars {
        if os.Getenv(v) == "" {
            log.Fatalf("Environment variable %s is not set", v)
        }
    }
}

九、使用gRPC进行通信

除了RESTful API，gRPC也是一种常见的微服务通信方式。在proto/目录下创建一个resource.proto文件：

syntax = "proto3";
package resource;
service ResourceService {
    rpc GetResource (ResourceRequest) returns (ResourceResponse);
    rpc CreateResource (Resource) returns (ResourceResponse);
    rpc UpdateResource (Resource) returns (ResourceResponse);
    rpc DeleteResource (ResourceRequest) returns (Empty);
}
message Resource {
    string id = 1;
    string name = 2;
    string data = 3;
}
message ResourceRequest {
    string id = 1;
}
message ResourceResponse {
    Resource resource = 1;
}
message Empty {}

生成Go代码：

protoc --go_out=plugins=grpc:. resource.proto

在main.go中设置gRPC服务器：

package main
import (
    "log"
    "net"
    "google.golang.org/grpc"
    "myapp/proto"
    "myapp/services"
)
func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }
    s := grpc.NewServer()
    proto.RegisterResourceServiceServer(s, &services.ResourceService{})
    if err := s.Serve(lis); err != nil {
        log.Fatalf("Failed to serve: %v", err)
    }
}

在services/目录下创建一个grpc_resource.go文件：

package services
import (
    "context"
    "myapp/proto"
)
type ResourceService struct {
    proto.UnimplementedResourceServiceServer
}
func (s *ResourceService) GetResource(ctx context.Context, req *proto.ResourceRequest) (*proto.ResourceResponse, error) {
    resource, err := GetResourceByID(req.Id)
    if err != nil {
        return nil, err
    }
    return &proto.ResourceResponse{Resource: &proto.Resource{
        Id:   resource.ID,
        Name: resource.Name,
        Data: resource.Data,
    }}, nil
}
// Implement other methods for CreateResource, UpdateResource, DeleteResource

十、利用Docker进行容器化

容器化是微服务中非常重要的一环。在项目根目录下创建一个Dockerfile：

FROM golang:1.17-alpine WORKDIR /app COPY go.mod ./ COPY go.sum ./ RUN go mod download COPY *.go ./ RUN go build -o /myapp EXPOSE 8080 CMD ["/myapp"]

创建一个docker-compose.yml文件：

version: '3.8' services: app: build: . ports: - "8080:8080" environment: - DB_HOST=db - DB_PORT=5432 - DB_USER=postgres - DB_PASSWORD=password - DB_NAME=mydb depends_on: - db db: image: postgres:13 environment: POSTGRES_USER: postgres POSTGRES_PASSWORD: password POSTGRES_DB: mydb ports: - "5432:5432"

十一、集成CI/CD管道

集成CI/CD管道可以自动化构建、测试和部署流程。这里以GitHub Actions为例，创建一个.github/workflows/ci.yml文件：

name: CI on: push: branches: - main pull_request: branches: - main jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Go uses: actions/setup-go@v2 with: go-version: 1.17 - name: Build run: go build -v ./... - name: Test run: go test -v ./... - name: Docker Build run: docker build -t myapp . - name: Docker Push run: | echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin docker tag myapp:latest ${{ secrets.DOCKER_USERNAME }}/myapp:latest docker push ${{ secrets.DOCKER_USERNAME }}/myapp:latest

通过上述步骤，便可以完成一个基本的Golang微服务项目的开发、容器化和CI/CD集成。