领域驱动设计（DDD）——仓储（Repository）详解和示例

已于 2025-01-09 15:50:12 修改
阅读量1.2k 收藏 11
点赞数 23
分类专栏： 开发技巧 架构 文章标签： 架构 java
于 2025-01-09 12:29:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/goTsHgo/article/details/145030802
版权

        在领域驱动设计（DDD，Domain-Driven Design）中， 仓储（Repository） 是一个重要的概念，用于解决持久化和领域模型之间的隔离问题。简单来说，仓储是领域模型与持久化存储（如数据库）之间的桥梁，它提供了一种在应用程序中操作领域对象的方式，而无需直接与数据库或底层存储交互。

DDD架构
DDD架构

       

 以下是对仓储的详细解释：

仓储的定义

仓储（Repository）的核心思想是：

提供一个中间层，让应用程序可以像操作内存中的对象集合一样操作领域对象，而不关心对象的持久化实现细节。

仓储是一个领域对象集合的抽象，应用程序可以通过它来存储、查询、更新、删除领域对象。

仓储的设计原则

  1. 隐藏持久化细节：
    仓储屏蔽了底层存储的复杂性（如 SQL 查询、事务管理等），领域层只需要通过仓储接口与之交互，而无需关心存储的实现细节。

  2. 提供领域模型的聚合操作：
    仓储通常与聚合根（Aggregate Root）紧密相关。每个聚合（Aggregate）通常会有一个对应的仓储，仓储只负责管理聚合根及其聚合内的对象。

  3. 保持统一接口：
    仓储通过接口定义了对领域对象的基本操作，比如添加、删除、查找和更新等操作。

仓储的职责

  1. 存储领域对象：
    负责将领域对象保存到持久化存储（如数据库）。

  2. 获取领域对象：
    提供方法来根据条件查询领域对象（如通过 ID 查找订单）。

  3. 删除领域对象：
    负责从存储中移除领域对象。

  4. 隐藏存储细节：
    将底层存储逻辑封装起来（如 SQL 查询或 ORM 操作），让领域模型专注于业务逻辑。

仓储的实现方法

        以下是使用 Java 的仓储模式实现的代码示例，包括详细注释，生产环境使用需要根据需求来调整。

示例场景：订单仓储
1. 定义聚合根（领域对象）
import java.time.LocalDateTime;

/**
 * 订单（Order）：这是领域模型中的聚合根。
 * 聚合根是领域模型中的一个重要概念，表示领域的一部分及其边界。
 */
public class Order {
    private final String orderId; // 订单的唯一标识
    private final String userId;  // 用户 ID
    private double totalAmount;   // 订单总金额
    private LocalDateTime createdAt; // 订单创建时间

    public Order(String orderId, String userId, double totalAmount) {
        this.orderId = orderId;
        this.userId = userId;
        this.totalAmount = totalAmount;
        this.createdAt = LocalDateTime.now();
    }

    // Getter 和 Setter 方法
    public String getOrderId() {
        return orderId;
    }

    public String getUserId() {
        return userId;
    }

    public double getTotalAmount() {
        return totalAmount;
    }

    public void setTotalAmount(double totalAmount) {
        this.totalAmount = totalAmount;
    }

    public LocalDateTime getCreatedAt() {
        return createdAt;
    }
}

2. 定义仓储接口
import java.util.Optional;

/**
 * 订单仓储接口（Order Repository）。
 * 定义了对订单领域对象的基本操作。
 */
public interface OrderRepository {
    /**
     * 保存订单。
     *
     * @param order 要保存的订单对象
     */
    void save(Order order);

    /**
     * 根据订单 ID 查找订单。
     *
     * @param orderId 订单 ID
     * @return 返回订单对象的 Optional（可能存在，也可能不存在）
     */
    Optional<Order> findById(String orderId);

    /**
     * 删除订单。
     *
     * @param orderId 订单 ID
     */
    void delete(String orderId);
}

3. 仓储实现（基于内存的示例）

        在学习中，仓储通常通过数据库实现（如基于 JDBC、JPA、mybatis等）。这里我们先用内存实现，便于理解：

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

/**
 * 订单仓储的内存实现。
 * 模拟将订单存储在内存中。
 */
public class InMemoryOrderRepository implements OrderRepository {
    private final Map<String, Order> storage = new HashMap<>(); // 用于模拟数据库的存储

    @Override
    public void save(Order order) {
        storage.put(order.getOrderId(), order); // 将订单保存到内存中
        System.out.println("订单已保存，订单 ID: " + order.getOrderId());
    }

    @Override
    public Optional<Order> findById(String orderId) {
        // 从内存中查找订单
        return Optional.ofNullable(storage.get(orderId));
    }

    @Override
    public void delete(String orderId) {
        storage.remove(orderId); // 从内存中移除订单
        System.out.println("订单已删除，订单 ID: " + orderId);
    }
}

4. 测试代码
public class RepositoryExample {
    public static void main(String[] args) {
        // 创建一个仓储实例
        OrderRepository orderRepository = new InMemoryOrderRepository();

        // 创建订单
        Order order = new Order("12345", "user001", 299.99);

        // 保存订单
        orderRepository.save(order);

        // 查找订单
        orderRepository.findById("12345").ifPresentOrElse(
                foundOrder -> System.out.println("找到订单，用户 ID: " + foundOrder.getUserId() + ", 总金额: " + foundOrder.getTotalAmount()),
                () -> System.out.println("订单未找到！")
        );

        // 删除订单
        orderRepository.delete("12345");

        // 再次查找订单
        orderRepository.findById("12345").ifPresentOrElse(
                foundOrder -> System.out.println("找到订单，用户 ID: " + foundOrder.getUserId()),
                () -> System.out.println("订单未找到！")
        );
    }
}
运行结果
订单已保存，订单 ID: 12345
找到订单，用户 ID: user001, 总金额: 299.99
订单已删除，订单 ID: 12345
订单未找到！

仓储的核心原理

  1. 隐藏存储细节：

    • 仓储封装了底层存储的逻辑（如保存、查找、删除等），使得领域模型不需要直接依赖数据库操作。

  2. 像操作集合一样操作领域对象：

    • 仓储让我们能够像操作内存中的集合一样操作领域对象，而底层实现可能使用数据库、文件存储等方式。

  3. 与聚合根紧密关联：

    • 仓储只负责管理聚合根，聚合根内部的其他对象由聚合根本身管理。例如，Order 是聚合根，仓储只操作 Order，而不会直接操作订单中的明细条目。

  4. 实现领域逻辑与基础设施的解耦：

    • 通过接口定义仓储，领域层只依赖仓储接口，具体的实现由基础设施层提供。这种设计符合 DDD 的分层架构。

仓储在生产环境中的使用

        在生产环境中，仓储通常使用 ORM 工具（如 mybatis、JPA）或直接使用数据库查询实现。以上的内存实现是一个简单的演示，实际环境中可以通过数据库实现。

如下是基于 JPA 的仓储实现示例：

@Repository
public class JpaOrderRepository implements OrderRepository {
    @PersistenceContext
    private EntityManager entityManager;

    @Override
    public void save(Order order) {
        entityManager.persist(order);
    }

    @Override
    public Optional<Order> findById(String orderId) {
        return Optional.ofNullable(entityManager.find(Order.class, orderId));
    }

    @Override
    public void delete(String orderId) {
        Order order = entityManager.find(Order.class, orderId);
        if (order != null) {
            entityManager.remove(order);
        }
    }
}

基于 MyBatis 的仓储实现示例

场景：订单（Order）仓储
  • 需求：
    • 需要对订单进行基本的持久化操作，包括保存、查询和删除。
    • 使用 MyBatis 进行 SQL 操作。
1. 定义领域模型
import java.time.LocalDateTime;

/**
 * 订单（Order）：这是领域模型中的聚合根。
 * 聚合根是领域模型中的一个重要概念，表示领域的一部分及其边界。
 */
public class Order {
    private String orderId;      // 订单的唯一标识
    private String userId;       // 用户 ID
    private double totalAmount;  // 订单总金额
    private LocalDateTime createdAt; // 订单创建时间

    // 构造方法
    public Order(String orderId, String userId, double totalAmount) {
        this.orderId = orderId;
        this.userId = userId;
        this.totalAmount = totalAmount;
        this.createdAt = LocalDateTime.now();
    }

    // Getter 和 Setter 方法
    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public double getTotalAmount() {
        return totalAmount;
    }

    public void setTotalAmount(double totalAmount) {
        this.totalAmount = totalAmount;
    }

    public LocalDateTime getCreatedAt() {
        return createdAt;
    }

    public void setCreatedAt(LocalDateTime createdAt) {
        this.createdAt = createdAt;
    }
}

2. 定义仓储接口

仓储接口定义了操作领域模型的基本方法。

import java.util.Optional;

/**
 * 订单仓储接口（OrderRepository）。
 * 定义对订单领域对象的持久化操作。
 */
public interface OrderRepository {
    /**
     * 保存订单。
     *
     * @param order 要保存的订单对象
     */
    void save(Order order);

    /**
     * 根据订单 ID 查找订单。
     *
     * @param orderId 订单 ID
     * @return 返回订单对象的 Optional（可能存在，也可能不存在）
     */
    Optional<Order> findById(String orderId);

    /**
     * 删除订单。
     *
     * @param orderId 订单 ID
     */
    void delete(String orderId);
}

3. 创建 MyBatis Mapper XML 文件

        在 MyBatis 中，SQL 语句通常定义在 Mapper 文件中。以下是一个基于 MyBatis 的 OrderMapper.xml 文件示例：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.example.repository.OrderMapper">

    <!-- 保存订单 -->
    <insert id="saveOrder">
        INSERT INTO orders (order_id, user_id, total_amount, created_at)
        VALUES (#{orderId}, #{userId}, #{totalAmount}, #{createdAt})
    </insert>

    <!-- 根据订单 ID 查询订单 -->
    <select id="findOrderById" resultType="com.example.domain.Order">
        SELECT order_id AS orderId,
               user_id AS userId,
               total_amount AS totalAmount,
               created_at AS createdAt
        FROM orders
        WHERE order_id = #{orderId}
    </select>

    <!-- 删除订单 -->
    <delete id="deleteOrder">
        DELETE FROM orders WHERE order_id = #{orderId}
    </delete>

</mapper>

  • 文件解析：
    • namespace 指定了 Mapper 的全限定名。
    • 每个 <insert>、<select> 和 <delete> 标签分别对应保存、查询和删除操作。
    • 使用 #{} 来映射 Java 对象的属性到 SQL 参数。
4. 实现仓储接口

通过 MyBatis 的 Mapper 动态代理实现仓储接口。

import org.apache.ibatis.annotations.Mapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.util.Optional;

/**
 * 基于 MyBatis 的订单仓储实现。
 */
@Repository
public class MyBatisOrderRepository implements OrderRepository {

    private final OrderMapper orderMapper; // 注入 MyBatis Mapper

    @Autowired
    public MyBatisOrderRepository(OrderMapper orderMapper) {
        this.orderMapper = orderMapper;
    }

    @Override
    public void save(Order order) {
        orderMapper.saveOrder(order); // 调用 MyBatis Mapper 的 save 方法
    }

    @Override
    public Optional<Order> findById(String orderId) {
        return Optional.ofNullable(orderMapper.findOrderById(orderId));
    }

    @Override
    public void delete(String orderId) {
        orderMapper.deleteOrder(orderId); // 调用 MyBatis Mapper 的 delete 方法
    }
}

5. 定义 MyBatis Mapper 接口

MyBatis 会为 Mapper 接口生成动态代理，实现具体的 SQL 调用。

@Mapper
public interface OrderMapper {
    void saveOrder(Order order); // 对应 XML 文件中的 saveOrder

    Order findOrderById(String orderId); // 对应 XML 文件中的 findOrderById

    void deleteOrder(String orderId); // 对应 XML 文件中的 deleteOrder
}
6. 数据库表结构

确保有一个对应的数据库表 orders，结构如下：

CREATE TABLE orders (
    order_id VARCHAR(50) PRIMARY KEY,
    user_id VARCHAR(50) NOT NULL,
    total_amount DECIMAL(10, 2) NOT NULL,
    created_at TIMESTAMP NOT NULL
);
7. 测试代码
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

/**
 * 仓储测试类。
 * 演示如何使用基于 MyBatis 的仓储实现。
 */
@Component
public class RepositoryTest implements CommandLineRunner {

    private final OrderRepository orderRepository;

    @Autowired
    public RepositoryTest(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }

    @Override
    public void run(String... args) {
        // 创建一个订单
        Order order = new Order("12345", "user001", 299.99);

        // 保存订单
        orderRepository.save(order);
        System.out.println("订单已保存！");

        // 查找订单
        orderRepository.findById("12345").ifPresentOrElse(
                foundOrder -> System.out.println("找到订单，用户 ID: " + foundOrder.getUserId() + ", 总金额: " + foundOrder.getTotalAmount()),
                () -> System.out.println("订单未找到！")
        );

        // 删除订单
        orderRepository.delete("12345");
        System.out.println("订单已删除！");
    }
}

8. 运行结果

执行测试代码时，控制台输出如下：

订单已保存！
找到订单，用户 ID: user001, 总金额: 299.99
订单已删除！
小结

        基于 MyBatis 的仓储实现将领域模型（Order）与数据库操作解耦，生产上通过以下方式实现代码：

  1. 定义领域模型：表示业务数据和逻辑。
  2. 定义仓储接口：提供统一的领域对象操作方法。
  3. 使用 MyBatis Mapper：通过 XML 或注解定义 SQL，完成数据库交互。
  4. 仓储实现：通过 MyBatis 的 Mapper 动态代理实现仓储接口。

        这种实现方式符合 DDD 的设计原则，同时充分利用 MyBatis 强大的 SQL 映射能力，是生产环境中一种高效且可靠的实现方式。

总结

        在 DDD 设计原则中，仓储的作用是为领域模型提供对持久化存储的访问，同时隐藏存储细节，从而实现领域逻辑与基础设施的解耦。通过仓储模式，我们能够更方便地操作领域对象，同时保持代码的清晰性和可扩展性。

三十二、领域驱动设计DDD（战术设计）
xiaoqi270620903的专栏
09-27 971
通过这些战术设计的概念，DDD 提供了一套结构化的方法来设计复杂业务系统。聚合：订单聚合管理订单及其项。聚合根：用户作为聚合根管理帖子。工厂创建订单对象。服务处理支付逻辑。领域服务处理发货。应用服务协调订单创建流程。事件通知系统状态变化。仓储处理订单存取。聚合与聚合根Order和OrderItem构成了订单聚合，Order作为聚合根管理聚合内部的状态和操作。工厂负责创建订单，封装了创建复杂对象的逻辑。服务负责处理订单的支付。领域服务负责处理订单的发货流程。应用服务。
三十、领域驱动设计DDD（基本概念）
xiaoqi270620903的专栏
09-26 485
领域是指业务领域，代表着系统所处的业务环境或问题空间。领域是我们设计软件时要解决的问题的核心。
领域驱动设计
活出我的精彩
08-21 635
领域驱动设计基本理论知识总结 本文内容提要： 1. 领域驱动设计之领域模型； 2. 为什么建立一个领域模型是重要的； 3. 领域通用语言（Ubiquitous Language）； 4. 将领域模型转换为代码实现的最佳实践； 5. 领域建模时思考问题的角度； 6. 领域驱动设计的标准分层架构； 7. 领域驱动设计过程中使用的模式； 8. 设计领域模型的一般步骤；...
DDD—Repository仓储&工厂模式
a6636656的博客
07-27 1702
而一旦涉及到数据逻辑的修改，就要到领域层中去修改代码，重新调试领域层与基础层的交互，或者当切换异构数据库类型时，需要大量修改领域层的代码，将业务逻辑和数据处理逻辑重新适配（主要在于异构数据库导致的SQL或数据对象调整），因此技术升级会变得特别麻烦。DO对象创建时，需要确保聚合根和它依赖的对象同时被创建，如果这项工作交给聚合根来实现，则聚合根的构造函数将变得异常庞大，所以我们把通用的初始化DO的逻辑，放到工厂中去实现，通过工厂模式封装聚合内复杂对象的创建过程，完成聚合根，实体和值对象的创建。...
仓储(Repository)应该属于DDD分层架构中的哪一层？
云笔记，记录工作学习中遇到的问题，希望对你有帮助
03-23 512
Repository 是 DDD 中的一个核心模式，用于封装对领域对象（如聚合根）的持久化逻辑，提供一个面向集合的接口，让领域层以类似内存操作的方式访问和管理数据。提供对聚合根的增删改查操作。屏蔽底层数据存储的细节（如数据库类型、ORM 框架）。确保领域层与基础设施层的解耦。在 Eric Evans 的《领域驱动设计》一书中，Repository 被视为领域层的一部分，因为它是领域模型的重要组成部分，与聚合根密切相关。Repository 接口属于领域层。
DDD理论学习系列（12）-- 仓储
weixin_34186128的博客
07-31 329
DDD理论学习系列——案例及目录 1. 引言 DDD中Repository这个单词，主要有两种翻译：资源库和仓储，本文取仓储之译。 说到仓储，我们肯定就想到了仓库，仓库一般用来存放货物，而仓库一般由仓库管理员来管理。当工厂生产了一批货物时，只需交给仓库管理员即可，他负责货物的堆放；当需要发货的时候，仓库管理员负责从仓库中捡货进行货物出库处理。当需要库存盘点时，仓库管理员负责核实货物状态和库存...
DDD之:Repository仓储模式
diaohuyi6830的博客
07-21 915
在DDD设计中大家都会使用Repository pattern来获取domain model所需要的数据。 1.什么事Repository? "A Repository mediates between the domain and data mapping layers, acting like an in-memory domain object collection. Clie...
初探领域驱动设计（2）Repository在DDD中的应用
weixin_34185320的博客
10-09 439
概述 　　上一篇我们算是粗略的介绍了一下DDD，我们提到了实体、值类型和领域服务，也稍微讲到了DDD中的分层结构。但这只能算是一个很简单的介绍，并且我们在上篇的末尾还留下了一些问题，其中大家讨论比较多的，也是我本人之前有一些疑问的地方就是Repository。我之前觉得IRepository和三层里面的IDAL很像，为什么要整出这么个东西来；有人说用EF的话就不需要Repository了；IRe...
微服务学习笔记 DDD中的Repository
qj4865的博客
05-17 1204
浅薄的了解ddd中的repository层，就是起到一个聚合的作用。他介于domain和dao层之间，相当于一个聚合dao数据的作用。比如说我一个查询需要先查cache，命中不到再去找dao，那我这个逻辑就可以放在repo层；又比如说我一个domain层需要一组数据，这个数据是从多个表拿的，那么我就也可以吧多个dao查出来的数据，在repo层聚合。 ...
领域驱动设计（DDD）详解：从理论到实践的系统化指南
最新发布
空
05-16 1057
领域驱动设计（Domain-Driven Design，DDD）是一种以业务为核心的设计方法论，旨在解决复杂业务场景下的软件架构难题。本文通过核心概念解析、实战案例拆解及分层架构设计，帮助开发者从零掌握DDD的核心思想与落地技巧。
领域驱动设计(DDD)与Spring Boot JPA实践指南
m0_53548081的博客
04-29 1158
DDD的基本概念和理念：解释了什么是领域驱动设计，以及它的核心理念，如以领域为中心、统一语言、协作设计等。 DDD的核心概念详解： 战略设计：界限上下文、上下文映射 战术设计：实体、值对象、聚合、领域服务、领域事件、仓储等 Spring Boot和JPA实现DDD的完整流程： 识别界限上下文 构建领域模型（包含完整的Java代码示例） 定义应用服务 创建REST控制器 处理领域事件 项目结构组织 DDD的优缺点分析： 优点：更好反映业务需求、提高代码可维护性、适应业务变化等 缺点：学习曲线陡峭、前
领域驱动设计(DDD)与ABP Vnext应用服务器搭建教程
资源摘要信息:"本指南是一份深入详解如何基于领域驱动设计（DDD）原则和ABP Vnext框架来搭建应用服务器的教程。DDD是一种软件开发方法论，强调在软件开发过程中以业务领域的核心概念为中心，通过定义清晰的领域模型...
DDD之Repository模式
weixin_45596022的博客
05-02 3543
一，传统架构下的实体模型 传统的应用架构，几乎就是根据需求设计数据库的表，根据表建立实体，对应着实体的就是DAO，Service，Controller，也就是传统的MVC三层架构。 回顾下我们平时写的代码，里面有着很多的xxxUtils工具类，很多的参数校验逻辑与业务逻辑混杂在一起，很多的实体类直接与数据库进行一对一映射。 好处很明显，在业务初期，开发起来很容易，相对比较简单，流水线式编码，但是，一旦后期需求变更，业务改造，数据库表发生变化，可能给我们带来毁灭性的负担。所谓牵一发而动全身，前面欠下了技术债，
应用程序框架实战二十二 : DDD分层架构之仓储（层超类型基础篇）
weixin_34293902的博客
12-17 316
　　前一篇介绍了仓储的基本概念，并谈了我对仓储的一些认识，本文将实现仓储的基本功能。 　　仓储代表聚合在内存中的集合，所以仓储的接口需要模拟得像一个集合。仓储中有很多操作都是可以通用的，可以把这部分操作抽取到基类中。 　　在Util.Domains项目中创建一个文件夹Repositories，这个文件夹用来放仓储相关的接口。在Repositories下创建一个仓储接口IRepository。 ...
DDD实战4 实现产品仓储
04-17 258
a.要实现仓储，首先要定义仓储接口。在领域层定义仓储接口，IProductRepository.cs。 public interface IProductRepository { void CreateProduct<T>(T productspu) where T:class,IAggregationRoot; } 产品持...
DDD中的Repository模式，值得所有人掌握！
weixin_54542328的博客
10-18 1052
大家好，我是飘渺。今天我们继续更新DDD（领域驱动设计） & 微服务系列。在之前的文章中，我们探讨了如何在DDD中结构化应用程序。我们了解到，在DDD中通常将应用程序分为四个层次，分别为用户接口层（Interface Layer），应用层（Application Layer），领域层（Domain Layer），和基础设施层（Infrastructure Layer）。此外，在用户注册的主题中，我们简要地提及了资源库模式。然而，那时我们并没有深入探讨。今天，我将为大家详细介绍资源库模式，这在DDD中是一个非
阿里技术专家详解DDD系列 第三讲 - Repository模式
Javaesandyou的博客
03-07 1599
为什么要用 Repository 实体模型 vs. 贫血模型 Entity（实体）这个词在计算机领域的最初应用可能是来自于Peter Chen在1976年的“The Entity-Relationship Model - Toward a Unified View of Data"（ER模型），用来描述实体之间的关系，而ER模型后来逐渐的演变成为一个数据模型，在关系型数据库中代表了数据的储存方式。 而2006年的JPA标准，通过@Entity等注解，以及Hibernate等ORM框架的实现，让很多Ja
ddd java repository_DDD之:Repository仓储模式
weixin_39637723的博客
02-17 483
在DDD设计中大家都会使用Repository pattern来获取domain model所需要的数据。1.什么事Repository?"A Repository mediates between the domain and data mapping layers, acting like an in-memory domain object collection. Client object...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值