Go：如何实现领域驱动设计（DDD，万字长文总结Java多进程

// Package aggregates holds aggregates that combines many entities into a full object

package aggregate

import (

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

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

)

// Customer 聚合包含了代表一个客户所需的所有实体

type Customer struct {

// Person是客户的根实体

// person.ID是聚合的主标识符

Person *entity.Person bson:"person"

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

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

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

Transactions []valueobject.Transaction bson:"transactions"

}

我将所有实体设置为指针，这是因为实体可以改变状态，我想让它反映在运行时所有访问它的实例中。值对象被保存为非指针，因为它们不能改变状态。

工厂函数-封装复杂的逻辑

到目前为止，我们只定义了不同的实体、值对象和聚合。现在开始实现一些实际业务逻辑，我们从工厂函数开始。工厂模式是一种设计模式，用于在创建所需实例的函数中封装复杂逻辑，调用者不知道任何实现细节。

工厂模式是一种非常常见的模式，您甚至可以在DDD应用程序之外使用它，而且您可能已经使用过很多次了。官方Go Elasticsearch客户端就是一个很好的例子。您将一个配置传入到NewClient函数中，该函数是一个工厂函数，返回客户端连接到弹性集群，可以插入/删除文档。对于其他开发人员来说很容易使用，在NewClient中做了很多事情：

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()

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

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

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以添加V：vip1024b 备注Java获取（资料价值较高，非无偿）

2021年Java中高级面试必备知识点总结

在这个部分总结了2019年到目前为止Java常见面试问题，取其面试核心编写成这份文档笔记，从中分析面试官的心理，摸清面试官的“套路”，可以说搞定90%以上的Java中高级面试没一点难度。

本节总结的内容涵盖了：消息队列、Redis缓存、分库分表、读写分离、设计高并发系统、分布式系统、高可用系统、SpringCloud微服务架构等一系列互联网主流高级技术的知识点。

目录：

（上述只是一个整体目录大纲，每个点里面都有如下所示的详细内容，从面试问题——分析面试官心理——剖析面试题——完美解答的一个过程）

部分内容：

对于每一个做技术的来说，学习是不能停止的，小编把2019年到目前为止Java的核心知识提炼出来了，无论你现在是处于什么阶段，如你所见，这份文档的内容无论是对于你找面试工作还是提升技术广度深度都是完美的。

不想被后浪淘汰的话，赶紧搞起来吧，高清完整版一共是888页，需要的话可以点赞+关注
目、讲解视频，并且后续会持续更新**
如果你觉得这些内容对你有帮助，可以添加V：vip1024b 备注Java获取（资料价值较高，非无偿）
[外链图片转存中…(img-XXaDZty3-1711547703191)]

2021年Java中高级面试必备知识点总结

在这个部分总结了2019年到目前为止Java常见面试问题，取其面试核心编写成这份文档笔记，从中分析面试官的心理，摸清面试官的“套路”，可以说搞定90%以上的Java中高级面试没一点难度。

本节总结的内容涵盖了：消息队列、Redis缓存、分库分表、读写分离、设计高并发系统、分布式系统、高可用系统、SpringCloud微服务架构等一系列互联网主流高级技术的知识点。

目录：

[外链图片转存中…(img-yB1ffcAS-1711547703192)]

（上述只是一个整体目录大纲，每个点里面都有如下所示的详细内容，从面试问题——分析面试官心理——剖析面试题——完美解答的一个过程）

[外链图片转存中…(img-FMgrKj95-1711547703192)]

部分内容：

[外链图片转存中…(img-EdaOCvmb-1711547703192)]

[外链图片转存中…(img-nN36aKDR-1711547703193)]

[外链图片转存中…(img-A5LiZIwR-1711547703193)]

对于每一个做技术的来说，学习是不能停止的，小编把2019年到目前为止Java的核心知识提炼出来了，无论你现在是处于什么阶段，如你所见，这份文档的内容无论是对于你找面试工作还是提升技术广度深度都是完美的。

不想被后浪淘汰的话，赶紧搞起来吧，高清完整版一共是888页，需要的话可以点赞+关注