Go API架构设计指南 #

project/  
├── main.go  
├── server.go // HTTP服务器  
├── handler.go // 处理函数  
└── store.go // 数据存储  

project/  
├── cmd/server/  
├── user.go // User相关所有逻辑  
├── order.go // Order相关所有逻辑  
├── payment.go // Payment相关所有逻辑  
└── database.go // 共享数据库连接  

project/  
├── cmd/  
├── internal/  
│ ├── user/  
│ │ ├── handler.go // HTTP处理  
│ │ ├── service.go // 业务逻辑  
│ │ └── store.go // 数据存储  
│ └── order/  
└── pkg/  

// 现状：Service层职责不清  
func MakeBillOverData(accountId string) (*OverviewData, error) {  
// 1. 数据查询 - 应该在Repository层  
results, _, err := form.Search(false)  
  
// 2. 业务计算 - Service层真正的职责  
for i := 0; i < len(*results); i++ {  
// 100+行的循环计算...  
}  
  
// 3. 数据转换 - 应该在DTO层  
return &overviewData, nil  
}  

// N+1查询问题  
for i := 0; i < len(*allAccount); i++ {  
for j := 0; j < len(*all); j++ {  
// 嵌套循环，O(n²)复杂度  
}  
}  

handlers/  
├── router.go // 50行：路由定义  
├── bill.go // 200行：账单相关  
├── account.go // 150行：账户相关  
├── mail.go // 200行：邮件相关  
└── middleware.go // 50行：中间件  

const (  
DefaultAnalysisMonths = 12  
DefaultRecentRecords = 5  
DefaultPageSize = 20  
)  

func HandleError(c *gin.Context, err error) {  
if qzErr, ok := err.(*e.QzError); ok {  
c.JSON(qzErr.Code, qzErr.ToResponse())  
} else {  
c.JSON(500, gin.H{"error": err.Error()})  
}  
}  

// 使用JOIN替代嵌套循环  
SELECT a.*, array_agg(ar.bill_name) as bill_names  
FROM accounts a  
LEFT JOIN account_relations ar ON a.id = ar.account_id  
GROUP BY a.id  

type BillService struct {  
cache map[string]*OverviewData  
cacheExpiry map[string]time.Time  
mu sync.RWMutex  
}  
  
func (s *BillService) GetOverview(accountId string) (*OverviewData, error) {  
if data := s.getFromCache(accountId); data != nil {  
return data, nil  
}  
// ... 计算逻辑  
s.setCache(accountId, data, 5*time.Minute)  
return data, nil  
}  

type BillRepository struct {  
db *gorm.DB  
}  
  
func (r *BillRepository) FindByAccount(ctx context.Context, accountID string) ([]*Bill, error) {  
// 数据访问逻辑  
}  
  
type BillService struct {  
repo *BillRepository  
config *Config  
}  

// 1. 路由组织（from Memos）  
func (s *Server) registerRoutes() {  
api := s.e.Group("/api")  
api.GET("/memo", s.GetMemoList)  
api.POST("/memo", s.CreateMemo)  
api.PATCH("/memo/:id", s.UpdateMemo)  
}  
  
// 2. 中间件链（from PocketBase）  
api.router.GET("/api/records",  
api.requireAuth(),  
api.paginate(),  
api.listRecords,  
)  
  
// 3. 依赖注入（from Answer）  
func NewQuestionController(  
questionService *service.QuestionService,  
rankService *service.RankService,  
) *QuestionController {  
return &QuestionController{  
questionService: questionService,  
rankService: rankService,  
}  
}  

// MVP模式：快速验证  
func QuickHandler(c *gin.Context) {  
// 直接在handler实现，快速验证想法  
}  
  
// 稳定后重构  
type Service struct {  
repo *Repository  
}  
func (s *Service) StableBusinessLogic() {  
// 功能稳定后，再抽取到Service层  
}  

// 1. 统一错误处理  
type APIError struct {  
Code int `json:"code"`  
Message string `json:"message"`  
}  
  
// 2. 请求/响应规范  
type PageRequest struct {  
Page int `json:"page" binding:"min=1"`  
PageSize int `json:"pageSize" binding:"min=1,max=100"`  
}  
  
// 3. 日志规范  
logger.WithField("user_id", userID).Info("User logged in")  

billx/  
├── cmd/billx/ # 应用入口  
├── internal/ # 私有代码  
│ ├── handler/ # HTTP处理器  
│ ├── service/ # 业务逻辑（需要时才加）  
│ └── repository/ # 数据访问  
├── pkg/ # 公共包  
│ ├── logger/ # 日志  
│ └── config/ # 配置  
├── api/ # API文档  
└── scripts/ # 脚本工具