Go：如何实现领域驱动设计（DDD），特殊渠道拿到阿里大厂面试真题

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Golang全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注go）

正文

func NewClient(cfg Config) (*Client, error) {

var addrs []string

if len(cfg.Addresses) == 0 && cfg.CloudID == “” {

addrs = addrsFromEnvironment()

} else {

if len(cfg.Addresses) > 0 && cfg.CloudID != “” {

return nil, errors.New(“cannot create client: both Addresses and CloudID are set”)

}

if cfg.CloudID != “” {

cloudAddr, err := addrFromCloudID(cfg.CloudID)

if err != nil {

return nil, fmt.Errorf(“cannot create client: cannot parse CloudID: %s”, err)

}

addrs = append(addrs, cloudAddr)

}

if len(cfg.Addresses) > 0 {

addrs = append(addrs, cfg.Addresses…)

}

}

urls, err := addrsToURLs(addrs)

if err != nil {

return nil, fmt.Errorf(“cannot create client: %s”, err)

}

if len(urls) == 0 {

u, _ := url.Parse(defaultURL) // errcheck exclude

urls = append(urls, u)

}

// TODO(karmi): Refactor

if urls[0].User != nil {

cfg.Username = urls[0].User.Username()

pw, _ := urls[0].User.Password()

cfg.Password = pw

}

tp, err := estransport.New(estransport.Config{

URLs: urls,

Username: cfg.Username,

Password: cfg.Password,

APIKey: cfg.APIKey,

ServiceToken: cfg.ServiceToken,

Header: cfg.Header,

CACert: cfg.CACert,

RetryOnStatus: cfg.RetryOnStatus,

DisableRetry: cfg.DisableRetry,

EnableRetryOnTimeout: cfg.EnableRetryOnTimeout,

MaxRetries: cfg.MaxRetries,

RetryBackoff: cfg.RetryBackoff,

CompressRequestBody: cfg.CompressRequestBody,

EnableMetrics: cfg.EnableMetrics,

EnableDebugLogger: cfg.EnableDebugLogger,

DisableMetaHeader: cfg.DisableMetaHeader,

DiscoverNodesInterval: cfg.DiscoverNodesInterval,

Transport: cfg.Transport,

Logger: cfg.Logger,

Selector: cfg.Selector,

ConnectionPoolFunc: cfg.ConnectionPoolFunc,

})

if err != nil {

return nil, fmt.Errorf(“error creating transport: %s”, err)

}

client := &Client{Transport: tp}

client.API = esapi.New(client)

if cfg.DiscoverNodesOnStart {

go client.DiscoverNodes()

}

return client, nil

}

DDD建议使用工厂来创建复杂的聚合、仓库和服务。我们将实现一个工厂函数，该函数将创建一个新的Customer实例。将创建一个名为NewCustomer的函数，它接受一个name参数，函数内部发生的事情不需要创建新customer的领域所知。

NewCustomer将验证输入是否包含创建Customer所需的所有参数：

在实际的应用程序中，我可能会建议在领域/客户中包含聚合的Customer和工厂。

package aggregate

import (

“errors”

“github.com/google/uuid”

“github.com/percybolmer/ddd-go/entity”

“github.com/percybolmer/ddd-go/valueobject”

)

var (

// 当person在newcustom工厂中无效时返回ErrInvalidPerson

ErrInvalidPerson = errors.New(“a customer has to have an valid person”)

)

type Customer struct {

// Person是客户的根实体

// person.ID是aggregate的主标志符

Person *entity.Person bson:"person"

// 一个客户可以持有许多产品

Products []*entity.Item bson:"products"

// 一个客户可以执行许多事务

Transactions []valueobject.Transaction bson:"transactions"

}

// NewCustomer是创建新的Customer聚合的工厂

// 它将验证名称是否为空

func NewCustomer(name string) (Customer, error) {

// 验证Name不是空的

if name == “” {

return Customer{}, ErrInvalidPerson

}

// 创建一个新person并生成ID

person := &entity.Person{

Name: name,

ID: uuid.New(),

}

// 创建一个customer对象并初始化所有的值以避免空指针异常

return Customer{

Person: person,

Products: make([]*entity.Item, 0),

Transactions: make([]valueobject.Transaction, 0),

}, nil

}

customer工厂函数现在帮助验证输入、创建新ID并确保正确初始化所有值。

现在我们已经有了一些业务逻辑，可以开始添加单元测试了。我将在aggregate包中创建一个customer_test.go，在其中测试与Customer相关的逻辑。

package aggregate_test

import (

“testing”

“github.com/percybolmer/ddd-go/aggregate”

)

func TestCustomer_NewCustomer(t *testing.T) {

// 构建我们需要的测试用例数据结构

type testCase struct {

test string

name string

expectedErr error

}

//创建新的测试用例

testCases := []testCase{

{

test: “Empty Name validation”,

name: “”,

expectedErr: aggregate.ErrInvalidPerson,

}, {

test: “Valid Name”,

name: “Percy Bolmer”,

expectedErr: nil,

},

}

for _, tc := range testCases {

// Run Tests

t.Run(tc.test, func(t *testing.T) {

//创建新的customer

_, err := aggregate.NewCustomer(tc.name)

//检查错误是否与预期的错误匹配

if err != tc.expectedErr {

t.Errorf(“Expected error %v, got %v”, tc.expectedErr, err)

}

})

}

}

我们不会在创造新customer方面深入，现在开始寻找我所知道的最佳设计模式的时候了。

仓库-仓库模式

DDD描述了应该使用仓库来存储和管理聚合。这是其中一种模式，一旦我学会了，我就知道我永远不会停止使用它。这种模式依赖于通过接口隐藏存储/数据库解决方案的实现。这允许我们定义一组必须使用的方法，如果它们被实现了，就可以被用作一个仓库。

这种设计模式的优点是，它允许我们在不破坏任何东西的情况下切换解决方案。我们可以在开发阶段使用内存存储，然后在生产阶段将其切换到MongoDB存储。它不仅有助于在不破坏任何利用仓库的东西的情况下更改所使用的底层技术，而且在测试中也非常有用。您可以简单地为单元测试等实现一个新的仓库。

我们将首先创建一个名为repository的文件。进入domain/customer包。在该文件中，我们将定义仓库所需的函数。我们需要Get、Add和Update函数处理customers。我们不会删除任何客户，一旦有客户在酒店，就永远是客户。我们还将在客户包中实现一些通用错误，不同的仓库实现可以使用这些错误。

// Customer包保存了客户领域的所有域逻辑

import (

“github.com/google/uuid”

“github.com/percybolmer/ddd-go/aggregate”

)

var (

// 当没有找到客户时返回ErrCustomerNotFound。

ErrCustomerNotFound = errors.New(“the customer was not found in the repository”)

// ErrFailedToAddCustomer在无法将客户添加到存储库时返回。

ErrFailedToAddCustomer = errors.New(“failed to add the customer to the repository”)

// 当无法在存储库中更新客户时，将返回ErrUpdateCustomer。

ErrUpdateCustomer = errors.New(“failed to update the customer in the repository”)

)

// CustomerRepository是一个接口，它定义了围绕客户仓库的规则

// 必须实现的函数

type CustomerRepository interface {

Get(uuid.UUID) (aggregate.Customer, error)

Add(aggregate.Customer) error

Update(aggregate.Customer) error

}

接下来，我们需要实现接口的实际业务逻辑，我们将从内存存储方式开始。在本文的最后，我们将了解如何在不破坏其他任何东西的情况下将其更改为MongoDB存储方案。

我喜欢将每个实现保存在它的目录中，只是为了让团队中的新开发人员更容易找到正确的代码位置。让我们创建一个名为memory的文件夹，表示仓库将内存用作存储。

另一种方式是在customer包中创建memory.go， 但我发现在更大的系统中，它会很快变得混乱

mkdir memory

touch memory/memory.go

让我们首先在memory.go文件中设置正确的结构，我们希望创建一个具有实现CustomerRepository接口的结构，并且不要忘记创建新仓库的工厂函数。

// memory包是客户仓库的内存中实现

package memory

import (

“sync”

“github.com/google/uuid”

“github.com/percybolmer/ddd-go/aggregate”

)

// MemoryRepository实现了CustomerRepository接口

type MemoryRepository struct {

customers map[uuid.UUID]aggregate.Customer

sync.Mutex

}

// New是一个工厂函数，用于生成新的客户仓库

func New() *MemoryRepository {

return &MemoryRepository{

customers: make(map[uuid.UUID]aggregate.Customer),

}

}

// Get根据ID查找Customer

func (mr *MemoryRepository) Get(uuid.UUID) (aggregate.Customer, error) {

return aggregate.Customer{}, nil

}

// Add将向存储库添加一个新Customer

func (mr *MemoryRepository) Add(aggregate.Customer) error {

return nil

}

// Update将用新的客户信息替换现有的Customer信息

func (mr *MemoryRepository) Update(aggregate.Customer) error {

return nil

}

我们需要添加一种从Customer聚合中检索信息的方法，例如来自根实体的ID。所以我们应该用一个获取ID的函数和一个更改名称的函数来更新聚合。

// GetID返回客户的根实体ID

func (c *Customer) GetID() uuid.UUID {

return c.Person.ID

}

// SetName更改客户的名称

func (c *Customer) SetName(name string) {

c.Person.Name = name

}

让我们向内存仓库添加一些非常基本的功能，以便它能按预期工作。

// memory包是客户仓库的内存实现

package memory

import (

“fmt”

“sync”

“github.com/google/uuid”

“github.com/percybolmer/ddd-go/aggregate”

“github.com/percybolmer/ddd-go/domain/customer”

)

// MemoryRepository实现了CustomerRepository接口

type MemoryRepository struct {

customers map[uuid.UUID]aggregate.Customer

sync.Mutex

}

// New是一个工厂函数，用于生成新的客户存储库

func New() *MemoryRepository {

return &MemoryRepository{

customers: make(map[uuid.UUID]aggregate.Customer),

}

}

// Get根据ID查找Customer

func (mr *MemoryRepository) Get(id uuid.UUID) (aggregate.Customer, error) {

if customer, ok := mr.customers[id]; ok {

return customer, nil

}

return aggregate.Customer{}, customer.ErrCustomerNotFound

}

// Add将向存储库添加一个新Customer

func (mr *MemoryRepository) Add(c aggregate.Customer) error {

if mr.customers == nil {

// 安全检查如果Customer没创建，在使用工厂是不应该发生，但你永远不知道

mr.Lock()

mr.customers = make(map[uuid.UUID]aggregate.Customer)

mr.Unlock()

}

// 确保Customer不在仓库中

if _, ok := mr.customers[c.GetID()]; ok {

return fmt.Errorf(“customer already exists: %w”, customer.ErrFailedToAddCustomer)

}

mr.Lock()

mr.customers[c.GetID()] = c

mr.Unlock()

return nil

}

// Update 将用新的Customer信息替换现有Customer户信息

func (mr *MemoryRepository) Update(c aggregate.Customer) error {

// 确保Customer在存储库中

if _, ok := mr.customers[c.GetID()]; !ok {

return fmt.Errorf(“customer does not exist: %w”, customer.ErrUpdateCustomer)

}

mr.Lock()

mr.customers[c.GetID()] = c

mr.Unlock()

return nil

}

和前面一样，我们应该为代码添加单元测试。我想从测试的角度指出仓库模式有多好。在单元测试中，使用仅为测试创建的仓库替换部分逻辑非常容易，这使得发下测试中的已知错误变得更加容易。

package memory

import (

“testing”

“github.com/google/uuid”

“github.com/percybolmer/ddd-go/aggregate”

“github.com/percybolmer/ddd-go/domain/customer”

)

func TestMemory_GetCustomer(t *testing.T) {

type testCase struct {

name string

id uuid.UUID

expectedErr error

}

//创建要添加到存储库中的模拟Customer

cust, err := aggregate.NewCustomer(“Percy”)

if err != nil {

t.Fatal(err)

}

id := cust.GetID()

// 创建要使用的仓库，并添加一些测试数据进行测试

// 跳过工厂

repo := MemoryRepository{

customers: map[uuid.UUID]aggregate.Customer{

id: cust,

},

}

testCases := []testCase{

{

name: “No Customer By ID”,

id: uuid.MustParse(“f47ac10b-58cc-0372-8567-0e02b2c3d479”),

expectedErr: customer.ErrCustomerNotFound,

}, {

name: “Customer By ID”,

id: id,

expectedErr: nil,

},

}

for _, tc := range testCases {

t.Run(tc.name, func(t *testing.T) {

_, err := repo.Get(tc.id)

if err != tc.expectedErr {

t.Errorf(“Expected error %v, got %v”, tc.expectedErr, err)

}

})

}

}

func TestMemory_AddCustomer(t *testing.T) {

type testCase struct {

name string

cust string

expectedErr error

}

testCases := []testCase{

{

name: “Add Customer”,

cust: “Percy”,

expectedErr: nil,

},

}

for _, tc := range testCases {

t.Run(tc.name, func(t *testing.T) {

repo := MemoryRepository{

customers: map[uuid.UUID]aggregate.Customer{},

}

cust, err := aggregate.NewCustomer(tc.cust)

if err != nil {

t.Fatal(err)

}

err = repo.Add(cust)

if err != tc.expectedErr {

t.Errorf(“Expected error %v, got %v”, tc.expectedErr, err)

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Go）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
rr, err)

}

})

}

}

func TestMemory_AddCustomer(t *testing.T) {

type testCase struct {

name string

cust string

expectedErr error

}

testCases := []testCase{

{

name: “Add Customer”,

cust: “Percy”,

expectedErr: nil,

},

}

for _, tc := range testCases {

t.Run(tc.name, func(t *testing.T) {

repo := MemoryRepository{

customers: map[uuid.UUID]aggregate.Customer{},

}

cust, err := aggregate.NewCustomer(tc.cust)

if err != nil {

t.Fatal(err)

}

err = repo.Add(cust)

if err != tc.expectedErr {

t.Errorf(“Expected error %v, got %v”, tc.expectedErr, err)

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Go）
[外链图片转存中…(img-AlSpRvyR-1713316220523)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！