Bessere Software durch aspektorientierte Programmierung mit Java ...

Bessere Software durch 

aspektorientierte Programmierung 

mit Java und AspectJ 

Stand: 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 

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

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 








Motivation 

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 

Modularisierung broken 

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

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

ClassA ClassB ClassC 

ConcernX 

ConcernX 

� Scattering: Belange sind auf mehrere Module verteilt. 

� Tangling: Module enthalten mehrere Belange. 

ConcernX 

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


AOP-Konzepte 

AOP modularisiert Cross-cutting Concerns 

� AOP führt neben Klassen Aspekte ein. 

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


ConcernX 

ConcernX 

ConcernX 

AspectX 

ConcernX 

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


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. 


ConcernX 

ConcernX 

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

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

ConcernX 

AspectX 

ConcernX 


Gliederung 

I. Einleitung 







� Tools 








Sprachumfang im Überblick 

Hello World 

Demo 


Sprachumfang im Überblick 

Anatomie von Aspekten 

1 

2 

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 



ContractJ (www.aspectbrains.org/contractj) 

� Bessere Lösung: 

� Annotations markieren Contracts. 

� Aspekte implementieren Contracts. 



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! 

metafinanz 

Informationssysteme GmbH 

Leopoldstr. 146 

80804 München 

phone: +49 89 360531-0 

fax: +49 89 360531-15 

kontakt@metafinanz.de 

www.metafinanz.de

Bessere Software durch aspektorientierte Programmierung mit Java ...

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?