O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Software modular bauen

Book Description

  • Praktische Umsetzung von Architekturprinzipien

Table of Contents

  1. Cover
  2. Titel
  3. Impressum
  4. Hingabe
  5. Inhaltsverzeichnis
  6. 1 Einleitung
    1. 1.1 Über dieses Buch
      1. 1.1.1 Zielgruppe
      2. 1.1.2 Aufbau
      3. 1.1.3 Herangehensweise
    2. 1.2 Motivation
    3. 1.3 Nachstellen der Beispiele
      1. 1.3.1 Voraussetzungen
      2. 1.3.2 Synchronisieren von Projekten
      3. 1.3.3 Ausführen der Projekte
    4. 1.4 Regeln
  7. 2 Grundlagen
    1. 2.1 Definitionen
    2. 2.2 Grundthese
      1. 2.2.1 Komponenten und Module
      2. 2.2.2 Selbstähnlichkeit von Architektur
        1. 2.2.2.1 Einfachheit versus Erweiterbarkeit und Entkopplung
      3. 2.2.3 Schnittstelle und Implementierung
    3. 2.3 Prinzipien und Konzepte
      1. Design Patterns
      2. SOLID
      3. Module
      4. Services
      5. Schnittstelle
      6. Dependency Injection
      7. Schichten
      8. Gemeinsam genutzte Komponenten
      9. Entkopplung externer Komponenten
      10. Ersetzbarkeit
      11. Parallele Verarbeitung
      12. Versionierung
      13. Repository
      14. Assembly
    4. 2.4 Modularity Patterns
      1. 2.4.1 Modularity Patterns in der Coding-Architektur
      2. 2.4.2 Modularity Patterns in der Komponentenarchitektur
      3. 2.4.3 Modularity Patterns in der Systemarchitektur
    5. 2.5 Vorgehen zur Definition modularer Architektur
      1. 2.5.1 Anforderungsanalyse
      2. 2.5.2 Sichten
      3. 2.5.3 Vorgehensmodelle während der Entwicklung
    6. 2.6 Modularitätsmodell (Modularity Maturity Model)
      1. Level 1: Ad hoc
      2. Level 2: Module
      3. Level 3: Modularität
      4. Level 4: Lose Kopplung
      5. Level 5: Devolution
      6. Level 6: Dynamik
  8. 3 Coding-Architektur: Erweiterbarkeit
    1. 3.1 Hintergrund von Coding Best Practices
      1. 3.1.1 Design Patterns
      2. 3.1.2 SOLID
      3. 3.1.3 Modularity Patterns in diesem Kapitel
    2. 3.2 Beschreibung des Anwendungsbeispiels
    3. 3.3 Factory Pattern
      1. 3.3.1 Umsetzung im Beispiel
    4. 3.4 Decision Map
      1. 3.4.1 Umsetzung im Beispiel
      2. 3.4.2 Cyclomatic Complexity
    5. 3.5 Single Responsibility
      1. 3.5.1 Umsetzung im Beispiel
    6. 3.6 Nachstellen des Beispiels
    7. 3.7 Exkurs: Adapter und Facade
      1. 3.7.1 Facade in Coding
      2. 3.7.2 Traditionelle Adapter
      3. 3.7.3 Modulare Adapter im Coding
      4. 3.7.4 Nachstellen des Beispiels
    8. 3.8 Zusammenfassung
  9. 4 Komponentenarchitektur: Grundlagen
    1. 4.1 Hintergrund eines modularen Laufzeitsystems
      1. 4.1.1 Module
        1. 4.1.1.1 Implementierungen von modularen Laufzeitsystemen
      2. 4.1.2 Services zur Kommunikation
      3. 4.1.3 Zusammenspiel von Modulen und Services
      4. 4.1.4 Kohäsion
      5. 4.1.5 Modulare Laufzeitsysteme im Vergleich
        1. 4.1.5.1 Kriterien
        2. 4.1.5.2 Bewertung der Frameworks
          1. OSGi
          2. DLL/COM
          3. Shared Libraries
        3. 4.1.5.3 Abschließende Bewertung
      6. 4.1.6 Modularity Patterns in diesem Kapitel
    2. 4.2 Umsetzung der Grundkonzepte am Beispiel OSGi
      1. 4.2.1 Moduldefinition
      2. 4.2.2 Sichtbarkeit von Klassen
        1. 4.2.2.1 Bundles in einem OSGi-Laufzeitsystem
        2. 4.2.2.2 Abhängigkeiten von Bundles
        3. 4.2.2.3 Transitive Abhängigkeiten
      3. 4.2.3 Services
        1. 4.2.3.1 Dynamik in OSGi
      4. 4.2.4 Versionierung von Bundles
    3. 4.3 Auswirkungen eines modularen Laufzeitsystems auf Patterns
      1. 4.3.1 Facade
      2. 4.3.2 Adapter
    4. 4.4 Umsetzung von Modularität in verschiedenen Laufzeitumgebungen
      1. 4.4.1 Eingebettete OSGi-Container
      2. 4.4.2 Eigenständiger OSGi-Container
      3. 4.4.3 Vergleich
    5. 4.5 Modularisierung durch Refactoring
      1. 4.5.1 Kohäsion am Refactoring-Beispiel
    6. 4.6 Zusammenfassung
  10. 5 Komponentenarchitektur: Entkopplung
    1. 5.1 Hintergrund modularisierter Software
      1. 5.1.1 Schnittstelle von Modulen
      2. 5.1.2 Dependency Injection
      3. 5.1.3 Modularität ohne Schnittstellen
        1. 5.1.3.1 Linken
        2. 5.1.3.2 Classloading
      4. 5.1.4 Modularity Patterns in diesem Kapitel
    2. 5.2 Grundlagen von Declarative Services
      1. 5.2.1 Declarative Services als Dependency-Injection-Framework
    3. 5.3 Entkopplung in der Beispielanwendung
      1. 5.3.1 Entkopplung der Datenquellen
      2. 5.3.2 Nachstellen des Beispiels
      3. 5.3.3 Laufzeitdynamik von Datenquellen
    4. 5.4 Exkurs: Zwei weitere SOLID-Prinzipien
      1. 5.4.1 Single-Responsibility-Prinzip für Module
      2. 5.4.2 Open-Closed-Prinzip für Module
    5. 5.5 Hierarchien in der Beispielanwendung
    6. 5.6 Schnittstellen in Modulen
    7. 5.7 Zusammenfassung
  11. 6 Systemarchitektur: Schichten
    1. 6.1 Hintergrund von Schichten in der Architektur
      1. 6.1.1 Schichtenarchitektur
      2. 6.1.2 Schichten in den Ebenen der Architektur
      3. 6.1.3 Modularity Patterns in diesem Kapitel
    2. 6.2 Entkoppelte Komponenten in der Beispielanwendung
      1. 6.2.1 Arbeit mit der OSGi Service Registry
      2. 6.2.2 Nachstellen des Beispiels
    3. 6.3 Gruppierung von Bundles
      1. 6.3.1 Eclipse Feature
      2. 6.3.2 Application im Apache-Aries-Projekt
      3. 6.3.3 OSGi-Subsystem-Spezifikation
      4. 6.3.4 Vergleich
    4. 6.4 Schichtenarchitektur mit OSGi
      1. 6.4.1 Arten der Abhängigkeiten zwischen Schichten
        1. 6.4.1.1 Reflection in Schichten
        2. 6.4.1.2 Strings in Schichten
      2. 6.4.2 Schichten in der Beispielanwendung
      3. 6.4.3 Data Transfer Objects (DTO) in den Schichten
      4. 6.4.4 Testen der einzelnen Schichten
        1. 6.4.4.1 Komplexität und Testbarkeit
    5. 6.5 Exkurs: Testbarkeit
      1. 6.5.1 Prinzip: Dependency Injection
      2. 6.5.2 Prinzip: Vermeidung von globalem Zustand
      3. 6.5.3 Prinzip: Law of Demeter
    6. 6.6 Zusammenfassung
  12. 7 Systemarchitektur: Erweiterbarkeit
    1. 7.1 Hintergrund von Schnittstellen
      1. 7.1.1 Schnittstellendesign
        1. 7.1.1.1 Prinzipien
        2. 7.1.1.2 Kompatibilität
          1. Lebenszyklus
          2. Versionierung
        3. 7.1.1.3 Regeln
          1. Bevorzugung von Interfacetypen
          2. Spezifische Typen verwenden
          3. Methodendesign
      2. 7.1.2 Ersetzbarkeit
      3. 7.1.3 Modularity Patterns in diesem Kapitel
    2. 7.2 Schnittstellen in der Beispielanwendung
      1. 7.2.1 Beispiel des API-Designs
      2. 7.2.2 Anwendung auf OSGi
        1. 7.2.2.1 API in der Anwendung
        2. 7.2.2.2 SPI und Microkernel
    3. 7.3 Erweiterung der Schnittstellen
      1. 7.3.1 Abstrakte Klassen
      2. 7.3.2 Data Transfer Object (DTO)
      3. 7.3.3 Schnittstellenevolution
      4. 7.3.4 Unterschiede zwischen API- und SPI-Evolution
    4. 7.4 Erweiterbarkeit mit OSGi
      1. 7.4.1 Design von Schnittstellen in Modulen
        1. 7.4.1.1 API in OSGi
        2. 7.4.1.2 SPI in OSGi
    5. 7.5 Ersetzbarkeit von Implementierungen
      1. Nachstellen des Beispiels
    6. 7.6 Kohäsion in der Beispielanwendung
    7. 7.7 Zusammenfassung
  13. 8 Systemarchitektur: Wiederverwendbarkeit entkoppelter Komponenten
    1. 8.1 Hintergrund entkoppelter wiederverwendbarer Komponenten
      1. 8.1.1 Abhängigkeiten zu externen Komponenten
      2. 8.1.2 Gemeinsam genutzte Aspekte
        1. 8.1.2.1 Aspektorientierte Programmierung
      3. 8.1.3 Modularity Patterns in diesem Kapitel
    2. 8.2 Entkopplung von externen Abhängigkeiten
      1. 8.2.1 Ein Adapter für eine externe Komponente in der Beispielanwendung
      2. 8.2.2 Weiterentwicklung mit externen Komponenten
      3. 8.2.3 Nachstellen des Beispiels
        1. 8.2.3.1 Füllen der Datenbank
        2. 8.2.3.2 Erweiterung der Beispielanwendung um eine Datenquelle
    3. 8.3 Gemeinsam genutzte Aspekte
      1. 8.3.1 Validierung
        1. 8.3.1.1 Einschränkungen bezüglich DTOs
      2. 8.3.2 Transaktionen
    4. 8.4 Zusammenfassung
  14. 9 Systemarchitektur: Funktionale Entkopplung
    1. 9.1 Hintergrund funktionaler Entkopplung
      1. 9.1.1 Parallele Verarbeitung im System
        1. 9.1.1.1 Exkurs: Kommandopatterns
        2. 9.1.1.2 Nachrichtenverarbeitung
        3. 9.1.1.3 Staged Event Driven Architecture (SEDA)
      2. 9.1.2 Versionierung von Modulen
        1. 9.1.2.1 Versionierungskonzept
          1. Version
          2. Versionsabhängigkeiten
      3. 9.1.3 Modularity Patterns in diesem Kapitel
    2. 9.2 Parallele Verarbeitung in der Beispielanwendung
      1. 9.2.1 Nachrichtenbasierte Verarbeitung
      2. 9.2.2 Nachstellen des Beispiels
      3. 9.2.3 Exkurs: Weitere Konzepte der parallelen Verarbeitung
        1. 9.2.3.1 Aktoren
        2. 9.2.3.2 Map and Reduce
    3. 9.3 Versionierung in der Beispielanwendung
      1. 9.3.1 Neue Implementierungen
      2. 9.3.2 Änderungen an einer Schnittstelle
        1. 9.3.2.1 Austausch eines API
        2. 9.3.2.2 Gleichzeitige Benutzung des alten und des neuen API
        3. 9.3.2.3 Austausch eines SPI
        4. 9.3.2.4 Gleichzeitige Benutzung des alten und des neuen SPI
      3. 9.3.3 Umsetzung im Projekt
      4. 9.3.4 Vorteile der Versionierung
      5. 9.3.5 Nachstellen des Beispiels
    4. 9.4 Zusammmenfassung
  15. 10 Komponentenarchitektur: Frameworks
    1. 10.1 Hintergrund der Frameworks
      1. 10.1.1 Geschichte der Frameworks
      2. 10.1.2 Frameworks für Dependency Injection
        1. 10.1.2.1 Spring
        2. 10.1.2.2 CDI
      3. 10.1.3 Java EE
      4. 10.1.4 Maven
      5. 10.1.5 Vergleich der Frameworks bezüglich Modularität
        1. 10.1.5.1 Kriterien
        2. 10.1.5.2 Bewertung der Frameworks
          1. OSGi
          2. Spring
          3. CDI
          4. Java EE 5
          5. Maven
        3. 10.1.5.3 Zusammenfassende Bewertung
    2. 10.2 Umsetzung der Beispielanwendung mit CDI
      1. 10.2.1 Struktur der Beispielanwendung
      2. 10.2.2 Anpassungen an Weld
        1. 10.2.2.1 Injizieren der Services
        2. 10.2.2.2 Erweiterungen in CDI
    3. 10.3 Umsetzung der Beispielanwendung mit Spring
      1. 10.3.1 Struktur der Beispielanwendung mit Spring
        1. 10.3.1.1 Injizieren der Services
        2. 10.3.1.2 Erweiterungen in Spring
        3. 10.3.1.3 Darstellung von Abhängigkeiten
    4. 10.4 Umsetzung der Beispielanwendung mit Maven
    5. 10.5 Nachstellen des Beispiels
    6. 10.6 Exkurs: Verwendung von OSGi
      1. 10.6.1 Eclipse
      2. 10.6.2 JBoss Application Server
      3. 10.6.3 GlassFish
      4. 10.6.4 IBM WebSphere
    7. 10.7 Zusammenfassung
  16. 11 Systemarchitektur: Product Line Engineering
    1. 11.1 Hintergrund zu Product Line Engineering
      1. 11.1.1 Domänen- und Anwendungsentwicklung
      2. 11.1.2 Variabilität
        1. 11.1.2.1 Variabilitätsklassen
      3. 11.1.3 Variabilität und Schnittstellen
    2. 11.2 Anwendung von PLE auf die Beispielanwendung
      1. 11.2.1 OSGi und PLE
      2. 11.2.2 Core Assets in OSGi
      3. 11.2.3 Variabilität in OSGi - Extension Point
      4. 11.2.4 Variabilität in OSGi - Konfiguration
      5. 11.2.5 Variabilität in OSGi - DSL
    3. 11.3 Mehrere Produkte
    4. 11.4 Nachstellen des Beispiels
    5. 11.5 Zusammenfassung
  17. 12 Systemarchitektur: Repository
    1. 12.1 Hintergrund von Repositories
      1. 12.1.1 Anwendungsfälle für ein Repository
      2. 12.1.2 Modularity Patterns in diesem Kapitel
    2. 12.2 Ein Repository für OSGi
      1. 12.2.1 Verwendung von p2 in Eclipse
    3. 12.3 Das p2-Repository für die Beispielanwendung
      1. 12.3.1 Abhängigkeiten zwischen Features
      2. 12.3.2 Eclipse-Support für Update-Site und Features
    4. 12.4 Verschiedene Einsatzmöglichkeiten
      1. 12.4.1 Verwendung von p2 per API
    5. 12.5 Maven-Repository
    6. 12.6 Zusammenfassung
  18. 13 Schlusswort
    1. 13.1 Zusammenfassung
      1. 13.1.1 Anwendung der Modularitätsstufen
        1. Einfache Anwendung
        2. Einteilung in Module zur Strukturierung
        3. Erweiterbarkeit der Implementierung
        4. Bereitstellen von Komponenten
        5. Mehrere Versionen innerhalb eines Laufzeitsystems
        6. Aktualisierung von Modulen während des Betriebs
      2. 13.1.2 Einordnung von OSGi bezüglich Produktivität
    2. 13.2 Ausblick
  19. A Appendix A: Tools zur Architekturvalidierung
    1. A.1 Korrektheit
      1. A.1.1 FindBugs
      2. A.1.2 PMD
    2. A.2 Metriken
      1. A.2.1 Eclipse Metrics
    3. A.3 Redundanz
      1. A.3.1 CPD
  20. B Appendix B: Projekt Jigsaw
    1. B.1 Designprinzipien
    2. B.2 Definitionen
      1. B.2.1 Modul
      2. B.2.2 Auflösung
      3. B.2.3 Phasen
    3. B.3 Moduldeklaration
      1. B.3.1 Exports
      2. B.3.2 Abhängigkeiten
      3. B.3.3 Services
    4. B.4 Vergleich mit OSGi
  21. C Appendix C: OSGi in der Praxis
    1. C.1 Lifecycle von Bundles
    2. C.2 Statusinformationen eines OSGi-Laufzeitsystems
  22. Referenzen
  23. Index