Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid AOP mit AspectJ.

Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid

AOP mit AspectJ


Inhalt

• Übersicht Einführung in AOP AOP mit AspectJ

• Kurzübersicht AspectJ Wie identifiziert AspectJ Stellen im Programmfluss? Wie definiert man, was an diesen Stellen passiert? Das neue Modul für crosscutting concerns: aspect

• Vertiefung in AspectJ Pointcut Advice Aspect Kontext eines joinpoints an den advice weiterreichen


Module beim Software Entwurf

• Anforderungen werden definiert und einem Modul zugeordnet• Module kommunizieren über eine definierte Schnittstelle• Die Abhängigkeiten, die dabei entstehen, sollten gering

gehalten werden• Gängige Techniken wie Prozedurale Programmierung, OOP

und Design Patterns helfen bei dieser Art von Modularisierung

Modul 3 Modul 4

Modul 2

Modul 1


Module mit systemweiten Abhängig-keiten („crosscutting concerns“)• Es gibt Anforderungen, die es nötig machen aus sehr vielen

Modulen auf ein anderes Modul zuzugreifen. Z.B. Bestimmte Aktionen sollen geloggt werden Bestimmte Aktionen erfordern die Autorisation des Benutzers

• Selbst wenn man ein Log-Modul oder ein Autorisations-Modul existiert, muss man immer noch in vielen Modulen darauf zugreifen

Log-Modul

Autorisations-Modul

Modul 3 Modul 4

Modul 2

Modul 1


Probleme mit konventionellen Techniken

• das Log-Modul z.B. kann seine Schnittstelle ändern es muss an sehr vielen Stellen der Code angepasst werden

• jeder Entwickler eines Moduls muss sich daran halten, .z.B. mit dem Log-Modul zu kommunizieren fehleranfällig

• Systemweite Anforderungen können hinzukommen oder sich ändern es muss an sehr vielen Stellen der Code angepasst werden

• der Code, der die eigentliche core logic implementiert wird unübersichtlicher

Fazit: systemweite Anforderungen können mit konventionellen Techniken wie OOP nicht vernünftig modularisiert werden


Beispiel – core logicpackage example1;

public class Module1 {private int answer;

public static void method1() {print("hello world! “ + answer);

}

public static void method2() { answer=42;

}

private static void print(String s) {System.out.println("printing: " + s);

}}

package example1;

public class Module2 {public static int method3() {

Module1.method1();return 42;

}}

package example1;

public class Test {public static void main(String[] args) {

Module1.method1();Module1.method2();Module2.method3();

}}


Beispiel – Log Modulpackage example2;

import java.util.Date;

public class LogModule {

public static void logPublicMethodExecutionBegin(String methodName) {System.out.println(new Date() + ": public method " + methodName + " begin");

}

public static void logPublicMethodExecutionEnd(String methodName) {System.out.println(new Date() + ": public method " + methodName + " end");

}

public static void logPrivateMethodExecutionBegin(String methodName) {System.out.println(new Date() + ": private method " + methodName + " begin");

}

public static void logPrivateMethodExecutionEnd(String methodName) {System.out.println(new Date() + ": private method " + methodName + " end");

}

}


Beispiel – Logmodul aufrufenpackage example2;

public class Module1 {private static int answer;

public static void method1() {LogModule.logPublicMethodExecutionBegin("method1");print("hello world!" + answer);LogModule.logPublicMethodExecutionEnd("method1");

}

public static void method2() {LogModule.logPublicMethodExecutionBegin("method2");answer = 42;LogModule.logPublicMethodExecutionEnd("method2");

}

private static void print(String s) {LogModule.logPrivateMethodExecutionBegin("print");System.out.println("printing: " + s);LogModule.logPrivateMethodExecutionEnd("print");

}}


Beispiel – Logmodul aufrufen (2)

package example2;

public class Module2 {public static void method3() {

LogModule.logPublicMethodExecutionBegin("method3");Module1.method1();LogModule.logPublicMethodExecutionEnd("method3");return 42;

}}


Aspektorientierte Programmierung

Modul 3 Modul 4

Modul 2

Modul 1

Log-ModulLog-Aspekt


Aspektorientierte Programmierung

• Bietet als Lösung für „crosscutting concerns“ eine neue Art von Modul: den Aspekt Dieser definiert an zentraler Stelle „was“ „wann“ geschehen soll

(„weaving rules“)

• Ein „aspect-weaver“ konstruiert aus der core logic und den Aspekten ein neues System, das weiterhin die Kernanforderungen erfüllt die systemweiten Anforderungen erfüllt

• Die core logic wird weiterhin mit konventioneller Technik implementiert

• Die core logic weiß nichts davon, dass zusätzliche Funktionalität „eingebaut“ wird


AOP mit AspectJ

• AOP ist wie z.B. OOP eine Methode zu programmieren• Es gibt verschiedene Implementierungen

Bei OOP z.B. C++, Java, Smalltalk Bei AOP gibt es z.B. AspectJ

• AspectJ benutzt Java, um die core logic zu implementieren erweitert die Sprache Java um die Möglichkeit Aspekte mit ihren

weaving rules zu implementieren bietet einen Compiler (ajc) an, der den aspect weaver darstellt erzeugt Java-Bytecode, der auf jeder JVM läuft ist in Eclipse mit dem plugin ajdt vertreten


Wo sind wir?





Wie identifiziert AspectJ Stellen im Programmfluss?

• Joinpoints sind alle Stellen im Programm, die im Programmfluss erreicht werden Methoden-Aufrufe Konstruktor-Aufrufe Variablenzuweisungen das Werfen einer Exception usw.


Joinpoints: Methodenaufrufpackage example1;



}


}


}}

package example1;



}}

package example1;



}}

call(public static void example1.Module1.method1())

Alle Aufrufe der public static Methode method1() in der Klasse example1.Module1


Joinpoints: Methodenausführungpackage example1;



}


}


}}

package example1;



}}

package example1;



}}

execution(public static void example1.Module1.method1())

Ausführung der public static Methode method1() in der Klasse example1.Module1


Joinpoints mit Wildcardspackage example1;



}


}


}}

package example1;



}}

package example1;



}}

Ausführung aller public Methoden in der Klasse example1.Module1 mit beliebigem Rückgabetyp

execution(public * example1.Module1.*())


Joinpoints: Parameter festlegenpackage example1;



}


}


}}

package example1;



}}

package example1;



}}

execution(* example1.Module1.*(String))

Ausführung aller Methoden in der Klasse example1.Module1 die genau einen Parameter vom Typ String entgegennehmen


Joinpoints: Parameter mit Wildcardspackage example1;



}


}


}}

package example1;



}}

package example1;



}}

Ausführung aller public Methoden im Package example1, die beliebige Parameter nehmen

execution(public * example1.*.*(..))


Joinpoints: lesender Feldzugriffpackage example1;



}


}


}}

package example1;



}}

package example1;



}}

get(private static int example1.Module1.answer)

Jeder lesende Zugriff auf das private static Feld answer in der Klasse example1.Module1


Joinpoints: schreibender Feldzugriffpackage example1;



}


}


}}

package example1;



}}

package example1;



}}

Jeder schreibende Zugriff auf das private static Feld answer in der Klasse example1.Module1

set(private static int example1.Module1.answer)


Pointcut

• Ein Pointcut definiert eine Menge von jointpoints, an denen neue Funktionalität „eingebaut“ werden soll.

• Man spricht dabei vom „Abfangen“ (engl. capture) von jointpoints

pointcut executionOfMethod1() : execution(* example1.Module1.method1())

Schlüsselwort Name Primitiver pointcut


Verknüpfung von pointcuts

• Pointcuts können mit booleschen Operatoren verknüpft werden, um andere Mengen von joinpoints abzufangen

pointcut executionOfMethod1OrMethod2() : executionOfMethod1() || execution(* example1.Module1.method2())

Oben definierter pointcut Neuer primitiver pointcut


Wo sind wir?





Wie definiert man, was passieren soll, wenn ein joinpoint abgefangen wird?

• Die Aktion, die ausgeführt werden soll heißt in AspectJ advice• Es gibt drei Varianten von advice:

Aktion wird vor dem joinpoint ausgeführt (before) nach dem joinpoint ausgeführt (after) um die Ausführung des joinpoints herum ausgeführt (around).

Diese Variante kann den joinpoint sogar umgehen


Definition von advice

before() : executionOfMethod1OrMethod2 () {LogModule.logPublicMethodExecutionBegin (thisJoinPoint.getSignature().getName());

}

Schlüsselwort pointcut

Block mit Java-Code

• before advice


Definition von advice

• around adivce

void around() : executionOfMethod1OrMethod2 () {LogModule.logPublicMethodExecutionBegin (thisJoinPoint.getSignature().getName());proceed();LogModule.logPublicMethodExecutionEnd (thisJoinPoint.getSignature().getName());

}

Rückgabetyp entspricht dem des joinpoints

Schlüsselwort proceed() führt den joinpoint aus.Kann weggelassen werden zum Überspringen des joinpoints.


Wo sind wir?





Das neue Modul für crosscutting concerns: aspect• AspectJ führt den aspect ein, eine logische Einheit vergleichbar

mit einer Klasse, die pointcuts und advices enthält.

public aspect SimpleLogAspect {

}




public aspect SimpleLogAspect {pointcut publicMethodExecution() : execution(public * *.Module*.* (..));

pointcut privateMethodExecution() : execution(private * *.Module*+.* (..));

}




public aspect SimpleLogAspect {pointcut publicMethodExecution() : execution(* *.Module*.* (..));

pointcut privateMethodExecution() : execution(* *.Module*+.* (..));

before() : publicMethodExecution() {LogModule.logPublicMethodExecutionBegin(thisJoinPoint.getSignature().getName());

}

before() : privateMethodExecution() {LogModule.logPrivateMethodExecutionBegin(“...”);

}

}




public aspect SimpleLogAspect {pointcut publicMethodExecution() : execution(* *.Module*.* (..));

pointcut privateMethodExecution() : execution(* *.Module*+.* (..));

before() : publicMethodExecution() {LogModule.logPublicMethodExecutionBegin(thisJoinPoint.getSignature().getName());

}

before() : privateMethodExecution() {LogModule.logPrivateMethodExecutionBegin(“...”);

}

after() : publicMethodExecution() {LogModule.logPublicMethodExecutionEnd(“...”);

}

after() : privateMethodExecution() {LogModule.logPrivateMethodExecutionEnd(“...”);

}}


Fragen?


Wo sind wir?



• Vertiefung in AspectJ Pointcut Advice Aspect Kontext von joinpoints


Pointcut

• Syntax

• Operatoren in der pointcut-Definition Unär: !pc für alle joinpoints außer denen, die durch pc gefangen

werden Binar: pc1 || pc2 für alle joinpoints, die entweder von pc1 oder von

pc2 gefangen werden Binär: pc1 && pc2 für alle joinpoints, die von pc1 und pc2 gefangen

werden Klammerung ist möglich

[access specifier] pointcut name([args]) : pointcut-definition


Signatur-Patterns

• Um die joinpoints, die ein pointcut abfängt, effizient zu definieren, benutzt man folgende Signatur-Patterns, die im folgenden näher erläutert werden

Typ-Signatur für Methoden-Signatur Konstuktor-Signatur Feld-Signatur


Typ-Signatur-Pattern

• für den Typ eines Feldes die Klasse einer Methode, die aufgerufen wird die Argumente einer Methode Exceptions, die geworfen werden

java.*.Date

Alle Typen, die Date heißen im Package javaoder einem direkten Subpackage

java..* Ein beliebiger Typ in einem beliebigen Subpackage von java

javax.swing.*Model+ eine beliebige Unterklasse/Unterinterface, z.B. TableModelund TreeModel. Oder aber eine Klasse die das Interface implementiert z.B. DefaultTableModel


Methoden-Signatur-Pattern

• für den Aufruf einer Methode: call(<Methoden-Signatur-Pattern>) die Ausführung einer Methode: execution(<Methoden-Signatur-Pattern>)

• Es müssen die Modifier, der return-Typ, der Klassenname, der Methodenname und die Parametertypen angegeben werden.

public static void LogModule.log*()

Typ-Signatur

* LogModule.*(..) throws IOException+

beliebigeModifier

beliebigeArgumente

wirft IOException oder Unterklassen

• Optional können auch die Typen der Exceptions, die geworfen werden angegeben werden


Konstruktor-Signatur-Pattern

• Werden wie Methoden-Signaturen verwendet. Nur ist der „Methoden“-Name immer new und es gibt keinen Rückgabewert

public Vector.new(*) genau ein Parameter beliebigen Typs



Feld-Signatur-Pattern

public static int *Module*.answer



Überblick joinpoint-Typen• Diese pointcuts fangen jointpoints, die in einer bestimmten

Situation auftreten

Joinpoint Typ Primitiver pointcut Syntax

Methoden-Ausführung execution(Methoden-Signatur)

Methoden-Aufruf call(Methoden-Signatur)

Lesender Variablenzugriff get(Feld-Signatur)

Schreibender Variablenzugriff set(Feld-Signatur)

Exception Handler Ausführung handler(Typ-Signatur)

Objektinitialisierung initialization(Konstruktor-Signatur)


Lexikalisch basierte pointcuts

• Der lexikalische Sichtbarkeitsbereich ist ein Teil des Quellcodes wie die Definition einer Klasse oder einer Methode.

• Diese pointcuts fangen alle jointpoints, die im lexikalischen Sichtbarkeitsbereich eines Typs liegen, unabhängig von der Situation (wie Methoden-Aufruf/-Ausführung usw.)

within(Typ-Signatur)

withincode(Methoden-Signatur)


Beispiel: joinpoint-Typen:Test :Module1

method1()print()

method1call

method1 execution

print call printexecution

method1()

method1 call&&

within(Module2)method1 execution

mainexecution

:Module2


Controlflow basierte pointcuts

• Weiterhin gibt es pointcuts, die alle joinpoints, die während der Ausführung von joinpoints, die von einem anderen pointcut abgefangen werden auftreten. Die joinpoints befinden sich im „control flow“ eines pointcuts

cflow(pointcut)alle joinpoints inklusive denen aus pointcut

cflowbelow(pointcut) alle joinpoints exklusive denen aus pointcut


Beispiel: Controlflow basierte pointcuts:Test :Module1:Module2

method3()method1()

print()

cflow(call(* Module2.method3())) fängt alle joinpoints in diesem Bereich

cflowbelow(call(* Module2.method3())) fängt alle joinpoints in diesem Bereich


Wo sind wir?



• Vertiefung in AspectJ Pointcut Advice Kontext von joinpoints Aspect


Advice

• Ähnelt einer Java-Methode• Enthält Java-Code, der ausgeführt wird, wenn ein joinpoint

abgefangen wird• Es gibt drei Typen

before after around


before advice

• Wird ausgeführt bevor der gefangene joinpoint ausgeführt wird. • Wird im advice body eine Exception geworfen, wird der joinpoint

nicht ausgeführt.

before() : executionOfMethod1() {doSomething();

}

Wird hier eine Exception geworfen, wird method1 nicht ausgeführt


after advice

• Es gibt drei Typen, die zwischen den Rückkehrmöglichkeiten der gefangenen Methode unterscheiden

after() : pointcut-spec wird immer ausgeführt

after() returning : pointcut-spec wird nur ausgeführt, wenndie Methode erfolgreich war

after() throwing : pointcut-spec

wird nur geworfen, wenn dieMethode eine Exception geworfen hat


around advice

• Wird um den joinpoint herum ausgeführt. Mit dem neuen Schlüsselwort proceed() wird die Ausführung des joinpoints veranlasst. Er hat einen Rückgabetyp, der dem der joinpoints entsprechen muss.

void around() throws e: executionOfMethod1() {LogModule.logBegin(„…“);try {

proceed();} catch(Exception e) {

LogModule.logExc(e);throw e;

}LogModule.logEnd(„…“);

}


around advice Rückgabetyp• muss dem Rückgabetyp der joinpoints entsprechen (oder

Object bei verschiedenen Rückgabetypen)int around() : executionOfMethod3() {

proceed();}

automatische Rückgabe

int around() : executionOfMethod3() {int i = proceed();System.out.println(“returned “ + i);return i;

}

Rückgabewert abfangen und selberan den Aufrufer zurückgeben

Object around() : executionOfMethod1OrMethod3() {Object ret = proceed();if(ret == null) {

return ret;}else {

return new Integer(((Integer) ret).intValue() + 1);}

}

•verschiedene Rückgabe-typen.•Rückgabewert verändert•beachte: automatischesWrappen primitiver Typen


Wo sind wir?



• Vertiefung in AspectJ Pointcut Advice Kontext von joinpoints Aspect


Pointcuts, die den Kontext abfangen können

• Bestimmte pointcuts können den Kontext eines joinpoints sammeln und an den advice weitergeben. Das sind die pointcuts target(), this() und args().

this(Typ) z.B. this(Vector): alle joinpoints, die in einem Objekt liegen,das vom Typ Vector ist (also auch in Unterklassen)

target(Typ)z.B. target(Vector): alle joinpoints, die eine Methodeauf einem Objekt aufrufen, das vom Typ Vector ist

args(Typ1, Typ2, …) z.B. args(String, *, int): alle joinpoints, die als Argument drei Parameter nehmen vom Typ String,beliebig und int.


Den Kontext eines joinpoints an den advice weiterreichen

• Der Kontext, den man im advice braucht, muss im advice und im zugehörigen pointcut deklariert werden wie die Parameter bei einer Methodendeklaration.

pointcut printOperation(String str) : call(* example1.Module1.print(String)) && args(str)

before(String printStr) : printOperation(printStr) {System.out.println(„Drucke „ + printStr);

}

Deklaration


Aspect

• Der aspect ist ein Klassenähnliches Modul, in dem pointcuts und advices definiert werden.

• Es können Variablen und Methoden definiert werden• Wiederholung des Beispiels aus der Einführung


Fragen?

Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid AOP mit AspectJ.

Documents

Transcript of Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid AOP mit AspectJ.