Table Of ContentKarl-Heinz Rau
Thomas Schuster
Agile objektorientierte
Software-Entwicklung
Schritt für Schritt vom Geschäftsprozess
zum Java-Programm
2. Auflage
Agile objektorientierte Software-Entwicklung
Karl-Heinz Rau · Thomas Schuster
Agile objektorientierte
Software-Entwicklung
Schritt für Schritt vom Geschäftsprozess
zum Java-Programm
2., aktualisierte Auflage
Karl-Heinz Rau Thomas Schuster
Fakultät für Wirtschaft und Recht Fakultät für Wirtschaft und Recht
Hochschule Pforzheim Hochschule Pforzheim
Pforzheim, Deutschland Pforzheim, Deutschland
ISBN 978-3-658-33394-2 ISBN 978-3-658-33395-9 (eBook)
https://doi.org/10.1007/978-3-658-33395-9
Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie;
detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.
© Springer Fachmedien Wiesbaden GmbH, ein Teil von Springer Nature 2016, 2021
Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Jede Verwertung, die nicht
ausdrücklich vom Urheberrechtsgesetz zugelassen ist, bedarf der vorherigen Zustimmung des Verlags.
Das gilt insbesondere für Vervielfältigungen, Bearbeitungen, Übersetzungen, Mikroverfilmungen und die
Einspeicherung und Verarbeitung in elektronischen Systemen.
Die Wiedergabe von allgemein beschreibenden Bezeichnungen, Marken, Unternehmensnamen etc. in diesem
Werk bedeutet nicht, dass diese frei durch jedermann benutzt werden dürfen. Die Berechtigung zur Benutzung
unterliegt, auch ohne gesonderten Hinweis hierzu, den Regeln des Markenrechts. Die Rechte des jeweiligen
Zeicheninhabers sind zu beachten.
Der Verlag, die Autoren und die Herausgeber gehen davon aus, dass die Angaben und Informationen in
diesem Werk zum Zeitpunkt der Veröffentlichung vollständig und korrekt sind. Weder der Verlag noch
die Autoren oder die Herausgeber übernehmen, ausdrücklich oder implizit, Gewähr für den Inhalt des
Werkes, etwaige Fehler oder Äußerungen. Der Verlag bleibt im Hinblick auf geografische Zuordnungen und
Gebietsbezeichnungen in veröffentlichten Karten und Institutionsadressen neutral.
Planung/Lektorat: Sybille Thelen
Springer Vieweg ist ein Imprint der eingetragenen Gesellschaft Springer Fachmedien Wiesbaden GmbH und ist
ein Teil von Springer Nature.
Die Anschrift der Gesellschaft ist: Abraham-Lincoln-Str. 46, 65189 Wiesbaden, Germany
Vorwort Auflage 1
Das Ziel dieses Lehrbuchs ist, ein durchgängiges Konzept zur agil geprägten Ent-
wicklung objektorientierter Anwendungs-Lösungen vorzustellen. Ausgangspunkt ist der
Geschäftsprozess im Unternehmen, der durch Anwendungs-Software unterstützt bzw.
ermöglicht werden soll. Dem Leser werden Methoden und Vorgehensweisen vorgestellt,
die eine systematische Ableitung von Anforderungen erlauben. Mit Hilfe von Prinzipien
und insbesondere von Mustern sowie dem Architekturansatz einer Java EE-geprägten
Web-Anwendung wird mit unterschiedlichen Technologien lauffähige Software ent-
wickelt.
Die primäre Zielgruppe sind Studierende des Bachelor- oder Master-Studiums der
Wirtschaftsinformatik, die bereits über Grundlagenkenntnisse in Java-Programmierung,
Modellierung mit der Unified Modelling Language (UML) und Datenbanken verfügen.
Auch Praktiker, die sich in die agile objektorientierte Software-Entwicklung einarbeiten
wollen, sind angesprochen. Unweigerlich reflektiert die Auswahl und Darstellung
der Inhalte die Anschauung, Erfahrung und Meinung des Autors. Der Leser dieses
Buches darf vor diesem Hintergrund nicht erwarten, dass hinsichtlich der existierenden
Methoden, Vorgehensweisen und Technologien Vollständigkeit angestrebt wird. Viel-
mehr wurde eine Auswahl aktueller und bewährter Ansätze derart getroffen, dass sich der
Lernende mit einer durchgängigen Vorgehensweise vertraut machen kann.
Im Titel des Buches wird der Begriff „agil“ verwendet. Dabei stehen weder XP oder
Scrum im Mittelpunkt, sondern ganz bewusst wurde der Disciplined Agile Delivery
(DAD) Ansatz von Scott Ambler als Prozessmodell gewählt. Diesem Prozessmodell
liegen eine Vorbereitungs-, Entwicklungs- und Einführungsphase zugrunde. Diese sind
jedoch agil konzipiert, sodass die Werte und Prinzipien des Agilen Manifests voll zum
Tragen kommen. Zur Vermittlung der Inhalte liegt den Ausführungen ein durchgängiges
Beispiel aus dem Hochschulbereich zugrunde. An diesem werden nach Möglichkeit die
Methoden, Muster und Technologien angewandt.
Das didaktische Konzept geht davon aus, dass sich das Buch sowohl zum Selbst-
studium eignet, als auch mit einer Präsenzveranstaltung kombiniert werden kann.
Der Autor hat die besten Erfahrungen damit gemacht, dass die Studierenden jeweils
Kapitel bzw. Teile davon vor der Lehrveranstaltung lesen und damit bereits fachlich
V
VI Vorwort Auflage 1
gut vorbereitet in die Lehrveranstaltung kommen. In der Veranstaltung werden die
wichtigsten Inhalte dialogorientiert vertieft und an einem einfachen durchgängigen Bei-
spiel angewandt.
Lernzuwachs
Zeit
Phase 1: Phase 2: Phase 3:
Individuelles Lernen im Lernen in der
Lernen Unterricht Kleingruppe
Dreistufiges Lernmodell
Dem dreistufigen Lernmodell gemäß, bearbeiten die Studierenden begleitend zu den
Präsenzveranstaltungen eine überschaubar komplexe Projektaufgabe in Teams von zwei
bis maximal drei Studierenden. In dieser Phase werden den Studierenden viele Frage-
stellungen erst bewusst. Dabei dient das Buch als Nachschlagewerk. Bei diesem Vor-
gehen wird ein hohes Maß an Lernzuwachs erreicht und das Buch leistet in allen Phasen
seinen Beitrag.
Jedes Kapitel wird durch einen Überblick mit explizit formulierten Lernergebnissen
eingeleitet und mit einer Zusammenfassung sowie Wiederholungsfragen und Aufgaben
abgeschlossen. Damit ist der Lernende in der Lage, sein Wissen auch selbst zu prüfen.
In den Kapiteln 4 bis 8 werden sowohl Konzepte als auch das durchgängige Fallbeispiel
anhand von konkretem Java-Programmcode dargestellt. Ergänzend zu den abgedruckten
Listings wird der gesamte Programmcode über die Online-Materialien des Verlags
sowie über GitHub zum Herunterladen und mitmachen bereitgestellt. Wenn im Text auf
Elemente des Programmcodes Bezug genommen wird, erfolgt dies in kursiver Schrift.
Das erste Kapitel beschäftigt sich mit Zielsetzungen der Software-Entwicklung und
einem Überblick über Prozessmodelle, wobei das bereits erwähnte DAD-Prozessmodell
den Schwerpunkt bildet. Da bei einem agilen Vorgehen die Unsicherheit über den end-
gültigen Projektumfang bewusst in Kauf genommen wird, wird das Kapitel mit einem
Abschnitt zur Vertragsgestaltung bei agilem Vorgehen abgerundet und mit einer Vor-
stellung des im Weiteren verwendeten Fallbeispiels abgeschlossen.
Vorwort Auflage 1 VII
Im Mittelpunkt des zweiten Kapitels stehen die Inhalte und Vorgehensweisen in
der Vorbereitungsphase. Bei der Erstellung eines ersten und vorläufigen Modells
zum Projektgegenstand werden das Aktivitätsdiagramm, Anwendungsfalldiagramm
und Klassenmodell gemäß der Unified Modelling Language (UML) verwendet.
Anwendungsfälle werden in User Stories heruntergebrochen und somit die Basis für
eine agil geprägte Release-Planung gelegt. Damit eine realistische Aufwandsabschätzung
mittels Story Points erfolgen kann, werden auch Aspekte der System-Architektur
behandelt.
Im dritten Kapitel werden Methoden und Vorgehensweisen für die Iterationsplanung
vorgestellt und auf das Fallbeispiel angewandt. Dabei werden in jeder Iteration der
Entwicklungsphase für die ausgewählten User Stories einer Iteration Teilaufgaben
abgeleitet. Eine wesentliche Kategorie von Teilaufgaben sind die sogenannten System-
Operationen, welche das zu entwickelnde Software-System zu erfüllen hat. Weitere
Abschnitte stellen ausgewählte Muster für einen verantwortungsorientierten Entwurf
sowie ausgewählte klassische Entwurfsmuster vor. Diese Muster werden sowohl anhand
grafischer Modelle als auch anhand von Beispiel-Code dargestellt.
Auf der Basis der Iterationsplanung und den methodischen Grundlagen, werden im
vierten Kapitel Fachklassen zur Umsetzung der ersten System-Operation entworfen und
implementiert. Dem agilen Ansatz gemäß, wird mithilfe von JUnit ein testgetriebenes
Vorgehen praktiziert. Bewusst wurde die Notwendigkeit des Refactoring herbeigeführt,
um aufzuzeigen, dass ein Mindestmaß an Just-in-Time-Modellierung sinnvoll sein
kann. Abgeschlossen wird das Kapitel mit den Grundlagen und dem Einsatz der Java
Persistence API (JPA, seit kurzem auch bekannt als Jakarta Persistence) zur Speicherung
von Java-Objekten.
Im Sinne der klassischen Drei-Schichten-Architektur steht im fünften Kapitel die
Präsentationsschicht im Mittelpunkt. Nach einer Darstellung der konzeptionellen Grund-
lagen von Java Server Faces (JSF) und den Enterprise JavaBeans (EJB) sowie deren
Anwendung an einem einfachen Beispiel, werden die Konzepte auf das Fallbeispiel
angewandt. Dabei werden situationsorientiert Erweiterungen der Konzepte vorgestellt
und angewandt.
Im sechsten Kapitel werden der Entwurf und die Implementierung der ersten Iteration
des Fallbeispiels fortgeführt. Dabei werden insbesondere zusätzliche Funktionalitäten
von JSF eingesetzt. Die erste Iteration und das Kapitel werden mit dem Iterations-
bericht (iteration review), der Retrospektive und einer Überarbeitung des Arbeitsvorrats
abgeschlossen. Insbesondere das Feedback der Benutzer im Rahmen des Iterations-
berichts führt dazu, dass eine Repriorisierung des Arbeitsvorrats notwendig wird. Ebenso
zeigt sich, dass eine ursprünglich hoch priorisierte User Story keinen Nutzen stiftet.
Damit soll die Zweckmäßigkeit des iterativen Ansatzes bei einem agilen Vorgehen erleb-
bar gemacht werden.
Das siebte Kapitel beschäftigt sich mit zwei weiteren Iterationen des Fallbeispiels,
sodass am Ende ein erstes Release eingesetzt werden kann. Inhaltlich stellen einerseits
die programmgesteuerte Erzeugung von PDF-Dokumenten und andererseits Grundlagen
einer servergestützten Authentifizierungs- und Autorisierungslösung Schwerpunkte dar.
VIII Vorwort Auflage 1
Das Buch endet mit Grundlagen zur Einführungsphase im achten Kapitel. Der
Schwerpunkt liegt auf zukunftsweisenden Aspekten. Auf viele Detailaspekte der ersten
Release-Einführung vom Fallbeispiel wird verzichtet. Angesprochen werden Grundlagen
von DevOps sowie der Microservice-Architektur. Ergänzend wird noch ein Beispiel mit
einem RESTful-Webservice dargestellt, das im Fallbeispiel zur Datenübernahme ein-
gesetzt werden könnte.
Für die Modellierung wurde das Produkt Innovator der Firma MID GmbH in
Nürnberg in der Version 14 eingesetzt. Für Hochschulen wird dieses Produkt kosten-
frei zur Verfügung gestellt. Die Programmierung erfolgte mit der Entwicklungs-
umgebung NetBeans in der Version 8.02, mit JDK 1.8, Java EE 7, JSF 2.2 und JPA 2.1
sowie dem Java EE Anwendungs-Server Glassfish 4.1. Jedes Kapitel endet mit Fragen
und Aufgaben. Die Lösungshinweise hierzu finden sich unter Online-Materialien auf
der Verlags-Homepage des Buches. Ebenso finden sich dort Dateien mit vollständigem
Programm-Code.
Zum Zustandekommen dieses Buches haben viele beigetragen. Insbesondere
möchte ich meinen Studierenden der letzten Jahre für ihre konstruktive Kritik danken.
Hilfreich waren Gespräche mit Vertretern aus der Software-Branche. So hatte ich
Gelegenheit zum Gedankenaustausch mit Herrn Oliver Fischer, Leiter Agiles Center
der Fiducia & GAD IT AG sowie Herrn Hagen Buchwald, Mitglied des Vorstands der
andrena objects AG, Karlsruhe. Mit seiner intensiven Projekterfahrung unterstützte
mich Herr Thomas Starz, Trainer und Coach für agiles Anforderungsmanagement und
Projektmanagement sowie Scrum Master (CSM, PSM). Besonderen Dank möchte
ich dem Lektorat IT beim Springer Vieweg Verlag für die angenehme und geduldige
Zusammenarbeit ausprechen. Erwähnen möchte ich insbesondere Frau Sybille Thelen
sowie Frau Dr. Sabine Kathke und bei technischen Fragen unterstützte mich stets Herr
Walter Fromm von Fromm Media Design. Meiner lieben Frau Jutta möchte ich für Ihre
Unterstützung und ihr Verständnis im Laufe dieses Buchprojektes ganz herzlich danken.
Bereits jetzt möchten ich mich bei Ihnen, lieber Leser, für Anregungen, Hinweise und
Kritik bedanken.
Und nun viel Freude und Erfolg beim Lesen, Üben und Lernen.
Pforzheim Karl-Heinz Rau
September 2015
Vorwort Auflage 2
Diese nun vorliegende, zweite Auflage ist eine primär technisch getriebene Über -
arbeitung der vorangegangenen Auflage. Wir haben für Sie, liebe Leser, die Haupt-
anwendung modernisiert. Das bedeutet, dass Sie jetzt eine responsive Anwendung
erleben, die auf neuen Bibliotheken und Servertechnik im Umfeld von Jakarta EE auf-
setzt. NetBeans ist inzwischen ein Apache Projekt geworden und wir haben im Buch
die derzeitige LTS Version 12 eingesetzt. Für die Anwendung kamen Jakarta EE 8,
OpenJDK 1.8 und 13 sowie JSF 2.3 mit PrimeFaces 7.0 und Jakarta Persistence zum
Einsatz. Als Laufzeitumgebung wurde nun der Payara Server (5.2020.2) und die Daten-
bank PostgreSQL eingesetzt. Auf Wunsch kann man beide Systeme grundsätzlich leicht
austauschen, dies wird im Buch jedoch nicht weiter betrachtet. Zwischenzeitlich gab es
auch die Überlegung auf die Variante Payara Micro Edition zu wechseln, da dies eine
größere Anpassung in der Architektur Anwendung bedeutet hätte, bleibt es jedoch einer
künftigen Auflage vorbehalten. Den Quellcode der Beispielanwendung finden Sie jetzt
auch bei GitHub (unter https://github.com/thomas-schuster/examadministration).
Neben dem Quellcode und den entsprechenden Änderungen im Buch wurden
auch die Zeichnungen und Modelle aktualisiert. Hierbei wurde wieder die Software
Innovator, nun in Version 15.0, eingesetzt. Ein herzlicher Dank für die gute und lang-
jährige Kooperation geht daher an die MID GmbH in Nürnberg. Persönlich danken
möchte ich auch dem Geschäftsführer von MID, Herrn Andreas Ditze. Für ihre Geduld,
guten Anmerkungen und die technische Unterstützung möchte ich weiterhin auch den
Damen und Herren des Verlags danken, besonders Frau Sybille Thelen, Frau Angela
Schulze-Thomin und Herrn Amose Stanislaus. Ihnen, lieber Leser, gilt der Dank für das
Lesen des Buches. Haben Sie viel Spaß bei der Mit- und Weiterentwicklung der Bei-
spielanwendung. Bei Anmerkungen und Rückfragen erreichen Sie uns gerne per E-Mail
([email protected]) oder direkt über das Repository des Quellcodes.
Pforzheim Karl-Heinz Rau
Juli 2021 Thomas Schuster
IX
Inhaltsverzeichnis
1 Grundlagen agiler Software-Entwicklung ............................ 1
1.1 Teilgebiete und Lernergebnisse .................................. 2
1.2 Ausgangssituation und Ziele in der Software-Entwicklung ............ 2
1.2.1 Charakterisierung der Ausgangssituation der Software-
Entwicklung ........................................... 2
1.2.2 Beschreibung von Zielen in der Software-Entwicklung ......... 4
1.3 Überblick zu Vorgehens- und Prozessmodellen ...................... 6
1.3.1 Überblick zu klassischen Vorgehens- und Prozessmodellen ...... 6
1.3.2 Grundlagen agiler Prozessmodelle. . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3.3 Charakterisierung des Prozessmodells
Disciplined Agile Delivery (DAD). . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.4 Vertragsgestaltung für agile Vorhaben ............................. 26
1.5 Vorstellung des Fallbeispiels .................................... 30
1.6 Quellcode des Buchprojekts .................................... 32
1.7 Zusammenfassung ............................................ 32
1.8 Wiederholungsfragen und Aufgaben .............................. 33
Literatur ......................................................... 35
2 Inhalt und Vorgehensweise in der Vorbereitungsphase .................. 37
2.1 Teilgebiete und Lernergebnisse .................................. 38
2.2 Grundlagen zur Vorbereitungsphase .............................. 38
2.3 Erstellung eines ersten Modells zum Projektgegenstand ............... 41
2.3.1 Modellierung der funktionalen Anforderungen ................ 41
2.3.2 Modellierung der nicht-funktionalen Anforderungen ........... 50
2.4 Erster Entwurf einer System-Architektur .......................... 57
2.5 Erstellung eines Release-Planes .................................. 60
2.5.1 Grundlagen zum Release Plan und die
Definition of Done (DoD) ................................ 60
2.5.2 Vorgehensweisen zur Aufwandsschätzung ................... 62
XI
