怎样在代码中融入架构思维

public Response createOrder(Request req) {
  checkParam(req);

  Order order = convertTo(req);
  
  saveData(order);
  
  return buildResponse(order);
}

public Response updateOrder(Request req) {
  checkParam(req);

  Order order = findOrder(req.getOrderId());
  Assert.notNull(order, "cannot find order");
  
  updateOrder(order, req);

  saveData(order);
  
  return buildResponse(order);
}

public Response queryOrder(Request req) {

  checkParam(req);

  Order order = findOrder(req.getOrderId());
  	
  return buildResponse(order);
}

// 不提供setter方法，保证逻辑内聚
@Getter
@Builder
public class Order {

  private OrderId orderId;

  // 订单状态，通过状态机组件来管理
  private OrderStatus status;

  private List<OrderItem> items;

  private Timestamp createTime;

  private UserId buyerId;

  private PayOrderId payOrderId;
  //...

  // 订单支付
  public void pay(Timestamp payTime, long payAmount, PayOrderId payOrderId) {
    // 1.校验订单状态
    // 2.校验支付金额是否正确
    // 3.修改payOrderId
    // 4.修改订单状态
  }
}

@Service
public class OrderAppService {

  // 库存领域服务
  InventoryService inventoryService;

  // 用户领域服务
  UserService userService;

  // 订单领域服务
  OrderService orderService;

  public OrderAppService(...) {// 依赖注入，省略...}

  // xx渠道下单
  // AppService层需要开启事务
  @Transactional
  public Response createOrderByXxxChannel(@Valid CreateOrderRequest req) {
    // 参数检查由框架层做了，业务代码里就不需要重复做
    
    // 构建订单的逻辑，包装在factory里
    // 创建订单的同时进行订单规则校验，生成订单号，判断是否幂等
    Order order = OrderFactory.newOrder(...);
    
    // 校验用户的状态
    // 具体要不要引入缓存，由用户模块来决定
    bool userAvailable = userService.available(order.getBuyerId);
    Assert.true(userAvailable, "用户状态异常");

    // 锁定库存
    // 具体是通过数据库实现还是缓存实现，由库存模块来决定，这里不需要关心
    inventoryService.lock(order.getItemType(), order.getQuantity());

    // 订单领域服务，负责处理订单
    // 包括订单信息入库，入库前的必要检查，发送订单创建的领域事件等
    // 入库前的必要检查也不是直接在service里面写，可能是调用order.readyToPay()来更新订单状态，核心的逻辑是在order里。往下翻有代码示例
    orderService.createOrder(order);
    
    return buildResponse(order);
  }	
}

// 领域事件的例子
// 订单领域服务
@Service
public class OrderService {

  OrderRepository orderRepository;

  EventPublisher eventPublisher;

  public OrderService(...) {// 依赖注入，省略...}

  // 领域服务层的入参通常是Entity或ValueObject
  public void createOrder(Order order) {
    // 调用实体的readyToPay，做一些事前校验，变更订单状态等
    order.readyToPay();

    // app service已经开了事务，这里直接调用repository的save
    // 数据存储的细节由repositoryImpl负责，领域层不需要关心
    orderRepository.save(order);

    // 发布领域事件，这个事件由订阅器消费，至于后面是发通知还是其他，就不关心了
    // 事件并不一定都是异步的，更多是为了解耦和隔离
    // 具体是同步还是异步，在事件组件里去配置，领域服务中不需要关心
    Event e = Event.createEvent(EventCode.ORDER_CREATED, order);
    eventPublisher.publish(e);
  }

  // 订单支付，也同样以Entity作为入参
  public void pay(Order order, PayOrder payOrder) {
    // ...
  }
}

// 抽象的批处理任务
@Slf4j
public abstract class AbstractTask {

  private String taskId;

  private TaskType type;

  private TaskStatus status;

  private String param;

  private int retryTimes;

  public AbstractTask(...) {// ...}

  // 任务的执行入口，支持传入参数
  public void ExecuteTask(String param) {
    // 前置条件判断
    bool canRun = preCheck();
    if (!canRun) {
      return;
    }
    log.info("task started")
    try {
      doExecute();
      status = TaskStatus.SUCCESS;
    } catch (BusinessException e) {
      ErrorCode c = e.getErrorCode();
      // 根据错误码判断是否可以重试，更新定时任务状态
      if (c == ErrorCode.XXX) {
        status = TaskStatus.WAITING_TO_RETRY;
        retryTimes++;
      } else {
        status = TaskStatus.FAILED;
        log.error("task run failed!", e);
      }
    } catch (Throwable e) {
      status = TaskStatus.FAILED;
      log.error("task run failed!", e);
    }
    // 后置处理，不影响任务执行结果，例如发送通知等可以放这里
    try {
      afterSuccess();
    } catch (...) {
      // ...
    }
  }

  protected abstract void preCheck();

  protected abstract void doExecute();

  protected abstract void afterSuccess();
}

public interface Order {
  ItemType getItemType();

  int getQuantity();

  OrderType getOrderType();
}

// 抽象之后库存接口就可以改为
public class InventoryService {
  public void lock(Order order) {
    OrderType orderType = order.getOrderType();
    if (orderType == OrderType.VIRTUAL) {
      // 虚拟订单
    }
  }
}