Injections für echte TypeScript-Junkies
Dependency Injection hat sich bei den meisten Softwareprojekten, Frameworks und Apps durchgesetzt. Dennoch ist es erstaunlich, wie viele Fragen man in diversen Foren im Kontext von JavaScript Frameworks zu diesem Thema findet. Muss Dependency Injection kompliziert sein? Wir meinen nicht. Mit TypeScript MetaData und Decorators lässt sich eine sehr kompakte, aber wirkungsvolle Dependency Injection aufbauen.
Spätestens seit dem Java Spring Framework hat sich Inversion of Control oder Dependency Injection (DI) als Designpattern etabliert. Die damals noch nicht so verbreitete Idee war es, Methoden, Klassen und Module so zu entwerfen, dass sie durch ihre Schnittstellen wirklich vollständig beschrieben sind. Das bedeutet, dass sie kein implizites oder globales Wissen mitbringen müssen, um korrekt zu funktionieren. Ein Gegenbeispiel dazu wären verschiedene Arten von Service-Locator-Patterns oder, noch schlimmer, mehrere globale Objekte, die Services bereitstellen. Diese Muster sind Antimuster, bei denen Methoden wissen, wo sie nachsehen müssen, um benötigte Services zu beziehen, z. B. für Datenzugriff, Authentifizierung usw. Der Zugriff auf die Services erfolgt global, beispielsweise über static-Methoden wie ServiceLocator.getDataSource(), DataAccess.getDataSource() oder Security.getAuthenticationService(). Je mehr von diesen globalen Abhängigkeiten umherschwirren, desto undurchschaubarer wird der Code, und er lässt sich vor allem nicht mehr modular Unit-testen, da sämtliche globalen Objekte in den richtigen Testzustand versetzt werden müssen. Bei der DI oder Inversion of Control läuft es eben umgekehrt: Nicht die einzelnen Codefragmente wissen, woher sie Services beziehen, sondern Letztere werden ihnen beim Aufruf einfach mitgegeben, z. B. als Konstruktorargumente. Damit sind jedes Codestück, jede Klasse und Methode wirklich eindeutig durch ihre Schnittstellen definiert.
Was hat das mit JavaScript zu tun?
In der guten alten Zeit, in der Web-Apps serverseitig, z. B. über MVC-Frameworks, gerendert wurden, beschränkte sich JavaScript auf die dynamische Manipulation des DOMs und evtl. auch noch auf Ajax-Datentransfer. jQuery, ähnliche Frameworks und ihr Programmiermodell saßen fest im Webstack-Sattel. Wie Sie wissen, hat sich die Situation mit voll ausgewachsenen JavaScript-Clientapplikationen stark verändert, denn sie sind eigentlich Rich Clients (Single-Page-Applikationen), die mit Backends kommunizieren. Statt jQuery und Co. finden wir MVVC-Patterns und reaktive Programmierung. Frameworks wie React.js, Angular und Vue.js sind wohlbekannt, und mit Progressive Web Apps wird die Lücke zwischen echter App und Web-App nochmal deutlich verkleinert.
Wenn wir heute von JavaScript-Clients sprechen, meinen wir daher in der Regel ausgewachsene Softwaresysteme, bei denen wir den gleichen Herausforderungen gegenüberstehen wie bei traditionellen Rich Clients. Daher wird es ganz selbstverständlich, dass wir zum Designen unserer Softwarebausteine Designpatterns wie Dependency Injection verwenden.
TypeScript Fanboy
Wie die regelmäßigen Leser vermutlich wissen, bin ich ein TypeScript-Fanboy. Bei den heutigen komplexen (mobilen) Web-Apps wird eine statische Typisierung, die die Flexibilität von JS nicht einschränkt, zum ALM Lifesaver. Wenn man dann noch Frameworks wie beispielsweise React.js verwendet, die UI-Komponenten nach JavaScript/TypeScript transpilieren, hat man ein langersehntes Ziel der UI-Entwicklung erreicht: UI-Komponenten sind statisch typisiert und werden vom Compiler überprüft. Vorbei sind die Zeiten, in denen man erst während des Betriebs bemerkt, dass aufgrund von Typos im Data Binding Fehler zur Laufzeit auftreten. Hatten Sie auch schon mal das Property fristName als Data Binding in einer UI-Komponente?
TypeScript Decorators und Metadata
Aber genug der Schwärmerei. TypeScript-Code lässt sich ähnlich wie in .NET mit Attributes oder wie in Java mit Annotations mit Metainformationen anreichern, die in TypeScript „Decorators“ heißen. Einen ersten Decorator sehen wir hier:
@injectionTarget()
class TestClass {
}
Die Klasse TestClass wird mit dem Decorator @injectionTarget() dekoriert. Daher wird dieser Decorator Klassen-Decorator genannt. Wie wir sehen werden, gibt es u. a. auch noch Parameter-Decorators.
Unsere Testklasse erhält dadurch die Metainformation, dass offensichtlich irgendetwas in diese Klasse injiziert wird. Aber bei TypeScript bzw. JavaScript kommt ein entscheidender Vorteil einer interpretierten Skriptsprache zum Tragen: Wenn eine Skriptdatei geladen wird (über <script>-Tags, import, require oder Ähnliches), wird der Code sequenziell durchlaufen und ausgeführt und die entsprechenden JS-Objekte werden angelegt. Es wird in unserem Fall z. B. das Klassenobjekt (oder JS-Konstruktorfunktionsobjekt) TestClass angelegt. Diese dynamische Lade- und Ausführungssequenz bietet ein paar spannende Möglichkeiten wie das Modifizieren von Klassenobjekten beim Laden. Und genau das macht den Unterschied zwischen .NET Attributes und TypeScript Decorators aus: Decorators sind Funktionen, nicht nur Labels oder Tags.
„Ja, und?“ kann man jetzt fragen. Und die Antwort lautet: „Man kann in Decorators alles tun – alles, was man in JS-Funktionen auch tun kann.“ Um es gleich konkreter zu machen, werfen wir einen Blick auf Listing 1, wo wir sehen, was der TS-Transpiler aus dem @ injectionTarget() macht.
Listing 1: Der Transpiler erzeugt aus Decorators Funktionsaufrufe – „testClass.js“
let TestClass = class TestClass {
};
TestClass = __decorate([
junkie_1.injectionTarget(),
...
__metadata("design:paramtypes", [String, String,
Object, Object, InjectedTestClass, IDummyInterface])
], TestClass);
Es wird die Funktion __decorate aufgerufen, die als Parameter unseren Decorator erhält. Ohne auf die Details der __decorate-Funktion einzugehen, führt das dazu, dass zur Ladezeit unserer Testklasse der Decorator mit der Klasse als Parameter aufgerufen wird. Das ist auch schon die Hauptidee: Wir haben nun die Klasse in der Hand und können sie manipulieren. Wir werden später noch auf die Codedetails des Decorators eingehen.
Grundidee der Dependency Injection mittels Decorators
Ein Klassen-Decorator kann also eine Klasse manipulieren. Wir werden dadurch die Konstruktorfunktion so modifizieren, dass wir beim Erzeugen einer Instanz der Klasse die zu injizierenden Daten/Objekte hineinschmuggeln können. Der grundlegende Ablauf (Abb. 1) ist der folgende:

Abb. 1: Vereinfachter Ablauf: Laden des Codes und Ausführen der App
-
Beim Laden der Skriptdateien werden die Klassenobjekte angelegt (Listing 1: let TestClass = class TestClass…)
-
Pro Klasse wird der Klassen-Decorator @injectionTarget() aufgerufen.
- Der Decorator erzeugt eine neue Klasse, die von der originalen erbt (extends).
-
-
Zur Ausführungszeit der Applikation:
-
Es werden die zu injizierenden Objekte/Daten in der DI Registry registriert.
-
Es werden Instanzen der dekorierten Klassen erzeugt, z. B. testObject = new TestClass(…).
-
Es wird der constructor der neuen, vom Decorator erstellten Klasse aufgerufen.
-
Diese holt aus der DI Registry die zu injizierenden Objekte/Werte.
-
Er ruft den Original-Constructor auf und fügt dabei die zu injizierenden Objekte/Daten als Parameter ein.
-
-
-
Aber halt!
Woher wissen wir, welche Parameter durch injizierte ersetzt werden? Bisher haben wir nur darüber gesprochen, dass die Hauptmagie darin besteht, dass der Klassen-Decorator eine neue Klasse anlegt und deren constructor irgendwie die zu injizierenden Objekte hineinschmuggelt. Aber woher weiß der neue constructor, welche Parameter zu injizieren sind? An dieser Stelle kommen die sogenannten Parameter-Decorators zum Einsatz...

