Fachhochschule Nordwestschweiz Departement Technik Studiengang Informatik Seminarbericht von Olivier Rode Betreuender Dozent Prof. Dr. Dominik ...
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
Seminararbeit WS07
AspectJ
Fachhochschule Nordwestschweiz
Departement Technik
Studiengang Informatik
Seminarbericht von
Olivier Rode
Betreuender Dozent
Prof. Dr. Dominik Gruntz
Seminarbericht WS07: AspectJ
1. EINLEITUNG.............................................................................................................................................. 3
2. INSTALLATION ........................................................................................................................................ 4
2.1 ASPECTJ INSTALLATION ....................................................................................................................... 4
2.2 ECLIPSE PLUGIN AJDT INSTALLATION ................................................................................................. 4
3. ERSTES PROGRAMM .............................................................................................................................. 5
4. BEGRIFFLICHKEITEN............................................................................................................................ 6
4.1 JOINPOINT (VERBINDUNGSPUNKT) ....................................................................................................... 6
4.2 ASPEKT ................................................................................................................................................. 6
4.3 POINTCUT(SCHNITTPUNKT) .................................................................................................................. 7
4.4 ADVICE(EMPFEHLUNG) ...................................................................................................................... 10
4.5 INTERTYPE-DEKLARATION ................................................................................................................. 12
5. FAZIT......................................................................................................................................................... 15
5.1 ECLIPSE PLUGIN AJDT ....................................................................................................................... 15
5.2 ASPECTJ ............................................................................................................................................. 15
6. QUELLENANGABEN.............................................................................................................................. 16
2/16Seminarbericht WS07: AspectJ
1. Einleitung
Eine Software hat grundsätzlich bestimmte Aufgaben und Anforderungen zu erfüllen, welche
man grob in zwei Bereiche aufteilen kann:
¾ Core concerns; bezeichnet die Kernfunktionalität einer Software.
¾ System concerns; sind Anforderungen, welche nicht einfach gekapselt werden können,
da sie an vielen verschiedenen Stellen implementiert werden müssen. So genannte
„querschneidende Anforderungen“ oder crosscutting concerns. Beispiele dafür sind
die Fehlerbehandlung und das Logging.
Mit herkömmlichen Programmiermethoden, wie OOP und ähnliches, ist es schwierig, die
Kernfunktionalität von Modulen von zusätzlichen Funktionalitäten zu trennen. In der Abbil-
dung 1, sieht man in rot den Code für das XML-Parsing in org.apache.tomcat. In der zweiten
Abbildung sieht man in rot den Code, der für das Logging innerhalb org.apache.tomcat. ge-
braucht wird. Man bemerkt, dass diese Logging-Codefragmente über die meisten Module
verteilt sind (crosscutting concern).
Abbildung 1 Abbildung 2
Die Aspektorientierte Programmierung versucht nun die Kern- und die zusätzliche Funktiona-
lität nicht nur logisch sondern auch physisch zu trennen. Dazu werden so genannte Aspekte
definiert, welche die crosscutting concerns einkapseln und ausserhalb der Softwarekomponen-
ten abspeichern. Diese Aspekte werden frühestens zur Übersetzungszeit automatisch in den
Programmcode eingefügt (weaving). Die aspektorientierte Erweiterung von Java nennt sich
AspectJ und ist Bestandteil des Eclipse Projektes.
3/16Seminarbericht WS07: AspectJ
2. Installation
Als erstes muss man den AspectJ Compiler herunterladen und installieren. Danach kann man,
wenn gewünscht, eine AspectJ-Erweiterung für eine Entwicklungsumgebung wie JBuilder,
NetBeans, Eclipse etc installieren. Wir werden uns im Folgenden mit der Eclipse-Installation
beschäftigen. Das AspectJ-Plugin für Eclipse findet man unter http://www.eclipse.org/aspectj.
2.1 AspectJ Installation
Einen aktuellen AspectJ-Compiler kann über http://www.eclipse.org/aspectj/downloads.php
herunter geladen werden. Der Compiler selbst ist in einem .jar File verpackt, welches man zur
Installation starten muss:
java –jar aspectj-1.5.0.jar
Daraufhin öffnet sich ein Installer, der nach dem Java Home-Verzeichnis sucht und ein Instal-
lationsverzeichnis vorschlägt. Nach der Installation wird man noch aufgefordert, den
CLASSPATH um aspectjrt.jar und den Suchpfad (PATH-Variable) um ein bin Verzeichnis zu
erweitern. Die einzelnen Schritte sind in einer README-Datei beschrieben, welche im Instal-
lationsverzeichnis zu finden ist.
Um zu testen, ruft man den Compiler am besten gleich mal auf.
ajc –help
Hat alles funktioniert, erscheint eine Übersicht aller zulässigen Operationen.
2.2 Eclipse Plugin AJDT Installation
Die bequemste Art ist sicherlich die Installation des AJDT über den Eclipse Update Manager.
Die URL lautet für Eclipse 3.x http://download.eclipse.org/technology/ajdt/3x/update/.
4/16Seminarbericht WS07: AspectJ
3. Erstes Programm
Als Ausgangspunkt der ersten Schritte wird HelloWorld.java verwendet.
public static void main (String[] args){
System.out.println("Hello World");
}
HelloWorld.java
Als nächstes wollen wir einen einfachen Aspekt einsetzen. Dieser gibt vor der Ausgabe Hello
World noch einen anderen Gruss aus. Es spielt keine Rolle, ob ein Aspekt die Endung .java
oder .aj besitzt. Es dient lediglich der besseren Unterscheidbarkeit.
public aspect WorldAspect {
public pointcut mainOperation():
execution(public static void helloworld.HelloWorld.main(String[]));
before(): mainOperation(){
System.out.println("Hello Aspect oriented world");
}
}
WorldAspect.aj
Als erstes müssen wir nun HelloWorld.java und WorldAspect.aj mit dem AspectJ-Compiler
kompilieren, damit die beiden zusammengeführt (weaving) werden.
ajc HelloWorld.java WorldAspect.aj
Danach kann HelloWorld.java wie gewöhnlich ausgeführt werden, wobei man die AspectJ
Laufzeitumgebung noch dem Classpath mitgeben muss.
java –classpath HelloWorld
Dadurch erhalten wir folgenden Output:
Hello Aspect oriented world
Hello World
5/16Seminarbericht WS07: AspectJ
4. Begrifflichkeiten
Eine Hürde beim Einstieg in AspectJ sind die vielen neuen Sprachkonstrukte, die neu einge-
führt werden. In den folgenden Unterkapiteln wird ein Überblick über die wichtigsten gege-
ben.
4.1 Joinpoint (Verbindungspunkt)
Der Joinpoint ist das Basiskonzept von AspectJ. Unter einem Joinpoint versteht man irgend-
einen identifizierbaren Punkt innerhalb eines Programms, an welchem Code erweitert oder
modifiziert werden soll. Joinpoints können sein:
¾ Aufruf einer Methode
¾ Ausführen einer Methode
¾ Behandeln einer Exception
¾ Zugriff auf eine Variable
¾ Initialisierung einer Klasse oder eines Objektes
Als kleines Beispiel betrachten wir 2 Zeilen Code und überlegen uns, was für mögliche Join-
points daraus resultieren:
…
Konto konto = new Konto();
Konto.einzahlen(100.0);
…
Abbildung 1
Aus dem Beispielcode in Abbildung 1 resultieren folgende Joinpoints:
¾ der Konstruktor der Konto-Klasse wird aufgerufen
¾ der Konstruktor wird ausgeführt
¾ die einzahlen()-Methode wird aufgerufen
¾ die einzahlen()-Methode wird ausgeführt
¾ die interne Variable kontostand wird verändert
4.2 Aspekt
Java wird durch AspectJ um genau eine Klasse, das Aspekt, erweitert.
…
aspect demo {
code
}
Die Aspekt-Klasse kann die Endung .java oder auch .aj tragen, wobei .aj für die bessere Un-
terscheidung zu empfehlen ist. Ein Aspekt kann normalen Java-Code beinhalten aber auch
durch die in den nachfolgenden Punkten (4.3-4.5) beschrieben Komponenten erweitert wer-
den.
¾ Aspekte können von abstrakten Aspekten aber auch von Java-Klassen abgeleitet sein.
¾ Aspekte können Interfaces implementieren.
6/16Seminarbericht WS07: AspectJ
¾ Es können abstrakte Aspekte erzeugt werden.
¾ Mit dem Schlüsselwort privileged kann sich ein Aspekt über alle Zugriffseinschrän-
kungen hinwegsetzen und auch auf private Attribute und Methoden fremder Klassen
und Aspekte zugreifen.
4.3 Pointcut(Schnittpunkt)
Ein Pointcut repräsentiert ein oder mehrere Joinpoints. Ein Pointcut adressiert gewissermas-
sen die Stelle(n) im Code bzw. im Programmfluss, die manipuliert werden soll(en).
4.3.1 Syntax
[Access-Typ] pointcut Name (Parameter) : {Auswahlmethoden;}
Access-Type := public | private | protected
4.3.2 Auswahlmethoden
Um die gewünschten Stellen im Code adressieren zu können, gibt es verschiedene Auswahl-
methoden. Im Folgenden sind die wichtigsten aufgeführt.
4.3.2.1 Call
Call adressiert den Aufruf einer Methode.
call(public void bank.Konto.einzahlen(double)); // Aufruf einer Methode
call(public void bank.Konto.new); // Aufruf des Konstruktors
4.3.2.2 Execution
Execution adressiert die Ausführung einer Methode. Der Unterschied zu Call ist, dass Metho-
den die mit Reflexion zum Zuge kommen oder main-Methoden nicht mit Call adressiert wer-
den können, da es keinen Punkt gibt, an dem die Methode aufgerufen wird.
execution(public void bank.Konto.einzahlen(double)); // Aufruf einer Methode
execution(public void bank.Konto.new); // Aufruf des Konstruktor
4.3.2.3 Get
Der Lesezugriff auf ein Klassen-Attribut lässt sich wie folgt beschreiben:
get(double bank.Konto.kontostand); // Jedes Mal, wenn auf die Variable “kontostand”
// zugegriffen wird, wird dieser Joinpoint aktiv.
4.3.2.4 Set
Der Schreibzugriff auf eine Klassen-Variable wird überwacht:
set(double bank.Konto.kontostand); // Jedes Mal, wenn in die Variable “kontostand”
// geschrieben wird, wird dieser Joinpoint aktiv.
7/16Seminarbericht WS07: AspectJ
4.3.2.5 Handler
Auch wenn ein Exception-Handler aufgerufen wird, kann dieser Joinpoint über handler() an-
gesprochen werden. Es werden alle Stellen angesprochen, an welchen die entsprechende Ex-
ception abgefangen wird.
handler(ArithmeticException); // immer wenn eine ArithmeticException geworfen und
// in einem catch-Block abgefangen wird, trifft dieser
// Joinpoint zu
4.3.2.6 Initialization
Damit wird ein Joinpoint angesprochen, wenn der Konstruktor aufgerufen wurde. Dieser
Punkt liegt nach dem Aufruf des Konstruktors der Superklasse, aber noch vor Beendigung des
Konstruktors der betrachteten Klasse.
initialization(bank.Konto.new);
4.3.2.7 Preinitialization
Damit wird der Punkt gekennzeichnet, bevor der Konstruktor der Superklasse zum Zuge
kommt.
preinitialization(bank.Konto.new);
4.3.2.8 Staticinitialization
Damit wird die Initialisierung einer Klasse angesprochen. Dies sind die statischen Teile einer
Klasse, die als „static“ definiert wurden.
staticinitialization(bank.Konto);
4.3.2.9 args
Zum einen erlaubt args den Zugriff auf die übergebenen Parameter und zum anderen wird
dadurch die Menge der möglichen JoinPoints eingegrenzt.
Pointcut callSetBirth(int year, int month, int day):
Call(public void User.setBirth(..))**
&& args(year, month, day);
** Da die Anzahl der Parameter durch den args eingeschränkt wird, können die Parameter bei
call einfach durch eine Wildcard ersetzt werden.
4.3.2.10 this
Durch this lässt sich der Aufruf einer Methode auf eine bestimmte Klasse einschränken. Bei
this können keine Wildcards (siehe 3.2.2) verwendet werden.
Pointcut callToString():
Call(public String toString())
&& this(test.UserTest);
8/16Seminarbericht WS07: AspectJ
In diesem Beispiel kann nur die Klasse UserTest die Methode aufrufen.
4.3.2.11 target
Beim target lässt sich die Methode auf die Klasse einschränken, in der sie aufgerufen wurde.
Bei target können keine Wildcards (siehe 3.2.2) verwendet werden.
Pointcut callToString():
Call(public String toString())
&& target(User);
In diesem Beispiel schränkt der Pointcut den Aufruf der toString-Methode auf die User Klasse
ein. Es wird nur die User.toString()-Klasse angesprochen.
4.3.2.12 within
Within kennzeichnet alle Joinpoints, welche innerhalb der angegebenen Klasse liegen.
Pointcut callAnUserMethod():
Call(public * User.*(..))
&& within(User);
Dieses Beispiel trifft immer dann zu, wenn eine Methode der User Klasse aufgerufen wird.
4.3.2.13 cflow
cflow dient zur Bestimmung aller im Kontrollfluss auftretenden und mit der Beschreibung
durch den im cflow definierten Pointcut übereinstimmenden Joinpoints.
Pointcut callSetAssignedInRequest():
Call(public void State.setAssigned())
&& cflow(call(public void Request.*(..));
Nur wenn sich der Joinpoint innerhalb des Kontrollflusses einer Request-Methode befindet
und die State.setAssigned()-Methode aufgerufen wurde, trifft dieser Pointcut zu.
4.3.2.14 if
Diese Pointcuts werden durch eine Überprüfung logischer Ausdrücke am Joinpoint bestimmt.
Mit der if-Anweisung kann man nicht nur direkt auf das Ergebnis eine booleschen Methode
verwenden, sondern man darf direkt auf eine Variable mit dem Typ boolean zugreifen, sofern
diese als public definiert wurde.
1)
Pointcut demoMethod():
call(public void State.setAssigned())
&& if(State.isEnabled()); // oder z.B. if(State.getInt() < 5)
Dieses Beispiel trifft immer dann zu, wenn die setAssigned() Methode der Klasse State aufge-
rufen wird und die Methode State.isEnabled() den Wert true zurückgibt.
9/16Seminarbericht WS07: AspectJ
4.3.3 Wildcards
In der Regel möchte man nicht nur ein Joinpoint ansprechen, sonder zum Beispiel alle Setter
oder alle Getter-Methoden einer Klasse. Dafür gibt es drei Arten von Wildcards:
* (Stern)
steht für eine beliebige Anzahl beliebiger Zeichen (ausser dem Punkt)
.. (2 Punkte)
steht für eine beliebige Anzahl beliebiger Zeichen (incl. dem Punkt)
+ (Pluszeichen)
steht für alle Unterklassen bzw. Interfaces des vorgegebenen Typs
Call(* bank.*Konto.*(*));
Call(java..Date.new(..);
Call(java.lang.Exception+.new(..));
4.3.4 Logische Operatoren
Über logische Operatoren (||, && und !) kann man Joinpoints erweitern oder einschränken.
get(private double bank.Konto.kontostand)
|| set(private double bank.Konto.kontostand);
4.4 Advice(Empfehlung)
Ein Advice ist eine Aktion, welche beim Erreichen eines bestimmten Pointcuts ausgeführt
werden soll. Der Advice enthält Programmcode, der ausgeführt werden soll. Es gibt 3 ver-
schiedene Advice-Typen.
4.4.1 Syntax
AdviceSpec [throws Exception-Liste] : pointcut{ body }
AdviceSpec := before(Parameter) |
after(Parameter) |
after(Parameter) returning [( Forma )] |
after(Parameter) throwing [( Forma )] |
around(Parameter)
4.4.2 before()-Advice
Dieser Advice ist der einfachste von allen und wird verwendet, falls irgendetwas vor dem
Joinpoint passieren soll (1) oder Preconditions überprüft werden sollen (2).
pointcut executeZieheZahl(Trommel t) :
execution(private int Ziehung.zieheZahl(Trommel))&& args(t);
1)
before(Trommel t) : executeZieheZahl(t) {
t.mixNumbers();
}
2)
before(Trommel t) : executeZiehungStart(t) {
if (t.getAnzahlKugelnInside() != 49) {
throw new IllegalArgumentException("keine 49 Kugeln in Trommel");
}
10/16Seminarbericht WS07: AspectJ
}
4.4.3 after()-Advice
Dieser Advice ist schon etwas umfangreicher. Es gibt insgesamt drei verschiedene after-
Advice Typen, welche für Postconditions sehr gut geeignet sind.
4.4.3.1 Unqualifizierter Advice
Der unqualifizierte Advice wird immer ausgeführt, genau wie finally bei Java. Damit ist die-
ser Advice prädestiniert für beispielsweise Aufräumarbeiten, wie das Freigeben von Ressour-
cen.
after(Reader r): execute(r) {
try{
r.close();
} catch (IOException ignored){}
}
4.4.3.2 After returning Advice
Dieser Advice wird nur ausgeführt, wenn keine Exception ausgelöst wurde.
after(String s) returning: executeGetWinners(s) {
Log.info("Gewinner wurden aus erfolgreich ermittelt.");
}
Für den Zugriff auf den Rückgabewert einer Methode steht das Schlüsselwort returning zur
Verfügung. Der Typ des Rückgabewerts muss mit dem Rückgabewert der angesprochenen
Methode übereinstimmen (1) bzw. darf auch einer der Oberklassen sein. Ist dies nicht der
Fall, lässt sich zwar der Advice übersetzen, aber er kommt nicht zur Ausführung. Hat man
einen Pointcut, der mehrere Joinpoints abdeckt, muss der angegebene Typ in returning die
gemeinsame Oberklasse sein. Im Zweifelsfall setzt man hier Object ein (2).
1)
after(String s) returning(List l): executeGetWinners(s) {
Log.info("Liste der Gewinner: ");
for (Iterator i = l.iterator(); i.hasNext();) {
Schein schein = (Schein) i.next();
Log.info("xxxxxx " + schein.getSpieler());
}
}
2)
after() returning(Object o): execution(public * Trommel.*(..)) {
Log.info(thisJoinPoint + " returns " + o);
}
4.4.3.3 After throwing Advice
Dieser Advice wird nur ausgeführt, falls eine Exception ausgelöst wurde. Dabei ist egal, ob
die Exception innerhalb der Methode mit einer try-catch-Block selber behandelt wird oder
nicht.
11/16Seminarbericht WS07: AspectJ
1)
after(String s) throwing: executeGetWinners(s) {
… Code …;
}
2)
after(String s) throwing (IOException e): executeGetWinners(s) {
… Code …;
}
Ist der Joinpoint allgemeiner gehalten, so dass alle möglichen Arten von Exceptions auftau-
chen können, nimmt man die gemeinsame Oberklasse aller Exceptions. Falls eine falsche Ex-
ceptionklasse verwendet wurde, gibt AspectJ keinen Fehler bei der Übersetzung aus. Nur lei-
der kommt dann dieser Advice nie zum Einsatz.
4.4.4 around()-Advice
Der around-Advice ist der mächtigste Advice. Man hat mit dem around-Advice die totale
Kontrolle über einen Joinpoint. Man kann nicht nur Code hinzufügen, sondern den Joinpoint
komplett ersetzen. Den eigentlichen Joinpoint kann man mit proceed() aufrufen, wobei pro-
ceed() für den gesamten Joinpoint inklusive allen Parametern steht und in einem Advice auch
mehrmals aufgerufen werden darf. Sobald ein Around-Advice ein Argument erwartet, wird
dieses auch im proceed()-Aufruf erwartet (2).
1)
String around() : call (String System.getProperty(String)) {
String value = proceed();
if (value == null) {
return "";
} else {
return value;
}
}
2)
void around(Trommel trommel) : executeMixNumbers(trommel) {
do {
proceed(trommel);
} while (trommel.isSorted());
}
4.5 Intertype-Deklaration
Unter Intertype-Deklaration versteht man die Erweiterung bestehender Klassen, Interfaces
und Aspekten mit zusätzlichem Code.
4.5.1 Erweiterung bestehender Klassen
Es können Methoden (2), Konstruktoren (Ausnahme: Default-Konstruktor) und Attribute (1)
in bereits bestehende Klassen eingefügt werden. Es muss dafür die vollständige Paketstruktur
angegeben werden. Diese Erweiterungen sind für normale Java-Klassen nicht sichtbar.
1)
Private boolean democlass.ready = true;
Private String name = „demo“;
2)
Public boolean democlass.isReady() {
Return ready;
}
12/16Seminarbericht WS07: AspectJ
4.5.2 Reihenfolge
Solange nur ein Advice für einen Joinpoint ausgeführt wird, gibt es keine Probleme. Wenn
aber mehrere Advices auf denselben JoinPoint zugreifen, ist die Ausführungsreihenfolge un-
bestimmt und nicht vorhersagbar.
4.5.2.1 Vorrangregeln zwischen Aspekten
Bei Advices in unterschiedlichen Aspekten kommen folgende Regeln zum Tragen:
1. Precedence Deklaration
Mit Hilfe von declare precedence : aspectA, aspectB; kann die Reihenfolge explizit
definiert werden.
2. Unter sticht Ober
Wenn ein Aspekt ein anderes Aspekt erweitert, erhält das Sub-Aspekt einen höheren
Vorrang als das Super-Aspekt.
3. Rest unbestimmt
Trifft keiner der Fälle zu, so ist das Verhalten unbestimmt, bzw. dem Zufall überlas-
sen.
4.5.2.2 Vorrangregeln innerhalb von Aspekten
Der Vorrang von Advices innerhalb eines Aspektes ist von der Art und dem Typ der Advices
abhängig. Dazu gibt es zwei Regeln:
1. Ein Advice ist ein after-Advice
Der Advice der spatter definiert wurde, erhält den Vorrang.
2. Kein Advice ist ein after-Advice
Der Advice, der zuerst definiert wurde, erhält den Vorrang.
Public aspect precedencedemo {
…
// Before1
// Before2
// After1
// After2
}
Nach Regel 1 und 2 gilt somit: After2 > After1 > Before1 > Before2
4.5.3 Eigene Compiler Meldungen
Man kann zur Compilezeit statisch Compiler Errors und Warnings auslösen. Dadurch kann
man zum Beispiel verhindern, dass bestimmte Methoden in bestimmten Klassen verwendet
werden oder man erzeugt bei derer Verwendung eine Warnung.
4.5.3.1 Syntax
declare warning : statisch bestimmbarer Pointcut : „Warnung“;
declare errror : statisch bestimmbarer Pointcut : „Fehler“;
4.5.3.2 Beispiele
Declare warning : call(public void java.io.OutputStream+.*(..)) :
“Bitte verwenden Sie die Writer-Klassen”;
Declare error : call(public void java.io.OutputStream+.*(..))
13/16Seminarbericht WS07: AspectJ
&& !withincode(public void demo.log(..)) :
„Bitte log() zur Ausgabe verwenden
4.5.4 Soft Exceptions
Die Soft Exceptions sind von der Klasse RuntimeException abgeleitet und benötigen kein
throws. Grundsätzlich beinhaltet Soft Exceptions weniger Informationen als normale Excepti-
ons, was die Problemfindung erschweren kann.
4.5.4.1 Syntax
declare soft : :
4.5.4.2 Beispiele
Public aspect softAspect{
Declare soft : IOException : within(Demo);
Überall in der Demo-Klasse, wo eine IOException geworfen werden könnte, legt AspecJ ei-
nen Wrapper herum. So kann der Entwickler die IOException in der Demo Klasse ganz igno-
rieren. Wenn eine solche Exception ausgelöst wird, wird automatisch die Soft Exception aus-
gelöst. Die Soft Eception beinhaltet weniger Informationen als die eigentliche Exception, was
unter umständen die Fehlersuche erschweren kann.
4.5.5 Hierarchie
In AspectJ kann man die Beziehung zwischen Datentypen verändern.
4.5.5.1 Syntax
declare parents : implements|extends
4.5.5.2 Beispiele
1)
declare parents : bank.* implements Serializable;
2)
declare parents : KontoList extends LinkedList;
3)
declare parents : (Testcase+ && !TestCase) extends MyTestCase;
1) Implementierung neuer Interfaces für eine oder mehrere (Wildcards) Klassen.
2) Erweiterung bestehender Klassen
3) Bei allen Testklassen, welche von Testcase abgeleitet sind wird noch eine Zwischenschicht
MyTestCase eingefügt.
14/16Seminarbericht WS07: AspectJ
5. Fazit
5.1 Eclipse Plugin AJDT
Die Installation des Plugins war sehr via der Update Seite sehr einfach. Die zur Verfügung
gestellten Tools erleichtern sehr das Arbeiten mit Aspkten. Es gibt zum Beispiel ein Cross
Reference Fenster, in welchem man sehr schön alle Advices sehen kann, die bei der Ausfüh-
rung eines bestimmten Programmes, einer Methode oder beim setzen einer Variable zum Zu-
ge kommen. Ein anderes sehr hilfreiches Tool ist die Aspect Visualization, in welchem man
Advices oder Advised-by Relationships
direkt sieht bzw. welche Aspekte oder
Teile davon in welchen Klassen geweaved
werden.
Ich hatte meine liebe Mühe mit diesem
Plugin, da es am Anfang überhaupt nicht
lief. Es kam scheinbar zu Komplikationen
mit den verschiedenen auf meinem Laptop
installierten Java Versionen. Auch produ-
ziert das Plugin oft einen Compiler Error.
Egal ob ich Eclipse 3.1 oder 3.2 verwendet
und egal ob ich AspectJ-1.5.2a oder
AspectJ-1.5.3 installiert habe. Das Plugin
scheint mir noch ein wenig fehleranfällig.
5.2 AspectJ
Wie wir gesehen haben, kann man mit
dem aspektorientierten Ansatz Softwaresysteme besser modularisieren. Der Grad der Vermi-
schung von funktionalen und nicht funktionalen Teil kann sehr stark reduziert werden. Der
Code wird besser lesbar, weil der gesamte Code, der nichts mit der Kernfunktionalität zu tun
hat, in Aspekte ausgelagert wird. Durch diese Auslagerung wird der Code auch besser wartbar
und kann auch einfacher wieder verwendet werden, da die Klassen nur noch ihre Kernfunkti-
onalität beinhalten und kein Beigemüse mehr. Durch AOP ist man zudem in der Lage auch
bereits bestehende Java Projekte leicht zu erweitern ohne sich dafür mit dem bereits bestehen-
den Code auseinander setzen zu müssen. Man kann durch AspectJ auch Design Pattern wie
zum Beispiel das Observer Pattern und viele mehr realisieren. Beim Observer Pattern hat der
aspektorientierte Ansatz den Vorteil, dass die zu beobachtenden Klassen keine Ahnung über
die Observer haben muss. Die Verwendung von AspectJ kann aber auch zu Problemen füh-
ren., wenn diese Technologie zum Beispiel zu unübersichtlich angewendet wird. Wie wir ge-
sehen haben, kann man das Verhalten von Klassen komplett von aussen ändern, Klassen er-
weitern und sogar über das Schlüsselwort privileged unbeschränkt auf private Daten anderer
Klassen zugreifen. Das macht unter anderem das Debugging schwierig, da zum Beispiel gan-
ze Klassen durch Aspekte ersetzt werden können und somit der Kontrollfluss aus den Klassen
nicht mehr direkt ersichtlich ist.
15/16Seminarbericht WS07: AspectJ
6. Quellenangaben
¾ The AspecJ Projekt
http://www.eclipse.org/aspectj/
¾ Buch „Aspektorientierte Programmierung mit AspectJ 5“
dpunkt Verlag, Oliver Böhm, ISBN 9783898643306
¾ Otto-von-Guericke-Universität Magdeburg
http://ivs.cs.uni-magdeburg.de/~dumke/PSK/AOP1.html
http://ivs.cs.uni-magdeburg.de/~dumke/PSK/AOP2.html
http://ivs.cs.uni-magdeburg.de/~dumke/PSK/AOP3.html
¾ Aspect Oriented Software Development conference
http://www.aosd.de/
¾ Aspektorientierte Programmierung
http://www.arikah.com/enzyklopadie/Aspektorientierte_Programmierung
¾ Praxisbuch Objektorientierung, Galileo Computing, Bernhard Lahres, Gregor Raýman
http://www.galileocomputing.de/openbook/oo/
16/16Sie können auch lesen
