Aspektorientierte Programmierung mit Java gezeigt am Beispiel einer konkreten Anwendung

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

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.