架构与系统设计 / 系统课时

编写创建订单应用服务

编写创建订单应用服务

创建订单应用服务要把一次用例串完整:接收请求数据,转换为领域对象需要的参数,调用订单聚合创建行为,再通过 Repository 持久化。关键不是把业务规则塞进 Service,而是让应用层只负责编排。

学习目标

  • 能划分请求对象、应用服务、订单聚合与 Repository 的职责
  • 能实现“输入转换 → 创建聚合 → 保存 → 返回结果”的完整用例
  • 能判断哪些校验应留在领域模型,而不是堆到应用服务中

应用服务只负责用例编排

创建订单通常同时涉及请求 DTO、应用服务、订单聚合和 Repository。应用服务知道“先做什么、后做什么”,但不应该决定“订单是否允许为空”“商品数量是否合法”这类业务规则;这些规则应由领域对象在创建时保证。

创建订单应用服务的数据流

这条链路里,Repository 接口表达“应用需要保存订单”这一能力;至于数据最终进入 MySQL、MongoDB 还是内存集合,是基础设施层实现要解决的问题。

用一个可运行示例串起流程

下面用单文件 Java 示例实现最小闭环。为了让示例可以直接运行,订单编号从请求中传入;真实项目中也可以把编号生成器作为独立依赖注入应用服务。

java
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class CreateOrderDemo {
    record OrderItemRequest(String productId, int quantity) {}

    record CreateOrderRequest(
            String orderId,
            String customerId,
            List<OrderItemRequest> items) {}

    record OrderItem(String productId, int quantity) {
        OrderItem {
            if (quantity <= 0) {
                throw new IllegalArgumentException("quantity must be positive");
            }
        }
    }

    enum OrderStatus {
        CREATED
    }

    static final class Order {
        private final String id;
        private final String customerId;
        private final List<OrderItem> items;
        private final OrderStatus status;

        private Order(
                String id,
                String customerId,
                List<OrderItem> items,
                OrderStatus status) {
            this.id = id;
            this.customerId = customerId;
            this.items = List.copyOf(items);
            this.status = status;
        }

        static Order create(String id, String customerId, List<OrderItem> items) {
            // “订单至少包含一个商品”属于领域不变量,由聚合自己保证。
            if (items.isEmpty()) {
                throw new IllegalArgumentException("order must contain at least one item");
            }
            return new Order(id, customerId, items, OrderStatus.CREATED);
        }

        String id() {
            return id;
        }

        OrderStatus status() {
            return status;
        }

        int totalQuantity() {
            return items.stream().mapToInt(OrderItem::quantity).sum();
        }
    }

    interface OrderRepository {
        void save(Order order);
    }

    static final class InMemoryOrderRepository implements OrderRepository {
        private final Map<String, Order> storage = new HashMap<>();

        @Override
        public void save(Order order) {
            storage.put(order.id(), order);
        }
    }

    record CreateOrderResult(String orderId, OrderStatus status, int totalQuantity) {}

    static final class CreateOrderService {
        private final OrderRepository orderRepository;

        CreateOrderService(OrderRepository orderRepository) {
            this.orderRepository = orderRepository;
        }

        CreateOrderResult execute(CreateOrderRequest request) {
            // 应用层负责 DTO 到领域值的转换,但不复制领域业务规则。
            List<OrderItem> items = request.items().stream()
                    .map(item -> new OrderItem(item.productId(), item.quantity()))
                    .toList();

            Order order = Order.create(request.orderId(), request.customerId(), items);
            orderRepository.save(order);

            return new CreateOrderResult(
                    order.id(),
                    order.status(),
                    order.totalQuantity());
        }
    }

    public static void main(String[] args) {
        OrderRepository repository = new InMemoryOrderRepository();
        CreateOrderService service = new CreateOrderService(repository);

        CreateOrderRequest request = new CreateOrderRequest(
                "O-1001",
                "C-2001",
                List.of(
                        new OrderItemRequest("P-10", 2),
                        new OrderItemRequest("P-20", 1)));

        CreateOrderResult result = service.execute(request);
        System.out.printf(
                "created order=%s, status=%s, totalQuantity=%d%n",
                result.orderId(),
                result.status(),
                result.totalQuantity());
    }
}

预期输出

text
created order=O-1001, status=CREATED, totalQuantity=3

应用服务没有自己判断“商品数量必须大于 0”或“订单不能为空”。它只完成输入转换、调用 Order.create、保存聚合和组装返回值,因此领域规则不会随着 REST、消息消费等入口变化而复制多份。

验证失败由领域模型负责

如果把请求改成空商品列表,Order.create 会立即拒绝创建;如果商品数量是 0,OrderItem 会拒绝构造。此时 Repository 不会被调用,因为非法聚合根本没有创建成功。

事务边界通常落在应用服务

在接入真实数据库后,创建订单往往还会伴随库存预留、领域事件或其他持久化动作。应用服务天然适合作为一次用例的事务边界:事务包住“创建成功后需要一起提交的操作”,Repository 实现仍留在基础设施层。

当应用服务只表达用例顺序、领域对象守住业务不变量、Repository 隔离持久化细节时,创建订单这条链路就具备了可测试、可替换入口和可替换存储实现的基础。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

编写创建订单应用服务

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通