Struts – Best Practices

Struts – Best Practices
If we complicate things, they get less simple.
Professor an der Cambridge University
… Simplifications have had a much greater long-range scientific
impact than individual feats of ingenuity. The opportunity for
simplification is very encouraging, because in all examples that
come to mind the simple and elegant systems tend to be easier and
faster to design and get right, more efficient in execution, and
much more reliable than the more contrived contraptions that
have to be debugged into some degree of acceptability … Simplicity and elegance are unpopular because they require hard work
and discipline to achieve and education to be appreciated.
Edsger W. Dijkstra
Complexity is a sign of technical immaturity. Simplicity of use is
the real sign of a well designed product whether it is an ATM or a
Patriot missile.
Daniel T. Ling
Simplicity is the soul of efficiency.
Austin Freeman, »The Eye of Osiris«
La perfection est atteinte non quand il ne reste rien à ajouter, mais
quand il ne reste rien à enlever.
[Perfektion ist nicht dann erreicht, wenn nichts mehr hinzuzufügen ist, sondern wenn nichts mehr da ist, was weggenommen werden kann.]
Antoine de Saint-Exupéry
Controlling complexity is the essence of computer programming.
Brian Kernighan
Der Unterschied zwischen einem guten und einem schlechten
Architekten besteht heute darin, daß dieser jeder Versuchung
erliegt, während der rechte ihr standhält.
Ludwig Wittgenstein
Simplicity does not precede complexity, but follows it.
Alan J. Perlis
Vic Cekvenich • Wolfgang Gehner
Struts – Best Practices
Die Erstellung kommerzieller Web-Anwendungen
– mit Praxisbeispielen und Übungen
Übersetzt aus dem Amerikanischen
von Angelika Shafir
Vic Cekvenich
[email protected]
Wolfgang Gehner
[email protected]
Übersetzung: Angelika Shafir, Tel Aviv, Israel
Lektorat: Michael Barabas
Copy-Editing: Ursula Zimpfer, Herrenberg
Satz und Herstellung: Verlagsservice Hegele, Dossenheim
Umschlaggestaltung: Helmut Kraus, Düsseldorf
Druck und Bindung: Koninklijke Wöhrmann B.V., Zutphen, Niederlande
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.
ISBN 3-89864-284-4
1. Auflage 2004
Copyright © 2004 dpunkt.verlag GmbH
Ringstraße 19 b
69115 Heidelberg
Die vorliegende Publikation ist urheberrechtlich geschützt. Alle Rechte vorbehalten.
Die Verwendung der Texte und Abbildungen, auch auszugsweise, ist ohne die schriftliche
Zustimmung des Verlags urheberrechtswidrig und daher strafbar. Dies gilt insbesondere
für die Vervielfältigung, Übersetzung oder die Verwendung in elektronischen Systemen.
Es wird darauf hingewiesen, dass die im Buch verwendeten Soft- und Hardwarebezeichnungen
sowie Markennamen und Produktbezeichnungen der jeweiligen Firmen im Allgemeinen warenzeichen-, marken- oder patentrechtlichem Schutz unterliegen.
Alle Informationen in diesem Buch wurden mit größter Sorgfalt kontrolliert. Weder Autoren
noch Verlag können für mögliche Fehler oder Schäden, die in Zusammenhang mit der Verwendung
des Buches stehen, eine juristische Verantwortung oder Haftung jeglicher Art übernehmen.
543210
v
Vorwort
Sind Sie Mechaniker oder Fahrer?
Manche Leute wachen frühmorgens auf und gehen in ihre Garage. Dann legen sie
sich unter das Auto, um sich den Motor vorzuknöpfen. Sie interessieren sich für
den Unterschied zwischen Viertaktern und Kreiskolbenmotoren, für Ventilsteuerung, Einspritzpumpe, Arbeitstakt und ähnliche Dinge.
Andere Leute wachen am Morgen ebenfalls auf und gehen in ihre Garage. Sie
fahren mit dem Auto zur Arbeit und starren auf die Autobahn. Sie machen sich normalerweise keine Gedanken darüber, in welchem Takt sich der Motor im Augenblick dreht, was der Auspuff macht oder wie's mit dem Einspritzsystem aussieht.
In der Programmierung gibt es ebenfalls zwei Gruppen von Menschen:
Systemprogrammierer und Anwendungsprogrammierer.
Systemprogrammierer schreiben Code, der von Anwendungsprogrammierern
benutzt und ausgewertet wird; sie schreiben Frameworks oder DAO-Implementierungen. Applikationsprogrammierer schreiben dagegen für Endbenutzer – um
Geschäftswert zu liefern. Sie nutzen die Arbeit anderer Leute, so dass sie sich auf
die Applikation konzentrieren können und sich nicht um die Technik (Mechanik)
kümmern müssen.
Applikationen lassen sich effizienter schreiben, wenn man ein Framework
und andere wiederverwendbare JARs sowie Komponenten ausnützt, statt das Rad
jedes Mal neu zu erfinden.
In diesem Buch lernen Sie, wie Sie mit Hilfe des Open-Source-Frameworks
Jakarta-Struts
■ qualitativ hochwertige Web-Applikationen
■ sehr viel schneller und
■ kosteneffektiv
konstruieren können.
Das Jakarta-Struts-Framework ist ein Projekt der Apache Software Foundation
(www.apache.org). Es bietet eine stabile Applikationsarchitektur und reduziert
enorm die Zeit, die erforderlich ist, um Web-Applikationen zu schreiben, die
Wertschöpfung und damit Geschäftswert liefern.
Struts basiert auf veröffentlichten Standards und bewährten Design-Paradigmen, wie z.B. dem Model-2-Ansatz, einer Variante der etablierten MVC-Archi-
vi
Vorwort
tektur (Model-View-Controller; wird seit den siebziger Jahren eingesetzt), die mit
der J2EE-Plattform (Java 2 Enterprise Edition) von Sun kompatibel ist.
Zusammen mit der Java Standard Tag Library (JSTL) bringt Struts JavaServlets, JavaBeans, Java Server Pages (JSP), Extensible Markup Language
(XML) und Message-Ressourcen in ein einheitliches Framework ein.
Was Sie in diesem Buch lernen
Im ersten Teil des Buchs (Grundlagen) lernen Sie, den Weg für die Entwicklungsphase mit Struts und JSTL zu pflastern. Dieser Teil behandelt Software- und
Hardwareanforderungen, solide Anforderungsspezifikationen, Datenbankeinrichtung, die Verwendung einfacher Actions, Beans und JSP und gibt Tipps zur
Projektplanung.
Im zweiten Teil (Bausteine) erfahren Sie, wie man eine solide und leistungsstarke Applikationsinfrastruktur konstruiert und die Vorteile umfangreicher
Wiederverwendung ausschöpft. Mit dieser Infrastruktur erhalten Sie ein Mittel an
die Hand, um solide Applikationsmodule sehr schnell und effizient zu erstellen.
Im dritten Teil (Perspektiven) lernen Sie, wie man eine umfangreiche
Benutzeroberfläche bereitstellt, die erweiterte Sicherheit bietet, und wie man eine
Applikation zukunftssicher macht und dafür sorgt, dass sie in einer Produktionsumgebung gut skaliert.
Best Practices
Jeder kann eine Brücke bzw. eine Web-Applikation konstruieren. Ein Ingenieur
kann Web-Applikationen aber erst durch Kenntnis (und Anwendung!) von Best
Practices optimal auslegen, d.h. beste Qualität, kürzeste Zeit, geringste Kosten.
Die Autoren haben das klägliche Misslingen von Entwicklungsprojekten gesehen, wenn Architekten und Entwickler die hervorragenden J2EE-Blueprints
fälschlicherweise als einzige Orientierung herangezogen haben. Deshalb deckt
dieses Buch nicht alles ab, was man mit J2EE und Struts machen kann. Vielmehr
konzentriert es sich auf die Best Practices, bei denen es sich gezeigt hat, dass sie
sich in der realen Welt am besten eignen und letztendlich zu solchen Web-Applikationen führen, die den höchsten Geschäftswert in Bezug auf Qualität, Geschwindigkeit und Kosten bieten.
Dieses Buch greift beispielsweise auf, wie man die Entwicklungsproduktivität
durch Maximierung der Wiederverwendung von Beans, Actions und Ereignissen
steigert, wie man die Zuverlässigkeit einer Applikation durch geschickte Auswahl
von Software und Hardware erhöht und wie wichtig eine solide Anforderungsspezifikation und Projektplanung für die kosteneffektive Entwicklung und Erfüllung der Kundenanforderungen sind.
Vorwort
vii
»Fools ignore complexity, experts avoid it; geniuses remove it.« (Alan Perlis)
Die Autoren behaupten nicht, Genies zu sein. Sie haben lediglich versucht, das Buch
einfach und kurz zu halten, indem sie sich auf die Ansätze konzentrierten, die in
der Praxis am besten funktionieren und den gesamten Projektzyklus abdecken.
Nachfolgend sind die 11 Best Practices aufgeführt, die schnell und kosteneffektiv zur Produktion von qualitativ hochwertigen Web-Applikationen beitragen.
Sie werden in den nächsten Kapiteln behandelt:
1. Erfülle die Kundenanforderungen effizient durch solide Anforderungsspezifikationen.
2. Spare Geld und erhöhe die Zuverlässigkeit mit effektiver Open-Source-Software.
3. Arbeite iterativ mit einem bewährten Prozess an der Entwicklung.
4. Führe Unit Tests durch.
5. Verwende MVC (Model-View-Controller).
6. Nutze objektorientierte Programmierung, um Wiederverwendung zu maximieren.
7. Verwende DAO (Data Access Objects).
8. Verwende CRUD-Ereignisse (Create-Read-Update-Delete).
9. Verwende CMA (Container Managed Authorization).
10. Führe Belastungstests durch.
11. Verwende Qualitätssicherung (QA) und verwalte Releases.
Praxisbezogenheit
Mit diesem Buch sollen Sie sofort loslegen können, es stützt sich also stark auf
Lernübungen. Um wirklich einen Nutzen aus diesem Buch zu ziehen, sollten Sie
die Übungen nicht überspringen. Sie helfen Ihnen, die Materie besser zu verstehen
und Vertrauen in die demonstrierten Technologien zu gewinnen1.
Wenn Sie mit dem Buch und den Übungen fertig sind, können Sie auf Wunsch
Ihre neu erworbenen Fähigkeiten mit basicPortal CMS erproben. Es wurde mit
Hilfe der in diesem Buch behandelten Best Practices erstellt.
basicPortal CMS ist eine dynamische, Struts-basierte Portalanwendung mit
Content Management, die die Funktionalitäten und Features auf sich vereint, die
in etwa 80% aller Web-Projekte benötigt werden. Dadurch können Sie sich auf die
Features konzentrieren, die speziell in Ihrem Web-Projekt vorkommen.
basicPortal unterstützt E-Commerce bzw. Kreditkarten, Nachrichten, LeadTracking, Content-Syndication, Foren, Kalender, Web-Logs (»Blogs«), Wikis,
E-Mail, schnelle standardisierte J2EE-Sicherheit, zeilenbasierte Sicherheit, Bilder,
Blobs und Uploads.
1. Der Begleit-Code für die Übungen ist zum Download erhältlich. Näheres hierzu siehe Seite 4
»Projekt einrichten«.
viii
Vorwort
Warum Struts?
Um die Entwicklung zu beschleunigen, können Sie ein proprietäres Framework
erwerben. Möglicherweise stellen Sie aber fest, dass der Anbieter es Ihnen nicht
gestattet, die Motorhaube zu öffnen, um das Öl zu wechseln. Jakarta-Struts ist
Open Source und lässt Sie unter die Haube gucken. Sie haben die Kontrolle über
den Quellcode und können ihn ändern, um eine Web-Applikation zu konstruieren, die die Anforderungen Ihres Kunden voll erfüllt.
Abgesehen davon bietet Struts weitere Vorteile, sowohl für Entwickler und
Programmierer als auch für das Geschäft Ihres Kunden.
Hier die wichtigsten Vorteile für den Entwickler:
■ Struts läuft auf jedem J2EE-Applikationsserver, darunter IBM WebSphere,
■
■
■
■
■
■
■
BEA WebLogic, Oracle IAS, Borland, Novell exteNd, Tomcat, Resin und
Orion.
Struts ist eine extrem solide und stabile Architektur (wobei diese Stabilität
durch Codebeiträge der Gemeinde noch gesteigert wird).
Struts lässt sich leicht anwenden, ist aber dennoch für große, datengesteuerte
Web-Applikationen geeignet.
Struts zerlegt komplexe Applikationen in einfache, konsistente Komponentenmengen.
Struts stellt sicher, dass alle Entwickler eines Teams nach dem gleichen Ansatz
programmieren.
Zu Struts gibt es eine komplette Dokumentation (Benutzer- und Entwicklerhandbücher).
Struts beruht auf Best Practices, weil viele Benutzer am Debugging mithelfen
und den Open-Source-Code verbessern.
Struts besitzt eine große Entwicklergemeinde, die praktisch sofortigen Support
leistet.
Darüber hinaus bietet Struts folgende Wertschöpfungsvorteile:
■ Schnelle und kosteneffektive Entwicklung
■ Wesentlich schnellere Marktgängigkeit und Produkt-Releases
■ Open Source: Die Lizenz ist entweder kostenlos oder zu einem symbolischen
Betrag zu erwerben.
■ Unabhängigkeit von geschlossenen, proprietären Systemen und folglich keine
teuren Lizenzen, die verwaltet, erneuert und aufgerüstet werden müssen.
■ Keine Abhängigkeit von Spezialistenarbeit und kommerziellen Anbietern
■ Zahlreiche Features erfüllen eine Vielzahl von Geschäftsbedürfnissen.
■ Plattformunabhängig
■ Höchst modular
Vorwort
ix
Warum Sie dieses Buch lesen sollten
Dieses Buch wurde für erfahrene Java-Entwickler und -Programmierer geschrieben, die entweder in einem bereichsübergreifenden IT-Team oder für einen internen Kunden oder auch als unabhängige Berater für externe Kunden arbeiten.
Wenn Sie als unabhängiger Berater für das Kundenprojekt von A (wie Analyse
der Benutzerbedürfnisse) bis Z (wie Zusammenstellung des vollständigen Projekts) zuständig sind, dann sollten Sie alle Projektphasen verstehen und selbst
dazu in der Lage sein, sie zu implementieren.
Wenn Sie zu einem internen bereichsübergreifenden IT-Team gehören, kann es
ratsam sein, auch die Aufgaben und Zuständigkeiten der anderen Teammitglieder,
wie z.B. Projektleiter, Systemanalytiker, Architekt und technische Support-Mitarbeiter, zu verstehen.
Wenn ein Projekt fehlschlägt, werden allzu oft die Entwickler oder Programmierer beschuldigt. Im langfristigen Interesse der ganzen Zunft und in Ihrem
eigenen Interesse kann es deshalb nicht schaden, kompetent zu sein und bessere
Ansätze vorschlagen zu können, z.B. auf einer vollständigen Anforderungsspezifikation vor der Entwicklung zu bestehen, eine Softwareauswahl zu empfehlen
oder sich für eine effektive Projektmanagementtechnik auszusprechen.
Dieses Buch eignet sich hervorragend für Teamarbeit. Seien Sie offen dafür,
Informationen und Erfahrungen mit Ihren Kollegen auszutauschen. Falls Sie derzeit oder künftig an einem großen Projekt beteiligt sind, kann das Konstruieren
und Arbeiten an der Grundlage eines gemeinsamen Verständnisses von Technologien für den Erfolg des Projekts Wunder wirken.
Was der Leser wissen sollte (Voraussetzungen)
Um aus diesem Buch den größten Nutzen zu ziehen, sollte Ihnen das MVC-Paradigma (Model-View-Controller) bekannt sein. Abbildung 1 zeigt die MVC2Architektur, die wir mit Struts und JSP verwenden werden.
Abbildung 1: Das MVC-Paradigma
x
Vorwort
Sie sollten den Request-Response-Zyklus und die Terminologie kennen. Der
Ablauf ist wie folgt:
1. Der Client-Browser postet eine Anfrage (Request) an das Controller-Servlet.
2. Das Controller-Servlet schickt sie an eine Action-Klasse.
3. Die Action bringt das Modell an die richtige Stelle (d.h., es liest Daten, aktualisiert sie, fügt Daten ein oder löscht sie).
4. Der Controller leitet das Ganze an eine JSP-Seite weiter.
5. JSP extrahiert die positionierten Daten aus dem Modell.
6. Der Controller gibt den JSP-Inhalt als Antwort (Response) zurück.
Sie sollten wissen, was JSPs sind und wie sie funktionieren.
Sie sollten auch einige Erfahrung mit dem Java-Servlet-API sowie mit HTML,
SQL und JavaScript haben.
Je mehr Java-Programmiererfahrung Sie mitbringen, umso besser. Im Idealfall
haben Sie bereits an der Entwicklung einer Java-Applikation, die es in die Produktion geschafft hat, mitgearbeitet.
Schnelltest 1: Navigieren Sie im Internet zu http://java.sun.com/products/
servlet/2.3/javadoc/index.html.
Sind Sie mit dem API vertraut?
Schnelltest 2: Verstehen Sie das folgende HTML-Fragment?
<FORM ACTION=http://localhost:80/myServlet>
First Name: <INPUT TYPE=”TEXT” NAME=”firstName”><BR>
Last Name: <INPUT TYPE=”TEXT” NAME=”lastName”> <BR>
<INPUT TYPE=”SUBMIT”>
</FORM>
Wenn die Antwort auf beide Fragen »nein« lautet, empfehlen wir Ihnen, sich
zuerst in die relevanten Themen einzulesen oder ein Teammitglied zu finden, das
Ihnen die erforderlichen Grundlagen beibringt.
Im Buch benutzter Code und Software
In diesem Buch verwenden wir Standardprogrammiertechniken, die mit jeder
gewählten Servlet-Engine, jedem Applikationsserver, jeder SQL-Datenbank und
jedem IDE funktionieren.
Dieses Buch ist eine Art Kochbuch, weil viele Projekte nicht nur Struts,
sondern auch andere Softwarezutaten nutzen. Wann immer andere »Zutaten«
notwendig sind, wird in diesem Buch einer Open-Source-Software gegenüber
proprietärer Software der Vorzug gegeben, weil Open Source zahlreiche Vorteile
bietet, wie wir im weiteren Verlauf noch sehen werden.
Vorwort
xi
Keine einzelne Softwarefirma, egal, wie groß sie sein mag, kann alle Werkzeuge in der jeweils besten Form selbst entwickeln und vertreiben. In der OpenSource-Gemeinde gibt es einfach zu viele »Köpfe«, um mit deren Errungenschaften ständig gleichziehen oder sie gar übertreffen zu können.
Geistiges Eigentum und Lizenz
Dieses Buch diskutiert und demonstriert die Verwendung lizenzierter Produkte.
Die meisten sind Open-Source-Lizenzen. Die Softwareprodukte in diesem Buch
(insbesondere Jasic und dessen Code) werden nur zur Wissensvermittlung diskutiert und zum Download zur Verfügung gestellt. Mit der Demonstration eines
Beispiels erwerben Sie also nicht das Eigentum daran. Sie müssen sich informieren, wem sie gehören und wofür Sie lizenziert sind.
Wichtiger Hinweis: Alle Entwürfe und Softwareprodukte unterliegen dem
jeweiligen Copyright; Entwürfe sind patentiert, insbesondere das basicPortalDatenmodell; seine Applikationen und Basisklassen sind patentiert, jedoch im
Rahmen einer flexiblen Lizenz erhältlich.
Über die Autoren
Vic Cekvenich verfügt über 14 Jahre Erfahrung in führenden IT- Positionen und
ist auf Projekt-Recovery spezialisiert. Er besitzt mehr als zehn Zertifizierungen in
Bereichen wie Java, SQL, objektorientierte Programmierung und EntityRelationship-Modeling. Er hat ein Buch über die Verwendung des MVC/StrutsFrameworks mit Data Access Objects (DAO) veröffentlicht und viele Arbeiten
und Artikel über weitere Themen in diesem Bereich geschrieben. Er wurde vom
Java Developer's Journal als »Trainer of the Year« ausgezeichnet und war auf der
Comdex, NetWorld, Windows World und vielen anderen wichtigen Fachmessen
präsent.
Vic Cekvenich hat für die NASA, CSC, Ford Motor Company, Bank of America, Perot Systems, BP-Amoco und andere Unternehmen in verschiedenen Positionen gearbeitet, die von der technischen Projektleitung bis zum Vice-President
von Managementinformationssystemen (MIS) reichen. Zu seinen Erfahrungen
zählen Arbeiten mit großen Teams, Etats von über einer Million Dollar und Datenbanken in Terabyte-Größe mit über 40.000 Benutzern.
Vic Cekvenich ist einer der maßgeblichen Entwickler bei baseBeans Engineering. Sein derzeitiges Projekt, das basicPortal-System, ist eine datenbankgesteuerte Web-Applikation mit Fokus auf Leistung und Bedienungsfreundlichkeit.
baseBeans Engineering (www.baseBeans.com) bietet kommerzielle Unterstützung für basicPortal-Benutzer. Entwickler sind eingeladen, ihre eigene Unterstützung einfließen zu lassen und jederzeit individuelle Module zu entwickeln.
xii
Vorwort
Vic Cekvenich erhielt den JDJ Readers’ Award für das »Best Java Training
Program«; er unterrichtet bereits seit über neun Jahren im Entwicklungsbereich.
Wolfgang Gehner verfügt über 13 Jahre Erfahrung im Projektmanagement, u.a.
von Multi-Millionen-Euro-Projekten, und hat 6 Jahre Erfahrung als Softwareentwickler, Analyst, Architekt und Trainer bzw. Coach.
Wolfgang Gehner ist Gründer und Chief Executive Officer der Firma
Infonoia SA (Information ohne Paranoia) mit Sitz in Genf in der Schweiz.
Infonoia (www.infonoia.com) entwickelt eine serverbasierte Enterprise
Document Management Suite. Sie umfasst Web-Applikationen für intelligentes
Dokumentenmanagement, Business Intelligence, Business Process Management
und Content Management sowie Dokumentenbanken auf intelligenten, servergesteuerten CD-ROMs und DVDs.
Der technologische Schwerpunkt liegt dabei auf vom Anwender unterstützten Lernalgorithmen, die für intelligente Dokumentenanalyse, inkrementielles
Web Crawling und -Monitoring sowie Textindizierung eingesetzt werden.
Die Firma Infonoia war erster Kunde und kommerzieller Anwender von
Applikationsservertechnologien in der Schweiz und einer der ersten in Europa.
Seit 2001 wendet Infonoia Struts aktiv in der Entwicklung von Web-Applikationen an.
Als Chefarchitekt von Infonoia zeichnet Wolfgang Gehner für Kunden verantwortlich wie Procter & Gamble, Deloitte & Touche, LVMH, Tetra Pak, die
Weltgesundheitsorganisation, die Universität Bielefeld, die Republik und den
Kanton Genf und Lombard Odier Darier Hentsch.
Kontaktinformationen
Wenn Sie Fragen oder Kommentare haben, kontaktieren Sie bitte die Autoren:
■ Vic Cekvenich ([email protected]) oder www.baseBeans.com.
■ Wolfgang Gehner ([email protected]) oder www.infonoia.com.
Danksagung
Unser besonderer Dank gilt unseren Lektoren Boris Baginski, Henning Brune,
C. DeFazio und Taylor Cowan.
Inhaltsverzeichnis
xiii
Inhaltsverzeichnis
Teil I – Grundlagen
1
1.1
1.2
1.3
1.4
1.5
1.6
1.7
1.8
1.9
1.10
Projekt einrichten
Softwareanforderungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Hardware- und Betriebssystemkonfiguration . . . . . . . . . . . . . . . . . . . . . . . . .
IDEs und Codegeneratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Produktionsumgebung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beliebtheit von Open-Source-Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zuverlässigkeit von Open-Source-Software . . . . . . . . . . . . . . . . . . . . . . . . . . .
Support für Open-Source-Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tomcat 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispiel-WARs testen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Web-Applikationsprojekt im IDE erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.10.1 Eclipse 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.10.2 Klassenpfad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.11 Applikationsserver konfigurieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 1.A: Installieren/Dekomprimieren . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 1.B: Beispiel-WARs installieren . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 1.C: IDE einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
3
4
5
6
6
7
8
9
9
10
10
11
12
12
13
14
15
2
Anforderungsspezifikation
2.1
Geschäftswert schnell und effizient erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2
Report-Erstellung mit iReports . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3
Kapitalverzinsung (Return on Investment, ROI) . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 2.A: Mockup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
17
18
19
19
20
3
3.1
21
21
22
22
23
23
25
25
26
27
Datenbankzugriff einrichten
Model-View-Controller (MVC) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.1 PostgreSQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2
Modell entwerfen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3
Entity-Relationship-(ER-)Diagramm erstellen . . . . . . . . . . . . . . . . . . . . . . . . .
3.4
JNDI-DataSource-Konfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 3.A: PostgreSQL installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 3.B: Modell entwerfen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 3.C (optional): Ausgabe/Reports . . . . . . . . . . . . . . . . . . . . . . . . . .
xiv
Inhaltsverzeichnis
4
4.1
4.2
Arbeiten mit einfachen Actions
Das »C« in Model-View-Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
ActionMappings verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.1 Drei Regeln zur Strukturierung von ActionMappings . . . . . . . . . . . .
4.3
Action-Klasse schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4
Struts-ActionServlet konfigurieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 4.A: Einfache Action 32
29
29
29
30
31
31
32
5
5.1
5.2
Arbeiten mit JSPs und View
JSP-Tags integrieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
JSP 2.0 und JSTL 1.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2.1 Internationalisierung/Lokalisierung . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3
Layout mit Tiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.1 Tiles-Definitionen erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.2 Tiles-Weiterleitung verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.4
Cascading Stylesheets (CSS) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.4.1 Stylesheets wiederverwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.5
Menünavigation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.5.1 Menüs anzeigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.6
JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 5.A: Layouts und Navigation . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 5.B: Stylesheets wiederverwenden . . . . . . . . . . . . . . . . . . . . . . . . .
35
35
36
36
37
39
39
40
41
42
42
43
44
44
45
6
6.1
6.2
6.3
6.4
6.5
Arbeiten mit einfachen Beans
Was ist eine JavaBean? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Formularbeispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Was ist eine FormBean? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ein »realistischer« Bean-Prototyp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
IDE-Makros schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.5.1 Bean mit JSP verknüpfen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.6
Logging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 6.A: Einfache FormBeans und Makros . . . . . . . . . . . . . . . . . . . . .
Übung 6.B: HTML-Text-Tag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
47
47
47
48
49
51
51
53
54
54
56
7
7.1
7.2
59
59
60
62
63
64
64
65
66
66
67
67
Tipps zum Entwicklungsprozess
Können Sie eine Brücke (oder Web-Applikation) bauen? . . . . . . . . . . . . . . . . .
Was ist Projektplanung? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2.1 Was sind Aufgaben? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.3
Iterative Prozessschritte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.4
Vertragsgemäß programmieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.5
Welcher Kandidat soll eingestellt werden? . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.6
Übergabestrategie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.7
Outsourcing auf Festpreisbasis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.8
Projektpolitik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Vorschau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Inhaltsverzeichnis
xv
Teil II – Bausteine
8
8.1
8.2
8.3
Datenzugriff richtig auslegen
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Datenschichtzugriff – das »M« in MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Beispiel eines DAO-Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.3.1 DAO-Implementierungsoptionen: entity- oder objektrelational? . . .
8.4
Abbildung eines DAO auf die Datenbank mit SQL . . . . . . . . . . . . . . . . . . . .
8.5
DAO mit dem DataSource-Pool verbinden . . . . . . . . . . . . . . . . . . . . . . . . . .
8.5.1 DAO verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.6
Was zeichnet einen guten Programmierer aus? . . . . . . . . . . . . . . . . . . . . . . .
8.7
Objektdisorientierte Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.8
Die Vorteile objektorientierter Programmierung . . . . . . . . . . . . . . . . . . . . . .
8.9
DAOs wiederverwendbar machen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.10 DAO-Helper-Objekte verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 8.A: DAO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
71
71
71
72
73
74
75
76
77
77
78
79
79
82
82
9
9.1
85
85
88
89
90
90
91
92
94
94
10
10.1
10.2
10.3
10.4
Wiederverwendbare Actions und Ereignisse
Meldungen von der Seite zur Action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
JSP-Anfrage- und Session-Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Actions gruppieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.4.1 Übliche Ereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.5 Action-Ereignisobjekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.6 Action erweitern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.7 Action-Klasse mit Ereignissen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 10.A: Noch mehr einfache Actions . . . . . . . . . . . . . . . . . . . . . . .
Übung 10.B: Meldungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 10.C: Anspruchsvolle Action mit Save-Event . . . . . . . . . . . . . . . .
97
97
99
99
102
103
103
104
106
107
107
108
109
11
11.1
11.2
11.3
113
113
115
116
117
118
Wiederverwendbare Beans
Unit Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1.1 JSP und Beans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2
MVC für FormBeans mit DAO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.3
Daten bearbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.4
Wiederverwendbare FormBean . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.5
Gemeinsame Bean-Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.6
Navigation zwischen Zeilen und Iterator-Adapter . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 9.A: Anspruchsvolle Beans und Unit Tests . . . . . . . . . . . . . . . . . .
11.4
Weitere Formularbehandlungs-Actions
Alternative MVC-Flussoptionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Insert-Ereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ausnahmebehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.3.1 Ausnahmefluss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Multizeilen-Aktualisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
xvi
Inhaltsverzeichnis
11.5 Transaktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.6 Master/Detail-Verarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.7 Bookmarks auf Actions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 11.A (optional): sql.date . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 11.B: Multizeilen-Aktualisierung . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 11.C (optional): OnNew . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
119
119
121
122
122
122
123
12
12.1
12.2
12.3
12.4
125
125
127
127
129
130
130
131
131
131
Validierung
Eingabevalidierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Validierungsmeldungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Validierungsfehler anzeigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Clientseitige Validierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.4.1 Geschäftsregeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.4.2 Doppelte Submit-Operationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Vorschau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 12.A: Validierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Teil III – Perspektiven
13
13.1
13.2
13.3
13.4
13.5
Dynamischer Site-Inhalt
Dynamischer Inhalt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Content Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Suchfunktion implementieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
SQL-Suche abbilden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
FormBean für Suchergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.5.1 JavaScript-Baum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.6 basicPortal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.7 Serviceorientierte Architektur mit dem Inversion of Control Pattern (IoC) . .
13.8 Asynchrone Verarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.9 E-Commerce und XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.10 Ad-hoc-Reports erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 13.A (optional): Report-Servlet . . . . . . . . . . . . . . . . . . . . . . . . . .
135
135
137
137
138
139
140
141
142
143
144
145
147
147
14
14.1
149
149
150
152
152
154
155
156
156
156
157
157
Sicherheit
Login-Sicherheit mit containerseitiger Autorisation . . . . . . . . . . . . . . . . . . . .
14.1.1 Containersicherheit konfigurieren . . . . . . . . . . . . . . . . . . . . . . . . . .
14.2 Sicherheit auf Zeilenebene implementieren . . . . . . . . . . . . . . . . . . . . . . . . . .
14.2.1 Sicherheit auf Zeilenebene zur Bean und SQL-Map hinzufügen . . . .
14.3 Inhärente Zugriffsrechte behandeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.4 Tiles- und Menüsicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.5 SSL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.6 Benutzer-IP-Bereiche identifizieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14.7 Weitere Sicherheitsfaktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 14.A: Sicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Inhaltsverzeichnis
xvii
15
15.1
Komplexe Formulare und Punktnotation
Komplexe Formulare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.1.1 Verschachtelte Beans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.2 Punktnotation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 15.A (optional): Verschachtelte Punktnotation . . . . . . . . . . . . . .
159
159
160
161
162
162
16
Dropdown-Elemente und Supertyp
16.1 Optionssammlung für Dropdown-Elemente verwenden . . . . . . . . . . . . . . . .
16.2 Optionswerte aus der Datenbank holen . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16.3 Supertyp implementieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16.4 SQL-Map und DAO für Supertypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 16.A: Optionsauswahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
165
165
167
167
168
169
169
17
17.1
17.2
17.3
17.4
Benutzeroberfläche ausgestalten
XML-RPC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Inhalt im XML-Format bereitstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fallbeispiel: Auf Struts-Beans über Excel zugreifen . . . . . . . . . . . . . . . . . . . .
Macromedia Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17.4.1 Macromedia Flex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17.5 Software als Utility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 17.A (optional): Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
171
171
172
172
173
176
176
177
177
18
18.1
18.2
18.3
18.4
18.5
Performance-Management
Betriebsüberwachung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Daten laden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Belastungstests durchführen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Datenbankserver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Applikationsserver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18.5.1 Gleicher physischer Standort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18.6 Prozess der SQL-Anfrageausführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18.6.1 Wie Datenbank-Engines Anfragen ausführen . . . . . . . . . . . . . . . . . .
18.6.2 Wie Datenbank-Engines Joins behandeln . . . . . . . . . . . . . . . . . . . . .
18.6.3 Stored Procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18.6.4 Weitere SQL-Tipps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18.7 Failover . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rückblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übung 18.A (optional): Belastungstest – OpenSTA . . . . . . . . . . . . . . . . .
Übung 18.B (optional): Stored Procedures . . . . . . . . . . . . . . . . . . . . . . .
179
179
180
181
182
182
183
183
184
185
186
187
188
188
189
190
19
19.1
19.2
19.3
19.4
19.5
19.6
191
191
192
192
193
195
195
Zukunftssicherheit der Applikation
Release Engineering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Änderungsmanagement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ant und Maven – Best Practices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
CVS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Failover-Recovery . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Applikationsserver auswählen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
xviii
19.7
19.8
19.9
19.10
Index
Inhaltsverzeichnis
Chain-Filter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Was ist überbewertet? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Häufige Fehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
196
196
197
198
199