Go分层架构下：是否应将接口移至独立包并定义抽象错误？

我在Go应用中做业务层与数据层（比如数据库层）分离时，对接口的使用有疑问。我知道业界建议在接口的使用位置定义接口。

我的应用里有封装集群Worker注册/注销逻辑的RegistryService，还有用链表存储模型的Memberlist结构体。

目前我在RegistryService的实现里声明了workerProvider接口，包含SaveWorker、DeleteWorkerByID等方法，这些方法会返回错误。但当前这些错误定义在memberlist包中，我想对错误做抽象，避免和memberlist的实现强耦合。

请问我是否应该把workerProvider接口移到独立包，并在该包中定义新的错误类型？

现有代码示例 #

registry包代码

package registry

import ( ... )
var (
    ErrWorkerAlreadyRegistered = errors.New("worker is already registered")
)

type workersProvider interface {
    SaveWorker(ctx context.Context, endpoint string, zone string) (domain.Worker, error)
    DeleteWorkerByID(ctx context.Context, id uuid.UUID) (domain.Worker, error)
    ListWorkers(ctx context.Context) ([]domain.Worker, error)
    FindWorkerByID(ctx context.Context, id uuid.UUID) (domain.Worker, error)
}

type RegistryService struct {
    log *slog.Logger
    wp  workersProvider
}

func NewRegistryService(log *slog.Logger, wp workersProvider) *RegistryService {
    return &RegistryService{
        log: log,
        wp:  wp,
    }
}

func (reg *RegistryService) RegisterWorker(ctx context.Context, endpoint string, zone string) (domain.Worker, error) {
    worker, err := reg.wp.SaveWorker(ctx, endpoint, zone)
    if err != nil {
        emptyWorker := domain.Worker{}
        switch {
        case errors.Is(err, memberlist.ErrWorkerAlreadyExists):
            return emptyWorker, ErrWorkerAlreadyRegistered
        default:
            return emptyWorker, lib.WrapError(op, err)
        }
    }

    return worker, nil
}

memberlist包代码

package memberlist

import(...)

var (
        ...
    ErrWorkerAlreadyExists = errors.New("worker already exists")
        ...
)

type Memberlist struct { ... }

func New() *Memberlist { ... }

func (mlist *Memberlist) SaveWorker(_ context.Context, endpoint string, zone string) (domain.Worker, error) {
  ...
  return domain.Worker{}, ErrWorkerAlreadyExists
  ...
}


func (reg *Memberlist) DeleteWorkerByID(_ context.Context, id uuid.UUID) (domain.Worker, error) { ... }

func (reg *Memberlist) ListWorkers(_ context.Context) ([]domain.Worker, error) { ... }

func (reg *Memberlist) FindWorkerByID(_ context.Context, id uuid.UUID) (domain.Worker, error) { ... }

核心结论：不需要把接口移到独立包，但建议在业务层统一抽象错误类型 #

具体分析： #

1. 接口定义留在使用方更符合最佳实践
   你现在把workersProvider定义在registry包（接口的消费方）完全正确——Go的接口设计原则就是"小而专"，只满足当前使用方的需求即可。如果移到独立包，会额外增加依赖层级，后续接口变更的成本也会更高，完全没必要。

2. 错误抽象的关键是解耦业务层与底层实现
   你当前在registry包中定义业务错误ErrWorkerAlreadyRegistered，并把底层错误转换成业务错误的思路是对的。可以优化的点是：

   • 避免直接依赖memberlist包的错误常量，改用errors.As判断自定义错误类型，这样即使底层实现替换，业务层也不需要修改判断逻辑。
   • 在业务层定义一套完整的业务错误体系，比如用自定义结构体实现error接口，携带错误码、上下文等信息，方便上层统一处理。

3. 优化后的错误处理示例
   先修改memberlist包的错误定义：

   // memberlist包
   type WorkerAlreadyExistsError struct{}
   
   func (e *WorkerAlreadyExistsError) Error() string {
       return "worker already exists"
   }
   
   // SaveWorker方法中返回自定义错误
   func (mlist *Memberlist) SaveWorker(_ context.Context, endpoint string, zone string) (domain.Worker, error) {
       // ... 业务逻辑
       return domain.Worker{}, &WorkerAlreadyExistsError{}
   }
   

   然后业务层用errors.As识别错误：

   // registry包
   func (reg *RegistryService) RegisterWorker(ctx context.Context, endpoint string, zone string) (domain.Worker, error) {
       worker, err := reg.wp.SaveWorker(ctx, endpoint, zone)
       if err != nil {
           var existsErr *memberlist.WorkerAlreadyExistsError
           if errors.As(err, &existsErr) {
               return domain.Worker{}, ErrWorkerAlreadyRegistered
           }
           return domain.Worker{}, lib.WrapError(op, err)
       }
       return worker, nil
   }
   

4. 什么时候需要把接口移到独立包？
   只有当这个接口需要被多个不相关的业务模块使用时（比如多个业务服务都依赖同一个数据访问契约），才需要把接口放到独立的ports或repository包中作为跨模块的标准契约。你的场景里只有RegistryService使用该接口，完全不需要这么做。

内容的提问来源于stack exchange，提问作者Anastasia Guseva