工厂模式是一种非常常见的模式，您甚至可以在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()
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)
}
found, err := repo.Get(cust.GetID())
if err != nil {
t.Fatal(err)
}
if found.GetID() != cust.GetID() {
t.Errorf(“Expected %v, got %v”, cust.GetID(), found.GetID())
}
})
}
}
很好，我们有了第一个仓库。记住要保持仓库与它们的领域相关。在这种情况下，仓库只处理Customer聚合，它应该只这样做。永远不要让仓库与任何其他聚合耦合，我们想要松耦合。
那么我们如何处理酒店的逻辑流呢，我们不能简单地依赖客户仓库？我们将在某一点上开始耦合不同的仓库，并构建一个表示酒店逻辑的流。
进入Services，这是我们需要学习的最后一部分。
Services——连接业务逻辑
我们有这些实体，一个聚合，和一个仓库，但它还不像一个应用程序，不是吗？这就是为什么我们需要下一个组件Service。
Service将把所有松散耦合的仓库绑定到满足特定领域需求的业务逻辑中。在酒店应用中，我们可能有一个Order服务，负责将仓库链接在一起以执行订单。因此，服务将拥有对CustomerRepository和ProductRepository的访问权。
Service通常包含执行某个业务逻辑流(如Order、Api或Billing)所需的所有仓库。你甚至可以在一个服务中包含另一个服务。
我们将实现Order服务，它随后可以成为酒店（Tavern）服务的一部分。让我们创建一个名为services的新文件夹，该文件夹将保存我们实现的服务。我们首先创建一个名为order.go的文件将持有OrderService，我们将使用它来处理酒店中的新订单。我们仍然缺少一些领域，因此我们将只从CustomerRepository开始，但很快会添加更多领域。
我想从创建一个新的Service的Factory开始，并演示一个非常简单的技巧，这是我从Jon Calhoun的web开发书中学到的。我们将为一个函数创建一个别名，该函数接受一个Service指针并修改它，然后允许使用这些别名的可变参数。通过这种方式更改Service的行为或替换仓库非常容易。
// service包，包含将仓库连接到业务流的所有服务
package services
import (
“github.com/percybolmer/ddd-go/domain/customer”
)
// OrderConfiguration是一个函数的别名，该函数将接受一个指向OrderService的指针并对其进行修改
type OrderConfiguration func(os *OrderService) error
//OrderService是OrderService的一个实现
type OrderService struct {
customers customer.CustomerRepository
}
// NewOrderService接受可变数量的OrderConfiguration函数，并返回一个新的OrderService
// 将按照传入的顺序调用每个OrderConfiguration
func NewOrderService(cfgs …OrderConfiguration) (*OrderService, error) {
// 创建orderservice
os := &OrderService{}
// 应用所有传入的Configurations
for _, cfg := range cfgs {
// 将service传递到configuration函数
最后
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！
如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
erService是OrderService的一个实现
type OrderService struct {
customers customer.CustomerRepository
}
// NewOrderService接受可变数量的OrderConfiguration函数，并返回一个新的OrderService
// 将按照传入的顺序调用每个OrderConfiguration
func NewOrderService(cfgs …OrderConfiguration) (*OrderService, error) {
// 创建orderservice
os := &OrderService{}
// 应用所有传入的Configurations
for _, cfg := range cfgs {
// 将service传递到configuration函数
最后
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-2cF5TEGF-1715688064395)]
[外链图片转存中…(img-Y9tBweZz-1715688064395)]
[外链图片转存中…(img-FyXHHWMl-1715688064396)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！
如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
1863
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
