Softwarearchitektur für die Praxis

430 Pages·2003·4.064 MB·German

by  Jürgen Dunkel, Andreas Holitschke (auth.)

(cid:2)(cid:3)(cid:4)(cid:5)(cid:6)(cid:7)(cid:8)(cid:4)(cid:9)(cid:10)(cid:8)(cid:4)(cid:11)(cid:12)(cid:7)(cid:13)(cid:14)(cid:8)(cid:4)(cid:11)(cid:5)(cid:6)(cid:13)(cid:15)(cid:8)(cid:5)(cid:16)(cid:8)(cid:11)(cid:17)(cid:8)(cid:4)(cid:7)(cid:13)(cid:18)(cid:19)(cid:17)(cid:15)
Die Reihe Xpert.pressdes Springer-Verlags
vermittelt Professionals in den Bereichen
Betriebs- und Informationssysteme,Software
Engineering und Programmiersprachen aktuell
und kompetent relevantes Fachwissen über
Technologien und Produkte zur Entwicklung
und Anwendung moderner Informations-
technologien.
Jürgen Dunkel • Andreas Holitschke
Softwarearchitektur
für die Praxis
Mit 186 Abbildungen
1 3
Jürgen Dunkel
Andreas Holitschke
FH Hannover
FB Informatik
Ricklinger Stadtweg 120
30459 Hannover
{juergen.dunkel,andreas.holitschke}@inform.fh-hannover.de
Bibliografische Information Der Deutschen Bibliothek
Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen
Nationalbibliografie;detaillierte bibliografische Daten sind im Internet über
<http://dnb.ddb.de>abrufbar.
ISSN 1439-5428
ISBN 978-3-642-62433-9 ISBN 978-3-642-55552-7 (eBook)
DOI 10.1007/978-3-642-55552-7
Dieses Werk ist urheberrechtlich geschützt. Die dadurch begründeten
Rechte,insbesondere die der Übersetzung,des Nachdrucks,des Vortrags,
der Entnahme von Abbildungen und Tabellen, der Funksendung, der
Mikroverfilmung oder der Vervielfältigung auf anderen Wegen und der
Speicherung in Datenverarbeitungsanlagen,bleiben,auch bei nur auszugs-
weiser Verwertung,vorbehalten.Eine Vervielfältigung dieses Werkes oder
von Teilen dieses Werkes ist auch im Einzelfall nur in den Grenzen der
gesetzlichen Bestimmungen des Urheberrechtsgesetzes der Bundesrepu-
blik Deutschland vom 9.September 1965 in der jeweils geltenden Fassung
zulässig. Sie ist grundsätzlich vergütungspflichtig. Zuwiderhandlungen
unterliegen den Strafbestimmungen des Urheberrechtsgesetzes.
http://www.springer.de
© Springer-Verlag Berlin Heidelberg 2003
Ursprü+nglich e+rschienen b+ei Springer-Verlag Be rlin He idelberg New York 2003
(cid:2)$%&’$((cid:8)(cid:4)(cid:13)(cid:4)(cid:8)(cid:3)(cid:4)(cid:5)(cid:6)&(cid:13)$%(cid:13)&)(cid:8)(cid:13))(cid:12)(cid:4)(cid:16)’$((cid:8)(cid:4)(cid:13) *&(cid:13)(cid:8)(cid:16)(cid:5)&(cid:5)$(cid:6)2003
Die Wiedergabe von Gebrauchsnamen,Handelsnamen,Warenbezeichnu-
ngen usw.in diesem Werk berechtigt auch ohne besondere Kennzeichnung
nicht zu der Annahme,daß solche Namen im Sinne der Warenzeichen- und
Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von
jedermann benutzt werden dürften.
Umschlaggestaltung:KünkelLopka Werbeagentur,Heidelberg
Satz:Word-Daten vom Autor,Belichtung:perform,Heidelberg
Vorwort
Eine Softwarearchitektur legt die wesentlichen Strukturen eines
Softwaresystems fest und ist die Grundlage der gesamten System-
entwicklung. Sie kann somit als Bauplan verstanden werden, der die
Entwicklung komplexer und umfangreicher Software erst ermög-
licht.
Dieses Buch bietet eine fundierte Einführung in die Architektur Leserkreis
großer Softwaresysteme.Es richtet sich gleichermaßen an Software-
entwickler, Studierende und Entscheidungsträger, die die grundle-
genden Konzepte moderner Softwarearchitektur, aber auch deren
praktische Umsetzung verstehen möchten.
Besonders IT-Experten aus der Praxis können davon profitieren,
dass alle vorgestellten Konzepte konkret und vollständig realisiert
werden. Anhand eines durchgehenden Beispiels entstehen so Refe-
renzsysteme für verschiedene Architekturvarianten, die den Anfor-
derungen und Bedürfnissen der Leser anpasst werden können. Diese
Systeme sind einfach genug, um sie noch im Detail verstehen zu
können, aber auch ausreichend komplex, um die grundlegenden Me-
chanismen guter Softwarearchitekturen aufzuzeigen.
Um schrittweise in das Thema Softwarearchitektur einzuführen, ge- Ziele des Buchs
hen wir in folgender Weise vor:
■ Zunächst werden die gemeinsamen Grundprinzipien tragfähiger ...allgemeine
Softwarearchitekturen herausgearbeitet und allgemeine Leitli- Leitlinien
nien für die Entwicklung eines Softwaresystems vorgestellt.
Insbesondere diskutieren wir verteilte Mehrschichtenarchitektu-
ren und grenzen die drei Standardschichten gegeneinander ab:
Anwendungs-, Persistenz- und Präsentationsschicht.
■ Für jede Standardschicht werden die grundlegenden Entwurfs- ...Architektur-
ziele, Architekturkonzepte, Entwurfsmuster sowie mögliche konzepte
Fehler im Detail präsentiert. Diese konzeptionellen Vorüberle-
gungen bilden die Grundlage und den Ausgangspunkt einer
Implementierung.
■ Für die Entwicklung einer Softwarearchitektur reichen allge- ...Implementie-
meineKonzepte nicht aus, sondern diese müssen auch praktisch rungen
umgesetzt werden. Deshalb stellen wir anhand eines durchge-
Vorwort ■ V
■
■
henden Beispiels vollständige Implementierungen für verschie-
dene Softwarearchitekturen vor.
Dabei wird für die Persistenzschicht ein eigenes Framework
entwickelt oder Enterprise JavaBeans (EJB) eingesetzt.
Für die Präsentationsschicht stellen wir ein GUI-Framework auf
Basis von Java-Swing vor und realisieren eine Weboberfläche
mitJava ServerPages (JSP).
benötigtes Zum Verständnis des Buches sind Grundkenntnisse der Software-
Vorwissen entwicklung erforderlich. Insbesondere werden die Konzepte ob-
jektorientierter Programmierung vorausgesetzt, wie sie bspw. in
[Meye97] vermitteltwerden.
Zur Darstellung der Softwarearchitekturen werden Klassendia-
gramme in der UML-Notation (Unified Modeling Language) ver-
wendet, weshalb die Grundelemente der UML bekannt sein sollten.
Eine gute und knappe Einführung bieten [FoSc97] und [Oest97].
Weil die Implementierung der Architekturkonzepte in Java er-
folgt, sind Java-Basiskenntnisse hilfreich. Die Grundideen der Im-
plementierungen können aber auch auf Basis anderer
objektorientierter Programmiersprachen verstandenwerden.
In den einzelnen Kapiteln ist Grundwissen der Swing-Bibliothek
bzw. des Datenbankzugriffs mit JDBC hilfreich. Diese Konzepte
werden hier nur sehr knapp dargestellt, als vertiefende Literatur sei-
en bspw. [HoCo99], [HoCo00], und [FiSa99] empfohlen.
Hinweise zur Durch den modularen Aufbau des Buches können die verschiedenen
Nutzung Kapitel auch unabhängig voneinander gelesen werden.
Ein guter Startpunkt ist sicherlich der erste Teil mit einer allge-
meinen Einführung in die Softwarearchitektur. Jede einzelne Soft-
wareschicht kann dann getrennt voneinander betrachtet werden. Da-
bei sollte zunächst das Einführungskapitel mit den zentralen Ideen
und Konzepten durchgearbeitet werden. Anschließend kann dann die
Umsetzung einer konkreten Architekturvariante erarbeitet werden.
Mit welcher Intensität die Implementierungsbeispiele studiert
werden, hängt vom Interesse ab. Für einen ersten Überblick müssen
die Programmbeispiele nicht in allen Details verstanden werden.
Webseite zum Sämtliche Sourcen stehen auf der Webseite zum Buch unter
Buch www.inform.fh-hannover.de/softwarearchitektur zur Verfügung.
Um die vorgestellten Konzepte verstehen und verwenden zu kön-
nen, empfehlen wir sehr, mit demProgrammcode„herumzuspielen“
und ihn vielleicht durch eigene Ideen zu erweitern.
Der Programmcode auf der Webseite ist vollständig und ablauf-
fähig, außerdem finden sich dort weitere nützliche Informationen
sowie Installationshinweise.
VI ■ Vorwort
■
■
Beim Stand der Drucklegung wurden die Beispiele in Java mit
einer Oracle-Datenbank, einem Bea WebLogic 6.1 Applikations-
server und einer Apache Tomcat Servlet Engine erstellt. In Zukunft
sollen auch weitere Systeme unterstützt werden. Aktuelle Hinweise
dazu finden sich auf der Webseite.
Der Anstoß zu diesem Buch entstand aufgrund unserer Erfahrungen Historie und
am Fachbereich Informatik der Fachhochschule Hannover. Danksagung
Für viele Studierende bedeutet die Entwicklung der ersten größe-
ren Softwaresysteme einen schwierigen Schritt. Zwar kennen sie ei-
ne Programmiersprache und ggf. auch einige Entwurfsmuster, aber
sie wissen nicht, wie manSoftwaresystememitflexiblen und tragfä-
higen Strukturen entwickelt.
Wir hoffen, mit dem vorliegenden Buch diese Lücke etwas
schließen zu können und einen praktischen Leitfaden für die Ent-
wicklung eigener Softwarearchitekturen zu bieten.
Zum Schluss möchten wir unseren Studenten und Kollegen für
die vielen Diskussionen danken, die in dieses Buch eingegangen
sind. Ein besonderer Dank gilt unserem Kollegen Prof. Dr. Ralf
Bruns, der unser Buchprojekt kritisch begleitet und uns mit vielen
Anregungen und Hinweisen geholfen hat.
Hannover, April 2003 Jürgen Dunkel Andreas Holitschke
Vorwort ■ VII
■
■
Inhaltsverzeichnis
1 Softwarearchitektur....................................................................1
1.1 Charakterisierung von Softwarearchitektur.......................1
1.1.1 Definitionen..........................................................1
1.1.2 Softwarearchitektur und Komplexität..................2
1.1.3 Softwarearchitektur und Qualität.........................6
1.1.4 Softwarearchitektur und Projektorganisation......9
1.2 Architekturebenen............................................................11
1.2.1 Architekturbasis..................................................11
1.2.2 Makroarchitektur................................................12
1.2.3 Mikroarchitektur.................................................13
1.2.4 Technische Architektur......................................15
1.3 Logische Softwareschichten.............................................16
1.3.1 Schichten alsStrukturierungsprinzip.................16
1.3.2 Drei-Schichten-Architektur................................17
1.3.3 Bewertung der Drei-Schichten-Architektur.......19
1.4 Physikalische Verteilung..................................................20
1.4.1 Charakterisierung verteilter Systeme.................20
1.4.2 Schwer- und leichtgewichtige Klienten.............22
1.4.3 Standardarchitekturen für verteilte Systeme......24
1.4.4 Makroarchitektur für das Beispielsystem..........27
2 Konzepte für denEntwurf derAnwendungsschicht.............31
2.1 Entwurfsziele....................................................................31
2.1.1 Verantwortlichkeit der Anwendungsschicht.....32
2.1.2 Schnittstelle zur Präsentationsschicht................35
2.1.3 Schnittstelle zur Persistenzschicht.....................36
2.1.4 Anforderungen an die Architektur.....................39
Inhalt ■ IX
■
■
2.2 Entwurfsfehler.................................................................40
2.3 Grundlegende Entwurfsmuster........................................43
2.3.1 Singleton............................................................43
2.3.2 Fassade (Facade)................................................45
2.3.3 Fabrikmethode (Factory Method).....................47
3 Implementierung der Anwendungsschicht............................51
3.1 BeispielanwendungSamComm.......................................51
3.1.1 Anwendungsfälle...............................................51
3.1.2 Benutzungsoberfläche.......................................53
3.1.3 Verwendete Persistenzschichten.......................55
3.2 Klassenentwurf und Architektur.....................................55
3.3 Implementierungsaspekte................................................57
3.3.1 Fachliche Klassen..............................................57
3.3.2 Anpassung anverschiedene
Persistenzmechanismen.....................................63
3.4 Verwendete Entwurfsmuster...........................................70
4 Konzepte für den Entwurf der Persistenzschicht.................73
4.1 Transformation eines Klassenmodells in ein
Datenmodell.....................................................................74
4.1.1 Transformationsschritte.....................................75
4.1.2 Datenmodell des Beispielsystems.....................81
4.2 Entwurfsziele...................................................................83
4.2.1 Verantwortlichkeiten der Persistenzschicht......84
4.2.2 Sperrkonzepte....................................................92
4.2.3 Schnittstelle zur Anwendungsschicht...............96
4.2.4 Anforderungen an die Architektur..................101
4.3 Entwurfsfehler...............................................................102
4.4 Grundlegende Entwurfsmuster......................................105
4.4.1 Frameworks.....................................................106
4.4.2 Schablonenmethode(Template Method)........108
4.4.3 Fabrikmethode(Factory Method)...................111
4.4.4 Fassade (Facade).............................................111
4.4.5 Singleton..........................................................112
4.4.6 Proxy................................................................112
X ■ Inhalt
■
■
5 Persistenz-Framework............................................................115
5.1 Anwendungsentwicklungmit dem
Persistenz-Framework....................................................116
5.1.1 Framework-API................................................116
5.1.2 Anpassung der fachlichen Klassen..................118
5.1.3 O/R-Mapping....................................................119
5.1.4 Suchabfragen....................................................121
5.2 Framework-Architektur..................................................122
5.3 Framework-Implementierung........................................127
5.3.1 Persistent Interface...........................................127
5.3.2 Verwaltung des Objekt-Lebenszyklus.............128
5.3.3 Broker-Architektur...........................................131
5.3.4 Erzeugen derBroker-Klassen..........................143
5.3.5 Generieren vonOids.........................................145
5.3.6 Verwaltung von Datenbankverbindungen.......146
5.3.7 Transaktionen...................................................148
5.3.8 Beziehungen zwischenObjekten.....................154
5.4 Verwendete Entwurfsmuster..........................................164
5.4.1 Schablonenmethoden(Template Method).......164
5.4.2 Fabrikmethode(Factory Method)....................165
5.4.3 Fassade (Facade)..............................................166
5.4.4 Singleton...........................................................167
5.5 Implementierung des Beispielsystems...........................167
5.5.1 Anpassung der Entitätsklassen.........................168
5.5.2 Anpassung der Geschäftsprozess-Klassen.......169
5.5.3 O/R-Mapping....................................................171
5.6 Bewertung des Persistenz-Frameworks.........................173
6 Enterprise JavaBeans (EJB)..................................................175
6.1 J2EE-Architektur............................................................175
6.2 Objekt-Persistenz mit EJB.............................................179
6.3 AnwendungsentwicklungmitEJB.................................181
6.3.1 Session Beans...................................................182
6.3.2 Entity Beans......................................................195
6.3.3 Lebenszyklus vonEJB.....................................206
6.4 FortgeschritteneKonzepte..............................................210
Inhalt ■ XI
■
■