Software modular bauen - Architektur von langlebigen Softwaresystemen - Grundlagen und Anwendung mit OSGi und Java

Inhaltsverzeichnis

1 Einleitung

1.1 Über dieses Buch

1.1.1 Zielgruppe

1.1.2 Aufbau

1.1.3 Herangehensweise

1.2 Motivation

1.3 Nachstellen der Beispiele

1.3.1 Voraussetzungen

1.3.2 Synchronisieren von Projekten

1.3.3 Ausführen der Projekte

1.4 Regeln

2 Grundlagen

2.1 Definitionen

2.2 Grundthese

2.2.1 Komponenten und Module

2.2.2 Selbstähnlichkeit von Architektur

2.2.3 Schnittstelle und Implementierung

2.3 Prinzipien und Konzepte

2.4 Modularity Patterns

2.4.1 Modularity Patterns in der Coding-Architektur

2.4.2 Modularity Patterns in der Komponentenarchitektur

2.4.3 Modularity Patterns in der Systemarchitektur

2.5 Vorgehen zur Definition modularer Architektur

2.5.1 Anforderungsanalyse

2.5.2 Sichten

2.5.3 Vorgehensmodelle während der Entwicklung

2.6 Modularitätsmodell (Modularity Maturity Model)

3 Coding-Architektur: Erweiterbarkeit

3.1 Hintergrund von Coding Best Practices

3.1.1 Design Patterns

3.1.2 SOLID

3.1.3 Modularity Patterns in diesem Kapitel

3.2 Beschreibung des Anwendungsbeispiels

3.3 Factory Pattern

3.3.1 Umsetzung im Beispiel

3.4 Decision Map

3.4.1 Umsetzung im Beispiel

3.4.2 Cyclomatic Complexity

3.5 Single Responsibility

3.5.1 Umsetzung im Beispiel

3.6 Nachstellen des Beispiels

3.7 Exkurs: Adapter und Facade

3.7.1 Facade in Coding

3.7.2 Traditionelle Adapter

3.7.3 Modulare Adapter im Coding

3.7.4 Nachstellen des Beispiels

3.8 Zusammenfassung

4 Komponentenarchitektur: Grundlagen

4.1 Hintergrund eines modularen Laufzeitsystems

4.1.1 Module

4.1.2 Services zur Kommunikation

4.1.3 Zusammenspiel von Modulen und Services

4.1.4 Kohäsion

4.1.5 Modulare Laufzeitsysteme im Vergleich

4.1.6 Modularity Patterns in diesem Kapitel

4.2 Umsetzung der Grundkonzepte am Beispiel OSGi

4.2.1 Moduldefinition

4.2.2 Sichtbarkeit von Klassen

4.2.3 Services

4.2.4 Versionierung von Bundles

4.3 Auswirkungen eines modularen Laufzeitsystems auf Patterns

4.3.1 Facade

4.3.2 Adapter

4.4 Umsetzung von Modularität in verschiedenen Laufzeitumgebungen

4.4.1 Eingebettete OSGi-Container

4.4.2 Eigenständiger OSGi-Container

4.4.3 Vergleich

4.5 Modularisierung durch Refactoring

4.5.1 Kohäsion am Refactoring-Beispiel

4.6 Zusammenfassung

5 Komponentenarchitektur: Entkopplung

5.1 Hintergrund modularisierter Software

5.1.1 Schnittstelle von Modulen

5.1.2 Dependency Injection

5.1.3 Modularität ohne Schnittstellen

5.1.4 Modularity Patterns in diesem Kapitel

5.2 Grundlagen von Declarative Services

5.2.1 Declarative Services als Dependency-Injection-Framework

5.3 Entkopplung in der Beispielanwendung

5.3.1 Entkopplung der Datenquellen

5.3.2 Nachstellen des Beispiels

5.3.3 Laufzeitdynamik von Datenquellen

5.4 Exkurs: Zwei weitere SOLID-Prinzipien

5.4.1 Single-Responsibility-Prinzip für Module

5.4.2 Open-Closed-Prinzip für Module

5.5 Hierarchien in der Beispielanwendung

5.6 Schnittstellen in Modulen

5.7 Zusammenfassung

6 Systemarchitektur: Schichten

6.1 Hintergrund von Schichten in der Architektur

6.1.1 Schichtenarchitektur

6.1.2 Schichten in den Ebenen der Architektur

6.1.3 Modularity Patterns in diesem Kapitel

6.2 Entkoppelte Komponenten in der Beispielanwendung

6.2.1 Arbeit mit der OSGi Service Registry

6.2.2 Nachstellen des Beispiels

6.3 Gruppierung von Bundles

6.3.1 Eclipse Feature

6.3.2 Application im Apache-Aries-Projekt

6.3.3 OSGi-Subsystem-Spezifikation

6.3.4 Vergleich

6.4 Schichtenarchitektur mit OSGi

6.4.1 Arten der Abhängigkeiten zwischen Schichten

6.4.2 Schichten in der Beispielanwendung

6.4.3 Data Transfer Objects (DTO) in den Schichten

6.4.4 Testen der einzelnen Schichten

6.5 Exkurs: Testbarkeit

6.5.1 Prinzip: Dependency Injection

6.5.2 Prinzip: Vermeidung von globalem Zustand

6.5.3 Prinzip: Law of Demeter

6.6 Zusammenfassung

7 Systemarchitektur: Erweiterbarkeit

7.1 Hintergrund von Schnittstellen

7.1.1 Schnittstellendesign

7.1.2 Ersetzbarkeit

7.1.3 Modularity Patterns in diesem Kapitel

7.2 Schnittstellen in der Beispielanwendung

7.2.1 Beispiel des API-Designs

7.2.2 Anwendung auf OSGi

7.3 Erweiterung der Schnittstellen

7.3.1 Abstrakte Klassen

7.3.2 Data Transfer Object (DTO)

7.3.3 Schnittstellenevolution

7.3.4 Unterschiede zwischen API- und SPI-Evolution

7.4 Erweiterbarkeit mit OSGi

7.4.1 Design von Schnittstellen in Modulen

7.5 Ersetzbarkeit von Implementierungen

7.6 Kohäsion in der Beispielanwendung

7.7 Zusammenfassung

8 Systemarchitektur: Wiederverwendbarkeit entkoppelter Komponenten

8.1 Hintergrund entkoppelter wiederverwendbarer Komponenten

8.1.1 Abhängigkeiten zu externen Komponenten

8.1.2 Gemeinsam genutzte Aspekte

8.1.3 Modularity Patterns in diesem Kapitel

8.2 Entkopplung von externen Abhängigkeiten

8.2.1 Ein Adapter für eine externe Komponente in der Beispielanwendung

8.2.2 Weiterentwicklung mit externen Komponenten

8.2.3 Nachstellen des Beispiels

8.3 Gemeinsam genutzte Aspekte

8.3.1 Validierung

8.3.2 Transaktionen

8.4 Zusammenfassung

9 Systemarchitektur: Funktionale Entkopplung

9.1 Hintergrund funktionaler Entkopplung

9.1.1 Parallele Verarbeitung im System

9.1.2 Versionierung von Modulen

9.1.3 Modularity Patterns in diesem Kapitel

9.2 Parallele Verarbeitung in der Beispielanwendung

9.2.1 Nachrichtenbasierte Verarbeitung

9.2.2 Nachstellen des Beispiels

9.2.3 Exkurs: Weitere Konzepte der parallelen Verarbeitung

9.3 Versionierung in der Beispielanwendung

9.3.1 Neue Implementierungen

9.3.2 Änderungen an einer Schnittstelle

9.3.3 Umsetzung im Projekt

9.3.4 Vorteile der Versionierung

9.3.5 Nachstellen des Beispiels

9.4 Zusammmenfassung

10 Komponentenarchitektur: Frameworks

10.1 Hintergrund der Frameworks

10.1.1 Geschichte der Frameworks

10.1.2 Frameworks für Dependency Injection

10.1.3 Java EE

10.1.4 Maven

10.1.5 Vergleich der Frameworks bezüglich Modularität

10.2 Umsetzung der Beispielanwendung mit CDI

10.2.1 Struktur der Beispielanwendung

10.2.2 Anpassungen an Weld

10.3 Umsetzung der Beispielanwendung mit Spring

10.3.1 Struktur der Beispielanwendung mit Spring

10.4 Umsetzung der Beispielanwendung mit Maven

10.5 Nachstellen des Beispiels

10.6 Exkurs: Verwendung von OSGi

10.6.1 Eclipse

10.6.2 JBoss Application Server

10.6.3 GlassFish

10.6.4 IBM WebSphere

10.7 Zusammenfassung

11 Systemarchitektur: Product Line Engineering

11.1 Hintergrund zu Product Line Engineering

11.1.1 Domänen- und Anwendungsentwicklung

11.1.2 Variabilität

11.1.3 Variabilität und Schnittstellen

11.2 Anwendung von PLE auf die Beispielanwendung

11.2.1 OSGi und PLE

11.2.2 Core Assets in OSGi

11.2.3 Variabilität in OSGi – Extension Point

11.2.4 Variabilität in OSGi – Konfiguration

11.2.5 Variabilität in OSGi – DSL

11.3 Mehrere Produkte

11.4 Nachstellen des Beispiels

11.5 Zusammenfassung

12 Systemarchitektur: Repository

12.1 Hintergrund von Repositories

12.1.1 Anwendungsfälle für ein Repository

12.1.2 Modularity Patterns in diesem Kapitel

12.2 Ein Repository für OSGi

12.2.1 Verwendung von p2 in Eclipse

12.3 Das p2-Repository für die Beispielanwendung

12.3.1 Abhängigkeiten zwischen Features

12.3.2 Eclipse-Support für Update-Site und Features

12.4 Verschiedene Einsatzmöglichkeiten

12.4.1 Verwendung von p2 per API

12.5 Maven-Repository

12.6 Zusammenfassung

13 Schlusswort

13.1 Zusammenfassung

13.1.1 Anwendung der Modularitätsstufen

13.1.2 Einordnung von OSGi bezüglich Produktivität

13.2 Ausblick

A Appendix A: Tools zur Architekturvalidierung

A.1 Korrektheit

A.1.1 FindBugs

A.1.2 PMD

A.2 Metriken

A.2.1 Eclipse Metrics

A.3 Redundanz

A.3.1 CPD

B Appendix B: Projekt Jigsaw

B.1 Designprinzipien

B.2 Definitionen

B.2.1 Modul

B.2.2 Auflösung

B.2.3 Phasen

B.3 Moduldeklaration

B.3.1 Exports

B.3.2 Abhängigkeiten

B.3.3 Services

B.4 Vergleich mit OSGi

C Appendix C: OSGi in der Praxis

C.1 Lifecycle von Bundles

C.2 Statusinformationen eines OSGi-Laufzeitsystems

Referenzen

Index

A

B

C

D

E

F

G

I

J

K

L

M

N

O

P

R

S

T

V

www.dpunkt.de