java ddd 是什么意思 ddd模型 java中使用

1. 面向对象设计是 DDD 的核心

DDD 着重于将业务领域中的概念和对象映射到对象中，使对象模型能够更好地反映业务的真实情况，从而使设计更具可理解性和可维护性。

DDD 是一种领域驱动的设计方法，旨在通过建立对领域模型的清晰理解来解决业务问题。和事务脚本不同，DDD 使用面向对象设计来应对复杂的业务场景。

简单来说，DDD 是由领域对象承载业务逻辑，所有的业务操作均在模型对象上完成，同一对象上不同的业务操作构成了对象的生命周期。

我们以订单为例，如下图所示：

1. 首先，用户操作下单，使用提交数据为其创建一个 Order 对象，版本 V1；
2. 随后，用户进行改地址操作，调用 Order 对象的 modifyAddress 方法，Order 从原来的 V1 变成 V2；
3. 用户完成支付后，调用 Order 对象的 paySuccess 方法，Order 从 V2 变成 V3；

从图上可见，在 DDD 设计中，所有的业务逻辑均由业务对象完成，所以面向对象是 DDD 设计的核心。

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提供了对底层数据存储的抽象，允许应用程序在没有直接与数据存储技术交互的情况下访问数据，同时该抽象允许在不修改应用程序代码的情况下更改数据存储技术。

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，具体如下：

<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 就开发完成。

不知道你是否存在疑问：

1. 说好的统一的易用方法在哪里？
2. 为什么没有看到实现代码？

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

5. 实战--订单

为了体现 Spring Data Jpa的强大功能，以最常见的订单为例，业务模型如下图所示：

1. 一笔下单对应一个订单（Order）
2. 一个订单可以有一个收获地址（OrderAddress）
3. 一个订单可以关联多个订单项（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 具有：

1. 懒加载能力，只有在访问到关联数据时才对数据进行加载
2. 自动同步能力，新增对象通过 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 可以帮助开发人员更有效地解决业务问题，提高代码的可读性，可重用性和可扩展性，并减少代码量。