什么是简洁架构？

著名作者Robert “Uncle Bob” Martin 在他的著作“简洁架构：软件结构和设计的工匠指南*”中提出了一个架构，其中包含可测试性和框架独立性，数据库和接口等重要方面。

Clean Architecture中的约束条件是：

  • 独立于框架。该体系结构不依赖于某些功能强大的软件库的存在。这使您可以使用这样的框架作为工具，而不必将系统塞进有限的约束中。
  • 可测试。业务规则可以在没有UI，数据库，Web服务器或任何其他外部元素的情况下进行测试。
  • 独立于用户界面。用户界面可以轻松更改，而无需更改系统的其余部分。例如，Web UI可以替换为控制台UI，而无需更改业务规则。
  • 独立于数据库。您可以替换Oracle或SQL Server，而使用Mongo，BigTable，CouchDB或其他。您的业​​务规则不绑定到数据库。
  • 独立于任何外部机构。事实上，你的业​​务规则根本就不了解外面的世界。

所以，基于这个约束，每个层必须是独立的和可测试的。

根据Uncle Bob的体系结构设计，我们可以将代码分为四层：

  • Entities实体：封装企业范围的业务规则。Go中的实体是一组数据结构和功能。
  • Use Cases用例：该层中的软件包含特定于应用程序的业务规则。它封装并实现了系统的所有用例。
  • Controller控制器：该层中的软件是一组适配器，可将数据从用例和实体最方便的格式转换为最适合某些外部机构（如数据库或Web）的格式
  • Framework & Driver 框架和驱动程序：该层通常由框架和工具组成，如数据库，Web框架等。

Golang的简洁架构

让我们以包用户为例：

ls -ln pkg/user
-rw-r — r — 1 501 20 5078 Feb 16 09:58 entity.go
-rw-r — r — 1 501 20 3747 Feb 16 10:03 mongodb.go
-rw-r — r — 1 501 20 509 Feb 16 09:59 repository.go
-rw-r — r — 1 501 20 2403 Feb 16 10:30 service.go

在文件entity.go中，我们有我们的实体：

//User data
type User struct {
    ID                 entity.ID    `json:"id" bson:"_id,omitempty"`
    Picture            string       `json:"picture" bson:"picture,omitempty"`
    Email              string       `json:"email" bson:"email"`
    Password           string       `json:"password" bson:"password,omitempty"`
    Type               Type         `json:"type" bson:"type"`
    Company            []*Company   `json:"company" bson:"company,omitempty"`
    CreatedAt          time.Time    `json:"created_at" bson:"created_at"`
    ValidatedAt        time.Time    `json:"validated_at" bson:"validated_at,omitempty"`
}

在文件repository.go中，我们有定义存储库的接口，其中实体将被存储。在这种情况下，存储库意味着Bob的Uncle Bob体系结构中的Framework＆Driver层。他的内容是：

package user

import "github.com/thecodenation/stamp/pkg/entity"

//Repository repository interface
type Repository interface {
    Find(id entity.ID) (*User, error)
    FindByEmail(email string) (*User, error)
    FindByChangePasswordHash(hash string) (*User, error)
    FindByValidationHash(hash string) (*User, error)
    FindAll() ([]*User, error)
    Update(user *User) error
    Store(user *User) (entity.ID, error)
    AddCompany(id entity.ID, company *Company) error
    AddInvite(userID entity.ID, companyID entity.ID) error
}

这个接口可以在任何类型的存储层中实现，比如MongoDB，MySQL等等。在我们的例子中，我们使用MongoDB来实现，如mongodb.go中所示：

package user

import (
    "errors"
    "os"
    "github.com/juju/mgosession"
    "github.com/thecodenation/stamp/pkg/entity"
    mgo "gopkg.in/mgo.v2"
    "gopkg.in/mgo.v2/bson"
)

type repo struct {
    pool *mgosession.Pool
}

//NewMongoRepository create new repository
func NewMongoRepository(p *mgosession.Pool) Repository {
    return &repo{
        pool: p,
    }
}

func (r *repo) Find(id entity.ID) (*User, error) {
    result := User{}
    session := r.pool.Session(nil)
    coll := session.DB(os.Getenv("MONGODB_DATABASE")).C("user")
    err := coll.Find(bson.M{"_id": id}).One(&result)
    if err != nil {
        return nil, err
    }
    return &result, nil
}

func (r *repo) FindByEmail(email string) (*User, error) {
}

func (r *repo) FindByChangePasswordHash(hash string) (*User, error) {
}

func (r *repo) FindAll() ([]*User, error) {
}

func (r *repo) Update(user *User) error {
}

func (r *repo) Store(user *User) (entity.ID, error) {
}

func (r *repo) AddCompany(id entity.ID, company *Company) error {
}

func (r *repo) AddInvite(userID entity.ID, companyID entity.ID) error {
}

func (r *repo) FindByValidationHash(hash string) (*User, error) {
}

文件service.go代表由Uncle Bob定义的用例层。在文件中我们有接口Service和他的实现。该service接口是：

//Service service interface
type Service interface {
    Register(user *User) (entity.ID, error)
    ForgotPassword(user *User) error
    ChangePassword(user *User, password string) error
    Validate(user *User) error
    Auth(user *User, password string) error
    IsValid(user *User) bool
    GetRepo() Repository
}

最后一层，我们架构中的Controller实现在api的内容中：

cd api ; tree
.
|____handler
| |____company.go
| |____user.go
| |____address.go
| |____skill.go
| |____invite.go
| |____position.go
|____rice-box.go
|____main.go

在下面的代码中，从api / main.go中，我们可以看到如何使用这些服务：

session, err := mgo.Dial(os.Getenv("MONGODB_HOST"))
if err != nil {
    elog.Error(err)
}
mPool := mgosession.NewPool(nil, session, 1)
queueService, err := queue.NewAWSService()
if err != nil {
        elog.Error(err)
}
userRepo := user.NewMongoRepository(mPool)
userService := user.NewService(userRepo, queueService)

现在我们可以轻松的为我们的软件包创建测试，例如：

package user

import (
    "testing"
    "time"

    "github.com/thecodenation/stamp/pkg/entity"
    "github.com/thecodenation/stamp/pkg/queue"
)

func TestIsValidUser(t *testing.T) {
    u := User{
        ID:        entity.NewID(),
        FirstName: "Bill",
        LastName:  "Gates",
    }
    userRepo := NewInmemRepository()
    queueService, _ := queue.NewInmemService()
    userService := NewService(userRepo, queueService)

    if userService.IsValid(&u) == true {
        t.Errorf("got %v want %v",
            true, false)
    }

    u.ValidatedAt = time.Now()
    if userService.IsValid(&u) == false {
        t.Errorf("got %v want %v",
            false, true)
    }
}

使用Clean Architecture，我们可以将数据库从MongoDB更改为Neo4j，而不用改写其他应用层。我们可以在不损失质量和开发效率的情况下进行迭代。

References