Aspektorientierte Programmierung mit JavaScript

Inhaltsverzeichnis

Aus der Sicht der Softwarearchitektur besteht der Sourcecode aus funktionalen und nichtfunktionalen Anforderungen. Erstere legen fest, was die Hauptaufgabe der Software ist – etwa das Berechnen des Kontosaldos zu einem speziellen Stichtag. Nichtfunktionale Anforderungen stehen für die Qualitätseigenschaften der Software. Darunter fallen zum Beispiel Zuverlässigkeit, Aussehen und Handhabung sowie Benutzbarkeit, Betrieb und Umgebungsbedingungen, Portierbarkeit und vor allem Wartbarkeit und Sicherheit.

Einige dieser Punkte finden sich später im Sourcecode wieder, beispielsweise die Wartbarkeit: Um eine Anwendung später besser betreuen zu können, wird als ein Bestandteil eine Logging-Funktion implementiert. Nun sind die Logging-Aufrufe zwischen den sauberen Code zu schreiben. Das bringt leider viele Nachteile mit sich. Beim Entwickeln der Software müssen Programmierer nebenbei eine ständige Implementierung der Logging-Aufrufe bedenken. Schlimmer ist, dass die Übersichtlichkeit des Sourcecodes leidet – neben den Hauptaufgaben stehen nun viele weitere Zeilen Code. In Listing 1 werden für jede Funktion ein Logging und eine zusätzliche Validierung durchgeführt, ob ein Parameter gesetzt wurde.

Listing 1: Funktionale und nichtfunktionale Anforderungen gemischt

class Calculator {
    add(valueA, valueB) {
        console.log("Start add function - valueA: " + valueA + 
                         " - valueB: " + valueB);
        let result = valueA + valueB;
        console.log("Result value: " + result);
        return result;
    }

    sub(valueA, valueB) {
        console.log("Start sub function - valueA: " + valueA + 
                         " - valueB: " + valueB);

        let result = valueA - valueB;
        console.log("Result value: " + result);
        return result;
    }

    sayHello(name) {
        console.log("Start sayHello function - name: " + name);

        if (name) {
            let result = "Hello " + name;
            console.log("Result value: " + result);
            return result;
        };

        throw new Error("Sorry, string was empty");
    }
}

Doch gibt es für diese Probleme eine Lösung: die aspektorientierte Programmierung. AOP ist eine Programmiertechnik mit dem Ziel, logische Aspekte (Ansichten) getrennt voneinander zu entwerfen zu
entwickeln und zu testen. Zu den Aspekten zählen meist folgende nichtfunktionale Anforderungen: Transaktionen, Caching, Auditfähigkeit und Logging. Die getrennt entwickelten Aspekte werden dann in der endgültigen Anwendung durch unterschiedliche Lösungsansätze zusammengefügt.

Das Programmierparadigma ist kein neues Konzept und stammt ursprünglich aus der objektorientierten Programmierung. Das erste Tool erschien 2001 für Java und hieß AspectJ. Unter .NET hat sich das Werkzeug PostSharp durchgesetzt. Die Idee dahinter ist, Aspekte in eigene Klassen zu schreiben. Durch diese Aspekte erweiterte Methoden erhalten eine Annotation beziehungsweise Attribute. Die Frameworks verweben dann den Aspekt-Code innerhalb der Methoden zur Lauf- oder Kompilierzeit, sodass der Soucecode zur Entwicklungszeit frei von nichtfunktionalen Anforderungen bleibt. Im Folgenden ein Beispiel in C# mit einem Logging-Aspekt:

Listing 2: PostSharp unter .NET – Aspekte wurden mit Attributen festgelegt.

public class Calculator
{
    [Logging]
    public int Add(int valueA, int valueB) 
    {
        int result = valueA + valueB;
        return result;
    }

    [Logging]
    public int Sub(int valueA, int valueB) {
        int result = valueA - valueB;
        return result;
    }
}

Ein weiterer Vorteil neben der Übersichtlichkeit ist ein zusätzlicher Gewinn an Flexibilität. Falls die Entscheidung spontan für ein anderes Logging-Framework getroffen wird, ist nicht der gesamte Soucecode umzuschreiben, sondern nur der Inhalt vom Logging-Aspekt. Eine wichtige Regel sollte übrigens bei AOP nicht gebrochen werden: Aspekte müssen wirklich nur nichtfunktionale Aufgaben erfüllen und keine Geschäftslogik.