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

Präsentation zum Thema: "Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid AOP mit AspectJ."—  Präsentation transkript:

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

2 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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

3 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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 3Modul 4 Modul 2 Modul 1

4 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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 3Modul 4 Modul 2 Modul 1

5 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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

6 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Beispiel – core logic package 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 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 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(); } package example1; public class Test { public static void main(String[] args) { Module1.method1(); Module1.method2(); Module2.method3(); }

7 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Beispiel – Log Modul package 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"); } package 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"); }

8 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Beispiel – Logmodul aufrufen package 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"); } package 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"); }

9 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Beispiel – Logmodul aufrufen (2) package example2; public class Module2 { public static void method3() { LogModule.logPublicMethodExecutionBegin("method3"); Module1.method1(); LogModule.logPublicMethodExecutionEnd("method3"); return 42; } package example2; public class Module2 { public static void method3() { LogModule.logPublicMethodExecutionBegin("method3"); Module1.method1(); LogModule.logPublicMethodExecutionEnd("method3"); return 42; }

10 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Aspektorientierte Programmierung Modul 3Modul 4 Modul 2 Modul 1 Log-Modul Log-Aspekt

11 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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

12 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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

13 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Wo sind wir? Ü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

14 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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.

15 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Joinpoints: Methodenaufruf package 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 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 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(); } package example1; public class Test { public static void main(String[] args) { Module1.method1(); Module1.method2(); Module2.method3(); } call(public static void example1.Module1.method1()) Alle Aufrufe der public static Methode method1() in der Klasse example1.Module1

16 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Joinpoints: Methodenausführung package 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 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 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(); } package example1; public class Test { public static void main(String[] args) { Module1.method1(); Module1.method2(); Module2.method3(); } execution(public static void example1.Module1.method1()) Ausführung der public static Methode method1() in der Klasse example1.Module1

17 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Joinpoints mit Wildcards package 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 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 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(); } package example1; public class Test { public static void main(String[] args) { Module1.method1(); Module1.method2(); Module2.method3(); } Ausführung aller public Methoden in der Klasse example1.Module1 mit beliebigem Rückgabetyp execution(public * example1.Module1.*())

18 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Joinpoints: Parameter festlegen package 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 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 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(); } package example1; public class Test { public static void main(String[] args) { Module1.method1(); Module1.method2(); Module2.method3(); } execution(* example1.Module1.*(String)) Ausführung aller Methoden in der Klasse example1.Module1 die genau einen Parameter vom Typ String entgegennehmen

19 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Joinpoints: Parameter mit Wildcards package 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 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 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(); } package example1; public class Test { public static void main(String[] args) { Module1.method1(); Module1.method2(); Module2.method3(); } Ausführung aller public Methoden im Package example1, die beliebige Parameter nehmen execution(public * example1.*.*(..))

20 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Joinpoints: lesender Feldzugriff package 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 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 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(); } package example1; public class Test { public static void main(String[] args) { Module1.method1(); Module1.method2(); Module2.method3(); } get(private static int example1.Module1.answer) Jeder lesende Zugriff auf das private static Feld answer in der Klasse example1.Module1

21 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Joinpoints: schreibender Feldzugriff package 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 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 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(); } package example1; public class Test { public static void main(String[] args) { Module1.method1(); Module1.method2(); Module2.method3(); } Jeder schreibende Zugriff auf das private static Feld answer in der Klasse example1.Module1 set(private static int example1.Module1.answer)

22 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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

23 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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()) pointcut executionOfMethod1OrMethod2() : executionOfMethod1() || execution(* example1.Module1.method2()) Oben definierter pointcut Neuer primitiver pointcut

24 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Wo sind wir? Ü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

25 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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

26 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Definition von advice before() : executionOfMethod1OrMethod2 () { LogModule.logPublicMethodExecutionBegin (thisJoinPoint.getSignature().getName()); } before() : executionOfMethod1OrMethod2 () { LogModule.logPublicMethodExecutionBegin (thisJoinPoint.getSignature().getName()); } Schlüsselwort pointcut Block mit Java-Code before advice

27 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Definition von advice around adivce void around() : executionOfMethod1OrMethod2 () { LogModule.logPublicMethodExecutionBegin (thisJoinPoint.getSignature().getName()); proceed(); LogModule.logPublicMethodExecutionEnd (thisJoinPoint.getSignature().getName()); } 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. Schlüsselwort proceed() führt den joinpoint aus. Kann weggelassen werden zum Überspringen des joinpoints.

28 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Wo sind wir? Ü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

29 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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 { }

30 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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 { pointcut publicMethodExecution() : execution(public * *.Module*.* (..)); pointcut privateMethodExecution() : execution(private * *.Module*+.* (..)); } public aspect SimpleLogAspect { pointcut publicMethodExecution() : execution(public * *.Module*.* (..)); pointcut privateMethodExecution() : execution(private * *.Module*+.* (..)); }

31 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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 { 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(“...”); }

32 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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 { 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(“...”); } 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(“...”); }

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

34 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Wo sind wir? Ü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 von joinpoints

35 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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

36 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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

37 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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 java oder einem direkten Subpackage Alle Typen, die Date heißen im Package java oder einem direkten Subpackage java..* Ein beliebiger Typ in einem beliebigen Subpackage von java javax.swing.*Model+ eine beliebige Unterklasse/Unterinterface, z.B. TableModel und TreeModel. Oder aber eine Klasse die das Interface implementiert z.B. DefaultTableModel eine beliebige Unterklasse/Unterinterface, z.B. TableModel und TreeModel. Oder aber eine Klasse die das Interface implementiert z.B. DefaultTableModel

38 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Methoden-Signatur-Pattern für  den Aufruf einer Methode: call ( )  die Ausführung einer Methode: execution ( ) 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+ beliebige Modifier beliebige Modifier beliebige Argumente beliebige Argumente wirft IOException oder Unterklassen Optional können auch die Typen der Exceptions, die geworfen werden angegeben werden

39 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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 Typ-Signatur-Pattern

40 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Feld-Signatur-Pattern public static int *Module*.answer Typ-Signatur-Pattern

41 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Überblick joinpoint-Typen Diese pointcuts fangen jointpoints, die in einer bestimmten Situation auftreten Joinpoint TypPrimitiver pointcut Syntax Methoden-Ausführungexecution(Methoden-Signatur) Methoden-Aufrufcall(Methoden-Signatur) Lesender Variablenzugriffget(Feld-Signatur) Schreibender Variablenzugriffset(Feld-Signatur) Exception Handler Ausführunghandler(Typ-Signatur) Objektinitialisierunginitialization(Konstruktor-Signatur)

42 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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)

43 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Beispiel: joinpoint-Typen :Test :Module1 method1() print() method1 call method1 execution print callprint execution method1() method1 call && within(Module2) method1 execution main execution :Module2

44 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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

45 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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

46 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Wo sind wir? Ü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  Kontext von joinpoints  Aspect

47 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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

48 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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(); } before() : executionOfMethod1() { doSomething(); } Wird hier eine Exception geworfen, wird method1 nicht ausgeführt

49 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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, wenn die Methode erfolgreich war wird nur ausgeführt, wenn die Methode erfolgreich war after() throwing : pointcut-spec wird nur geworfen, wenn die Methode eine Exception geworfen hat wird nur geworfen, wenn die Methode eine Exception geworfen hat

50 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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(„…“); } void around() throws e: executionOfMethod1() { LogModule.logBegin(„…“); try { proceed(); } catch(Exception e) { LogModule.logExc(e); throw e; } LogModule.logEnd(„…“); }

51 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid around advice Rückgabetyp muss dem Rückgabetyp der joinpoints entsprechen (oder Object bei verschiedenen Rückgabetypen) int around() : executionOfMethod3() { proceed(); } int around() : executionOfMethod3() { proceed(); } automatische Rückgabe int around() : executionOfMethod3() { int i = proceed(); System.out.println(“returned “ + i); return i; } int around() : executionOfMethod3() { int i = proceed(); System.out.println(“returned “ + i); return i; } Rückgabewert abfangen und selber an den Aufrufer zurückgeben Rückgabewert abfangen und selber an den Aufrufer zurückgeben Object around() : executionOfMethod1OrMethod3() { Object ret = proceed(); if(ret == null) { return ret; } else { return new Integer(((Integer) ret).intValue() + 1); } 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: automatisches Wrappen primitiver Typen

52 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid Wo sind wir? Ü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  Kontext von joinpoints  Aspect

53 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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) 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 Methode auf einem Objekt aufrufen, das vom Typ Vector ist z.B. target(Vector) : alle joinpoints, die eine Methode auf 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. z.B. args(String, *, int) : alle joinpoints, die als Argument drei Parameter nehmen vom Typ String, beliebig und int.

54 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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); } pointcut printOperation(String str) : call(* example1.Module1.print(String)) && args(str) before(String printStr) : printOperation(printStr) { System.out.println(„Drucke „ + printStr); } Deklaration

55 Universität Bonn, Seminar AOP mit AspectJ WS 2003, Sebastian Scheid 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

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