用好 DDD 必须先过 Spring Data 这关

原创 | 使用JPA实现DDD持久化-JPA,Hibernate与Spring Data JPA 2002年,Martin Fowler在他的名著《企业应用架构模式》中首次提出“数据映射器(Data Mapper)”模式,将面向对象的领域模型映射到关系数据库中。 2003年,澳大利亚程序员Gavin King,数据系统素人,因为嫌弃EJB Entity Bean 1.1的架构复杂,自行开发了一个对象关系映射框架Hibernate。值得一提的是,此前他从未用SQL开发过任何系统。为了开发Hibernate,他临时去书店买了一个SQL基础的书。现在Hibernate已经成为最流行的对象关系影射(ORM)工具 阅读详情

点击上方“芋道源码”,选择“设为星标”

管她前浪,还是后浪?

能浪的浪,才是好浪!

每天 10:33 更新文章,每天掉亿点点头发...

源码精品专栏

 

来源:geekhalo


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

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

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

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

我们以订单为例,如下图所示:

28c3d9e08dbb1d6d94e8f41cc3891a9f.png
  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?

假设,有一台非常牛逼的计算机,计算资源无限、内存大小无限、永不掉电、永不宕机,那最简单高效的方式便是将模型对象全部放在内存中。

但,现实不存在这样的机器,我们不得不将内存对象写入磁盘,下次使用时,在将其从磁盘读入到内存。

整体结构如下图所示:

ddd0a1335adc378451e573fa10f26d54.png

和上图相比,具有如下特点:

  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,具体如下:

<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 接口中的方法就能满足大部分需求,典型方法包括:

3fbcd586bc57fc5d4ba1fcfc7f56da2d.png

5. 实战--订单

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

e23dea20b41f721cf09ea957af9deb78.png
  1. 一笔下单对应一个订单(Order)

  2. 一个订单可以有一个收获地址(OrderAddress)

  3. 一个订单可以关联多个订单项(OrderItem)

对应到领域模型如下:

d4feee9b52d3b0302ec1a0beed4b0589.png

核心代码如下:

@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);  
}

首先,看一个添加地址的场景,生单时没有提供收货地址,生单后修改地址:

3353df070bcd10232d8618b81cc0c318.png

@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 可以帮助开发人员更有效地解决业务问题,提高代码的可读性,可重用性和可扩展性,并减少代码量。



欢迎加入我的知识星球,一起探讨架构,交流源码。加入方式,长按下方二维码噢:

c50b9ef13a3d49e902330441e5199271.png

已在知识星球更新源码解析如下:

d1dc8001946c01f95d55d1913b2cfd23.jpeg

0999935989f5c7ffcd86ac145a252a95.jpeg

29d7cc3193b182f1608315a2fa82571c.jpeg

2696d802fe25822e7f63ff71af5a6835.jpeg

最近更新《芋道 SpringBoot 2.X 入门》系列,已经 101 余篇,覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例,以及超 4W 行代码的电商微服务项目。

获取方式:点“在看”,关注公众号并回复 666 领取,更多内容陆续奉上。

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
基于DDD领域驱动设计通用后台权限系统开发 基于DDD领域驱动设计通用后台权限系统开发,响应式布局BootStrap,精美后台模板加代码,可更换皮肤。 立即下载

相关推荐

DDD项目实例

DDD技术实例

六个思考维度:DDD + SpringBoot工程九层结构图解与实战

微服务和九层结构表述的是不同维度概念。微服务重点描述系统与系统之间交互关系,九层结构重点描述一个工程不同模块之间交互关系

JAVA前线技术专栏 9190

领域驱动设计(DDD):分层架构

在应用系统开发中,采用严格的、单一的、真正的的分层架构是可以的,但实际上我们已经采用了多种架构模式设计系统。当多种不同范式的架构混合在一起,你会不会出现“指鹿为马”的现象呢? 在研究分层架构时,常通过概念性的定义或OSI七层应用(架构)来说明或解释分层架构:架构模式Layers有助于将应用程序划分为多组子任务,其中每组子任务都位于特定抽象层。图片取自《POSA,Vol.I,p22》作为一个在项目中引入分层架构的应用者,我们应该从更具体的规范来实现分层架构:相

SpringBoot-DDD领域驱动设计的概念

SpringBoot-DDD领域驱动设计的概念 大家都知道软件开发不是一蹴而就的事情,我们不可能在不了解产品(或行业领域)的前提下进行软件开发,在开发前通常需要进行大量的业务知识梳理,然后才能到软件设计的层面,最后才是开发。而在业务知识梳理的过程中,必然会形成某个领域知识,根据领域知识来一步步驱动软件设计,就是领域驱动设计(DDD,Domain-Driven Design)的基本概念 。 为什么需要 DDD 在业务初期,功能大都非常简单,普通的 CRUD 就基本能满足要求,此时系统是清晰的。但随着产品的不断

weixin_45203607的博客 6673

淘宝扫码登录避坑指南:如何避免异地登录风控并稳定获取Cookie(附Python代码)

本文深入解析了淘宝扫码登录的风控机制,提供了从环境仿真到代码实现的完整避坑指南。通过精细化伪装请求头、管理会话与IP策略,并附上Python示例代码,帮助开发者稳定获取Cookie,有效避免异地登录风控,实现自动化流程的可靠集成。

l6m7n8的博客 595

激光雷达+相机标定避坑指南:手把手教你用KITTI数据完成坐标转换

本文详细介绍了激光雷达与相机标定的实战指南,利用KITTI数据集完成精准坐标转换。从数据准备、工具链搭建到标定矩阵加载与验证,再到坐标转换流水线的工程实现,提供了全面的避坑技巧和工程实践建议。特别强调了多传感器融合中的常见问题及解决方案,帮助开发者提升自动驾驶和机器人感知系统的环境感知精度。

book8的博客 837

Spring编程使用DDD的小把戏

上面编写的代码并不完善,例如对参数的拦截点,只拦截了PostMapping, 忽略的参数只忽略了 @Autowired 注解,基本只覆盖了我自身使用的场景,但是基于这个原理,可以自行拓展,对更多的场景进行适配,完成对Service 代码和逻辑的拆解,将独立的功能封装到各自的实体领域中,方便代码管理与阅读,并且职责清晰。

cainiao1412的博客 1108

远距离长航时低成本泡沫垂直起降固定翼无人机技术详解

该技术通过采用泡沫材料制造无人机机体,并结合高效的垂直起降与固定翼飞行机制,实现了低成本、长航时、远距离的飞行能力。然而,需要注意的是,泡沫材料在强度和耐候性方面可能较传统金属材料有所不足,因此在设计和制造过程中需要采取额外的加固和防护措施。用于森林防火、水域监测、空气质量检测等场景,通过搭载相应的传感器和摄像设备,对大范围区域进行高效、精准的监测。- 增强智能化水平:集成更多先进的传感器、算法和人工智能技术,提升无人机的自主决策能力和作业效率。

专注多旋翼、复合翼无人机技术研究,从事低空经济行业。 1202

用好 DDD 必须先过 Spring Data 这关!

1. 面向对象设计是 DDD 的核心DDD 着重于将业务领域中的概念和对象映射到对象中,使对象模型能够更好地反映业务的真实情况,从而使设计更具可理解性和可维护性。DDD 是一种领域驱动的设计方法,旨在通过建立对领域模型的清晰理解来解决业务问题。和事务脚本不同,DDD 使用面向对象设计来应对复杂的业务场景。简单来说,DDD 是由领域对象承载业务逻辑,所有的业务操作均在模型对象上完成,同一对象上不同的...

Java知音 830

Google OR-Tools的CP-SAT求解器,为什么比传统线性规划更适合你的组合优化问题?

本文深入解析Google OR-Tools中的CP-SAT求解器为何比传统线性规划更适合解决组合优化问题。CP-SAT融合约束规划与可满足性理论,原生支持复杂逻辑约束和离散决策,在物流、生产调度等领域展现出显著优势。通过技术对比和实战案例,展示CP-SAT在处理高组合复杂度问题时的卓越性能。

weixin_28700593的博客 929

VxWorks系列 快速导航

Vxworks系列快速阅览导航

Mr.Sugarcane 1315

解密DDD:领域事件--系统解耦的终极武器

???? 这是一个或许对你有用的社群???? 一对一交流/面试小册/简历优化/求职解惑,欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料:《项目实战(视频)》:从书中学,往事上“练”《互联网高频面试题》:面朝简历学习,春暖花开《架构 x 系统设计》:摧枯拉朽,掌控面试高频场景题《精进 Java 学习指南》:系统学习,互联网主流技术栈《必读 Java 源码专栏》:知其然,知其所以然????这是一个或许...

芋艿V 946

图像紫边消除(depurple)

对图像紫边形成原因、消除方法进行了介绍。

沧海一升的博客 7568

Spring Boot 2.x实战57 - Spring Data 1 - DDD与Spring Data(Repository)

Spring Data 是一个伞型项目,包含主流的数据库的访问技术。这些不同的数据访问项目都使用相同的编程模型,他们都是基于Repository规范接口。我们在本章选关系型数据库的访问技术Spring Data JPA和NoSQL的访问Spring Data Elasticsearch。 1. Spring Data Repository 1.1 DDD与Spring Data 1.1.1 DDD DDD是Domain-Driven Design的缩写,即领域驱动设计。它是解决复杂业务需求的一些列高级技术。

汪云飞记录本 1629

pip install安装markitdown时出现ERROR: ‘packages/markitdown[all]‘ is not a valid editable requirement解决方案

本文主要介绍了pip install安装markitdown时出现ERROR: ‘packages/markitdown[all]’ is not a valid editable requirement解决方案,希望能对使用markitdown的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案

weixin_43178406的博客 3万+

华为自研 ERP、Oracle EBS 与 SAP 上线时系统配置思路设计差异深度分析

本文对比分析了华为自研ERP、Oracle EBS和SAP S/4HANA三大ERP系统在上线配置思路上的核心差异。从架构设计看,华为采用分布式微服务架构,SAP采用分层服务架构,Oracle采用集中式一体化架构;在模块配置上,华为以业务场景为导向,SAP基于行业模板,Oracle强调模块独立性;数据迁移方面,华为侧重业务规则清洗,SAP注重数据质量监控,Oracle依赖标准化工具;流程适配上,华为系统随流程调整,SAP在框架内优化,Oracle需定制开发;定制开发模式差异明显,华为采用插件化扩展,SAP使

金牌架构师 1456

markdownlint MD059 规则详解:如何用 descriptive-link-text 让 Markdown 链接文本更具描述性

本文围绕 markdownlint 的 `MD059`(别名 `descriptive-link-text`)规则展开:讲解它为何存在、默认的禁用词表与 `prohibited_texts` 参数如何配置、命中判定的边界行为,并结合 [lib/md059.mjs](https://link.gitcode.com/i/923711c892733ffe06a36d16f573a43b) 的源码与 [

gitblog_00740的博客 663

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

spring 2个jdbc_领域设计:Spring-Data-JDBC对DDD的支持

Spring在2018年9月发布了Spring-Data-JDBC子项目的1.0.0.RELEASE版本(目前版本为1.0.6-RELEASE),Spring-Data-JDBC设计借鉴了DDD,提供了对DDD的支持,包括:聚合与聚合根仓储领域事件在前面领域设计:聚合与聚合根一文中,通过列子介绍了聚合与聚合根;而在领域设计:领域事件一文中,通过例子介绍了领域事件。本文结合Spring-Data-J...

weixin_36211941的博客 365

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

一文读懂 Spring Data JDBC

摘要:SpringDataJDBC是Spring提供的轻量级数据访问技术,核心特性包括基于聚合根的持久化、无代理懒加载、简单映射等,相比SpringDataJPA更简单直接。与JdbcTemplate相比,SpringDataJDBC提供了更高层次的抽象,可大幅减少样板代码。在DDD设计中,解决聚合查询性能问题的策略包括:精心设计聚合粒度、使用查询方法返回非聚合视图、有限支持懒加载。最佳实践是设计小聚合、区分命令和查询场景、在便利性和性能间权衡。

weixin_66681451的博客 1784

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

spring boot 高性能批量新增_领域设计:Spring-Data-JDBC对DDD的支持

Spring在2018年9月发布了Spring-Data-JDBC子项目的1.0.0.RELEASE版本(目前版本为1.0.6-RELEASE),Spring-Data-JDBC设计借鉴了DDD,提供了对DDD的支持,包括:聚合与聚合根仓储领域事件在前面领域设计:聚合与聚合根一文中,通过列子介绍了聚合与聚合根;而在领域设计:领域事件一文中,通过例子介绍了领域事件。本文结合Spring-Data-J...

weixin_39562928的博客 493

DDD with Spring最佳实践:避免常见的架构设计陷阱

在软件开发领域,领域驱动设计(DDD)与Spring框架的结合为构建复杂业务系统提供了强大的方法论支持。本文将深入探讨DDD with Spring的核心实践,帮助开发者识别并规避常见的架构设计陷阱,构建出更具可维护性和扩展性的企业级应用。 ## 理解DDD与Spring的完美结合 DDD强调通过领域模型来反映业务需求,而Spring框架则提供了全面的基础设施支持,两者的结合能够有效提升复杂系

gitblog_00852的博客 1045

Spring Boot 2.x实战59 - Spring Data 3 - DDD下Spring Data JPA(聚合、值对象、库的定义与使用)

2.4 定义聚合 2.4.1 定义实体 我们使用javax.persistence.Entity注解来定实体类: @Entity public class Person {} 一个实体类会映射数据库的一张表,我们启用了spring.jpa.hibernate.ddl-auto: update,Spring Data会自动为我们建一个首字母小写的表person。 我们可以通过@Table(name = "tb_person")来定制的表名。 2.4.2 定义Id 我们使用javax.persistence.

汪云飞记录本 1191

[Source Title] — Applied to [Problem]

> One-paragraph executive summary: how the source maps to the situation, > the key insight, the bottom line. ## The Core Parallel How the source's central dynamic maps onto the user's situation. ##

gitblog_00913的博客 318

Spring Data JDBC快速入门:5分钟搭建高效数据访问层

Spring Data JDBC是Spring Data项目的重要组成部分,它提供了基于JDBC的Repository抽象,让开发者能够轻松构建Spring驱动的应用程序的数据访问层。作为一个简单、轻量级且有主见的ORM框架,Spring Data JDBC简化了数据访问代码的编写,同时保持了对底层JDBC的完全控制。 ## 📦 快速添加依赖 要开始使用Spring Data JDBC,首先

gitblog_00712的博客 954
上一篇: 美团:SPI 的原理是什么?
下一篇: 阿里版 ChatGPT 已进入测试
公众号-芋道源码
博客等级 码龄10年 1640粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值