Struts – Best Practices
Transcrição
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