基于 DDD 的前端工程 V2 #

// ✗ 错误
// 这是一个贫血的 Order 实体，它只知道自己的数据，不知道任何业务行为。
export class Order {
  public id: string;
  public items: OrderItem[] = [];
  public totalPrice: number = 0;
  public isPaid: boolean = false;

  constructor(id: string) {
    this.id = id;
  }

  // 只有一堆公开的 getter 和 setter (或直接 public 属性)，允许外部自由读写
  public setPaid(status: boolean): void {
    this.isPaid = status;
  }

  public setTotalPrice(price: number): void {
    this.totalPrice = price;
  }

  public addItem(item: OrderItem): void {
    this.items.push(item);
  }
}

// ✓ 正确
// 这是一个充血的 Order 实体。数据和行为被封装在一起。
export class Order {
  public readonly id: string; // ID 创建后不可变
  private _items: OrderItem[] = [];
  private _isPaid: boolean = false;

  constructor(id: string) {
    this.id = id;
  }

  // ---- 公开的只读属性，保护内部状态 ----
  public get items(): readonly OrderItem[] {
    return this._items;
  }
  
  public get isPaid(): boolean {
    return this._isPaid;
  }
  
  // 总价是一个计算属性，而不是一个可随意设置的字段，确保它总是正确的
  public get totalPrice(): number {
    return this._items.reduce((sum, item) => sum + item.subtotal, 0);
  }

  // ---- 公开的业务方法，表达业务意图 ----
  
  /**
   * 向订单中添加商品。所有相关的业务规则都在这里强制执行。
   */
  public addItem(productId: string, price: number, quantity: number): void {
    // 业务规则 1: 检查订单是否已支付 (保护不变量)
    if (this._isPaid) {
      throw new Error("Cannot add items to a paid order.");
    }
    
    // 业务规则 2 & 3: 创建并添加商品。总价会自动通过 getter 计算，无需手动更新。
    const newItem = new OrderItem(productId, price, quantity);
    this._items.push(newItem);
    
    console.log(`Item added. New total price for order ${this.id} is ${this.totalPrice}`);
  }

  /**
   * 支付订单
   */
  public pay(): void {
    if (this._items.length === 0) {
      throw new Error("Cannot pay for an empty order.");
    }
    this._isPaid = true;
    console.log(`Order ${this.id} has been paid.`);
  }
}

// ✗ 错误
class ContractModel implements ContractInfo {
  /**
   * 强读标识，单个合同的属性
   */
  @observable forceReadFlag = '';

  /**
   * 合同信息列表，合同集合数据
   */
  @observable contractInfoList = null;

  /**
   * 合同展示文案，UI 层所需
   */
  @observable displayText = '';
}

// ✓ 正确
// 合同模型分为单体合同模型 contract 以及合同合集 contractCollection
export class Contract {
  /** 合同唯一标识 */
  id: number;

  /** 强读标识 Y/N */
  forceReadFlag: string;

  /**
   * 业务逻辑：检查是否需要强制阅读
   */
  isForceRead(): boolean {
    return this.forceReadFlag === 'Y';
  }
}

export class ContractCollection {
  /** 合同列表 */
  public contracts: Contract[];

  /**
   * 业务逻辑：获取合同展示文案
   */
  getDisplayText(): string {
    if (this.contracts && this.contracts.length > 0) {
      const contractTextArr: string[] = [];
      this.contracts.forEach((contract: Contract) => {
        // 过滤出贷款告知书
        if (contract.contractType !== 'LOAN_APPLY_NOTICE') {
          contractTextArr.push(contract.getDisplayText());
        }
      });
      return contractTextArr.join('、');
    } else {
      ...
    }
  }

  /**
   * 业务逻辑：获取强读合同列表
   */
  getForceReadContracts(): Contract[] {
    return this.contracts.filter(contract => contract.isForceRead());
  }
}

// ✗ 错误
// src/domain/models/apply/personal-info.vo.ts
export class PersonalInfoModel implements PersonalInfo {
    ...
   /**
    * 组装提交参数
    * 收集表单数据并组装成提交格式
    * @returns 提交参数对象
    */
   @action.bound
   assembleSubmitParams(): any {
    const {
      custName,
      certId,
      custTypeSelected,
      careerType,
      incomeRange,
      highestDegree,
      schoolName,
      graduateYear
    } = this;
    
    // 组装提交参数
    const submitParams = {
      applyPersonalInfo: {
        custName,
        certId,
        custTypeSelected
      },
      applyCompanyInfo: {
        careerType,
        incomeRange,
      },
      applyEducationInfo: {
        highestDegree,
        schoolName,
        graduateYear,
      },
    };
    
    console.log('📋 [FormValidationService] 组装提交参数:', submitParams);
    return submitParams;
  }
}


// ✓ 正确
// src/api/apply/translator.ts
export function personalInfoSubmitTranslator(personalInfo: {
  custName?: string;
  certId?: string;
  custTypeSelected?: string;
  careerType?: string;
  incomeRange?: string;
  highestDegree?: string;
  schoolName?: string;
  graduateYear?: string;
}): any {
  const {
    custName = '',
    certId = '',
    custTypeSelected = '',
    careerType = '',
    incomeRange = '',
    highestDegree = '',
    schoolName = '',
    graduateYear = '',
  } = personalInfo || {};

  // 组装提交参数 - 按照后端接口要求的 DTO 结构
  const submitParams = {
    // 个人基础信息
    applyPersonalInfo: {
      custName,
      certId,
      custTypeSelected,
    },
    // 职业收入信息
    applyCompanyInfo: {
      careerType,
      incomeRange,
    },
    // 教育背景信息
    applyEducationInfo: {
      highestDegree,
      schoolName,
      graduateYear,
    },
  };

  return submitParams;
}

// ✗ 错误
class HomePage extends Component {
  async componentDidMount() {
    // 不应该在视图层直接调用 API
    const data = await fetch('/api/user');
    // 不应该在视图层进行数据转换
    this.setState({ 
      userName: data.nickName || '未知用户' 
    });
  }
}

// ✓ 正确
// model 层
@action.bound
updateUser = (userInfo: Partial<UserInfo>) => {
  this.user.setState(userInfo);
};

// 数据接口层，纯函数转换器
export function userInfoTranslator(data: any): UserInfo {
  return {
    name: data.nickName || '',
    // ...
  };
}