---

1. 面向對象設計是 DDD 的核心

DDD 著重于將業務領域中的概念和對象映射到對象中，使對象模型能夠更好地反映業務的真實情況，從而使設計更具可理解性和可維護性。

DDD 是一種領域驅動的設計方法，旨在通過建立對領域模型的清晰理解來解決業務問題。和事務腳本不同，DDD 使用面向對象設計來應對復雜的業務場景。

簡單來說，DDD 是由領域對象承載業務邏輯，所有的業務操作均在模型對象上完成，同一對象上不同的業務操作構成了對象的生命周期。

我們以訂單為例，如下圖所示：

1. 首先，用戶操作下單，使用提交數據為其創建一個 Order 對象，版本 V1；
2. 隨后，用戶進行改地址操作，調用 Order 對象的 modifyAddress 方法，Order 從原來的 V1 變成 V2；
3. 用戶完成支付后，調用 Order 對象的 paySuccess 方法，Order 從 V2 變成 V3；

從圖上可見，在 DDD 設計中，所有的業務邏輯均由業務對象完成，所以面向對象是 DDD 設計的核心。

基于 Spring Boot + MyBatis Plus + Vue & Element 實現的后臺管理系統 + 用戶小程序，支持 RBAC 動態權限、多租戶、數據權限、工作流、三方登錄、支付、短信、商城等功能

• 項目地址：https://github.com/YunaiV/ruoyi-vue-pro
• 視頻教程：https://doc.iocoder.cn/video/

2. 為什么需要 Repository？

假設，有一臺非常牛逼的計算機，計算資源無限、內存大小無限、永不掉電、永不宕機，那最簡單高效的方式便是將模型對象全部放在內存中。

但，現實不存在這樣的機器，我們不得不將內存對象寫入磁盤，下次使用時，在將其從磁盤讀入到內存。

整體結構如下圖所示：

和上圖相比，具有如下特點：

1. 業務操作沒變，仍舊依次完成 下單、改地址、支付等操作

2. 引入持久化存儲（MySQL），可以將 Order 對象存儲于關系數據庫

3. 配合 Order 的生命周期，操作中增加 save、load 和 update 等操作

• 用戶下單創建 Order 對象，通過 save 方法將 Order 對象持久化到 DB

• 接收到業務操作，需執行load，從 DB 加載數據到內存 并對 Order 對象的狀態進行恢復
• 在業務操作完成后，需執行update，將 Order 對象的最新狀態同步的 DB

相對全內存版本確實增加了不小的復雜性，為了更好的對這些復雜性進行管理，引入 Repository 模式。

在領域驅動設計（DDD）中，Repository 是一種設計模式，它是用來存儲領域對象的容器。它提供了一種統一的方式來查詢和存儲領域對象。Repository提供了對底層數據存儲的抽象，允許應用程序在沒有直接與數據存儲技術交互的情況下訪問數據，同時該抽象允許在不修改應用程序代碼的情況下更改數據存儲技術。

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 實現的后臺管理系統 + 用戶小程序，支持 RBAC 動態權限、多租戶、數據權限、工作流、三方登錄、支付、短信、商城等功能

• 項目地址：https://github.com/YunaiV/yudao-cloud
• 視頻教程：https://doc.iocoder.cn/video/

3. 什么才是好的 Repository ？

好的 Repository 應該在滿足業務需求的前提下，具備以下特性：

1. 高內聚： 好的 Repository 應該滿足單一職責原則，每個 Repository 只關注一種領域對象的存儲；
2. 松耦合： 好的 Repository 應該通過抽象接口與其他層進行交互，保證它們之間的耦合度低；
3. 簡單易用： 好的 Repository 應該提供一組易于使用的方法，方便開發人員使用；
4. 可維護性： 好的 Repository 應該易于維護，維護人員不需要長時間閱讀代碼才能了解它的工作原理；

說的太官方了，用人話就是：

1. 需要一個統一的 Repository 接口，用于對易用方法save、load、update進行管理
2. 為每個聚合根創建一個 Repository 接口，繼承自 統一Repository，只關注該聚合根的存儲
3. Repository 的實現盡可能的簡單，最好不用實現（人都是懶的）

4. 初始 Spring Data

Spring Data是一個框架，旨在簡化數據訪問層的開發。它通過抽象和模板化方法，使得與各種數據存儲（如關系型數據庫，文檔數據庫，圖形數據庫，緩存等）的交互變得更加簡單和標準化。

Spring Data 通過提供簡單的、通用的數據訪問接口（如Repository）和自動生成實現代碼，使得開發人員不必編寫重復的數據訪問代碼。這樣，開發人員可以專注于業務邏輯，而無需關注數據存儲和訪問的細節。

總的來說，Spring Data的主要解決的問題是：簡化數據訪問層的開發，提高代碼復用性，降低開發復雜度。

Spring Data 對多種數據存儲提供了支持，本文以 Spring Data Jpa 為例，快速實現應用程序與關系數據庫的交互。

4.1. 引入 Spring Data Jpa

Spring Data JPA 是 Spring Data 家族的重要成員，主要解決 Java 應用程序使用 JPA 完成對數據庫的訪問問題。它提供了一種簡單而靈活的方法來訪問和管理數據，并且可以消除重復代碼和提高開發效率。

首先，需要在pom中 引入 spring-data-jpa-starter，具體如下：

org.springframework.boot
spring-boot-starter-data-jpa

其次，引入 MySQL 驅動，具體如下：

com.mysql
mysql-connector-j
runtime

Spring Data Jpa 默認實現是 Hibernate，而 Hibernate 是目前最流行且功能最強大的 JPA 實現，它提供了強大的映射、查詢和事務管理能力。

4.2. 完成配置

在 application.yml 增加 DB 和 Jpa 相關配置，具體如下：

spring:
application:
name:Spring-Data-for-DDD-demo
datasource:
#數據庫配置信息
driver-class-name:com.mysql.cj.jdbc.Driver
url:jdbc:mysql://127.0.0.1:3306/books
username:root
password:root
jpa:
#打印sql
show-sql:true

在啟動類上啟用 Spring Data Jpa。

@SpringBootApplication
//開啟SpringDataJpa，basePackages是Repository接口存放的包路徑
@EnableJpaRepositories(basePackages="com.geekhalo.springdata4ddd.order.repository")
publicclassApplication{

publicstaticvoidmain(String[]args){
SpringApplication.run(Application.class,args);
}

}

4.3. 使用 Repository

一切就緒，接下來就可以為模型創建專屬 Repository，具體如下：

publicinterfaceOrderCommandRepositoryextendsJpaRepository<Order,Long>{
}

至此，Order 的專屬 Repository 就開發完成。

不知道你是否存在疑問：

1. 說好的統一的易用方法在哪里？
2. 為什么沒有看到實現代碼？

一般情況下，JpaRepository 接口中的方法就能滿足大部分需求，典型方法包括：

5. 實戰--訂單

為了體現 Spring Data Jpa的強大功能，以最常見的訂單為例，業務模型如下圖所示：

1. 一筆下單對應一個訂單（Order）
2. 一個訂單可以有一個收獲地址（OrderAddress）
3. 一個訂單可以關聯多個訂單項（OrderItem）

對應到領域模型如下：

核心代碼如下：

@Data
@Entity
@Table(name="tb_order")
@Setter(AccessLevel.PRIVATE)
publicclassOrder{

@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
privateLongid;

@Column(name="user_id")
privateLonguserId;

@Column(name="status")
@Enumerated(EnumType.STRING)
privateOrderStatusstatus;

@Column(name="price")
privateintprice;

//收貨地址
@OneToOne(cascade=CascadeType.ALL,fetch=FetchType.LAZY)
@JoinColumn(name="user_address_id")
privateOrderAddressaddress;

//訂單項
@OneToMany(fetch=FetchType.LAZY,cascade=CascadeType.ALL)
@JoinColumn(name="order_id")
privateListitems=newArrayList<>();

}

5.1. 生單

先簡單看下生單的核心代碼，具體如下：

@Transactional(readOnly=false)
publicOrdercreateOrder(CreateOrderCommandcommand){
//創建內存對象
Orderorder=Order.create(command);
//保存到數據庫
this.repository.save(order);
returnorder;
}

//Order實體上的create方法
publicstaticOrdercreate(CreateOrderCommandcommand){
//創建內存對象
Orderorder=newOrder();
order.setUserId(command.getUserId());

StringuserAddress=command.getUserAddress();
if(!StringUtils.hasText(userAddress)){
//設置收獲地址
OrderAddressorderAddress=newOrderAddress();
orderAddress.setDetail(userAddress);
order.setAddress(orderAddress);
}

//添加訂單項
ListproductForBuys=command.getProducts();
productForBuys.stream()
.map(productForBuy->OrderItem.create(productForBuy))
.forEach(orderItem->order.addOrderItem(orderItem));

order.init();
returnorder;
}

單元測試，具體如下：

@Test
voidcreateOrder(){
//創訂單，將整個Order聚合根全部保存到數據庫，包括
//1.order
//2.orderItem
//3.orderAddress
CreateOrderCommandcommand=createOrderCommand(10L);
Orderorder=this.applicationService.createOrder(command);
Assertions.assertNotNull(order.getId());
}

運行單元測試，打印以下 SQL:

//createOrder方法中repository.save(order)產生的SQL：
//插入收貨地址
Hibernate:insertintotb_order_address(detail)values(?)
//插入order
Hibernate:insertintotb_order(user_address_id,price,status,user_id)values(?,?,?,?)
//插入orderItem
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
//將orderitem與order進行綁定（這步存在性能損耗，但是目前沒有更好的解決方案）
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?

是否發現 Spring Data Jpa 的強大之處：核心邏輯全部內聚在 Order 類，在沒有寫任何數據層訪問代碼的前提下，一個 save 方法便可以將這組高內聚的對象保存到 DB。

5.2. 修改地址

修改地址核心代碼如下：

@Transactional(readOnly=false)
publicvoidmodifyAddress(LongorderId,Stringaddress){
OptionalorderOptional=repository.findById(orderId);
if(orderOptional.isPresent()){
Orderorder=orderOptional.get();
order.modifyAddress(address);
this.repository.save(order);
}
}

//Order實體上的方法
publicvoidmodifyAddress(Stringaddress){
if(this.address==null){
this.address=newOrderAddress();
}
this.address.modify(address);
}

//OrderAddress實體上的方法
publicvoidmodify(Stringaddress){
setDetail(address);
}

首先，看一個添加地址的場景，生單時沒有提供收貨地址，生單后修改地址：

@Test
voidmodifyAddress_add(){
//新訂單不存儲地址信息（沒有userAddress）
Orderorder=null;
{
CreateOrderCommandcommand=createOrderCommand(20L);
//將收獲地址設置為null
command.setUserAddress(null);
order=this.applicationService.createOrder(command);
Assertions.assertNotNull(order.getId());
}

//修改時，直接創建地址（插入新數據）
Stringaddress="新增地址";
//Lazy加載，只加載orderAddress
//修改后，只更新OrderAddress
this.applicationService.modifyAddress(order.getId(),address);

OrderorderInDB=this.repository.findById(order.getId()).get();
Assertions.assertEquals(address,orderInDB.getAddress().getDetail());
}

運行單測可，控制臺輸出以下信息：

//createOrder方法中repository.save(order)產生的SQL：
//生單時沒有地址，所以沒有向tb_order_address插入數據
Hibernate:insertintotb_order(user_address_id,price,status,user_id)values(?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?

//modifyAddress方法中repository.findById(orderId)產生的SQL
//從DB中加載數據，構建內存的Order對象
Hibernate:selectorder0_.idasid1_0_0_,order0_.user_address_idasuser_add5_0_0_,order0_.priceasprice2_0_0_,order0_.statusasstatus3_0_0_,order0_.user_idasuser_id4_0_0_fromtb_orderorder0_whereorder0_.id=?

//modifyAddress方法中this.repository.save(order)產生的SQL
//為Order對象添加orderAddress后，自動向數據庫添加數據
Hibernate:insertintotb_order_address(detail)values(?)
//更新Order的user_address，完成數據綁定
Hibernate:updatetb_ordersetuser_address_id=?,price=?,status=?,user_id=?whereid=?

//repository.findById(order.getId())產生的SQL
//從DB中加載數據，構建內存的Order對象，進行結果檢測
Hibernate:selectorder0_.idasid1_0_0_,order0_.user_address_idasuser_add5_0_0_,order0_.priceasprice2_0_0_,order0_.statusasstatus3_0_0_,order0_.user_idasuser_id4_0_0_fromtb_orderorder0_whereorder0_.id=?

看一個更新地址的場景，生單時設置收貨地址，然后操作修改地址：

@Test
voidmodifyAddress_update(){
//新訂單部存在地址信息（沒有userAddress）
Orderorder=null;
{
CreateOrderCommandcommand=createOrderCommand(30L);
order=this.applicationService.createOrder(command);
Assertions.assertNotNull(order.getId());
}

//Lazy加載，只加載orderAddress
//修改后，只更新OrderAddress
Stringaddress="修改地址";
this.applicationService.modifyAddress(order.getId(),address);

OrderorderInDB=this.repository.findById(order.getId()).get();
Assertions.assertEquals(address,orderInDB.getAddress().getDetail());
}

運行測試用例，輸出如下信息：

//createOrder方法中repository.save(order)產生的SQL：
//創建帶有地址的訂單
Hibernate:insertintotb_order_address(detail)values(?)
Hibernate:insertintotb_order(user_address_id,price,status,user_id)values(?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?

//modifyAddress方法中repository.findById(orderId)產生的SQL
//從DB中加載數據，構建內存的Order對象
Hibernate:selectorder0_.idasid1_0_0_,order0_.user_address_idasuser_add5_0_0_,order0_.priceasprice2_0_0_,order0_.statusasstatus3_0_0_,order0_.user_idasuser_id4_0_0_fromtb_orderorder0_whereorder0_.id=?
//在對order.address進行訪問時，進行自動加載
Hibernate:selectorderaddre0_.idasid1_1_0_,orderaddre0_.detailasdetail2_1_0_fromtb_order_addressorderaddre0_whereorderaddre0_.id=?

//modifyAddress方法中this.repository.save(order)產生的SQL
//OrderAddress信息發生變化，將變更更新到數據庫
Hibernate:updatetb_order_addresssetdetail=?whereid=?

//repository.findById(order.getId())產生的SQL
//從DB中加載數據，構建內存的Order對象，進行結果檢測
Hibernate:selectorder0_.idasid1_0_0_,order0_.user_address_idasuser_add5_0_0_,order0_.priceasprice2_0_0_,order0_.statusasstatus3_0_0_,order0_.user_idasuser_id4_0_0_fromtb_orderorder0_whereorder0_.id=?

從該用例可看出，Jpa 具有：

1. 懶加載能力，只有在訪問到關聯數據時才對數據進行加載
2. 自動同步能力，新增對象通過 insert 將其插入數據庫，修改對象通過 update 對數據庫數據進行更新

5.3. 支付

修改地址是簡單的一對一，那對于較復雜的一對多，Jpa 是否也具有 懶加載 和 自動同步能力呢？

支付核心代碼如下：

@Transactional(readOnly=false)
publicvoidpaySuccess(PaySuccessCommandcommand){
OptionalorderOptional=repository.findById(command.getOrderId());
if(orderOptional.isPresent()){
Orderorder=orderOptional.get();
order.paySuccess(command);
this.repository.save(order);
}
}

//Order實體上的paySuccess方法
publicvoidpaySuccess(PaySuccessCommandpaySuccessCommand){
this.setStatus(OrderStatus.PAID);
this.items.forEach(OrderItem::paySuccess);
}
//OrderItem上的paySuccess方法
publicvoidpaySuccess(){
setStatus(OrderItemStatus.PAID);
}

單元測試如下：

@Test
voidpaySuccess(){
Orderorder=null;
{
CreateOrderCommandcommand=createOrderCommand(50L);
order=this.applicationService.createOrder(command);
Assertions.assertNotNull(order.getId());
}

PaySuccessCommandpaySuccessCommand=newPaySuccessCommand();
paySuccessCommand.setOrderId(order.getId());
paySuccessCommand.setPrice(1000L);
paySuccessCommand.setChanel("微信支付");
//Lazy加載，只加載orderItem
//修改后，更新order和OrderItem
this.applicationService.paySuccess(paySuccessCommand);
OrderorderInDB=this.repository.findById(order.getId()).get();
Assertions.assertEquals(OrderStatus.PAID,orderInDB.getStatus());
orderInDB.getItems().forEach(orderItem->{
Assertions.assertEquals(OrderItemStatus.PAID,orderItem.getStatus());
});
}

運行單元測試，控制臺出現信息如下：

//createOrder方法中repository.save(order)產生的SQL：
//創建帶有地址的訂單
Hibernate:insertintotb_order_address(detail)values(?)
Hibernate:insertintotb_order(user_address_id,price,status,user_id)values(?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:insertintotb_order_item(amount,price,product_id,product_name,status)values(?,?,?,?,?)
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?
Hibernate:updatetb_order_itemsetorder_id=?whereid=?

//paySuccess方法中repository.findById(orderId)產生的SQL
//從DB中加載數據，構建內存的Order對象
Hibernate:selectorder0_.idasid1_0_0_,order0_.user_address_idasuser_add5_0_0_,order0_.priceasprice2_0_0_,order0_.statusasstatus3_0_0_,order0_.user_idasuser_id4_0_0_fromtb_orderorder0_whereorder0_.id=?
//訪問order.items，觸發自動加載
Hibernate:selectitems0_.order_idasorder_id7_2_0_,items0_.idasid1_2_0_,items0_.idasid1_2_1_,items0_.amountasamount2_2_1_,items0_.priceasprice3_2_1_,items0_.product_idasproduct_4_2_1_,items0_.product_nameasproduct_5_2_1_,items0_.statusasstatus6_2_1_fromtb_order_itemitems0_whereitems0_.order_id=?

//paySuccess方法中this.repository.save(order)產生的SQL
//將Order變更更新到數據庫
Hibernate:updatetb_ordersetuser_address_id=?,price=?,status=?,user_id=?whereid=?
//將OrderItem變更更新到數據庫
Hibernate:updatetb_order_itemsetamount=?,price=?,product_id=?,product_name=?,status=?whereid=?
Hibernate:updatetb_order_itemsetamount=?,price=?,product_id=?,product_name=?,status=?whereid=?
Hibernate:updatetb_order_itemsetamount=?,price=?,product_id=?,product_name=?,status=?whereid=?
Hibernate:updatetb_order_itemsetamount=?,price=?,product_id=?,product_name=?,status=?whereid=?
Hibernate:updatetb_order_itemsetamount=?,price=?,product_id=?,product_name=?,status=?whereid=?

//repository.findById(order.getId())產生的SQL
//從DB中加載數據，構建內存的Order對象，進行結果檢測
Hibernate:selectorder0_.idasid1_0_0_,order0_.user_address_idasuser_add5_0_0_,order0_.priceasprice2_0_0_,order0_.statusasstatus3_0_0_,order0_.user_idasuser_id4_0_0_fromtb_orderorder0_whereorder0_.id=?

從 SQL 中可見，在復雜的 一對多 場景，懶加載 和 自動同步能力 仍舊有效。

從代碼上可以清晰得出：在 Spring Data Jpa 的助力下，無需編寫任何數據層訪問代碼，便可以完成領域對象的管理。

6. 小結

DDD 和 Jpa 都是面向對象設計的巔峰之作，兩者結合威力巨大。

結合使用 DDD 和 JPA 可以有效地將領域模型與數據庫持久化技術相結合。開發人員可以使用領域驅動的方法管理數據，并通過 JPA 將數據存儲在數據庫中，從而避免冗長的數據持久化代碼。

此外，使用 DDD 和 JPA 還有其他優勢：

• 提高代碼可讀性： 領域驅動的設計方法可以幫助開發人員更清晰地了解領域模型，使代碼更易于閱讀和維護。
• 減少代碼量： 使用 JPA 可以減少代碼量，因為開發人員不需要編寫手動的數據持久化代碼。
• 提高代碼的可重用性： 通過使用領域模型，開發人員可以創建一組可重用的實體，并在多個地方使用它們。
• 提高代碼的可擴展性： 使用 DDD 和 JPA 可以使代碼更易于擴展，因為它們遵循領域驅動的設計方法。

總之，使用 DDD 和 JPA 可以幫助開發人員更有效地解決業務問題，提高代碼的可讀性，可重用性和可擴展性，并減少代碼量。

---

---

審核編輯 ：李倩