FACHHOCHSCHULE LANDSHUT
Fachbereich Informatik

Aspektorientierte Programmierung mit Java gezeigt am Beispiel einer konkreten Anwendung

Diplomarbeit

zur Erlangung des Grades eines
Diplom Informatikers (FH)

erstellt von

Eduard Hildebrandt

Eingereicht: 10. Januar 2005

II. Kurzfassung

Diese Diplomarbeit untersucht die Praxistauglichkeit der aspektorierten Programmierung (AOP) mit Java am Beispiel einer konkreten J2EE Anwendung. Nach einer kurzen Einführung in die Grundzüge der aspektorientierten Programmierung, werden die versichenenen Einsatzgebiete, wie Logging, Pooling, Qualitätssicherung oder Testen von Software vorgestellt. Dabei wird die AOP Lösung immer mit einer herkönlichen Java Implementierung vergliechen und die Vor- und Nachteile der beiden Implementierungen untersucht. Als Ergebnis dieser Arbeit soll geprüft werden, ob AOP inzwischen bereit für den Praxiseinsatz ist und der Nutzen sowie Probleme dieser Technologie untersucht werden.

Inhaltsverzeichnis

I. Eidesstattliche Erklärung ... 3
II. Kurzfassung ... 4
III. Danksagung ... 5
IV. Inhaltsverzeichnis ... 6
VI. Abbildungsverzeichnis ... 8

Kapitel 1: Einführung ... 9
1.1 Einleitung ... 9
1.2 Ziel der Arbeit ... 10
1.3 Voraussetzungen ... 10
1.4 Motivation ... 10
1.5 Aspektorientierte Programmierung ... 12
1.6 Weben von Aspekten ... 14
1.6.1 statisches Weben ... 14
1.6.7 dynamisches Weben ... 14
1.7. AspectJ ... 14
1.7.1 Schnittpunkte (engl. pointcuts) ... 15
1.7.2 Advices ... 16
1.7.3 Aspekte ... 16
1.7.4 Introductions ... 17
1.7.5 Compiler Regeln ... 17
1.8. „Hello World“ mit AspectJ ... 18
1.9. Zusammenfassung ... 19

Kapitel 2: Die Anwengung - iPad ... 21
2.1 Anforderungen ... 21
2.2 Design ... 23
2.2.1 Klassen Design ... 23
2.2.2 Datenbank Design ... 23
2.2.3 Grafische Oberfläche ... 24
2.2.4 Architektur ... 25
2.3 Implementierung ... 27
2.3.1 Allgemeines ... 27
2.3.2 Technologien ... 27
2.3.2.1 Hibernate ... 27
2.3.2.2 Axis ... 28
2.3.2.3 Lucene ... 28
2.3.2.4 Eclipse RCP ... 29
2.3.2.5 JDIC ... 31
2.3.3 Probleme und Erfahrungen ... 31
2.3.3.1 SWT ... 31
2.3.3.1 Performance ... 32
2.4 Bewertung des Designs und Architektur ... 32
2.5 Zusammenfassung ... 33

Kapitel 3: Tracing und Logging ... 34
3.1 Konventionelles Logging ... 34
3.2 Logging mit AspectJ ... 36
3.2.1 Protokollieren von Methodenaufrufen ... 36
3.2.2 Protokollieren von Feldzugriffen ... 39
3.2.3 Protokollieren von Exceptions ... 40
3.3 Spezielle Logging Anwendungen ... 42
3.3.1 Protokollieren von SQL Statements ... 42
3.3.2 Protokollieren von Sessions ... 42
3.3.3 Protokollieren von Webservice Requests ... 43
3.4 Einsatz in der Beispielanwendung ... 44
3.5 Zusammenfassung ... 44

Kapitel 4: Qualitätssicherung ... 45
4.1 Best-Practices Richtlinien ... 45
4.2 EJB Richtlinien ... 46
4.3 Swing Richtlinien  ... 47
4.4 Architektur Richtlinien  ... 48
4.5 Benutzerdefinierte Richtlinien  ... 49
4.6 Richtlinien für Namenskonventionen ... 50
4.7 Weitere Tools  ... 51
4.8 Einsatz in der Beispielanwendung ... 51
4.9 Zusammenfassung  ... 52

Kapitel 5: Pooling und Caching  ... 53
5.1 Thread Pool  ... 54
5.1.1 Java Implementierung ... 54
5.1.2 AspectJ Implementierung ... 56
5.1.3 Bewertung ... 57
5.2 XSLT Cache ... 58
5.2.1 Java Implementierung ... 58
5.2.2 AspectJ Implementierung ... 60
5.2.3 Bewertung ... 60
5.3 Einsatz in der Beispielanwendung ... 61

Kapitel 6: Design Patterns  ... 62
6.1 Singleton Pattern  ... 62
6.1.1 Java Implementierung ... 62
6.1.2 AspectJ Implementierung ... 62
6.1.3 Bewertung ... 64
6.2 Observer Pattern  ... 64
6.2.1 Java Implementierung ... 65
6.2.2 AspectJ Implementierung ... 65
6.2.3 Bewertung ... 67
6.3 Zusammenfassung  ... 67

Kapitel 7: Testen mit AspectJ ... 68
7.1 Prüfungen privater Variablen ... 68
7.2 Austausch von Methoden und Objekten ... 69
7.3 Virtuelle Mock Objekte ... 70
7.4 Unit Test Coverage ... 71

Kapitel 8: Fazit ... 73
8.1 Bewertung der Technologie ... 73
8.3 Ausblick in die Zukunft  ... 74
8.4 Zusammenfassung  ... 75

VII. Literaturverzeichnis  ... 76

VIII. Abkürzungsverzeichnis ... 78

IX. Glossar  ... 79

X. Anhänge ... 84
Anhang A: Eingesetzte Hilfsmittel ... 84
!! Anhang B: CD-ROM - nicht enthalten !!
Anhang D: Java AOP Implementierungen ... 87
Anhang E: AspectJ Plugins für Entwicklungsumgebungen  ... 88

Kapitel 1: Einführung
1.1 Einleitung
Der Mensch hätte nur selten Großes erreicht, wenn er alle Frustrationen hinnehmen würde. Treibt doch die Frage „Muss es so sein?“ unseren Erfindungsgeist an. Hieraus erwachsen politische Reformen und wissenschaftliche Erneuerungen. Die Römer mochten Frustrationen nirgendwo hinnehmen. Sie gingen nicht gerne auf schlammigen Straßen, also pflasterten sie diese. Sie verabscheuten die winterliche Kälte und ersannen so die Fußbodenheizung.

Nicht anderes verhält es sich mit dem Prozess der Softwareentwicklung. Die Unzufriedenheit der Programmierer treibt diese dazu, immer wieder neuere und effizientere Wege bei der Softwareentwicklung zu beschreiten.

In den frühen Tagen der Informatik haben die Entwickler ihre Programme direkt in Form von Maschinen-Befehlen eingegeben. Leider verbrachten die Programmierer mehr Zeit damit, über den Befehlsatz für den jeweiligen Prozessor, als über das eigentliche Problem nachzudenken. So entstanden die ersten höheren Programmiersprachen, die eine Abstraktion der zugrunde liegenden Maschine erlaubten.

Mit der Zeit kamen die prozeduralen Sprachen und ermöglichten es, die Probleme in kleinere Teilprobleme zu zerlegen und diese in Prozeduren abzubilden. Da die Komplexität der Programme jedoch ständig anwuchs, wurde bald eine ausgefeiltere Technik benötigt.

Während bei prozeduralen Programmiersprachen die Daten und Prozeduren getrennt betrachtet wurden, werden diese in der objektorientierten Programmierung zu einer Einheit in Form von Objekten zusammengefasst. Die objektorientierte Programmierung (OOP) betrachtet ein System als eine Menge von Objekten, die untereinander interagieren. Abstraktion, Kapselung, Vererbung und Polymorphie sind die grundlegenden Prinzipien der OOP. Dieser Programmierstil bietet softwaretechnisch gegenüber anderen älteren Verfahren große Vorteile, da hiermit eine wesentlich natürlichere Modellierung ermöglicht wird und große Systeme leichter verwaltet werden können.

Programmierparadigmen und –sprachen definieren die Art und Weise, wie wir uns mit Maschinen verständigen. Jede neue Methode präsentiert einen anderen Weg die realen Objekte der Welt - auf eine für uns Menschen natürlichere Art - in Datenkonstrukte auf dem Rechner abzubilden. Die Evolution der Programmiermethoden ermöglicht es uns immer bessere und komplexere Softwaresysteme zu bauen.

Zum Zeitpunkt der Erstellung dieser Arbeit ist OOP die am weitesten verbreitete Methodenlehre. In der Tat hat OOP seine Stärken beim Modellieren von allgemeinen Verhalten gezeigt. Ein Bankkonto, auf dem man einen Betrag einzahlen oder abheben kann, lässt sich mit OOP sehr leicht und elegant modellieren.

In der Praxis zeigt sich jedoch, dass es beim Entwurf eines Softwaresystems viele technische Anforderungen, wie z.B. Logging, Persistenz oder Authentifizierung gibt, die sich nicht klar auf eine funktionale Einheit beschränken lassen. Sie durchdringen das gesamte System und lassen sich nur sehr schwer und umständlich in Form von Klassen kapseln. Solche Anforderungen werden auch als „querschneidende Anforderungen“ oder „cross-cutting concerns“ bezeichnet.

Durch ausschließlich funktionale Dekomposition und Refaktorisierung ist es nur in wenigen Fällen möglich, solche Anforderungen unabhängig voneinander und vom Gesamtsystem mit reiner OOP zu modellieren. Beispielsweise ist es nicht möglich den Zugriff auf das Objekt Konto zu protokollieren, ohne die Struktur der Klasse zu verändern. Hier liegen die Grenzen von objektorientierter Programmierung.

Genau hier versucht die aspektorientierte Programmierung (AOP) Abhilfe zu leisten. Ziel der Aspektorientierten Programmierung ist es querschneidende Anforderungen in Form von Aspekten zu kapseln und die Komponenten des Systems von ihnen frei zu halten.

AOP könnte der nächste große Schritt in der Entwicklung der Programmiermethoden sein.

1.2 Ziel der Arbeit
Mit dieser Diplomarbeit soll die Praxistauglichkeit dieser neuen Technologie am Beispiel einer J2EE Anwendung evaluiert werden.

Es sei darauf hingewiesen, dass diese Arbeit keine vollständige Beschreibung der AspectJSprache darstellen soll. Auch wenn eine ausführliche, deutschsprachige Dokumentation für AspectJ noch fehlt, ist es nicht Ziel dieser Arbeit eine solche zu erstellen. Der Autor erklärt zwar alle wichtigen Sprachelemente von AspectJ, für die Programmierung mit AspectJ ist jedoch ein Studium der Dokumentation [AJDOC] oder der im Anhang C vorgeschlagenen Literatur unumgänglich.

Es ist auch nicht Thema dieser Arbeit ist, das Design und die Architektur der Anwendung zu beschreiben. Aus diesem Grund beleuchtet das zweite Kapitel nur die wichtigsten Design- und Architekturentscheidungen und soll keine vollständige Dokumentation darstellen. Auch wenn viele Konzepte der Anwendung aus der Sicht eines Software-Architekten sehr interessant sind, wurde auf eine ausführliche Beschreibung dieser Konzepte zu Gunsten von AOP Themen verzichtet.

1.3 Voraussetzungen
Bei dieser Diplomarbeit werden Kenntnisse in der Modellierung und Implementierung von objektorientierten Softwaresystemen vorausgesetzt. Außerdem sind Programmierkenntnisse in Java sowie ein Grundverständnis der Java 2 Platform Enterprise Edition (J2EE) notwendig.
Praktische Erfahrungen auf diesem Gebiet sind, zum Verständnis von großem Vorteil.

1.4 Motivation
Anforderungen, wie z.B. das Parsen einer XML Datei, lassen sich mit OOP relativ einfach implementieren. Die Grafik in der Abbildung 1 visualisiert den Quellcode von Apache Tomcat. Jeder Balken repräsentiert eine Klasse. Der Quellcode, welcher zum Parsen einer XML Datei notwendig ist, wurde in der Grafik hervorgehoben dargestellt. Wie man der Grafik entnehmen kann, ist der Code innerhalb einer einzigen Klasse gekapselt. Dies macht es einfach, den Code zu modifizieren und wieder zu verwenden.

[...]