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
Kapitel 1: Einführung
1.1 Einleitung
1.2 Ziel der Arbeit
1.3 Voraussetzungen
1.4 Motivation
1.5 Aspektorientierte Programmierung
1.6 Weben von Aspekten
1.6.1 statisches Weben
1.6.7 dynamisches Weben
1.7. AspectJ
1.7.1 Schnittpunkte (engl. pointcuts)
1.7.2 Advices
1.7.3 Aspekte
1.7.4 Introductions
1.7.5 Compiler Regeln
1.8. „Hello World“ mit AspectJ
1.9. Zusammenfassung
Kapitel 2: Die Anwengung - iPad
2.1 Anforderungen
2.2 Design
2.2.1 Klassen Design
2.2.2 Datenbank Design
2.2.3 Grafische Oberfläche
2.2.4 Architektur
2.3 Implementierung
2.3.1 Allgemeines
2.3.2 Technologien
2.3.2.1 Hibernate
2.3.2.2 Axis
2.3.2.3 Lucene
2.3.2.4 Eclipse RCP
2.3.2.5 JDIC
2.3.3 Probleme und Erfahrungen
2.3.3.1 SWT
2.3.3.1 Performance
2.4 Bewertung des Designs und Architektur
2.5 Zusammenfassung
Kapitel 3: Tracing und Logging
3.1 Konventionelles Logging
3.2 Logging mit AspectJ
3.2.1 Protokollieren von Methodenaufrufen
3.2.2 Protokollieren von Feldzugriffen
3.2.3 Protokollieren von Exceptions
3.3 Spezielle Logging Anwendungen
3.3.1 Protokollieren von SQL Statements
3.3.2 Protokollieren von Sessions
3.3.3 Protokollieren von Webservice Requests
3.4 Einsatz in der Beispielanwendung
3.5 Zusammenfassung
Kapitel 4: Qualitätssicherung
4.1 Best-Practices Richtlinien
4.2 EJB Richtlinien
4.3 Swing Richtlinien
4.4 Architektur Richtlinien
4.5 Benutzerdefinierte Richtlinien
4.6 Richtlinien für Namenskonventionen
4.7 Weitere Tools
4.8 Einsatz in der Beispielanwendung
4.9 Zusammenfassung
Kapitel 5: Pooling und Caching
5.1 Thread Pool
5.1.1 Java Implementierung
5.1.2 AspectJ Implementierung
5.1.3 Bewertung
5.2 XSLT Cache
5.2.1 Java Implementierung
5.2.2 AspectJ Implementierung
5.2.3 Bewertung
5.3 Einsatz in der Beispielanwendung
Kapitel 6: Design Patterns
6.1 Singleton Pattern
6.1.1 Java Implementierung
6.1.2 AspectJ Implementierung
6.1.3 Bewertung
6.2 Observer Pattern
6.2.1 Java Implementierung
6.2.2 AspectJ Implementierung
6.2.3 Bewertung
6.3 Zusammenfassung
Kapitel 7: Testen mit AspectJ
7.1 Prüfungen privater Variablen
7.2 Austausch von Methoden und Objekten
7.3 Virtuelle Mock Objekte
7.4 Unit Test Coverage
Kapitel 8: Fazit
8.1 Bewertung der Technologie
8.3 Ausblick in die Zukunft
8.4 Zusammenfassung
Zielsetzung & Themen
Die Diplomarbeit untersucht die praktische Anwendbarkeit der aspektorientierten Programmierung (AOP) mit AspectJ innerhalb des J2EE-Umfelds. Das primäre Ziel ist es zu evaluieren, inwieweit AOP geeignet ist, querschneidende Anforderungen modular zu kapseln und dadurch die Softwareentwicklung sowie Wartung zu vereinfachen, ohne die objektorientierte Programmierung zu ersetzen.
- Grundlagen der aspektorientierten Programmierung und Funktionsweise des "Webens"
- Einsatz von AOP zur Lösung querschneidender Belange wie Logging, Tracing und Exception-Handling
- Qualitätssicherung durch automatisiertes Durchsetzen von Richtlinien und Namenskonventionen mittels AspectJ
- Performanceoptimierung durch Implementierung von Pooling- und Caching-Mechanismen
- Verbesserung von Design-Patterns (Singleton, Observer) und Erleichterung von Unit-Tests durch virtuelle Mock-Objekte
Auszug aus dem Buch
1.7.1 Schnittpunkte (engl. pointcuts)
Webepunkte, auch „join points“ genannt, sind eindeutige Punkte im Programmablauf, an denen durch den Compiler zusätzliche Anweisungen eingefügt werden können. Ein Webepunkt könnte ein Methoden- oder Konstruktoraufruf, der Zugriff auf eine Variable oder die Initialisierung einer Klasse sein.
Mehrere Webepunkte werden zu so genannten Schnittpunkten, im Englischen auch „pointcuts“ genannt, zusammengefasst. Schnittpunkte selektieren mit einer Art Abfragesprache eine Menge von Webepunkten. Ein Beispiel für solch eine Auswahl von Webepunkte wäre: „Alle Variablenzugriffe in allen Klassen, die mit ‚EJB’ enden, jedoch nicht im Package com.mybank.konto.“
Die Syntax für die Definition eines Poincuts in AspectJ lautet:
[abstract] [Modifikator] pointcut Bezeichnung ([Parameter]) : Pointcut-Typ;
Mögliche Pointcut Typen in AspectJ sind das Aufrufen oder Ausführen einer Methode (call, execution), der Zugriff auf Variablen (get, set), Ausnahmebehandlung (handler), das Ausführen von Aspektcode (adviceexecution) oder die Initialisierung von Klassen und Variablen (staticinitialization, initialization, preinitialization). Weiterhin existieren so genannte strukturbasierte Pointcuts, mit denen es möglich ist, bestimmte Bereiche auszuwählen, wie z.B. den Code innerhalb eines bestimmten Typs bzw. einer Klasse (within, withincode) oder innerhalb eines Schnittpunktes (cflow, cflowbelow). Auch ist es möglich, den Typ der Klassen oder Methodenparameter (this, target, args) zu bestimmen.
Zusammenfassung der Kapitel
Kapitel 1: Einführung: Definiert die Grundlagen von AOP im Gegensatz zu OOP und stellt AspectJ als Werkzeug zur Kapselung von querschneidenden Anforderungen vor.
Kapitel 2: Die Anwengung - iPad: Beschreibt das Design und die Architektur der im Rahmen der Arbeit entwickelten Beispielanwendung im J2EE-Umfeld.
Kapitel 3: Tracing und Logging: Erläutert den Einsatz von AOP zur Kapselung von Logging-Logik, um den Geschäfts-Quellcode sauber zu halten.
Kapitel 4: Qualitätssicherung: Demonstriert, wie AspectJ genutzt werden kann, um Compiler-Regeln für Best-Practices, EJB-Konventionen und Architekturvorgaben durchzusetzen.
Kapitel 5: Pooling und Caching: Zeigt die Implementierung von Performanceoptimierungen mittels AOP, insbesondere für Thread-Pools und Caching-Strategien.
Kapitel 6: Design Patterns: Analysiert, wie Design Patterns wie Singleton und Observer durch AOP flexibler und weniger fehleranfällig umgesetzt werden können.
Kapitel 7: Testen mit AspectJ: Untersucht Strategien, um Unit-Tests zu erleichtern, wie etwa den Zugriff auf private Variablen oder die Erstellung virtueller Mock-Objekte.
Kapitel 8: Fazit: Zieht Bilanz über die Praxistauglichkeit der AOP-Technologie und gibt einen Ausblick auf ihre zukünftige Bedeutung.
Schlüsselwörter
Aspektorientierte Programmierung, AspectJ, J2EE, Software-Architektur, Qualitätssicherung, Logging, Tracing, Pooling, Caching, Design Patterns, Unit-Tests, Mock-Objekte, Compiler-Regeln, Java, Anwendungsentwicklung.
Häufig gestellte Fragen
Worum geht es in dieser Arbeit grundsätzlich?
Die Arbeit untersucht die Praxistauglichkeit der aspektorientierten Programmierung (AOP) mit Java am Beispiel einer konkreten J2EE-Anwendung.
Was sind die zentralen Themenfelder?
Die Themen umfassen die logische Trennung von Geschäftslogik und technischen Anforderungen wie Logging, Qualitätssicherung, Performanceoptimierung und vereinfachtes Testen.
Was ist das primäre Ziel der Arbeit?
Das Ziel ist es zu evaluieren, ob AOP eine sinnvolle Ergänzung zur objektorientierten Programmierung darstellt, um Modularität und Wartbarkeit zu erhöhen.
Welche wissenschaftliche Methode wird verwendet?
Die Arbeit basiert auf einem experimentellen Ansatz, bei dem eine Beispielanwendung unter Einsatz verschiedener AOP-Konzepte implementiert und mit traditionellen Java-Lösungen verglichen wird.
Was wird im Hauptteil behandelt?
Der Hauptteil gliedert sich in Anwendungsbeispiele für Logging, Architekturvorgaben, Performanceoptimierungen durch Caching/Pooling, Erweiterungen von Design Patterns und den Einsatz von AspectJ in der Testphase.
Welche Schlüsselwörter charakterisieren die Arbeit?
Die zentralen Schlagworte sind Aspektorientierte Programmierung, AspectJ, J2EE, Qualitätssicherung und Software-Architektur.
Wie trägt AOP konkret zur Qualitätssicherung bei?
AOP ermöglicht es, Architekturregeln, EJB-Spezifikationen oder Namenskonventionen direkt als Compiler-Warnungen oder -Fehler zu definieren, wodurch Verstöße schon während der Kompilierung erkannt werden.
Inwiefern unterscheidet sich die AOP-Lösung für das Singleton-Pattern von der klassischen Variante?
Während klassische Singletons den Zugriff über eine statische Methode erzwingen, erlaubt AOP das Singleton-Verhalten auf Klassen anzuwenden, ohne deren bestehenden Code ändern zu müssen, indem Konstruktoraufrufe abgefangen werden.
- Quote paper
- Eduard Hildebrandt (Author), 2005, Aspektorientierte Programmierung mit Java gezeigt am Beispiel einer konkreten Anwendung, Munich, GRIN Verlag, https://www.grin.com/document/36518
