Golang Web应用清洁架构实践指南

根据你的描述，你已经有了一个不错的基础架构，但在依赖管理和业务逻辑组织上遇到了典型的清洁架构挑战。以下是我的分析和建议：

1. 依赖注入优化

你的控制器构造函数确实过于庞大。可以使用依赖容器或选项模式来简化：

// internal/di/container.go
package di

type Container struct {
    cfg             config.ConfigApp
    userSvc         *user.Service
    tokenSvc        *token.Service
    // ... 其他依赖
}

func NewContainer(cfg config.ConfigApp) (*Container, error) {
    db, err := database.New(cfg.Database)
    if err != nil {
        return nil, err
    }
    
    queries := repository.New(db)
    
    return &Container{
        cfg:      cfg,
        userSvc:  user.NewService(queries),
        tokenSvc: token.NewService(queries),
        // ... 初始化其他服务
    }, nil
}

// handlers/controller.go
package handlers

type Controller struct {
    container *di.Container
}

func NewController(container *di.Container) *Controller {
    return &Controller{
        container: container,
    }
}

2. 业务逻辑分离

对于文件上传这类复杂业务逻辑，应该创建专门的用例层：

// internal/usecase/fileupload.go
package usecase

type FileUploadUseCase struct {
    userRepo         user.Repository
    subscriptionRepo subscription.Repository
    productRepo      product.Repository
    storage          storage.Storage
}

func NewFileUploadUseCase(
    userRepo user.Repository,
    subscriptionRepo subscription.Repository,
    productRepo product.Repository,
    storage storage.Storage,
) *FileUploadUseCase {
    return &FileUploadUseCase{
        userRepo:         userRepo,
        subscriptionRepo: subscriptionRepo,
        productRepo:      productRepo,
        storage:          storage,
    }
}

func (uc *FileUploadUseCase) Execute(ctx context.Context, req UploadRequest) (*UploadResponse, error) {
    // 验证用户
    user, err := uc.userRepo.GetByID(ctx, req.UserID)
    if err != nil {
        return nil, err
    }
    
    // 检查订阅状态
    subscription, err := uc.subscriptionRepo.GetActive(ctx, user.ID)
    if err != nil {
        return nil, err
    }
    
    // 获取产品限制
    product, err := uc.productRepo.GetByID(ctx, subscription.ProductID)
    if err != nil {
        return nil, err
    }
    
    // 检查存储限制
    usedSpace, err := uc.storage.GetUsedSpace(ctx, user.ID)
    if err != nil {
        return nil, err
    }
    
    if usedSpace+req.FileSize > product.MaxStorage {
        return nil, ErrStorageLimitExceeded
    }
    
    // 执行上传
    fileURL, err := uc.storage.Upload(ctx, req.File, user.ID)
    if err != nil {
        return nil, err
    }
    
    return &UploadResponse{
        FileURL: fileURL,
        UserID:  user.ID,
    }, nil
}

3. 接口定义和依赖倒置

为每个服务定义接口，减少直接依赖：

// internal/domain/user/repository.go
package user

type Repository interface {
    GetByID(ctx context.Context, id int64) (*User, error)
    GetByEmail(ctx context.Context, email string) (*User, error)
    Create(ctx context.Context, user *User) error
    Update(ctx context.Context, user *User) error
}

// internal/infrastructure/persistence/user_repository.go
package persistence

type UserRepository struct {
    queries *repository.Queries
}

func (r *UserRepository) GetByID(ctx context.Context, id int64) (*user.User, error) {
    dbUser, err := r.queries.GetUserByID(ctx, id)
    if err != nil {
        return nil, err
    }
    
    return &user.User{
        ID:        dbUser.ID,
        Email:     dbUser.Email,
        CreatedAt: dbUser.CreatedAt,
    }, nil
}

4. 处理器简化

处理器只负责HTTP相关逻辑：

// internal/handlers/file_upload.go
package handlers

func (c *Controller) HandleFileUpload(w http.ResponseWriter, r *http.Request) {
    // 从上下文获取用户（中间件已设置）
    userID, ok := r.Context().Value("userID").(int64)
    if !ok {
        http.Error(w, "unauthorized", http.StatusUnauthorized)
        return
    }
    
    // 解析请求
    file, header, err := r.FormFile("file")
    if err != nil {
        http.Error(w, "invalid file", http.StatusBadRequest)
        return
    }
    defer file.Close()
    
    // 构建请求对象
    req := usecase.UploadRequest{
        UserID:   userID,
        File:     file,
        FileSize: header.Size,
        FileName: header.Filename,
    }
    
    // 执行业务逻辑
    resp, err := c.fileUploadUseCase.Execute(r.Context(), req)
    if err != nil {
        switch err {
        case usecase.ErrStorageLimitExceeded:
            http.Error(w, "storage limit exceeded", http.StatusForbidden)
        default:
            http.Error(w, "internal server error", http.StatusInternalServerError)
        }
        return
    }
    
    // 返回响应
    json.NewEncoder(w).Encode(resp)
}

5. 测试简化

使用接口可以轻松进行单元测试：

// internal/usecase/fileupload_test.go
package usecase_test

func TestFileUploadUseCase(t *testing.T) {
    mockUserRepo := &mockUserRepository{}
    mockSubRepo := &mockSubscriptionRepository{}
    mockProductRepo := &mockProductRepository{}
    mockStorage := &mockStorage{}
    
    usecase := NewFileUploadUseCase(
        mockUserRepo,
        mockSubRepo,
        mockProductRepo,
        mockStorage,
    )
    
    // 设置mock行为
    mockUserRepo.On("GetByID", mock.Anything, int64(1)).
        Return(&user.User{ID: 1, Email: "test@example.com"}, nil)
    
    // 执行测试
    resp, err := usecase.Execute(context.Background(), UploadRequest{
        UserID:   1,
        FileSize: 1024,
    })
    
    assert.NoError(t, err)
    assert.NotNil(t, resp)
}

6. 项目结构调整建议

internal/
├── domain/
│   ├── user/
│   │   ├── entity.go
│   │   ├── repository.go
│   │   └── service.go
│   ├── subscription/
│   └── product/
├── usecase/
│   ├── fileupload/
│   │   ├── usecase.go
│   │   └── port.go
│   └── userregistration/
├── infrastructure/
│   ├── persistence/
│   │   ├── user_repository.go
│   │   └── sqlc_adapter.go
│   ├── web/
│   │   ├── handlers/
│   │   └── middlewares/
│   └── storage/
└── di/
    └── container.go

这种结构的关键优势：

1. 依赖方向清晰：高层模块不依赖低层模块，都依赖抽象
2. 业务逻辑集中：用例层包含完整的业务规则
3. 易于测试：通过接口可以轻松mock依赖
4. 可维护性高：每个模块职责单一，变更影响范围小

你的服务层应该专注于领域逻辑，而不是协调多个服务。通过用例层来组合多个领域服务，处理器只负责HTTP层面的转换和响应。