丁香五月色播婷婷色播,国产性一乱一性一伧一色,jizz中国女人自拍偷拍

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

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

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

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

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

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

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

2. 為什么需要 Repository？

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

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

整體結構如下圖所示：

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

業務操作沒變，仍舊依次完成下單、改地址、支付等操作
引入持久化存儲（MySQL），可以將 Order 對象存儲于關系數據庫
配合 Order 的生命周期，操作中增加 save、load 和 update 等操作
1. 用戶下單創建 Order 對象，通過 save 方法將 Order 對象持久化到 DB
2. 接收到業務操作，需執行load，從 DB 加載數據到內存并對 Order 對象的狀態進行恢復
3. 在業務操作完成后，需執行update，將 Order 對象的最新狀態同步的 DB

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

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

3. 什么才是好的 Repository ？

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

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

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

需要一個統一的 Repository 接口，用于對易用方法save、load、update進行管理
為每個聚合根創建一個 Repository 接口，繼承自統一Repository，只關注該聚合根的存儲
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 // 開啟 Spring Data Jpa， basePackages 是 Repository 接口存放的包路徑 @EnableJpaRepositories(basePackages = "com.geekhalo.springdata4ddd.order.repository") public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } 4.3. 使用 Repository

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

public interface OrderCommandRepository extends JpaRepository { }

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

不知道你是否存在疑問：

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

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

方法

含義

save、saveAll

保存或更新，如果數據庫沒有則執行 insert 操作，數據庫有則執行 update 操作

findById

根據主鍵查詢實體

findAllById

根據主鍵批量獲取實體

count

查詢數量

delete、deleteById

刪除數據

findAll

分頁或排序

5. 實戰--訂單

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

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

對應到領域模型如下：

核心代碼如下：

@Data @Entity @Table(name = "tb_order") @Setter(AccessLevel.private) public class Order { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(name = "user_id") private Long userId; @Column(name = "status") @Enumerated(EnumType.STRING) private OrderStatus status; @Column(name = "price") private int price; // 收貨地址 @.NEToOne(cascade = CascadeType.ALL, fetch = FetchType.LAZY) @JoinColumn(name = "user_address_id") private OrderAddress address; // 訂單項 @OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL) @JoinColumn(name = "order_id") private List items = new ArrayList<>(); } 5.1. 生單

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

@Transactional(readOnly = false) public Order createOrder(CreateOrderCommand command){ // 創建內存對象 Order order = Order.create(command); // 保存到數據庫 this.repository.save(order); return order; } // Order 實體上的 create 方法 public static Order create(CreateOrderCommand command) { // 創建內存對象 Order order = new Order(); order.setUserId(command.getUserId()); String userAddress = command.getUserAddress(); if (!StringUtils.hasText(userAddress)){ // 設置收獲地址 OrderAddress orderAddress = new OrderAddress(); orderAddress.setDetail(userAddress); order.setAddress(orderAddress); } // 添加訂單項 List productForBuys = command.getProducts(); productForBuys.stream() .map(productForBuy -> OrderItem.create(productForBuy)) .forEach(orderItem -> order.addOrderItem(orderItem)); order.init(); return order; }

單元測試，具體如下：

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

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

// createOrder 方法中 repository.save(order) 產生的 SQL： // 插入收貨地址 Hibernate: insert into tb_order_address (detail) values (?) // 插入 order Hibernate: insert into tb_order (user_address_id, price, status, user_id) values (?, ?, ?, ?) // 插入 orderItem Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) // 將 order item 與 order 進行綁定（這步存在性能損耗，但是目前沒有更好的解決方案） Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=?

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

5.2. 修改地址

修改地址核心代碼如下：

@Transactional(readOnly = false) public void modifyAddress(Long orderId, String address){ Optional orderOptional = repository.findById(orderId); if (orderOptional.isPresent()){ Order order = orderOptional.get(); order.modifyAddress(address); this.repository.save(order); } } // Order 實體上的方法 public void modifyAddress(String address){ if (this.address == null){ this.address = new OrderAddress(); } this.address.modify(address); } // OrderAddress 實體上的方法 public void modify(String address) { setDetail(address); }

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

@Test void modifyAddress_add() { // 新訂單不存儲地址信息（沒有 userAddress） Order order = null; { CreateOrderCommand command = createOrderCommand(20L); // 將收獲地址設置為 null command.setUserAddress(null); order = this.applicationService.createOrder(command); Assertions.assertNotNull(order.getId()); } // 修改時，直接創建地址（插入新數據） String address = "新增地址"; // Lazy 加載，只加載 orderAddress // 修改后，只更新 OrderAddress this.applicationService.modifyAddress(order.getId(), address); Order orderInDB = this.repository.findById(order.getId()).get(); Assertions.assertEquals(address, orderInDB.getAddress().getDetail() ); }

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

// createOrder 方法中 repository.save(order) 產生的 SQL： // 生單時沒有地址，所以沒有向 tb_order_address 插入數據 Hibernate: insert into tb_order (user_address_id, price, status, user_id) values (?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? // modifyAddress 方法中 repository.findById(orderId) 產生的 SQL // 從 DB 中加載數據，構建內存的 Order 對象 Hibernate: select order0_.id as id1_0_0_, order0_.user_address_id as user_add5_0_0_, order0_.price as price2_0_0_, order0_.status as status3_0_0_, order0_.user_id as user_id4_0_0_ from tb_order order0_ where order0_.id=? // modifyAddress 方法中 this.repository.save(order) 產生的 SQL // 為 Order 對象添加 orderAddress 后，自動向數據庫添加數據 Hibernate: insert into tb_order_address (detail) values (?) // 更新 Order 的 user_address，完成數據綁定 Hibernate: update tb_order set user_address_id=?, price=?, status=?, user_id=? where id=? // repository.findById(order.getId()) 產生的 SQL // 從 DB 中加載數據，構建內存的 Order 對象，進行結果檢測 Hibernate: select order0_.id as id1_0_0_, order0_.user_address_id as user_add5_0_0_, order0_.price as price2_0_0_, order0_.status as status3_0_0_, order0_.user_id as user_id4_0_0_ from tb_order order0_ where order0_.id=?

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

@Test void modifyAddress_update() { // 新訂單部存在地址信息（沒有 userAddress） Order order = null; { CreateOrderCommand command = createOrderCommand(30L); order = this.applicationService.createOrder(command); Assertions.assertNotNull(order.getId()); } // Lazy 加載，只加載 orderAddress // 修改后，只更新 OrderAddress String address = "修改地址"; this.applicationService.modifyAddress(order.getId(), address); Order orderInDB = this.repository.findById(order.getId()).get(); Assertions.assertEquals(address, orderInDB.getAddress().getDetail() ); }

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

// createOrder 方法中 repository.save(order) 產生的 SQL： // 創建帶有地址的訂單 Hibernate: insert into tb_order_address (detail) values (?) Hibernate: insert into tb_order (user_address_id, price, status, user_id) values (?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? // modifyAddress 方法中 repository.findById(orderId) 產生的 SQL // 從 DB 中加載數據，構建內存的 Order 對象 Hibernate: select order0_.id as id1_0_0_, order0_.user_address_id as user_add5_0_0_, order0_.price as price2_0_0_, order0_.status as status3_0_0_, order0_.user_id as user_id4_0_0_ from tb_order order0_ where order0_.id=? // 在對 order.address 進行訪問時，進行自動加載 Hibernate: select orderaddre0_.id as id1_1_0_, orderaddre0_.detail as detail2_1_0_ from tb_order_address orderaddre0_ where orderaddre0_.id=? // modifyAddress 方法中 this.repository.save(order) 產生的 SQL // OrderAddress 信息發生變化，將變更更新到數據庫 Hibernate: update tb_order_address set detail=? where id=? // repository.findById(order.getId()) 產生的 SQL // 從 DB 中加載數據，構建內存的 Order 對象，進行結果檢測 Hibernate: select order0_.id as id1_0_0_, order0_.user_address_id as user_add5_0_0_, order0_.price as price2_0_0_, order0_.status as status3_0_0_, order0_.user_id as user_id4_0_0_ from tb_order order0_ where order0_.id=?

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

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

5.3. 支付

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

支付核心代碼如下：

@Transactional(readOnly = false) public void paySuccess(PaySuccessCommand command){ Optional orderOptional = repository.findById(command.getOrderId()); if (orderOptional.isPresent()){ Order order = orderOptional.get(); order.paySuccess(command); this.repository.save(order); } } // Order 實體上的 paySuccess 方法 public void paySuccess(PaySuccessCommand paySuccessCommand){ this.setStatus(OrderStatus.PAID); this.items.forEach(OrderItem::paySuccess); } // OrderItem 上的 paySuccess 方法 public void paySuccess() { setStatus(OrderItemStatus.PAID); }

單元測試如下：

@Test void paySuccess() { Order order = null; { CreateOrderCommand command = createOrderCommand(50L); order = this.applicationService.createOrder(command); Assertions.assertNotNull(order.getId()); } PaySuccessCommand paySuccessCommand = new PaySuccessCommand(); paySuccessCommand.setOrderId(order.getId()); paySuccessCommand.setPrice(1000L); paySuccessCommand.setChanel("微信支付"); // Lazy 加載，只加載 orderItem // 修改后，更新 order 和 OrderItem this.applicationService.paySuccess(paySuccessCommand); Order orderInDB = 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: insert into tb_order_address (detail) values (?) Hibernate: insert into tb_order (user_address_id, price, status, user_id) values (?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: insert into tb_order_item (amount, price, product_id, product_name, status) values (?, ?, ?, ?, ?) Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? Hibernate: update tb_order_item set order_id=? where id=? // paySuccess 方法中 repository.findById(orderId) 產生的 SQL // 從 DB 中加載數據，構建內存的 Order 對象 Hibernate: select order0_.id as id1_0_0_, order0_.user_address_id as user_add5_0_0_, order0_.price as price2_0_0_, order0_.status as status3_0_0_, order0_.user_id as user_id4_0_0_ from tb_order order0_ where order0_.id=? // 訪問 order.items，觸發自動加載 Hibernate: select items0_.order_id as order_id7_2_0_, items0_.id as id1_2_0_, items0_.id as id1_2_1_, items0_.amount as amount2_2_1_, items0_.price as price3_2_1_, items0_.product_id as product_4_2_1_, items0_.product_name as product_5_2_1_, items0_.status as status6_2_1_ from tb_order_item items0_ where items0_.order_id=? // paySuccess 方法中 this.repository.save(order) 產生的 SQL // 將 Order 變更更新到數據庫 Hibernate: update tb_order set user_address_id=?, price=?, status=?, user_id=? where id=? // 將 OrderItem 變更更新到數據庫 Hibernate: update tb_order_item set amount=?, price=?, product_id=?, product_name=?, status=? where id=? Hibernate: update tb_order_item set amount=?, price=?, product_id=?, product_name=?, status=? where id=? Hibernate: update tb_order_item set amount=?, price=?, product_id=?, product_name=?, status=? where id=? Hibernate: update tb_order_item set amount=?, price=?, product_id=?, product_name=?, status=? where id=? Hibernate: update tb_order_item set amount=?, price=?, product_id=?, product_name=?, status=? where id=? // repository.findById(order.getId()) 產生的 SQL // 從 DB 中加載數據，構建內存的 Order 對象，進行結果檢測 Hibernate: select order0_.id as id1_0_0_, order0_.user_address_id as user_add5_0_0_, order0_.price as price2_0_0_, order0_.status as status3_0_0_, order0_.user_id as user_id4_0_0_ from tb_order order0_ where order0_.id=?

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