AspectJ – Eine Aspektorientierte Programmiersprache Vortrag zum Praktikum „Extreme Programming“ Thema: AspectJ – Eine Aspektorientierte Programmiersprache Von: Sven Bartel Hinweis: Die Folien basieren auf Folien der Vorlesung „Aspect-Oriented Software Development 2004“ (Dr. Günter Kniesel u.M.)

Aspektorientierte Programmierung AspectJ – Eine Aspektorientierte Programmiersprache Überblick 1. Motivation Aspektorientierte Programmierung Eine beispielorientierte Einführung in AspectJ 3.1 Beispiel: ein Editor für Figuren 3.2 Joinpoints 3.3 Pointcuts 3.4 Advice 3.5 Aspekt 4. Details zu AspectJ 4.1 Wildcards 4.2 Der Parameter-Mechanismus 4.3 Anwendung: Bedingungen für Methoden 4.4 Inter-type Declarations Zusammenfassung Übungsaufgabe

Grenzen der Objektorientierung: AspectJ – Eine Aspektorientierte Programmiersprache 1. Motivation Grenzen der Objektorientierung: Dekomposition führt nicht immer zur „nahtlosen“ Kapselung von Verhaltensweisen Beispiele für solche Verhaltensweisen: Tracing Logging

Schlechte Modularität (1) Beispiel: Logging in org.apache.tomcat AspectJ – Eine Aspektorientierte Programmiersprache 1. Motivation Schlechte Modularität (1) Beispiel: Logging in org.apache.tomcat Quelle: aspectj.org Webseite Code auf viele Klassen verteilt Logging ist nicht modularisiert – Logging ist ein „crosscutting concern“ Weitere Beispiele: Sicherheit, Debugging, Synchronisation, Transaktionen,…

Schlechte Modularität (2) AspectJ – Eine Aspektorientierte Programmiersprache 1. Motivation Schlechte Modularität (2) Begriffsbildung Scattering: Code eines bestimmten Concern ist über verschiedene Teile des Programms verteilt Tangling: Code in einem bestimmten Teil adressiert verschiedene Concerns Folgen Redundanz schwer nachzuvollziehender Code Probleme bei Änderungen

2. Aspektorientierte Programmierung (AOP) AspectJ – Eine Aspektorientierte Programmiersprache 2. Aspektorientierte Programmierung (AOP) realisiert cross-cutting concerns als first-class Elemente extrahiert cross-cutting concerns von der ursprünglichen Objekt-Struktur realisiert diese in einer zusätzlich geschaffenen Dimension dabei verwendete Struktur: textuell, genannt „Aspekt“ ursprüngliche Objekt-Struktur

cross-cutting concerns werden modularisiert AspectJ – Eine Aspektorientierte Programmiersprache 2. Aspektorientierte Programmierung Aspekte Vorteile cross-cutting concerns werden modularisiert weniger Tangling, bessere Wartbarkeit, kürzerer Code, bessere Wiederverwendbarkeit ursprüngliche Objekt-Struktur

Technische Bestandteile von AOP AspectJ – Eine Aspektorientierte Programmiersprache 2. Aspektorientierte Programmierung Technische Bestandteile von AOP Modell gibt den Rahmen vor um die Struktur der crosscutting concerns zu definieren (AspectJ: Joinpoints) 2. Mittel zur Identifizierung von Joinpoints (AspectJ: Pointcuts) 3. Mittel zur Beeinflussung des Verhaltens bei Joinpoints (AspectJ: Aspekte) 4. Mittel für das „ Zusammenweben“ zu einem funktionellen System (AspectJ: ajc compiler kompiliert Java und webt Aspekte in Klassen)

Welche Mechanismen stehen zur Verfügung um Anwendungen mit Aspekten zu AspectJ – Eine Aspektorientierte Programmiersprache 2. Aspektorientierte Programmierung Begriffsbildung: („AOP is Quantification and Obliviousness“ [Filman2004]) Quantification: Welche Mechanismen stehen zur Verfügung um Anwendungen mit Aspekten zu erstellen? Welche Prädikate stehen zur Verfügung um Situationen zu beschreiben auf die Aspekte angewendet werden Obliviousness: Anhand des Basis-Codes ist nicht feststellbar, dass der Aspekt ausgeführt wird

3. Eine beispielorientierte Einführung in AspectJ AspectJ – Eine Aspektorientierte Programmiersprache 3. Eine beispielorientierte Einführung in AspectJ Hinweis: Folien orientieren sich am zweiten Teil des Tutorials:

3.1 Beispiel: Ein einfacher Editor für Figuren AspectJ – Eine Aspektorientierte Programmiersprache 3.1 Beispiel: Ein einfacher Editor für Figuren

class Line implements FigureElement{ private Point p1, p2; AspectJ – Eine Aspektorientierte Programmiersprache 3.1 Beispiel: Ein Editor für Figuren Quelltextauszug class Line implements FigureElement{ private Point p1, p2; Point getP1() { return p1; } Point getP2() { return p2; } void setP1(Point p1) { this.p1 = p1; } void setP2(Point p2) { this.p2 = p2; } void moveBy(int dx, int dy) { ... } } class Point implements FigureElement { private int x = 0, y = 0; int getX() { return x; } int getY() { return y; } void setX(int x) { this.x = x; } void setY(int y) { this.y = y; }

Aufgabe: Aktualisieren des Displays AspectJ – Eine Aspektorientierte Programmiersprache 3.1 Beispiel: Ein Editor für Figuren Aufgabe: Aktualisieren des Displays Ansammlung von Figurelementen die sich bewegen müssen das Display bei Bedarf aktualisieren Anzahl der Figurelemente kann komplex sein Events treten asynchron auf

method execution join point AspectJ – Eine Aspektorientierte Programmiersprache 3.2 Joinpoint Wohldefinierte Punkte in der Ausführung eines Java-Programms, wie z.B. Methodenaufrufe & Konstruktorenaufrufe (call join points) Ausführung von Methoden & Konstruktoren (execution call points) Feldzugriffe (get & set) method call join point A Line dispatch method execution join point

Prädikat, das eine Menge von Joinpoints definiert AspectJ – Eine Aspektorientierte Programmiersprache 3.3 Pointcut (1) Prädikat, das eine Menge von Joinpoints definiert Aufbau: public pointcut mypointcut() : call (void Line.setP1(Point)) Pointcut type Keyword Access specifier Pointcut name Signature

Beispiel (anonymer Pointcut): call (void Line.setP1(Point)) AspectJ – Eine Aspektorientierte Programmiersprache 3.3 Pointcut Pointcut (2) Beispiel (anonymer Pointcut): call (void Line.setP1(Point)) Pointcuts können durch Boolesche Ausdrücke logisch verknüpft werden Pointcuts können benannt werden Pointcuts können über mehrere Klassen selektieren Beispiel: public pointcut move() : call (void Line.setP1(Point)) || call (void Line.setP2(Point)) || call (void Point.setX(int)) || call (void Point.setY(int));

call ist ein „Primitiver Pointcut“ AspectJ – Eine Aspektorientierte Programmiersprache 3.3 Pointcut Primitive Pointcuts call ist ein „Primitiver Pointcut“ Weitere Primitive Pointcut Bezeichner sind: call, execution - this, target, args get, set - within, withincode handler - cflow, cflowbelow initialization, staticinitialization Weitere Details: AspectJ Quick Reference

Erläuterung primitiver Pointcuts: call, execution, within AspectJ – Eine Aspektorientierte Programmiersprache 3.3 Pointcut Erläuterung primitiver Pointcuts: call, execution, within

Code der einem Pointcut zugeordnet wird AspectJ – Eine Aspektorientierte Programmiersprache 3.4 Advice Code der einem Pointcut zugeordnet wird und damit zusätzliches Verhalten bei den vom Pointcut definierten Joinpoints einführt. der Code kann vor (before advice) nach (after advice) während (around advice) einem Pointcut ausgeführt werden

Beispiel: after advice AspectJ – Eine Aspektorientierte Programmiersprache 3.4 Advice Beispiel: after advice pointcut move(): call (void Line.setP1(Point)) || call (void Line.setP2(Point)); after() returning: move() { <nach jedem „move“ auszuführender Code> } Varianten: after throwing after returning

Repräsentation eines „crosscutting concerns“ im Code AspectJ – Eine Aspektorientierte Programmiersprache 3.5 Aspekt Repräsentation eines „crosscutting concerns“ im Code Aspekte ähneln einer Klasse können Methoden, Felder, Pointcuts und Advices beinhalten können abstract sein können von Klassen abgeleitet werden und Interfaces implementieren

Box impliziert vollständig lauffähigen Code AspectJ – Eine Aspektorientierte Programmiersprache 3.5 Aspekt Beispiel: Ein einfacher Aspekt ohne AspectJ: mit AspectJ: class Line { private Point p1, p2; Point getP1() { return p1; } Point getP2() { return p2; } void setP1(Point p1) { this.p1 = p1; Display.update(); } void setP2(Point p2) { this.p2 = p2; aspect DisplayUpdating { pointcut move(): call(void Line.setP1(Point)) || call(void Line.setP2(Point)); after() returning: move() { Display.update(); } Box impliziert vollständig lauffähigen Code

* beliebiger Teil einer Klasse, Interface oder eines Package AspectJ – Eine Aspektorientierte Programmiersprache Details zu AspectJ 4.1 Wildcards * beliebiger Teil einer Klasse, Interface oder eines Package .. alle direkten und indirekten subpackages + alle Subtypen (Subklassen oder Subinterfaces) Beispiel: javax..*Model+

public pointcut mypointcut() : call (void Line.setP1(Point)) Pointcut AspectJ – Eine Aspektorientierte Programmiersprache 4.2 Wildcards Übung: Signaturen (1) Wiederholung: public pointcut mypointcut() : call (void Line.setP1(Point)) Pointcut type Keyword Access specifier Pointcut name Signature

public void Line.set*(*) AspectJ – Eine Aspektorientierte Programmiersprache 4.2 Wildcards Übung: Signaturen (2) public void Line.set*(*) public void Line.*() public * Line.*() public * Line.*(..) !public * Line.*(..) * Line+.*(..)

4.2 Parameter-Mechanismus AspectJ – Eine Aspektorientierte Programmiersprache 4.2 Parameter-Mechanismus Ergänzung: target(Line) selektiert alle Joinpoints, falls das Objekt, auf dem die Methode aufgerufen wird, instanceof Line ist (entsprechend gilt dies für Subklassen von Line)

before (FigureElement fe) : move(fe) { AspectJ – Eine Aspektorientierte Programmiersprache 4.2 Parameter-Mechanismus before (FigureElement fe) : move(fe) { System.out.println( fe + “ is about to move”); } pointcut move(FigureElement figElt): target(figElt) && (call(void FigureElement.moveBy(int, int))

 Demonstration des AJDT AspectJ – Eine Aspektorientierte Programmiersprache 4.2 Der Parameter-Mechanismus Aspekt: Aktualisieren des Displays aspect DisplayUpdating { pointcut move(FigureElement figElt): target(figElt) && (call(void FigureElement.moveBy(int, int) || call(void Line.setP1(Point)) || call(void Line.setP2(Point)) || call(void Point.setX(int)) || call(void Point.setY(int))); after(FigureElement fe) returning: move(fe) { Display.update(fe); }  Demonstration des AJDT

4.3 Anwendung: Bedingungen für Methoden AspectJ – Eine Aspektorientierte Programmiersprache 4.3 Anwendung: Bedingungen für Methoden Vorbedingungen: Prüfe, ob die Parameter gültig sind Nachbedingungen: Prüfe, ob die berechneten Werte gültig sind Während der Ausführung: Korrekte Werte erzwingen

<result type> proceed(arg1, arg2, …) AspectJ – Eine Aspektorientierte Programmiersprache 4.3 Anwendung: Bedingungen für Methoden Einschub 1) proceed <result type> proceed(arg1, arg2, …) nur im around advice 2) args Beispiel: args(String,..,int) selektiert Joinpoints in allen Methoden, die als ersten Parameter String und als letzten int erwarten

aspect PointBoundsPreCondition { before(int newX): AspectJ – Eine Aspektorientierte Programmiersprache 4.3 Anwendung: Bedingungen für Methoden Vorbedingungen aspect PointBoundsPreCondition { before(int newX): call(void Point.setX(int)) && args(newX) { assert(newX >= MIN_X); assert(newX <= MAX_X); } before(int newY): call(void Point.setY(int)) && args(newY) { assert(newY >= MIN_Y); assert(newY <= MAX_Y); private void assert(boolean v) { if ( !v ) throw new RuntimeException(); nach dem ‘:’ folgt immer ein pointcut – primitiv oder benannt (selbst-definiert)

aspect PointBoundsPostCondition { after(Point p, int newX) returning: AspectJ – Eine Aspektorientierte Programmiersprache 4.3 Anwendung: Bedingungen für Methoden Nachbedingung aspect PointBoundsPostCondition { after(Point p, int newX) returning: call(void Point.setX(int)) && target(p) && args(newX) { assert(p.getX() == newX); } after(Point p, int newY) returning: call(void Point.setY(int)) && target(p) && args(newY) { assert(p.getY() == newY); private void assert(boolean v) { if ( !v ) throw new RuntimeException();

 Demo aspect PointBoundsEnforcement { void around(Point p, int newX): AspectJ – Eine Aspektorientierte Programmiersprache 4.3 Anwendung: Bedingungen für Methoden Während der Ausführung: korrekte Werte forcieren aspect PointBoundsEnforcement { void around(Point p, int newX): call(void Point.setX(int)) && target(p) && args(newX) { proceed(p, clip(newX, MIN_X, MAX_X)); } void around(Point p, int newY): call(void Point.setY(int)) && target(p) && args(newY) { proceed(p, clip(newY, MIN_Y, MAX_Y)); private int clip(int val, int min, int max) { return Math.max(min, Math.min(max, val));  Demo

 Demo 4.4 Inter-type Declarations Beispiele: AspectJ – Eine Aspektorientierte Programmiersprache 4.4 Inter-type Declarations Beispiele: declare parents : C extends D; declare parents : C implements I,J; declare warning : set(* Point.*)&&!within(Point) : „bad set“ ; pointcut illegalNewFigElt(): (call(Point.new(..)) || call(Line.new(..))) && !withincode(* Figure.make*(..)); declare error: illegalNewFigElt(): "Use factory method instead.";  Demo

„AOP is Quantification and Obliviousness“ AspectJ: AspectJ – Eine Aspektorientierte Programmiersprache Zusammenfassung „AOP is Quantification and Obliviousness“ AspectJ: Joinpoints: Wohldefinierte Punkte in der Ausführung eines Java-Programms Pointcuts: Prädikat, das eine Menge von Joinpoints definiert (primitiv + selbst-definiert) Advice: Code der einem Pointcut zugeordnet wird und damit zusätzliches Verhalten bei den vom Pointcut definierten Joinpoints einführt Aspekt: Repräsentation eines „crosscutting concerns“ im Code Details zu AspectJ: Wildcards Parameter-Mechanismus Inter-type Declarations

6. Übungsaufgabe: Caching von Fibonacci-Zahlen AspectJ – Eine Aspektorientierte Programmiersprache 6. Übungsaufgabe: Caching von Fibonacci-Zahlen public class Fibonacci { // naive implementation of fibonacci // with a lot of redundant calculations of the same values. public static int fib(int n) { if ( n < 2) { System.out.println(n + "."); return 1; } else { System.out.print(n + ","); return fib(n-1) + fib(n-2); } public static void main(String[] args) { int value=10; int f = fib(value); System.out.println("fib("+value+") = " + f);

Lösung.. AspectJ – Eine Aspektorientierte Programmiersprache 6. Übungsaufgabe Lösung..

Mögliche Lösung der Übungsaufgabe: AspectJ – Eine Aspektorientierte Programmiersprache 6. Übungsaufgabe Mögliche Lösung der Übungsaufgabe: import java.util.HashMap; public aspect OptimizeFibonacciAspect { private HashMap cache = new HashMap(); private pointcut fibs(int n): call(int Fibonacci.fib(int)) && args(n); int around(int n): fibs(n) { Integer result = (Integer)cache.get(new Integer(n)); if (result == null) { // not found, calculate! int f = proceed(n); cache.put(new Integer(n), new Integer(f)); return f; } else return result.intValue(); // found, done! }

AspectJ – Eine Aspektorientierte Programmiersprache 7. Anhang 7.1 Control-Flow

7.1 Erläuterung primitiver Pointcuts: call, execution, within AspectJ – Eine Aspektorientierte Programmiersprache 7.1 Erläuterung primitiver Pointcuts: call, execution, within

7.2 Erläuterung primitiver Pointcuts: cflow, cflowbelow AspectJ – Eine Aspektorientierte Programmiersprache 7.2 Erläuterung primitiver Pointcuts: cflow, cflowbelow

AspectJ – Eine Aspektorientierte Programmiersprache 7.3 Webzeit in AspectJ