DDD 实战1 - 基础代码模型

2021-02-12 本文已影响0人原水寒

本文首先介绍一下 DDD 代码模型的分层策略，然后介绍一下各层的职责，最后基于 DDD 开发一个订单中心，来实践 DDD.

DDD 分层策略

image.png

在 DDD 中，共有四层（领域层、应用层、用户接口层、基础设施层），其层级实际上是环状架构。如上图所示。根据整洁架构思想，在上述环状架构中，越往内层，代码越稳定，其代码不应该受外界技术实现的变动而变动，所以依赖关系是：外层依赖内层。按照这个依赖原则，DDD 代码模块依赖关系如下：

image.png

领域层（domain）：位于最内层，不依赖其他任何层；

应用层（application）：仅依赖领域层；

用户接口层（interfaces）：依赖应用层和领域层；

基础设施层（infrastructure）：依赖应用层和领域层；

启动模块（starter）：依赖用户接口层和基础设施层，对整个项目进行启动。
注意：interfaces 和 infrastructure 位于同一个换上，二者没有依赖关系。

DDD 各层职责

领域模型层 domain

包括实体、值对象、领域工厂、领域服务（处理本聚合内跨实体操作）、资源库接口、自定义异常等

应用服务层 application

跨聚合的服务编排，仅编排聚合根。包括：应用服务等

用户接口层 interfaces

本应用的所有流量入口。包括三部分：

web 入口的实现：包括 controller、DTO 定义、DTO 转化类
消息监听者（消费者）：包括 XxxListener
RPC 接口的实现：比如在使用 Dubbo 时，我们的服务需要开放 Dubbo 服务给第三方，此时需要创建单独的模块包，例如 client 模块，包含 Dubbo 接口和 DTO，在用户接口层中，去做 client 中接口的实现以及 DTO 转化类

基础设施层 infrastructure

本应用的所有流量出口。包括：

资源库接口的实现
数据库操作接口、数据库实现（如果使用mybatis，则包含 resource/*.xml）、数据库对象 DO、DO 转化类
中间件的实现、文件系统实现、缓存实现、消息实现等
第三方服务接口的实现

基于 DDD 开发订单中心

需求：基于 DDD 开发一个订单中心，实现下订单、查询订单等功能
代码：https://github.com/zhaojigang/ordercenter

ordercenter 根模块
├── order-application 应用模块
├── order-domain 领域模块
├── order-infrastructure 基础设施模块
├── order-interfaces 用户接口模块
├── order-starter 启动模块
└── pom.xml 根模块

领域层代码模型

image.png

包依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>
    </dependencies>

引入 spring-boot-autoconfigure:2.4.2，在领域工厂中需要用到 Spring 注解

DDD 标识注解 common.ddd.AggregateRoot

/**
 * 标注一个实体是聚合根
 */
@Documented
@Retention(SOURCE)
@Target(TYPE)
public @interface AggregateRoot {
}

自定义异常 common.exception.OrderException

/**
 * 自定义异常
 */
@Data
public class OrderException extends RuntimeException {
    private Integer code;
    private String message;

    public OrderException(Integer code, String message) {
        this.code = code;
        this.message = message;
    }
}

将自定义异常放在领域层，因为 DDD 推荐使用充血模型，在领域实体、值对象或者领域服务中，也会做一些业务逻辑，在业务逻辑中，可以根据需要抛出自定义异常

资源库接口 io.study.order.repository.OrderRepository

/**
 * 订单资源库接口
 */
public interface OrderRepository {
    /**
     * 保存订单
     *
     * @param order 订单
     */
    void add(Order order);

    /**
     * 根据订单ID获取订单
     * @param orderId
     */
    Order orderOfId(OrderId orderId);
}

资源库接口放置在领域层，实现领域对象自持久化，同时实现依赖反转。

依赖反转：将依赖关系进行反转，假设 Order 要做自持久化，那么需要拿到资源库的实现 OrderRepositoryImpl 才行，那么 domain 包就要依赖 infrastructure 包，但是这不符合 外层依赖内层 的原则，所以需要进行依赖反转，由 infrastructure 包依赖 domain 包。实现依赖反转的方式就是在被依赖方中添加接口（例如，在 domain 包中添加 OrderRepository 接口），依赖包对接口进行实现（infrastructure 包中对 OrderRepository 进行实现），这样的好处是，domain 可以完全仅关注业务逻辑，不要关心具体技术细节，不用去关心，到底是存储到 mysql，还是 oracle，使用的数据库框架是 mybatis 还是 hibernate，技术细节的实现由 infrastructure 来完成，真正实现了业务逻辑和技术细节的分离

资源库的命名推荐：对于资源库，推荐面向集合进行设计，即资源库的方法名采用与集合相似的方法名，例如，保存和更新是 add、addAll，删除时 remove、removeAll，查询是 xxxOfccc，例如 orderOfId，ordersOfCondition，复数使用 xxxs 的格式，而不是 xxxList 这样的格式

一个聚合具有一个资源库：比如订单聚合中，Order 主订单是聚合根，OrderItem 子订单是订单聚合中的一个普通实体，那么在订单聚合中只能存在 OrderRepository，不能存在 OrderItemRepository，OrderItem 的 CRUD 都要通过 OrderRepository 先获得 Order，再从 Order 中获取 List<OrderItem>，再做逻辑。这样的好处，保证了聚合根值整个聚合的入口，对聚合内的其他实体和值对象的方访问，只能通过聚合根，保证了聚合的封装性

领域工厂 io.study.order.factory.OrderFactory

/**
 * 订单工厂
 */
@Component
public class OrderFactory {
    private static OrderRepository orderRepository;

    @Autowired
    public OrderFactory(OrderRepository repository) {
        orderRepository = repository;
    }

    public static Order createOrder() {
        return new Order(orderRepository);
    }
}

工厂的作用：创建聚合。
工厂的好处：

创建复杂的聚合，简化客户端的使用。例如 Order 的创建需要注入资源库，订单创建后，可以直接发布订单创建事件。

可读性好（更加符合通用语言），比如对于创建订单，createOrder 就比 new Order 的语义更加明确

更好的保证一致性，防止出错，假设创建两个主订单 Order，两个主订单下分别还要创建多个子订单 OrderItem，每个子订单中需要存储主订单的ID，如果由客户端来设置 OrderItem 中的主订单ID，可能会将A主订单的ID设置给B主订单下的子订单，可能出现数据不一致的问题，具体的示例见《实现领域驱动》P183。

实体唯一标识 io.study.order.domain.OrderId

import lombok.Value;

/**
 * 订单ID
 */
@Value
public class OrderId {
    private Long id;

    public static OrderId of(Long id) {
        return new OrderId(id);
    }

    public void validId(){
        if (id == null || id <= 0) {
            throw new OrderException(400, "id 为空");
        }
    }
}

推荐使用强类型的对象作为实体的唯一标识，好处有两个：
a. 用来避免传参混乱，同时提升接口的可读性，例如 xxx(Long orderId, Long goodsId)，假设上述接口第一个参数传了 goodsId，第二个传了 orderId，那么编译期是无法发现的，改为 xxx(OrderId orderId, GoodsId, goodsId) 即可避免，同时可读性也较高。
b. 唯一标识中会有一些其他行为方法，如果唯一标识使用弱类型，那么这些行为方法将会泄露在实体中

唯一标识类是一个值对象，推荐值对象设置为不可变对象，使用 @lombok.Value 标注值对象，既可标识该对象为值对象，也可以是该类变为不可变类。例如，表示后的 OrderId 没有 setXxx 方法。

值对象的行为函数都是无副作用函数（即不能影响值对象本身的状态，例如 OrderId 对象被创建后，不能再使用 setXxx 修改其属性值），如果确实有属性需要变动，值对象需要整个换掉（例如，重新创建一个 OrderId 对象）

聚合根 io.study.order.domain.Order

/**
 * 订单聚合根
 */
@Setter
@Getter
@AggregateRoot
public class Order {
    /**
     * 订单 ID
     */
    private OrderId id;
    /**
     * 订单名称
     */
    private String name;
    /**
     * 订单资源库
     */
    private OrderRepository orderRepository;

    protected Order(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }

    /**
     * 创建订单
     *
     * @param order
     */
    public void saveOrder(Order order) {
        orderRepository.add(order);
    }

    public void setName(String name) {
        if (name == null) {
            throw new OrderException(400, "name 不能为空");
        }
        this.name = name;
    }

    public void setGoodsId(Long goodsId) {
        if (goodsId == null) {
            throw new OrderException(400, "goodsId 不能为空");
        }
        this.goodsId = goodsId;
    }

    public void setBuyQuality(Integer buyQuality) {
        if (buyQuality == null) {
            throw new OrderException(400, "buyQuality 不能为空");
        }
        this.buyQuality = buyQuality;
    }
}

聚合根是一个特殊的实体，是整个聚合对外的使者，其他聚合与改聚合沟通的方式只能是通过聚合根

由于使用工厂来创建 Order，那么 Order 的构造器需要设置为 protected，防止外界直接使用进行创建

实体单个属性的校验需要在 setXxx 中完成自校验

实体是可变的、具有唯一标识，其唯一标识通常需要设计成强类型

聚合中的 XxxRepository 可以通过上述的工厂进行注入，也可以使用“双委派”机制，即提供类似方法：createOrder(Order order, XxxRepository repository)，然后应用层在调用该方法时，传入注入好的 repository 实例即可。但是这样的方式，提高了客户端使用的复杂性。

应用层代码模型

image.png

包依赖

    <dependencies>
        <dependency>
            <groupId>io.study</groupId>
            <artifactId>order-domain</artifactId>
            <version>${project.version}</version>
        </dependency>
    </dependencies>

应用服务 io.study.order.app.service.OrderAppService

/**
 * 订单应用服务
 */
@Service
public class OrderAppService {
    /**
     * 创建一个订单
     *
     * @param order
     */
    public void createOrder(Order order) {
        /**
         * 存储订单
         */
        order.saveOrder(order);
        /**
         * 扣减库存
         */
    }
}

应用服务用于服务编排，如上述先存储订单，然后再调用库存服务减库存。（库存服务属于第三方服务，第三方服务的集成见下一小节）

基础设施层代码模型

image.png

包依赖

    <dependencies>
        <!-- 领域模块 -->
        <dependency>
            <groupId>io.study</groupId>
            <artifactId>order-domain</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>
        <!-- mapstruct -->
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct-processor</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok-mapstruct-binding</artifactId>
            <scope>provided</scope>
        </dependency>
        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

mapstruct 用于实现模型映射器，关于其使用见 https://www.jianshu.com/p/53aac78e7d60

数据存储采用 mysql，数据库操作框架使用 mybatis，可以看到，领域层对具体的技术实现并不关注，仅关注业务，通过 DDD 实现了技术细节与业务逻辑的解耦。

资源库实现 io.study.order.repository.impl.OrderRepositoryImpl

/**
 * 订单资源库实现类
 */
@Repository
public class OrderRepositoryImpl implements OrderRepository {
    @Resource
    private OrderDAO orderDAO;

    @Override
    public void add(Order order) {
        orderDAO.insertSelective(OrderDOConverter.INSTANCE.toDO(order));
    }

    @Override
    public Order orderOfId(OrderId orderId) {
        OrderDO orderDO = orderDAO.selectByPrimaryKey(orderId.getId());
        return OrderDOConverter.INSTANCE.fromDO(orderDO);
    }
}

数据库操作接口 io.study.order.data.OrderDAO

/**
 * 订单 DAO
 * 使用 mybatis-generator 自动生成
 */
@org.apache.ibatis.annotations.Mapper
public interface OrderDAO {
    int insertSelective(OrderDO record);
    OrderDO selectByPrimaryKey(Long id);
}

数据库实现类 resources/mapper/OrderDAO.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="io.study.order.data.OrderDAO">
    <resultMap id="BaseResultMap" type="io.study.order.data.OrderDO">
        <id column="id" property="id" jdbcType="BIGINT"/>
        <result column="name" property="name" jdbcType="VARCHAR"/>
    </resultMap>
    <sql id="Base_Column_List">
    id, name
    </sql>
    <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Long">
        select
        <include refid="Base_Column_List"/>
        from `order`
        where id = #{id,jdbcType=BIGINT}
    </select>
    <insert id="insertSelective" parameterType="io.study.order.data.OrderDO">
        insert into `order`
        <trim prefix="(" suffix=")" suffixOverrides=",">
            <if test="id != null">
                id,
            </if>
            <if test="name != null">
                name,
            </if>
        </trim>
        <trim prefix="values (" suffix=")" suffixOverrides=",">
            <if test="id != null">
                #{id,jdbcType=BIGINT},
            </if>
            <if test="name != null">
                #{name,jdbcType=VARCHAR},
            </if>
        </trim>
    </insert>
</mapper>

数据对象

/**
 * 订单数据库对象
 */
@Data
public class OrderDO {
    /**
     * 订单 ID
     */
    private Long id;
    /**
     * 订单名称
     */
    private String name;
}

数据对象转换器 io.study.order.data.OrderDOConverter

/**
 * OrderDO 转换器
 */
@org.mapstruct.Mapper
public interface OrderDOConverter {
    OrderDOConverter INSTANCE = Mappers.getMapper(OrderDOConverter.class);

    @Mapping(source = "id.id", target = "id")
    OrderDO toDO(Order order);

    @Mapping(target = "id", expression = "java(OrderId.of(orderDO.getId()))")
    void update(OrderDO orderDO, @MappingTarget Order order);

    default Order fromDO(OrderDO orderDO) {
        Order order = OrderFactory.createOrder();
        INSTANCE.update(orderDO, order);
        return order;
    }
}

在创建实体对象时，需要使用工厂进行创建，这样才能为实体注入资源库实现。

用户接口层代码模型

image.png

包依赖

    <dependencies>
        <!-- 领域模块 -->
        <dependency>
            <groupId>io.study</groupId>
            <artifactId>order-domain</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!-- 应用模块 -->
        <dependency>
            <groupId>io.study</groupId>
            <artifactId>order-application</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>
        <!-- mapstruct -->
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mapstruct</groupId>
            <artifactId>mapstruct-processor</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok-mapstruct-binding</artifactId>
            <scope>provided</scope>
        </dependency>
        <!-- springboot-web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- springfox -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-boot-starter</artifactId>
        </dependency>
    </dependencies>

引入 springfox-boot-starter:3.0.0 来实现自动化可测试的 Rest 接口文档

Controller io.study.order.web.OrderController

/**
 * Order 控制器
 */
@Api("订单控制器")
@RestController
@RequestMapping("order")
public class OrderController {
    @Resource
    private OrderAppService orderAppService;
    @Resource
    private OrderRepository orderRepository;

    /**
     * 创建一个订单
     *
     * @param orderDto
     */
    @ApiOperation("创建订单")
    @PostMapping("/create")
    public void createOrder(@RequestBody OrderDto orderDto) {
        orderAppService.createOrder(OrderDtoAssembler.INSTANCE.fromDTO(orderDto));
    }

    /**
     * 查询一个订单
     *
     * @param id 订单ID
     * @return
     */
    @ApiOperation("根据订单ID获取订单")
    @GetMapping("/find/{id}")
    public OrderDto findOrder(@PathVariable Long id) {
        Order order = orderRepository.orderOfId(OrderId.of(id));
        return OrderDtoAssembler.INSTANCE.toDTO(order);
    }
}

数据传输对象 io.study.order.web.dto.OrderDto

/**
 * 订单数据传输对象
 */
@ApiModel("订单")
@Data
public class OrderDto {
    /**
     * 订单 ID
     */
    @ApiModelProperty("订单ID")
    private Long id;
    /**
     * 订单名称
     */
    @ApiModelProperty("订单名称")
    private String name;
}

DTO 转换类 io.study.order.web.assembler.OrderDtoAssembler

/**
 * OrderDTO<=>Order 转换器
 */
@Mapper
public interface OrderDtoAssembler {
    OrderDtoAssembler INSTANCE = Mappers.getMapper(OrderDtoAssembler.class);
    /**
     * DTO 转 Entity
     * @param dto
     * @return
     */
    default Order fromDTO(OrderDto dto) {
        Order order = OrderFactory.createOrder();
        INSTANCE.update(dto, order);
        return order;
    }

    /**
     * Entity 转 DTO
     * @param order
     * @return
     */
    @Mapping(source = "id.id", target = "id")
    OrderDto toDTO(Order order);

    @Mapping(target = "id", expression = "java(OrderId.of(orderDto.getId()))")
    void update(OrderDto orderDto, @MappingTarget Order order);
}

转换器应该写在外层还是内层，比如 OrderDtoAssembler 是应该写在 interfaces 层，还是写在 application 层，从依赖关系来考虑：假设写在 application 层，由于 DTO 是定义在 interfaces 层，那么 application 需要依赖 interfaces，与 外层依赖内层 的原则不符，那么 DTO 是否可以写在 application 层，假设现在有个需要对外提供的 Dubbo 接口，该接口中存在的 DTO 是需要打包给第三方的，所以并不适合写在 application 层。

启动模块代码模型

image.png

包依赖

    <dependencies>
        <!-- 基础设施层 -->
        <dependency>
            <groupId>io.study</groupId>
            <artifactId>order-infrastructure</artifactId>
            <version>${project.version}</version>
        </dependency>
        <!-- 用户接口层 -->
        <dependency>
            <groupId>io.study</groupId>
            <artifactId>order-interfaces</artifactId>
            <version>${project.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

启动器 io.study.order.OrderApplication

/**
 * 应用启动器
 */
@EnableOpenApi
@SpringBootApplication
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
}

springfox3.x 通过注解 @EnableOpenApi 来启动自动配置

配置文件 resource/application.properties

mybatis.mapper-locations=/mapper/*.xml

spring.datasource.username: root
spring.datasource.password: xxx
spring.datasource.url: jdbc:mysql://localhost:3306/my-test?useUnicode=true&characterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

DDD 实战1 - 基础代码模型

DDD 分层策略

DDD 各层职责

领域模型层 domain

应用服务层 application

用户接口层 interfaces

基础设施层 infrastructure

基于 DDD 开发订单中心

领域层代码模型

包依赖

DDD 标识注解 common.ddd.AggregateRoot

自定义异常 common.exception.OrderException

资源库接口 io.study.order.repository.OrderRepository

领域工厂 io.study.order.factory.OrderFactory

实体唯一标识 io.study.order.domain.OrderId

聚合根 io.study.order.domain.Order

应用层代码模型

包依赖

应用服务 io.study.order.app.service.OrderAppService

基础设施层代码模型

包依赖

资源库实现 io.study.order.repository.impl.OrderRepositoryImpl

数据库操作接口 io.study.order.data.OrderDAO

数据库实现类 resources/mapper/OrderDAO.xml

数据对象

数据对象转换器 io.study.order.data.OrderDOConverter

用户接口层代码模型

包依赖

Controller io.study.order.web.OrderController

数据传输对象 io.study.order.web.dto.OrderDto

DTO 转换类 io.study.order.web.assembler.OrderDtoAssembler

启动模块代码模型

包依赖

启动器 io.study.order.OrderApplication

配置文件 resource/application.properties

猜你喜欢

热点阅读