Go 微服务 Monorepo 重构实战:从代码重复到优雅复用
本文详细解析了一个 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 架构重构,我们实现了:
- 代码复用:公共模块统一维护,各服务按需引用
- 类型安全:通过泛型和接口,保持类型安全的同时支持扩展
- 独立部署:各服务独立构建、独立部署,互不影响
- 开发体验:IDE 完美支持,跳转、补全、重构都很顺畅
这种架构特别适合:
- 多个 Go 微服务共享基础设施代码
- 团队协作开发,需要统一规范
- 快速孵化新服务,复用已有能力
希望这篇文章对你有帮助!如有问题欢迎交流。