jugm 07 - aspectj

Stand: 26.11.2007

Bessere Software durch

aspektorientierte Programmierung

mit Java und AspectJ

Seite 2© Bessere Software durch AOP mit Java und AspectJ 26.11.2007 -

Gliederung

I. Einleitung

II. Was ist AOP?� Motivation

� Konzepte und Begriffe

III. Überblick über AspectJ� „Hello World“

� Sprachumfang im Überblick

� Tools

IV. AspectJ in der Praxis

� Performance-Logging

� Design by Contract

� JavaBeans Bound Properties

V. Optional: AspectJ Load Time Weaving und Eclipse Plug-ins

VI. Fazit und Diskussion


Einleitung

Vorstellung

� Heiko Seeberger

� 36 Jahre

� Market Unit Manager of Enterprise Architecture bei metafinanz

� OO-Kenntnisse seit 1993, Java seit 1999

� Schwerpunkte: AspectJ, Eclipse und SOA

� Aktiver Open Source Contributor


Gliederung

I. Einleitung





� Tools








Seperation of Concerns

� Herausforderung: Komplexität

� Ansatz: Problemstellung in überschaubare und disjunkte „Häppchen“ (Belange) zerlegen.

� Ergebnis:� Verständliche Anforderungen

� Klare Konzepte

� Hochwertige Lösungen

� Höherer Grad an Wiederverwendung

=> Modularisierung ist gut!

� Objektorientierung (OO) fördert Modularisierung:� Packages

� Klassen

� Methoden

� …

Motivation


Motivation

Modularisierung broken

� OO vermag i.d.R. nicht, alle Belange zu modularisieren.

� Manche Belange durchsetzen die OO-Module: Cross-cutting Concerns.

� Scattering: Belange sind auf mehrere Module verteilt.

� Tangling: Module enthalten mehrere Belange.

=> Die Software könnte noch besser (verständlicher, wartbarer , wiederverbendbarer etc.) sein.

ClassA ClassB ClassC

ConcernXConcernX

ConcernXConcernX

ConcernX

ConcernX


AOP-Konzepte

AOP modularisiert Cross-cutting Concerns

� AOP führt neben Klassen Aspekte ein.

� Cross-cutting Concerns werden von Klassen in Aspekte verlagert.

=> Jedes Modul behandelt genau einen Belang => Vollständige Modularisierung.


ConcernXConcernX

ConcernXConcernX

ConcernX

ConcernX

AspectX

ConcernX


AOP-Konzepte

Weaving

� Herausforderung: Die separierten Belange wieder zusammenführen.

� Ansatz: Dieser Vorgang wird mit Weaving („Weben“) bezeichnet.

� Ergebnis: Die vormals separierten Belange „spielen wieder zusammen“.

� Mehrere Strategien:� Precompiler.

� Compile-time Weaving: Beim/nach dem Compilieren (Java).

� Load-time Weaving: Beim Class Loading (Java).


ConcernXConcernX

ConcernXConcernX

ConcernX

ConcernX

AspectX

ConcernX


Gliederung

I. Einleitung





� Tools








Sprachumfang im Überblick

Hello World

Demo


Sprachumfang im Überblick

Anatomie von Aspekten

12

Dynamic cross-cutting

Static cross-cutting


Dynamic cross-cutting

Dynamische Aspekte von Aspekten

� Joinpoints sind Programmstellen, an denen Weaving ansetzen kann, z.B.� Methoden-Aufrufe, Feldzugriffe, Instantiierung etc.

� Pointcuts definieren bestimmte Mengen von Joinpoints, z.B.� „alle Methoden-Aufrufe“ oder „alle Methoden-Aufrufe der Klasse X mit einem Parameter“ oder …

� Advices enthalten die Belange und steuern unter Bezug auf Pointcuts das Weaving,� z.B. „Vor PointcutX soll dieser Belang eingewoben werden“.



Klassen „aufbohren“

� Hinzufügen von Feldern, Methoden und Konstruktoren.

� „Gewöhnliche“ Syntax mit vorangestelltem Klassennamen.

Demo



Eltern adoptieren

� Typen erweitern, d.h. neue extends hinzufügen.

� Interfaces implementieren, d.h. neue implements hinzufügen.

Demo



Default-Implementierungen für Interfaces

� Hinzufügen von Feldern und Methoden-Implementierungen zu Interfaces!

� Macht gemixte Methoden direkt zugreifbar.

Demo



Eigene Compiler-Meldungen

� Anhand von statischen Pointcuts gibt der AspectJ-Compiler Fehler oder Warnungen aus.

� Nützlich für die Qualitätssicherung:� Nutzung von unerwünschtem Code verhindern.

� Einhalten von Richtlinien sicherstellen.

Demo


Gliederung

I. Einleitung





� Tools








Performance-Logging

Ein Praxisbeispiel

� Reporting von Performance-Kennzahlen aus dem laufenden Betrieb.

� Messung der Ausführungsdauer von Anwendungsfällen.

� Kommt im Kernsystem der Allianz Versicherung zum Einsatz.


Design by Contract

Verbindliche Schnittstellen

� Design by Contract: Klare Vorgaben, was vom API erwartet und geliefert wird.� Preconditions definieren die Erwartungshaltung.

� Postconditions beschreiben die Liefergarantien.

� Erfolgsfaktoren:� Contracts müssen klar kommuniziert werden => Nutzer des API wissen Bescheid.

� Contracts dürfen nicht gebrochen werden können => Herausgeber des API kann sich verlassen.

� Die Umsetzung muss einfach sein.

� „Zweitbeste“ Lösung: � Contracts in JavaDoc beschreiben. => Vollständig? Refactoring?

� Contracts in den Implementierungen umsetzen, d.h. durch den Nutzer. => Verlässlichkeit?

� Mühsame Ansatz, oft redundanter Code.

Demo


Design by Contract

ContractJ (www.aspectbrains.org/contractj)

� Bessere Lösung: � Annotations markieren Contracts.

� Aspekte implementieren Contracts.


Design by Contract

ContractJ

� Annotations sind ausdrucksstark. => Klare Kommunikation der Contracts.

� Annotations identifizieren und beschreiben Contracts gleichzeitig. => Vollständig und konsistent.

� Aspekte liegen in der Hoheit des API-Herausgebers. => Hohes Maß an Verlässlichkeit.

� Weiterführende Informationen siehe Eclipse Magazin Vol. 12 „Design by Contract“:� http://www.metafinanz.de/fileadmin/Dokumente/Kontakt/2007_08_hsr_eclipse.pdf

Demo


JavaBeans Bound Properties

PropertyChanges kommunizieren

� JavaBeans definieren PropertyChangeListener:� „A PropertyChange event gets fired whenever a bean changes a bound property. You can register a

PropertyChangeListener with a source bean so as to be notified of any bound property updates.“

� Implementierung sehr mühsam, da viel „Glue Code“ zu schreiben:� Listener registrieren und deregistrieren.

� Für jede Bound Property muss ein PropertChangeEvent gefeuert werden.

� Trotz Hilfsklasse PropertyChangeSupport viel „Handarbeit“ erforderlich.Demo


JavaBeans Bound Properties

Active Beans (www.aspectbrains.org/activebeans)

� Einfachere Lösung:� Annotations markieren Klassen, deren Properties gebunden werden sollen.

� Aspekte fügen mittels Static und Dynamic Cross-cutting den Glue Code ein. Demo


Gliederung

I. Einleitung





� Tools








Fazit

AOP bzw. AspectJ ist sehr nützlich

� AOP ermöglicht volle Seperation of Concerns und führt dadurch zu besserer Software.

� AspectJ ist eine reife und sehr mächtige AOP-Sprache für Java.

� Vorschlag für schrittweise Einführung:� Eigene Compiler-Meldungen verwenden.

� Fertige Aspekte bzw. Aspekt-Libraries für Standard-Szenarien einsetzen.

� Eigene Aspekte für individuelle Cross-cutting Concerns erstellen.

=> Nutzen Sie AspectJ!

� Fragen und Antworten …


Herzlichen Dank!

metafinanzInformationssysteme GmbH

Leopoldstr. 14680804 München

phone: +49 89 360531-0fax: +49 89 [email protected]

www.metafinanz.de

jugm 07 - aspectj

Technology