DDD中Go语言实现Repository模式的最优方案及痛点解决

针对你遇到的两个核心痛点，这里提供两种兼顾领域层独立性和查询灵活性的实现思路：

方案一：领域层定义抽象查询对象，数据层做ORM适配 #

核心思路是在领域层定义不依赖任何数据库/ORM的纯查询结构体，将ORM相关的转换逻辑完全隔离到数据实现层，既避免领域层被污染，也能减少重复的if/else冗余。

领域层代码（无ORM依赖） #

package domain

import "time"

type User struct {
    ID           string
    Role         string
    CreatedAt    time.Time
    // 其他业务字段...
}

// 抽象查询对象，用指针区分"未设置"和"零值"
type UserFilter struct {
    Limit         int
    Offset        int
    RoleIn        []string
    CreatedBefore *time.Time // nil表示不启用该过滤条件
}

type IUsersRepository interface {
    GetByID(ctx context.Context, userID string) (User, error)
    Find(ctx context.Context, filter UserFilter) ([]User, error)
}

数据实现层（以GORM为例） #

package persistence

import (
    "context"
    "your-project/domain"
    "gorm.io/gorm"
)

type GormUsersRepo struct {
    db *gorm.DB
}

func (r *GormUsersRepo) Find(ctx context.Context, filter domain.UserFilter) ([]domain.User, error) {
    query := r.db.WithContext(ctx)

    // 仅当条件有效时才追加查询规则
    if filter.Limit > 0 {
        query = query.Limit(filter.Limit)
    }
    if filter.Offset > 0 {
        query = query.Offset(filter.Offset)
    }
    if len(filter.RoleIn) > 0 {
        query = query.Where("role IN ?", filter.RoleIn)
    }
    if filter.CreatedBefore != nil {
        query = query.Where("created_at < ?", *filter.CreatedBefore)
    }

    var users []domain.User
    return users, query.Find(&users).Error
}

// 实现GetByID方法...

优点：领域层完全独立，查询条件结构清晰，维护成本低；缺点：新增查询条件时需要同时修改UserFilter和数据层的转换逻辑，适合查询规则相对稳定的场景。

方案二：抽象查询修饰器，数据层做规则解析 #

如果需要更灵活的动态查询组合，可以在领域层定义纯抽象的查询修饰器（不涉及任何ORM细节），由数据层负责将修饰器转换为具体的数据库操作。

领域层代码（无ORM依赖） #

package domain

import "time"

type User struct {
    ID           string
    Role         string
    CreatedAt    time.Time
    // 其他业务字段...
}

type UserQueryModifier struct {
    Type  string // 标识修饰器类型，如"limit"、"role_in"
    Value interface{} // 携带的参数值
}

type IUsersRepository interface {
    GetByID(ctx context.Context, userID string) (User, error)
    Find(ctx context.Context, modifiers ...UserQueryModifier) ([]User, error)
}

// 领域层提供预定义的修饰器构造函数
func WithLimit(limit int) UserQueryModifier {
    return UserQueryModifier{Type: "limit", Value: limit}
}

func WithRoleIn(roles []string) UserQueryModifier {
    return UserQueryModifier{Type: "role_in", Value: roles}
}

func WithCreatedBefore(t time.Time) UserQueryModifier {
    return UserQueryModifier{Type: "created_before", Value: t}
}

数据实现层（以GORM为例） #

package persistence

import (
    "context"
    "time"
    "your-project/domain"
    "gorm.io/gorm"
)

type GormUsersRepo struct {
    db *gorm.DB
}

func (r *GormUsersRepo) Find(ctx context.Context, modifiers ...domain.UserQueryModifier) ([]domain.User, error) {
    query := r.db.WithContext(ctx)

    for _, mod := range modifiers {
        switch mod.Type {
        case "limit":
            query = query.Limit(mod.Value.(int))
        case "role_in":
            query = query.Where("role IN ?", mod.Value.([]string))
        case "created_before":
            query = query.Where("created_at < ?", mod.Value.(time.Time))
        // 新增条件时只需扩展case分支
        }
    }

    var users []domain.User
    return users, query.Find(&users).Error
}

优点：支持动态组合查询条件，领域层无需感知数据库细节；缺点：需要维护修饰器类型与数据库操作的映射关系，适合查询规则频繁变化的场景。

额外优化建议 #

如果觉得数据层的if/else或switch分支过于冗余，可以结合代码生成工具（如go generate），根据领域层的查询对象或修饰器自动生成对应的数据库转换代码，减少手动重复劳动。

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