6. Aspektorientierte Programmierung AOP

Aspektorientierung zu verstehen, ist recht abstrakt. Am besten trifft der Ausdruck verweben von Klassen zu. Hierbei wird eine bestehende Klasse mit einer anderen so verwoben, daß daß diese sich, abweichend von ihrem ursprünglichem Entwurf, völlig anders verhält. Das Besondere hierbei ist, daß kein Eingriff in den Code erforderlich ist. Dies ist code reuse par excellence. Ein Beispiel zeigt mustergültig die Weiterverwendung des Codes einer bestehenden Klasse, also code reuse in seiner elementarsten Form, ein Beispiel in der Programmiersprache Python:

import aspekts.py

class C:
    def machwas(self):
        print "machwas"

def aspekt(self, *args, **keyw):
    print "vorherdies"
    rv = self.__proceed(*args,**keyw)
    print "nachherdas"
    return rv

Die Kasse C, ohne diese zu verändern, wird erweitert:

wrap_around( C.machwas, aspekt )

Nun führen wir aus:

o = C()
o.machwas()
    
Ausgabe:

vorherdies
machwas
nachherdas

Wie man sehen kann, werden hier zwei Codes miteinander verwoben (code weaving). Zwei Anwendungen für AOP sind z.B. Logging, Persistenz (Hibernation) und Profiling (Zeitmessungen). Während man ohne AOP in jeder Klasse Logging - Funktionen bzw. Profiling - Funktionen implementieren muß, kann man mit AOP die Klassen so belassen, wie sie sind, sie behalten also ihre ursprüngliche Aufgabe. Logging bzw. Profiling wird über Aspekte eingeführt. Nur eine Klasse enthält Code für Logging bzw. Profiling, was die Wartbarkeit des Codes sehr vereinfacht. AOP hilft sehr bei folgenden Zielen in der Teamprogrammierung:

• Klassen sollten nie mehr, als eine Aufgabe erfüllen - Bessere Trennung der Zuständigkeiten von Modulen separation of conserns

• Quellcode wird übersichtlich gehalten - Klareres Design

• Sehr gute Wiederverwendbarkeit von Code - Weniger redundanter Code

• Bei Änderungen muß nur sehr wenig Code verändert werden

• Erheblich bessere Wiederverwendung von Modulen - Hohe Modularität (tangled code)

• Bei Änderungen der Anforderungen muß nicht an vielen Stellen Code verändert werden, sondern nur in einer Klasse zentral, welches sich dann auf viele Klassen auswirkt.

• Einfachere Fehlersuche - Fehler haben eine hohe Lokalität, Korrekturen nur in äußerst wenig Code-Teilen notwendig. Die in Java oft in den Klassen behandelten Exceptions machen bei normaler Programmierung 11% des Codes aus, bei AOP nur ca. 3%

Dies führt insgesamt zu besserer Qualität von Software und großen Produktivitätssteigerungen bei deren Entwicklung, weil die "innere Reibung" erheblich reduziert wird. Wann sollte man AOP einsetzen? Hierzu gibt es eine ganz klare Antwort: Immer dann, wenn unklar ist, wo, in welcher Klasse etwas untergebracht werden soll, wie z.B. Logging. Wenn man sich z.B. das Apache Tomcat Modul anschaut, so findet sich "logging" über hunderte von Klassen verteilt - eine sehr schlechte Modularität, während hingegen das Modul "UML pattern matching" nur in zwei Klassen gekapselt ist.

AOP erweitert die Möglichkeiten der Strukturierung von Code:

• Prozedurale Programmierung erlaubt die Strukturierung von Code nur in einer Dimension: Nur GoSUBs und GOTOs ermöglichen eine geringe Strukturierung.

• Objektorientierte Programmierung (OOP) erweitert die prozedurale Programmierung um Objekte, die ihre Eigenschaften vererben können, was eine Schachtelung des Codes ermöglicht, jedoch auch hohe Abhängigkeiten schafft, was die Entwicklung gerade bei komplexen Verflechtungen des Codes in großen Projekten oft stagnieren läßt. Außerdem wirken sich kleine Fehler an den Basisklassen norm auf alle weitere Klassen aus. Sie potenzieren sich.

• Aspektorientierte Programmierung (AOP) erweitert OOP wiederum um eine Dimension, nämlich die Aspekte, die den oft hochgradig verschachtelten Code entzerren, und die Code-Teile, die viele Klassen gemeinsam haben, in eigene Klassen auslagert. Dies ermöglicht eine hohe Modularität des Codes und vermeidet insbesondere doppelten Code.

Die Definition von AOP ist schwierig, hunderte Bücher wurden geschrieben (von denen kaum eines leicht verständlich geschrieben ist):

• Aspekte sind Aufgaben, die nicht klar Objekten zugeordnet werden können.

• Aspekte können getrennt vom Objekt programmiert und bearbeitet werden.

• Der Objektcode ist unabhängig vom Aspektcode

• Aspekte und Objekte werden miteinander verwoben um ein gewünschtes, verändertes Verhalten eines Objektes zu erreichen.

• Das Verweben kann auch mit Hilfe von Markern (Markerungspunkten) komplexer gestaltet werden.

• Aspekte können vererbt werden

Folgende Beispiele für Python, Java und C++ zeigen eindrucksvoll die Möglichkeiten, die AOP bietet:

• Python aspektorientierte Programmierung

• Python Lightweight AOP

• Python LogiLab AOP GPL Modul

• AspektJ JAVA AOP Implementierung mit Eclipse.

Der Ursprung von AOP in JAVA (AspektJ) liegt 1997 beim Xerox Palo Alto Research Center. AspektJ ermöglicht es, Aspekte unter JAVA zu beschreiben, sodaß ein eigener Compiler die Aspekte in den Code einwebt. Es ist heute fester Bestandteil des IBM Eclipse - Projektes, aber auch in JBuilder enthalten.

Wann also sollte man AOP einsetzen? Martin Lippert und Cristina Videira Lopes haben in "A Study on Exception Detection and Handling using Aspekt Oriented Programming" einige Fälle untersucht: Weitere Dokumente zu AOP im Internet. AOP unter JAVA bietet nicht in jedem Fall elementare Vorteile gegenüber OOP bzw. herkömmlicher Programmierung, insbesondere dann nicht, wenn die *Denkweisen* nicht geschult wurden. "Lightweight AOP" - Module gibt es für jede OOP, deren Nutzung hat sich als nützlich herausgestellt, und ist leicht im Team einzuführen.