Princip inverze závislostí v TypeScriptu

V našich aplikacích můžeme rozlišovat dva typy tříd:

• Nízkoúrovňové třídy které provádějí operace jako čtení z databáze nebo ukládání souboru.
• Třídy na vysoké úrovni které implementují obchodní logiku a používají tyto třídy nízké úrovně.

Tento princip navrhuje, že třídy na vysoké úrovni závisí na rozhraních namísto konkrétních implementací. To je snazší pochopit na příkladu.

V následujícím špatném příkladu máme OrderService třída, která ukládá objednávky do databáze. OrderService třída přímo závisí na nízkoúrovňové třídě MySQLDatabase .

Pokud bychom v budoucnu chtěli změnit databázi, kterou používáme, museli bychom upravit OrderService třída.

class OrderService {
  database: MySQLDatabase;

  // constructor

  save(order: Order): void {
    if (order.id === undefined) {
      this.database.insert(order);
    } else {
      this.database.update(order);
    }
  }
}

class MySQLDatabase {
  insert(order: Order) {
    // insert
  }

  update(order: Order) {
    // update
  }
}

Můžeme to zlepšit vytvořením rozhraní a vytvořením OrderService třída na něm závislá. Tímto způsobem obracíme závislost. Nyní třída vysoké úrovně závisí na abstrakci místo třídy na nízké úrovni.

class OrderService {
  database: Database;

  // constructor

  save(order: Order): void {
    this.database.save(order);
  }
}

interface Database {
  save(order: Order): void;
}

class MySQLDatabase implements Database {
  save(order: Order) {
    if (order.id === undefined) {
      // insert
    } else {
      // update
    }
  }
}

Nyní můžeme přidávat nové databáze bez úpravy OrderService třída.