Question

我正在尝试使用Go跟踪Clean Architecture。该应用程序是一个简单的图像管理应用程序。

我想知道如何最好地设计我的存储库层的接口。我不想将所有存储库方法组合到一个大接口中，就像我发现的一些示例一样，我认为在Go中，小接口通常是首选。我认为与管理映像有关的用例代码不需要知道存储库还可以存储用户。因此，我想拥有UserReader，UserWriter和ImageReader和ImageWriter。复杂之处在于代码需要是事务性的。事务管理属于“清洁体系结构”的范畴尚有争议，但我认为用例层需要能够控制事务。我认为单笔交易属于业务规则，而不是技术细节。

现在的问题是，如何构造接口？

功能方法

因此，通过这种方法，我打开一个事务，运行提供的功能，然后在没有错误的情况下提交。

type UserRepository interface {
    func ReadTransaction(txFn func (UserReader) error) error
    func WriteTransaction(txFn func (UserWriter) error) error
}

type ImageRepository interface {
    func ReadTransaction(txFn func (ImageReader) error) error
    func WriteTransaction(txFn func (ImageWriter) error) error
}

问题：不，我不能在单个事务中轻松编写用户和图像，我必须为此创建一个额外的UserImageRepository接口，并提供单独的实现

作为存储库的交易

type ImageRepository interface {
    func Writer() ImageReadWriter
    func Reader() ImageReader
}

我认为这与功能方法非常相似。它不会解决合并使用多个存储库的问题，但至少可以通过编写一个简单的包装程序来实现。

一个实现可能看起来像这样：

type BoltDBRepository struct {}
type BoltDBTransaction struct { *bolt.Tx }
func (tx *BoltDBTransaction) WriteImage(i usecase.Image) error
func (tx *BoltDBTransaction) WriteUser(i usecase.User) error
....

不幸的是，如果我实现这样的事务方法：

func (r *BoltDBRepository) Writer() *BoltDBTransaction
func (r *BoltDBRepository) Reader() *BoltDBTransaction

因为它没有实现ImageRepository接口，所以我需要一个简单的包装器

type ImageRepository struct { *BoltDBRepository }
func (ir *ImageRepository) Writer() usecase.ImageReadWriter
func (ir *ImageRepository) Reader() usecase.ImageReader

交易作为价值

type ImageReader interface {
    func WriteImage(tx Transaction, i Image) error
}

type Transaction interface { 
    func Commit() error
}

type Repository interface {
    func BeginTransaction() (Transaction, error)
}

和存储库实现看起来像这样

type BoltDBRepository struct {}
type BoltDBTransaction struct { *bolt.Tx }

// implement ImageWriter
func (repo *BoltDBRepository) WriteImage(tx usecase.Transaction, img usecase.Image) error {
  boltTx := tx.(*BoltDBTransaction)
  ...
}

问题：虽然可以，但是我必须在每个存储库方法的开头键入assert，这似乎有些乏味。

这些是我可以想到的方法。哪个最合适，或者有更好的解决方案？

Answer 1

存储库表示保存数据的位置，建筑元素也是如此。

交易是解决非功能性需求（原子操作）的技术细节，因此必须像内部引用或架构元素中的私有功能一样使用。

在这种情况下，如果您的存储库是这样写的：

type UserRepository interface {
    func Keep(UserData) error
    func Find(UUID) UserData
}

type ImageRepository interface {
    func Keep(ImageData) error
    func Find(UUID) ImageData
}

事务处理方法是实现的详细信息，因此您可以创建UserRepository和ImageRepository的“实现”，将其像内部引用一样使用。

type UserRepositoryImpl struct {
    Tx Transaction
}

func (r UserRepository) func Keep(UserData) error { return r.Tx.On(...)} 
func (r UserRepository) func Find(UUID) UserData { return r.Tx.WithResult(...)}

这样，您也可以将用户和图像保持在单个事务中。

例如，如果客户端具有对userRepository和imageRepository的引用，并且它负责userData和imageData，并且还希望将两个数据都保留在单个事务中，那么：

//open transaction and set in participants
tx := openTransaction()
ur := NewUserRepository(tx)
ir := NewImageRepository(tx)
//keep user and image datas
err0 := ur.Keep(userData)
err1 := ir.Keep(imageData)
//decision
if err0 != nil || err1 != nil {
  tx.Rollback()
  return
}
tx.Commit()

这是干净，客观且在洋葱体系结构，DDD和3层体系结构（马丁·福勒）中可以很好地工作！

在洋葱架构中：

实体：用户和图像（无业务规则）
用例：存储库界面（应用程序规则：保留用户和图像）
控制器：A / N
DB / Api ：客户端，TX，存储库实现

Answer 2

如果您要回购，则必须保留一些状态字段

type UserRepositoryImpl struct {
    db Transaction
    someState bool
}

func (repo *UserRepositoryImpl) WithTx(tx Transaction) *UserRepositoryImpl {
    newRepo := *repo
    repo.db = tx
    return &newRepo
}

func main() {
    repo := &UserRepositoryImpl{ 
        db: connectionInit(),
        state: true,
    }

    repo.DoSomething()

    tx := openTransaction()
    txrepo := repo.WithTx(tx)

    txrepo.DoSomething()
    txrepo.DoSomethingElse()
}

Golang交易API设计

功能方法

作为存储库的交易

交易作为价值

2 个答案: