Go 微服务 Monorepo 重构实战:从代码重复到优雅复用

2026-01-07后端5 分钟239 次阅读
AI 摘要salmon-ai

本文详细解析了一个 Go 微服务项目从多仓库独立服务重构为 Monorepo 的实战过程,重点说明了三个服务中 common、认证中间件、Redis 工具、日志和数据库连接等代码重复

本文记录了一次真实的 Go 微服务项目重构过程,将三个独立服务整合为 Monorepo 架构,实现公共模块抽象和代码复用。

一、背景

1.1 项目现状

我的后端微服务项目 s-cloud 采用 Java + Go 混合架构:

  • Java 服务:认证、博客、AI、搜索等核心业务
  • Go 服务:宠物小程序、壁纸服务、爬虫服务

随着 Go 服务数量增加,我发现一个严重问题:三个 Go 服务有大量重复代码。

1.2 重复代码分析

对比三个服务的 internal/common/ 目录:

复制代码
pet-service/internal/common/          wallpaper-service/internal/common/    crawler-service/internal/common/
├── base/                             ├── base/                             ├── base/
├── constants/                        ├── constants/                        ├── constants/
├── contextx/                         ├── contextx/                         ├── contextx/
├── enums/                            ├── enums/                            ├── enums/
├── redisutil/                        ├── redisutil/                        ├── redisutil/
├── response/                         ├── response/                         ├── response/
├── security/                         ├── security/                         ├── security/
├── types/                            ├── types/                            ├── types/
└── vo/                               └── vo/                               └── vo/

以 response/resultvo.go 为例,三个服务的代码几乎一模一样,只是 import 路径不同:

go 复制代码
// pet-service
import "pet-service/internal/common/enums"

// wallpaper-service  
import "wallpaper-service/internal/common/enums"

// crawler-service
import "crawler-service/internal/common/enums"

同样的问题存在于:

  • 认证中间件 middleware/auth.go
  • Redis 工具 redisutil/
  • 日志组件 pkg/logger/
  • 数据库连接 dal/mysql/、dal/redis/

1.3 痛点总结

问题 影响
代码重复 3份相同代码,维护成本 x3
修改同步 改一处需改三处,容易遗漏
新服务接入 需要复制粘贴大量代码
版本不一致 各服务公共代码可能存在差异

二、解决方案:Go Workspace + Monorepo

2.1 技术选型

Go 1.18+ 引入了 Go Workspace 特性,完美支持 Monorepo 架构:

  • go.work 文件管理多个模块
  • 各模块可以相互引用
  • 独立构建、独立部署
  • IDE 完美支持

2.2 目标架构

复制代码
s-cloud-go/
├── go.work                    # Workspace 配置
├── pkg/                       # 公共模块
│   ├── go.mod
│   ├── response/              # 统一响应
│   ├── auth/                  # 认证中间件
│   ├── dal/                   # 数据访问层
│   └── ...
└── services/                  # 业务服务
    ├── pet/                   # 宠物服务
    │   ├── go.mod
    │   └── ...
    ├── wallpaper/             # 壁纸服务
    └── crawler/               # 爬虫服务

三、完整 Demo 实现

下面是一个可直接运行的最小化 Demo,演示 Monorepo 架构。

3.1 创建项目结构

bash 复制代码
mkdir -p go-monorepo-demo/{pkg,services/demo}
cd go-monorepo-demo

3.2 创建公共模块 pkg

pkg/go.mod

go 复制代码
module github.com/example/go-monorepo-demo/pkg

go 1.21

pkg/response/result.go

go 复制代码
package response

// ResultVO 统一响应结构
type ResultVO[T any] struct {
	Code int    `json:"code"`
	Msg  string `json:"msg"`
	Data T      `json:"data"`
}

// Ok 成功响应
func Ok[T any]() ResultVO[T] {
	return ResultVO[T]{Code: 200, Msg: "success"}
}

// OkData 成功响应(带数据)
func OkData[T any](data T) ResultVO[T] {
	return ResultVO[T]{Code: 200, Msg: "success", Data: data}
}

// Fail 失败响应
func Fail[T any](msg string) ResultVO[T] {
	return ResultVO[T]{Code: 500, Msg: msg}
}

// FailWithCode 失败响应(自定义错误码)
func FailWithCode[T any](code int, msg string) ResultVO[T] {
	return ResultVO[T]{Code: code, Msg: msg}
}

pkg/auth/middleware.go

go 复制代码
package auth

import (
	"net/http"
	"strings"

	"github.com/gin-gonic/gin"

	"github.com/example/go-monorepo-demo/pkg/response"
)

// UserInfo 用户信息接口
type UserInfo interface {
	GetUserID() int64
	GetNickname() string
}

// Config 认证配置
type Config struct {
	// TokenHeader 请求头名称,默认 Authorization
	TokenHeader string
	// TokenPrefix Token 前缀,默认 Bearer
	TokenPrefix string
	// ValidateToken Token 验证函数
	ValidateToken func(token string) bool
	// ParseUser 解析用户信息函数
	ParseUser func(token string) (UserInfo, error)
}

// DefaultConfig 默认配置
func DefaultConfig() *Config {
	return &Config{
		TokenHeader: "Authorization",
		TokenPrefix: "Bearer ",
		ValidateToken: func(token string) bool {
			return token != ""
		},
	}
}

// Middleware 认证中间件
func Middleware(cfg *Config, requireLogin bool) gin.HandlerFunc {
	if cfg == nil {
		cfg = DefaultConfig()
	}

	return func(c *gin.Context) {
		// 提取 Token
		authHeader := c.GetHeader(cfg.TokenHeader)
		token := ""
		if authHeader != "" {
			if strings.HasPrefix(authHeader, cfg.TokenPrefix) {
				token = authHeader[len(cfg.TokenPrefix):]
			}
		}

		// 存入 Context
		c.Set("token", token)

		if requireLogin {
			if token == "" {
				c.JSON(http.StatusOK, response.FailWithCode[any](401, "未登录"))
				c.Abort()
				return
			}
			if !cfg.ValidateToken(token) {
				c.JSON(http.StatusOK, response.FailWithCode[any](403, "Token 无效"))
				c.Abort()
				return
			}
			// 解析用户信息
			if cfg.ParseUser != nil {
				if user, err := cfg.ParseUser(token); err == nil {
					c.Set("user", user)
				}
			}
		}

		c.Next()
	}
}

// GetToken 从 Context 获取 Token
func GetToken(c *gin.Context) string {
	if v, ok := c.Get("token"); ok {
		return v.(string)
	}
	return ""
}

// GetUser 从 Context 获取用户信息
func GetUser[T UserInfo](c *gin.Context) (T, bool) {
	var zero T
	if v, ok := c.Get("user"); ok {
		if user, ok := v.(T); ok {
			return user, true
		}
	}
	return zero, false
}

pkg/logger/logger.go

go 复制代码
package logger

import (
	"log"
	"os"
)

var (
	infoLogger  = log.New(os.Stdout, "[INFO] ", log.Ldate|log.Ltime|log.Lshortfile)
	errorLogger = log.New(os.Stderr, "[ERROR] ", log.Ldate|log.Ltime|log.Lshortfile)
)

func Info(format string, v ...any) {
	infoLogger.Printf(format, v...)
}

func Error(format string, v ...any) {
	errorLogger.Printf(format, v...)
}

3.3 创建业务服务 demo

services/demo/go.mod

go 复制代码
module github.com/example/go-monorepo-demo/services/demo

go 1.21

require (
	github.com/example/go-monorepo-demo/pkg v0.0.0
	github.com/gin-gonic/gin v1.9.1
)

services/demo/internal/model/user.go

go 复制代码
package model

// DemoUser 演示用户
type DemoUser struct {
	ID       int64  `json:"id"`
	Nickname string `json:"nickname"`
	Role     string `json:"role"`
}

// GetUserID 实现 UserInfo 接口
func (u *DemoUser) GetUserID() int64 {
	return u.ID
}

// GetNickname 实现 UserInfo 接口
func (u *DemoUser) GetNickname() string {
	return u.Nickname
}

services/demo/internal/handler/handler.go

go 复制代码
package handler

import (
	"github.com/gin-gonic/gin"

	"github.com/example/go-monorepo-demo/pkg/auth"
	"github.com/example/go-monorepo-demo/pkg/logger"
	"github.com/example/go-monorepo-demo/pkg/response"
	"github.com/example/go-monorepo-demo/services/demo/internal/model"
)

// Hello 公开接口
func Hello(c *gin.Context) {
	logger.Info("Hello endpoint called")
	c.JSON(200, response.OkData("Hello, Go Monorepo!"))
}

// Profile 需要登录的接口
func Profile(c *gin.Context) {
	user, ok := auth.GetUser[*model.DemoUser](c)
	if !ok {
		c.JSON(200, response.Fail[any]("获取用户信息失败"))
		return
	}
	logger.Info("Profile endpoint called by user: %s", user.Nickname)
	c.JSON(200, response.OkData(user))
}

// List 列表接口
func List(c *gin.Context) {
	items := []map[string]any{
		{"id": 1, "name": "Item 1"},
		{"id": 2, "name": "Item 2"},
		{"id": 3, "name": "Item 3"},
	}
	c.JSON(200, response.OkData(items))
}

services/demo/cmd/main.go

go 复制代码
package main

import (
	"github.com/gin-gonic/gin"

	"github.com/example/go-monorepo-demo/pkg/auth"
	"github.com/example/go-monorepo-demo/pkg/logger"
	"github.com/example/go-monorepo-demo/services/demo/internal/handler"
	"github.com/example/go-monorepo-demo/services/demo/internal/model"
)

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

	// 配置认证
	authCfg := &auth.Config{
		TokenHeader: "Authorization",
		TokenPrefix: "Bearer ",
		ValidateToken: func(token string) bool {
			// 简单验证:token 不为空即可
			return token != ""
		},
		ParseUser: func(token string) (auth.UserInfo, error) {
			// 模拟解析用户(实际项目从 Redis/JWT 解析)
			return &model.DemoUser{
				ID:       1001,
				Nickname: "测试用户",
				Role:     "user",
			}, nil
		},
	}

	// 公开接口
	r.GET("/hello", handler.Hello)
	r.GET("/list", handler.List)

	// 需要登录的接口
	authGroup := r.Group("/api")
	authGroup.Use(auth.Middleware(authCfg, true))
	{
		authGroup.GET("/profile", handler.Profile)
	}

	logger.Info("Server starting on :8080")
	r.Run(":8080")
}

3.4 创建 go.work

在项目根目录创建 go.work:

go 复制代码
go 1.21

use (
	./pkg
	./services/demo
)

3.5 完整目录结构

复制代码
go-monorepo-demo/
├── go.work
├── pkg/
│   ├── go.mod
│   ├── auth/
│   │   └── middleware.go
│   ├── logger/
│   │   └── logger.go
│   └── response/
│       └── result.go
└── services/
    └── demo/
        ├── go.mod
        ├── cmd/
        │   └── main.go
        └── internal/
            ├── handler/
            │   └── handler.go
            └── model/
                └── user.go

3.6 运行 Demo

bash 复制代码
# 进入项目根目录
cd go-monorepo-demo

# 下载依赖
go work sync

# 运行服务
go run ./services/demo/cmd/main.go

3.7 测试接口

bash 复制代码
# 公开接口
curl http://localhost:8080/hello
# {"code":200,"msg":"success","data":"Hello, Go Monorepo!"}

curl http://localhost:8080/list
# {"code":200,"msg":"success","data":[{"id":1,"name":"Item 1"},{"id":2,"name":"Item 2"},{"id":3,"name":"Item 3"}]}

# 需要登录的接口(无 Token)
curl http://localhost:8080/api/profile
# {"code":401,"msg":"未登录","data":null}

# 需要登录的接口(带 Token)
curl -H "Authorization: Bearer test-token" http://localhost:8080/api/profile
# {"code":200,"msg":"success","data":{"id":1001,"nickname":"测试用户","role":"user"}}

四、核心设计要点

4.1 用户信息泛型化

不同服务的用户信息结构不同,通过接口 + 泛型解决:

go 复制代码
// pkg/auth/middleware.go
type UserInfo interface {
    GetUserID() int64
    GetNickname() string
}

// 各服务实现自己的用户结构
type PetUser struct { ... }      // 宠物服务
type AdminUser struct { ... }    // 管理后台

4.2 配置注入

通过配置结构体注入服务特定逻辑:

go 复制代码
authCfg := &auth.Config{
    ValidateToken: myValidateFunc,  // 自定义验证逻辑
    ParseUser:     myParseFunc,     // 自定义解析逻辑
}

4.3 模块独立性

  • pkg/ 不依赖任何业务服务
  • 各服务只依赖 pkg/,不相互依赖
  • 可独立构建、独立部署

五、重构收益

维度 重构前 重构后
代码重复 3份相同的 common 代码 1份公共 pkg
维护成本 改一处需改3处 改一处全局生效
新服务接入 复制粘贴大量代码 引用 pkg + 写业务
构建方式 各服务独立构建 统一构建 + 独立打包
代码行数 ~15000 行(含重复) ~8000 行

六、注意事项

6.1 go.work 不要提交到 Git

go.work 是本地开发用的,不应该提交到版本控制:

gitignore 复制代码
# .gitignore
go.work
go.work.sum

6.2 CI/CD 构建

在 CI 环境中,使用 replace 指令替代 go.work:

go 复制代码
// services/demo/go.mod
replace github.com/example/go-monorepo-demo/pkg => ../../pkg

6.3 版本管理

如果需要发布 pkg 为独立包,可以打 tag:

bash 复制代码
git tag pkg/v1.0.0
git push origin pkg/v1.0.0

七、总结

通过 Go Workspace + Monorepo 架构重构,我们实现了:

  1. 代码复用:公共模块统一维护,各服务按需引用
  2. 类型安全:通过泛型和接口,保持类型安全的同时支持扩展
  3. 独立部署:各服务独立构建、独立部署,互不影响
  4. 开发体验:IDE 完美支持,跳转、补全、重构都很顺畅

这种架构特别适合:

  • 多个 Go 微服务共享基础设施代码
  • 团队协作开发,需要统一规范
  • 快速孵化新服务,复用已有能力

希望这篇文章对你有帮助!如有问题欢迎交流。

觉得有用就点个赞,不用登录也能读

评论

0 条
登录 之后才能评论
—
还没有评论,来说第一句