解构领域驱动设计（三）：领域驱动设计

@Override
public void pay(int orderId,float amount) {
    DesignerOrder order = designerOrderRepository.selectByKey(orderId);   // 领域对象的加载
    if (order == null) {
        AppException.throwAppException(AppExceptionMessage.DESIGNER_ORDER_NOT_EXIST_CODE,AppExceptionMessage.DESIGNER_ORDER_NOT_EXIST,orderId);
    }
    
    order.pay(amount);    // 领域对象业务规则实现
    designerOrderRepository.update(order);    // 领域对象状态持久化
}

public class DesignerOrder implements Entity<DesignerOrder> {
    private int id;
    private int designerId;

    private DesigningProgressReport progressReport;
    ……

    public Designer getDesigner() {
        return designerRepository.getDesignerById(this.designerId);
    }

    public DesigningProgressReport getProgressReport() {
        return this.progressReport; 
    }

    ……
}

public class DesignerOrder implements Entity<DesignerOrder> {
    public void pay(float amount) {
        Assert.isTrue(amount > 0,"The amount must be bigger than 0.");

        if (!DesignerOrderWorkflowService.canChangeState(state,DesignerOrderState.PAID)) {
            BusinessException.throwException(DomainExceptionMessage.PAYMENT_NOT_IN_READY_STATE_CODE,DomainExceptionMessage.PAYMENT_NOT_IN_READY_STATE,this.id,this.state);
        }

        if (Math.abs(amount - this.expectedAmount) > 0.01) {
            BusinessException.throwException(DomainExceptionMessage.PAYMENT_NOT_MATCHED_CODE,DomainExceptionMessage.PAYMENT_NOT_MATCHED,this.expectedAmount,amount);
        }

        this.state = DesignerOrderWorkflowService.changeState(this.id,state,DesignerOrderState.PAID);
        this.actualPaidAmount = amount;

        // 付款完成后，自动启动进度跟踪
        this.progressReport.startup();
    }
}

@Data
@EqualsAndHashCode(of = {"id"})
public class DesignerOrder implements Entity<DesignerOrder> {
    private int id;
    private DesignerOrderState state;
    private int customerId;
    private int designerId;
    private float area;

    private float expectedAmount;
    private int estimatedDays;
    private DesigningProgressReport progressReport;

    private String abortCause;

    private float actualPaidAmount;

    private int feedbackStar;
    private String feedbackDescription;

    private Date createdTime;
    private Date updatedTime;

    @Override
    public boolean sameIdentityAs(DesignerOrder other) {
        return this.equals(other);
    }

    public void measure(float area) {
        Assert.isTrue(area > 0,"The area must be bigger than 0.");

        this.state = DesignerOrderWorkflowService.changeState(this.id,DesignerOrderState.MEASURED);
        this.area = area;
    }

    public void quote(float amount,int[] estimatedDaysList) {
        Assert.isTrue(amount > 0,"The price must be bigger than 0.");
        this.assertEstimatedDaysList(estimatedDaysList);

        this.state = DesignerOrderWorkflowService.changeState(this.id,DesignerOrderState.QUOTED);
        this.expectedAmount = amount;
        this.progressReport = DesigningProgressReportFactory.newReport(this,estimatedDaysList);
        this.estimatedDays = this.progressReport.getEstimatedCompletionDays();
    }

    private void assertEstimatedDaysList(int[] estimatedDaysList) {
        if (null == estimatedDaysList || estimatedDaysList.length != 4) {
            throw new IllegalArgumentException("The size of estimatedDaysList must be 4.");
        }

        for (int days : estimatedDaysList) {
            if (days <= 0) {
                throw new IllegalArgumentException("Each element of estimatedDaysList must be bigger than 0.");
            }
        }
    }

    public void pay(float amount) {
        Assert.isTrue(amount > 0,DesignerOrderState.PAID);
        this.actualPaidAmount = amount;

        // 付款完成后，自动启动进度跟踪
        this.progressReport.startup();
    }

    public RefundOrder refund(String cause) {
        this.assertCanRefund();

        this.state = DesignerOrderWorkflowService.changeState(this.id,DesignerOrderState.REFUND);

        return RefundOrderFactory.newRefundOrder(this,cause);
    }
}

public class RouteSpecification extends AbstractSpecification<Itinerary> implements ValueObject<RouteSpecification> {

  private Location origin;
  private Location destination;
  private Date arrivalDeadline;

  public RouteSpecification(final Location origin,final Location destination,final Date arrivalDeadline) {
    Validate.notNull(origin,"Origin is required");
    Validate.notNull(destination,"Destination is required");
    Validate.notNull(arrivalDeadline,"Arrival deadline is required");
    Validate.isTrue(!origin.sameIdentityAs(destination),"Origin and destination can‘t be the same: " + origin);

    this.origin = origin;
    this.destination = destination;
    this.arrivalDeadline = (Date) arrivalDeadline.clone();
  }

  public Location origin() {
    return origin;
  }

  public Location destination() {
    return destination;
  }

  public Date arrivalDeadline() {
    return new Date(arrivalDeadline.getTime());
  }

  @Override
  public boolean isSatisfiedBy(final Itinerary itinerary) {
    return itinerary != null &&
           origin().sameIdentityAs(itinerary.initialDepartureLocation()) &&
           destination().sameIdentityAs(itinerary.finalArrivalLocation()) &&
           arrivalDeadline().after(itinerary.finalArrivalDate());
  }

  @Override
  public boolean sameValueAs(final RouteSpecification other) {
    return other != null && new EqualsBuilder().
      append(this.origin,other.origin).
      append(this.destination,other.destination).
      append(this.arrivalDeadline,other.arrivalDeadline).
      isEquals();
  }

  @Override
  public boolean equals(final Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    final RouteSpecification that = (RouteSpecification) o;

    return sameValueAs(that);
  }

  @Override
  public int hashCode() {
    return new HashCodeBuilder().
      append(this.origin).
      append(this.destination).
      append(this.arrivalDeadline).
      toHashCode();
  }
}

public class DesignerOrderWorkflowService {
    private DesignerOrderWorkflowService() { }

    private static Map<DesignerOrderState,DesignerOrderState[]> states = new HashMap<>();
    static {
        states.put(DesignerOrderState.NEW,new DesignerOrderState[]{ DesignerOrderState.MEASURED,DesignerOrderState.ABORTED });
        states.put(DesignerOrderState.MEASURED,new DesignerOrderState[]{ DesignerOrderState.QUOTED,DesignerOrderState.ABORTED });
        states.put(DesignerOrderState.QUOTED,new DesignerOrderState[]{ DesignerOrderState.ACCEPT_QUOTE,DesignerOrderState.REJECT_QUOTE,DesignerOrderState.ABORTED });
        states.put(DesignerOrderState.REJECT_QUOTE,DesignerOrderState.ABORTED });
        states.put(DesignerOrderState.ACCEPT_QUOTE,new DesignerOrderState[]{ DesignerOrderState.PAID,DesignerOrderState.ABORTED });
        states.put(DesignerOrderState.PAID,new DesignerOrderState[]{ DesignerOrderState.REFUND,DesignerOrderState.COMPLETION });
        states.put(DesignerOrderState.COMPLETION,new DesignerOrderState[]{ DesignerOrderState.FEEDBACK });

        states.put(DesignerOrderState.ABORTED,new DesignerOrderState[]{ DesignerOrderState.FEEDBACK });
        states.put(DesignerOrderState.REFUND,new DesignerOrderState[]{ DesignerOrderState.FEEDBACK });
        states.put(DesignerOrderState.FEEDBACK,new DesignerOrderState[]{ DesignerOrderState.FEEDBACK }); // 允许多次评价
    }

    public static boolean canChangeState(DesignerOrderState state,DesignerOrderState nextState) {
        Assert.notNull(state,"The state can not be null.");
        Assert.notNull(nextState,"The nextState can not be null.");

        DesignerOrderState[] nextStates = states.get(state);
        for (DesignerOrderState possibleNextState : nextStates) {
            if (possibleNextState.equals(nextState)) {
                return true;
            }
        }

        return false;
    }

    public static boolean canAbort(DesignerOrder order) {
        return canChangeState(order.getState(),DesignerOrderState.ABORTED);
    }

    public static DesignerOrderState changeState(long orderId,DesignerOrderState state,DesignerOrderState nextState) {
        if (!canChangeState(state,nextState)) {
            BusinessException.throwException(DomainExceptionMessage.STATE_CHANGE_ILLEGAL_CODE,DomainExceptionMessage.STATE_CHANGE_ILLEGAL,orderId,nextState);
        }

        return nextState;
    }

    public static boolean isCompleted(DesignerOrder order) {
        return order.getState() == DesignerOrderState.ABORTED ||
                order.getState() == DesignerOrderState.REFUND ||
                order.getState() == DesignerOrderState.COMPLETION ||
                order.getState() == DesignerOrderState.FEEDBACK;
    }
}

PurchaSEOrder purchaSEOrder = purchaSEOrderBiz.getByKey(“0012946”);

List<PurchaSEOrderItem> purchaSEOrderItems = purchaSEOrderItemBiz.getByOrderId(“0012946”);
changePurchaSEOrderItems(purchaSEOrderItems);
if (new PurchaSEOrderApprovedLimitSpecify(purchaSEOrderItems,purchaSEOrder).isSatisfied()) {
    purchaSEOrderItemBiz.updateBatch(purchaSEOrderItems);
}

PurchaSEOrder order = purchaSEOrderRepository.load(id);
order.addItem(…)/removeItem(…)/updateItem(…); // 注意：这里是重点，对聚合根内部的变更，只能通过聚合根，不能通过获取内部对象进行操作
purchaSEOrderRepository.save(order);

public class PurchaSEOrder {
    private PurchaSEOrderItemRepository orderItemRepository;
    private List<PurchaSEOrderItem> orderItems;
    // ……
    public void addItem(int itemId,int count) {
        PurchaSEOrderItem orderItem = PurchaSEOrderItemFactory.create(this,itemId,count);
        orderItems.add(orderItem);
        if (!new PurchaSEOrderApprovedLimitSpecification(this).isSatisfied()) {
            BusinessException.throwException(…);
            return;
        }
        
        orderItemRepository.save(orderItem);
        this.updateTimestamp();
    }
    // ……
}

public class DesignerOrderFactory {
    private DesignerOrderFactory() {}

    public static DesignerOrder createOrder(int customerId,int designerId) {
        DesignerOrder designerOrder = new DesignerOrder();
        designerOrder.setCustomerId(customerId);
        designerOrder.setDesignerId(designerId);
        designerOrder.setState(DesignerOrderState.NEW);

        return designerOrder;
    }
}

@Repository
public class DesignerOrderRepositoryImpl implements DesignerOrderRepository {
    private static final String DESIGNER_ORDER_TABLE = "designer_order";

    @Autowired
    private DesignerOrderMapper designerOrderMapper;

    @Override
    public void create(DesignerOrder order) {
        if (designerOrderMapper.create(order) == 0) {
            TableException.throwTableException(DESIGNER_ORDER_TABLE,TableOperation.CREATE);
        }
    }

    @Override
    public DesignerOrder selectByKey(int id) {
        DesignerOrder order = designerOrderMapper.selectByKey(id);
        buildConnection(order);
        return order;
    }

    @Override
    public DesignerOrder selectOneBySpecification(DesignerOrder example) {
        DesignerOrder designerOrder = designerOrderMapper.selectOneBySpecification(example);
        buildConnection(designerOrder);
        return designerOrder;
    }

    @Override
    public List<DesignerOrder> selectBySpecification(DesignerOrder example) {
        List<DesignerOrder> designerOrders = designerOrderMapper.selectBySpecification(example);
        buildConnection(designerOrders);
        return designerOrders;
    }

    @Override
    public void update(DesignerOrder order) {
        if (designerOrderMapper.update(order) == 0) {
            TableException.throwTableException(DESIGNER_ORDER_TABLE,TableOperation.UPDATE);
        }
    }
}