清洁架构：遥不可及的理想——给开发者的寓言

在西藏宁静的山区高处，一座古老寺院安静的大厅里，住着一位年轻的学徒。他致力于追求和谐——不仅在他自己内部，而且在他的编程技巧中。他的目标是创建一个完美的应用程序，一个能够体现清洁架构深刻原理的应用程序，就像山间溪流的清澈一样。但他意识到这条道路的艰辛，于是向一位可敬的明师寻求智慧。

徒弟谦卑地走近师父并问道：

—“噢，明智的师父，我已经构建了一个应用程序来管理购买。我的建筑干净纯粹吗？”

师父耐心地观察弟子，回答道：

—“向我展示你所创造的东西，我们将一起辨别真相。”

学徒展示了他的作品，其中数据库逻辑和用例流程交织在一起——业务逻辑与技术框架紧密地交织在一起，就像一张错综复杂的网中的线。

// app.tsimport sqlite3 from 'sqlite3';import { open, database } from 'sqlite';interface purchase {    id: number;    title: string;    cost: number;}async function initializedatabase(): promise {    const db = await open({        filename: ':memory:',        driver: sqlite3.database,    });    await db.exec(`    create table purchases (      id integer primary key,      title text,      cost real    )  `);    return db;}async function addpurchaseifcan(db: database, purchase: purchase): promise {    const { id, title, cost } = purchase;    const row = await db.get(        `select sum(cost) as totalcost from purchases where title = ?`,        [title]    );    const totalcost = row?.totalcost || 0;    const newtotalcost = totalcost + cost;    if (newtotalcost  {    const db = await initializedatabase();    await addpurchaseifcan(db, { id: 3, title: 'rice', cost: 2 });})();

登录后复制

大师思考代码后说道：

——“你的代码就像一条河流，目的的清水与实现的泥浆混合在一起。业务和技术问题本应分开进行，但它们已合而为一。为了在你的建筑中实现真正的纯粹，你必须将它们分开，就像天空与大地分开一样。”

道路上的第一步

听从师父的话，徒弟开始着手重构他的代码。他开始分离各层，在数据库和业务逻辑流之间划出明显的界限。他还引入了接口，使他的代码与依赖倒置原则保持一致，这是清洁架构的神圣教义之一。现在，他的应用不再依赖于具体的实现，而是依赖于思想的抽象。

// app.tsimport { initializedatabase } from './db/init';import { purchaserepository } from './db/purchaserepository';import { addpurchaseifcan } from './usecases/addpurchaseifcan';(async () => {  const db = await initializedatabase();  const purchaserepository = new purchaserepository(db);  await addpurchaseifcan(purchaserepository, { id: 3, title: 'rice', cost: 2 });})();

登录后复制

// usecases/addpurchaseifcan.tsimport { ipurchaserepository, purchase } from './ipurchaserepository';export async function addpurchaseifcan(  purchaserepository: ipurchaserepository,  purchase: purchase): promise {  const { id, title, cost } = purchase;  const totalcost = await purchaserepository.gettotalcostbytitle(title);  const newtotalcost = totalcost + cost;  if (newtotalcost < 99999) {    await purchaserepository.add(purchase);    console.log('purchase added successfully.');  } else {    console.log('total cost exceeds 99999.');  }}

登录后复制

// usecases/ipurchaserepository.tsexport interface ipurchaserepository {  add(purchase: purchase): promise;  gettotalcostbytitle(title: string): promise;}export interface purchase {  id: number;  title: string;  cost: number;}

登录后复制

// db/init.tsimport sqlite3 from 'sqlite3';import { open, database } from 'sqlite';export async function initializedatabase(): promise {  const db = await open({    filename: ':memory:',    driver: sqlite3.database,  });  await db.exec(`    create table purchases (      id integer primary key,      title text,      cost real    )  `);  return db;}

登录后复制

// db/purchaserepository.tsimport { database } from 'sqlite';import { ipurchaserepository, purchase } from 'usecases/ipurchaserepository';export class purchaserepository implements ipurchaserepository {  private db: database;  constructor(db: database) {    this.db = db;  }  async add(purchase: purchase): promise {    const { id, title, cost } = purchase;    await this.db.run(      `insert into purchases (id, title, cost) values (?, ?, ?)`,      [id, title, cost]    );    return purchase;  }  async gettotalcostbytitle(title: string): promise {    const row = await this.db.get(      `select sum(cost) as totalcost from purchases where title = ?`,      [title]    );    const totalcost = row?.totalcost || 0;    return totalcost;  }}

登录后复制

徒弟回到师傅并问道：

——“我已经为我的存储库分离了各层并使用了接口。我的建筑现在干净了吗？”

大师再次检查代码，回复：

——“你们已经向前迈出了一步，但总成本的计算仍然停留在基础设施上，它不属于那里。这不是这种智慧应该存在的地方。总成本的知识属于商业领域，而不是地球上的工具。将其移至用例中，过程的智慧可以保持其纯粹性。”

分离的教训

有了这种洞察力，学徒意识到总成本的计算是业务逻辑的一部分。他再次重构了代码，将逻辑转移到用例中，使业务问题不受技术基础设施的影响。

// usecases/ipurchaserepository.tsexport interface ipurchaserepository {  add(purchase: purchase): promise;-  gettotalcostbytitle(title: string): promise;+  getpurchasesbytitle(title: string): promise;}...

登录后复制

// usecases/addpurchaseifcan.tsimport { ipurchaserepository, purchase } from './ipurchaserepository';export async function addpurchaseifcan(  purchaserepository: ipurchaserepository,  purchasedata: purchase,  limit: number): promise {  const { id, title, cost } = purchasedata;  const purchases = await purchaserepository.getpurchasesbytitle(title);  let totalcost = 0;  for (const purchase of purchases) {    totalcost += purchase.cost;  }  const newtotalcost = totalcost + cost;  if (newtotalcost >= limit) {    console.log(`total cost exceeds ${limit}.`);  } else {    await purchaserepository.add(purchasedata);    console.log('purchase added successfully.');  }}

登录后复制

// db/purchaserepository.tsimport { database } from 'sqlite';import { ipurchaserepository } from './ipurchaserepository';export class purchaserepository implements ipurchaserepository {  ...  async getpurchasesbytitle(title: string): promise {    const rows = await this.db.all(      `select * from purchases where title = ?`,      [title]    );    return rows.map((row) => ({      id: row.id,      title: row.title,      cost: row.cost,    }));  }}

登录后复制

再次回到师父身边，问道：

—“我已将总成本计算转移到用例中，并将业务逻辑与基础设施分开。我的建筑现在纯净了吗？”

师父带着温柔的微笑回答：

——“你已经取得了很大的进步，但要小心——就像山风带来冬天的寒冷一样，你的计算可能会带来隐藏的错误。 javascript 的算术就像新手的思维一样，在处理大数或小数时可能会不精确。”

与无常的相遇

学徒明白javascript中浮点运算的缺陷可能会导致微妙但危险的错误。他修改了代码，转向更可靠的工具，一个专为精确计算而设计的库，寻求工作的清晰度。

// usecases/addpurchaseifcan.ts+ import decimal from 'decimal.js';import { ipurchaserepository, purchase } from './ipurchaserepository';export async function addpurchaseifcan(  purchaserepository: ipurchaserepository,  purchasedata: purchase,  limit: number): promise {  const { id, title, cost } = purchasedata;  const purchases = await purchaserepository.getpurchasesbytitle(title);  let totalcost = new decimal(0);  for (const purchase of purchases) {-    totalcost += purchase.cost;+    totalcost = totalcost.plus(purchase.cost);  }- const newtotalcost = totalcost + cost;+ const newtotalcost = totalcost.plus(cost);- if (newtotalcost >= limit) {+ if (newtotalcost.greaterthanorequalto(limit)) {    console.log(`total cost exceeds ${limit}.`);  } else {    await purchaserepository.add(purchasedata);    console.log('purchase added successfully.');  }}

登录后复制

他再次问师父：

—“我已经改进了我的计算，使用了更好的工具来避免错误。我的建筑现在达到纯粹了吗？”

上人目光坚定如山，答道：

——“你做得很好，但你的架构仍然受到束缚。您的业务逻辑现在取决于这个新工具decimal.js的详细信息。如果有一天你需要改变这个工具，你的逻辑基础就会动摇。真正的纯洁是摆脱这种束缚。”

依赖倒置的智慧

认识到大师话语的深度，学徒试图将他的代码从这种执着中解放出来。他抽象了算术运算，颠倒了依赖关系，这样他的业务逻辑就不再依赖于任何一种工具。

// usecases/calculator.tsexport abstract class calculator {  abstract create(a: number): calculator;  abstract add(b: calculator | number): calculator;  abstract greaterthanorequal(b: calculator | number): boolean;}

登录后复制

// usecases/addpurchaseifcan.ts+ import { calculator } from 'usecases/calculator';- import decimal from 'decimal.js';import { ipurchaserepository, purchase } from './ipurchaserepository';

登录后复制

// decimalcalculator.tsimport decimal from 'decimal.js';import { calculator } from 'usecases/calculator.ts';export class decimalcalculator extends calculator {  private value: decimal;  constructor(value: number | decimal) {    super();    this.value = new decimal(value);  }  create(a: number): calculator {    return new decimalcalculator(a);  }  add(b: calculator | number): calculator {    return new decimalcalculator(this.value.plus(b.value));  }  greaterthanorequal(b: calculator | number): boolean {    return this.value.greaterthanorequalto(b.value);  }}

登录后复制

// useCases/addPurchaseIfCan.tsimport { Calculator } from 'useCases/calculator';import { IPurchaseRepository, Purchase } from './IPurchaseRepository';export class addPurchaseIfCan {  private purchaseRepository: IPurchaseRepository;  private calculator: Calculator;  private limit: string;  constructor(    purchaseRepository: IPurchaseRepository,    calculator: Calculator,    limit: number  ) {    this.purchaseRepository = purchaseRepository;    this.calculator = calculator;    this.limit = limit.toString();  }  async execute(purchaseData: Purchase): Promise {    const { id, title, cost } = purchaseData;    const purchases = await this.purchaseRepository.getPurchasesByTitle(title);    let totalCost = this.calculator.create(0);    for (const purchase of purchases) {      totalCost.add(purchase.cost);    }    totalCost = totalCost.add(cost);    if (totalCost.greaterThanOrEqual(this.limit)) {      console.log(`Total cost exceeds ${limit}.`);    } else {      await this.purchaseRepository.add({        id,        title,        cost: parseFloat(cost.toString()),      });      console.log('Purchase added successfully.');    }  }}

登录后复制

最后一次回到师父身边，他问道：

——“我使用依赖倒置抽象了我的操作，确保我的业务逻辑不再与实现绑定。我的建筑现在真的干净了吗？”

师父开示：

——“这条路上你已经走得很远了。但请记住，即使您努力追求纯度，您的用例仍然取决于编写它们的语言。您现在使用的是 javascript 和 typescript，但有一天这些工具可能会消失。当那一天到来时，你会用新的语言重建一切吗？”