既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
// 当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函数
err := cfg(os)
if err != nil {
return nil, err
}
}
return os, nil
}
看看我们如何在工厂方法中接受可变数量的OrderConfiguration？这是一种允许动态工厂，并允许开发人员配置代码结构的非常整洁的方法，前提是已经实现了相关函数。这个技巧对于单元测试非常有用，因为您可以用所需的仓库替换服务中的某些部分。
对于较小的服务，这种方法似乎有点复杂了。我想指出的是，在示例中，我们只使用configurations来修改仓库，但这也可以用于内部设置和选项。对于较小的服务，也可以创建一个简单的工厂函数，例如接受CustomerRepository。
让我们创建一个应用CustomerRepository的OrderConfiguration，这样我们就可以开始创建Order的业务逻辑。
// WithCustomerRepository将给定的客户仓库应用到OrderService
func WithCustomerRepository(cr customer.CustomerRepository) OrderConfiguration {
// 返回一个与OrderConfiguration别名匹配的函数，
// 您需要返回这个，以便父函数可以接受所有需要的参数
return func(os *OrderService) error {
os.customers = cr
return nil
}
}
// WithMemoryCustomerRepository将内存客户仓库应用到OrderService
func WithMemoryCustomerRepository() OrderConfiguration {
// 创建内存仓库，如果我们需要参数，如连接字符串，它们可以在这里输入
cr := memory.New()
return WithCustomerRepository(cr)
}
现在，要使用这个，您可以在创建服务时简单地链接所有configurations，从而使我们能够轻松地更换组件。
// 在开发中使用的内存示例
NewOrderService(WithMemoryCustomerRepository())
// 我们将来可以像这样切换到MongoDB
NewOrderService(WithMongoCustomerRepository())
让我们开始为Order服务添加功能，这样顾客就可以在酒店里购买东西。
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
可以接受所有需要的参数
return func(os *OrderService) error {
os.customers = cr
return nil
}
}
// WithMemoryCustomerRepository将内存客户仓库应用到OrderService
func WithMemoryCustomerRepository() OrderConfiguration {
// 创建内存仓库，如果我们需要参数，如连接字符串，它们可以在这里输入
cr := memory.New()
return WithCustomerRepository(cr)
}
现在，要使用这个，您可以在创建服务时简单地链接所有configurations，从而使我们能够轻松地更换组件。
// 在开发中使用的内存示例
NewOrderService(WithMemoryCustomerRepository())
// 我们将来可以像这样切换到MongoDB
NewOrderService(WithMongoCustomerRepository())
让我们开始为Order服务添加功能，这样顾客就可以在酒店里购买东西。
[外链图片转存中…(img-fLmnyxku-1715391010297)]
[外链图片转存中…(img-6ypnDqzY-1715391010298)]
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
扫一扫
876
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
