用好 DDD 必须先过 Spring Data 这关
点击上方“芋道源码”，选择“设为星标”
管她前浪，还是后浪？
能浪的浪，才是好浪！
每天 10:33 更新文章，每天掉亿点点头发...
源码精品专栏
1. 面向对象设计是 DDD 的核心
DDD 着重于将业务领域中的概念和对象映射到对象中，使对象模型能够更好地反映业务的真实情况，从而使设计更具可理解性和可维护性。
DDD 是一种领域驱动的设计方法，旨在通过建立对领域模型的清晰理解来解决业务问题。和事务脚本不同，DDD 使用面向对象设计来应对复杂的业务场景。
简单来说，DDD 是由领域对象承载业务逻辑，所有的业务操作均在模型对象上完成，同一对象上不同的业务操作构成了对象的生命周期。
我们以订单为例，如下图所示：
首先，用户操作下单，使用提交数据为其创建一个 Order 对象，版本 V1； 随后，用户进行改地址操作，调用 Order 对象的 modifyAddress方法，Order 从原来的 V1 变成 V2；用户完成支付后，调用 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？
假设，有一台非常牛逼的计算机，计算资源无限、内存大小无限、永不掉电、永不宕机，那最简单高效的方式便是将模型对象全部放在内存中。
但，现实不存在这样的机器，我们不得不将内存对象写入磁盘，下次使用时，在将其从磁盘读入到内存。
整体结构如下图所示：
和上图相比，具有如下特点：
业务操作没变，仍旧依次完成 下单、改地址、支付等操作
引入持久化存储（MySQL），可以将 Order 对象存储于关系数据库
配合 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 应该在满足业务需求的前提下，具备以下特性：
高内聚： 好的 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，具体如下：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
其次，引入 MySQL 驱动，具体如下：
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<scope>runtime</scope>
</dependency>
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, Long> {
}
至此，Order 的专属 Repository 就开发完成。
不知道你是否存在疑问：
说好的统一的易用方法在哪里？ 为什么没有看到实现代码？
一般情况下，JpaRepository 接口中的方法就能满足大部分需求，典型方法包括：
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;
// 收货地址
@OneToOne(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<OrderItem> 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<ProductForBuy> 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<Order> 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<Order> 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 中可见，在复杂的 一对多 场景，懒加载 和 自动同步能力 仍旧有效。
从代码上可以清晰得出：在 Spring Data Jpa 的助力下，无需编写任何数据层访问代码，便可以完成领域对象的管理。
6. 小结
DDD 和 Jpa 都是面向对象设计的巅峰之作，两者结合威力巨大。
结合使用 DDD 和 JPA 可以有效地将领域模型与数据库持久化技术相结合。开发人员可以使用领域驱动的方法管理数据，并通过 JPA 将数据存储在数据库中，从而避免冗长的数据持久化代码。
此外，使用 DDD 和 JPA 还有其他优势：
提高代码可读性： 领域驱动的设计方法可以帮助开发人员更清晰地了解领域模型，使代码更易于阅读和维护。 减少代码量： 使用 JPA 可以减少代码量，因为开发人员不需要编写手动的数据持久化代码。 提高代码的可重用性： 通过使用领域模型，开发人员可以创建一组可重用的实体，并在多个地方使用它们。 提高代码的可扩展性： 使用 DDD 和 JPA 可以使代码更易于扩展，因为它们遵循领域驱动的设计方法。
总之，使用 DDD 和 JPA 可以帮助开发人员更有效地解决业务问题，提高代码的可读性，可重用性和可扩展性，并减少代码量。
欢迎加入我的知识星球，一起探讨架构，交流源码。加入方式，长按下方二维码噢：
已在知识星球更新源码解析如下：
最近更新《芋道 SpringBoot 2.X 入门》系列，已经 101 余篇，覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。
提供近 3W 行代码的 SpringBoot 示例，以及超 4W 行代码的电商微服务项目。
获取方式：点“在看”，关注公众号并回复 666 领取，更多内容陆续奉上。
文章有帮助的话，在看，转发吧。
谢谢支持哟 (*^__^*）
微信扫码关注该文公众号作者
戳这里提交新闻线索和高质量文章给我们。
来源: qq
点击查看作者最近其他文章