当前位置：首页 > 文章列表 > 文章 > 前端 > 清洁架构：遥不可及的理想——给开发者的寓言

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

来源：dev.to 2024-10-19 19:19:02 0浏览收藏

今天golang学习网给大家带来了《清洁架构：遥不可及的理想——给开发者的寓言》，其中涉及到的知识点包括等等，无论你是小白还是老手，都适合看一看哦~有好的建议也欢迎大家在评论留言，若是看完有所收获，也希望大家能多多点赞支持呀！一起加油学习~

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

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

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

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

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

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

// app.ts
import 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<{ totalcost: number }>(
        `select sum(cost) as totalcost from purchases where title = ?`,
        [title]
    );
    const totalcost = row?.totalcost || 0;
    const newtotalcost = totalcost + cost;

    if (newtotalcost < 99999) {
        await db.run(
            `insert into purchases (id, title, cost) values (?, ?, ?)`,
            [id, title, cost]
        );
        console.log('purchase added successfully.');
    } else {
        console.log('total cost exceeds 99999.');
    }
}

(async () => {
    const db = await initializedatabase();
    await addpurchaseifcan(db, { id: 3, title: 'rice', cost: 2 });
})();

大师思考代码后说道：

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

道路上的第一步

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

// app.ts

import { 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.ts

import { 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.ts

export interface ipurchaserepository {
  add(purchase: purchase): promise;
  gettotalcostbytitle(title: string): promise;
}

export interface purchase {
  id: number;
  title: string;
  cost: number;
}

// db/init.ts

import 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.ts

import { 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<{ totalcost: number }>(
      `select sum(cost) as totalcost from purchases where title = ?`,
      [title]
    );
    const totalcost = row?.totalcost || 0;
    return totalcost;
  }
}

徒弟回到师傅并问道：

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

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

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

分离的教训

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

// usecases/ipurchaserepository.ts

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

// usecases/addpurchaseifcan.ts

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 = 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.ts

import { 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.ts
export 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.ts

import 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.ts

import { 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，但有一天这些工具可能会消失。当那一天到来时，你会用新的语言重建一切吗？”