Auf einen Blick
Auf einen Blick 1 Überblick ............................................................................................................
Auf einen Blick 1 Überblick ...................................................................................................................................
33
2 Der Java EE Server ..................................................................................................................
77
3 Planung und Entwurf ............................................................................................................ 149 4 Servlets ....................................................................................................................................... 201 5 Java Server Pages ................................................................................................................... 291 6 Die relationale Datenbank .................................................................................................. 375 7 JDBC ............................................................................................................................................ 433 8 Die Java Persistence API ....................................................................................................... 509 9 Java Server Faces .................................................................................................................... 701 10 Enterprise JavaBeans ............................................................................................................ 901
Inhalt
Inhalt Geleitwort des Fachgutachters ......................................................................................................................
21
Über dieses Buch .................................................................................................................................................
23
1
Überblick
33
1.1
Der Java-EE-7-Standard ...................................................................................................................
33
1.1.1 1.1.2 1.1.3 1.1.4 1.1.5 1.1.6
Wer definiert den Java-EE-Standard? ....................................................................... Die Java-EE-Spezifikation .............................................................................................. Java EE Server und Java-EE-Profile ............................................................................. Komponenten und Container ..................................................................................... Die Datenhaltung ............................................................................................................ Anwendungsszenarien ..................................................................................................
35 36 36 37 38 39
Die Java-EE-Software-Architektur ..............................................................................................
42
1.2.1 1.2.2
Das MVC-Entwurfsmuster ........................................................................................... Die mehrschichtige Software-Architektur ..............................................................
43 43
Die Technologien von Java EE 7 ...................................................................................................
46
1.3.1 1.3.2 1.3.3
Die Web-Technologien des Java-EE-7-Standards ................................................. Die Enterprise-Technologien des Java-EE-7-Standards ...................................... Webservices-Technologien ..........................................................................................
50 65 72
1.4
Los geht's mit der Praxis .................................................................................................................
73
2
Der Java EE Server
77
2.1
Die Installation ....................................................................................................................................
77
2.1.1 2.1.2 2.1.3
Das JDK 7 installieren ..................................................................................................... »GlassFish Server Open Source Edition 4« herunterladen ................................ Die Verzeichnisse von GlassFish 4 .............................................................................
77 78 81
Domänen und Instanzen ................................................................................................................
Die Textkonsole ..................................................................................................................................
85
2.3.1 2.3.2
87 90
1.2
1.3
2.2
2.3
Eine Domäne erzeugen ................................................................................................. Der Start einer Domäne ................................................................................................
7
Inhalt
Inhalt
2.4
2.5
Der DAS ..................................................................................................................................................
Der Aufbau einer Java-EE-Anwendung .................................................................... Java-EE-Module ................................................................................................................ Die Enterprise-Archiv-Datei .......................................................................................... Die Erstellung der Web-Komponente (mit UTF-8) ............................................... Die Erzeugung des Web-Moduls und der ».ear«-Datei ....................................... Die Installation .................................................................................................................
110 110 112 113 115 115
Eclipse installieren ........................................................................................................... Eclipse auf UTF-8 umstellen ......................................................................................... Die Installation des GlassFish-Plug-ins .................................................................... Eine Java-EE-Anwendung in Eclipse erzeugen .......................................................
121 122 125 130
3.4
Planung und Entwurf
3.1
Die Projektplanung mit Scrum ..................................................................................................... 150 3.1.1 3.1.2 3.1.3 3.1.4
Einführung ......................................................................................................................... User-Story 0 »As a user I want to be welcomed« ................................................. User-Story 1 »As a user I want to register« ............................................................. User-Story 2 »As a customer I want to sign in« ..................................................... User-Story 3 »As a customer I want to sell items« ............................................... User-Story 4 »As a customer I want to search items« ........................................ User-Story 5 »As a customer I want to buy items« ..............................................
163 165 165 167 169 170 170
Die Datei »index.html« .................................................................................................. Die Datei »register.html« ............................................................................................. Die Datei »signin.html« ................................................................................................. Die Datei »sell.html« ...................................................................................................... Die Datei »search.html« ................................................................................................ Die Datei »styles.css« .....................................................................................................
173 175 178 180 183 184
Das HTTP-Monitoring ....................................................................................................................... 187 3.5.1 3.5.2 3.5.3
Die Verbindung zum Server herstellen .................................................................... Der HTTP-Request ........................................................................................................... Die HTTP-Response .........................................................................................................
188 188 189
3.5.4 3.5.5
Das Monitoring in Eclipse ............................................................................................. Die Firefox-Entwickler-Symbolleiste .........................................................................
192 194
4
Servlets
4.1
Ein technischer Überblick ............................................................................................................... 202 4.1.1 4.1.2 4.1.3 4.1.4
152 152 153 155
Die Datentypen für den Entwurf ................................................................................................. 157
159 159 159 160 160 161
Die UI-Prototypen .............................................................................................................................. 171 3.4.1 3.4.2 3.4.3 3.4.4 3.4.5 3.4.6
Die Bedienung des DAS über »asadmin« ................................................................. Die Bedienung des DAS über einen Webbrowser .................................................
3.2.3 3.2.4 3.2.5 3.2.6 3.2.7 3.2.8
4.2
Die Arbeitsweise des Web-Containers ..................................................................... Der Lebenszyklus eines Servlets ................................................................................. Das HttpServlet ................................................................................................................ Die Bekanntmachung und Konfiguration eines Servlets ...................................
201
202 203 204 205
Die Servlet-API ..................................................................................................................................... 209 4.2.1 4.2.2
Die Service-Methoden ................................................................................................... Die Beantwortung eines HTTP-Requests ................................................................
209 211
9
Inhalt
Inhalt
4.2.3 4.2.4 4.2.5 4.2.6 4.2.7 4.2.8 4.2.9 4.2.10
4.3
242 243 246 247
Multipart/Form-Data ..................................................................................................... Die Konfiguration des Servlets .................................................................................... Informationen zu einem Part auslesen .................................................................... Hochgeladene Dateien konfigurieren ...................................................................... Den Wertebereich einlesen ..........................................................................................
Die Methoden eines Filters ........................................................................................... Die Konfiguration eines Filters .................................................................................... Mehrere Filter vor ein Servlet setzen ........................................................................ Filter mit Umleitung .......................................................................................................
Die page-Direktive .......................................................................................................... Die taglib-Direktive ......................................................................................................... Die include-Direktive ...................................................................................................... Den Kopfteil und Fußteil der JSPs in gesonderte JSPF-Dateien auslagern .................................................................................................
Die HTML-Seiten des Onlineshops in JSP-Dateien umbenennen ................... Das automatisch generierte Servlet ......................................................................... Eine JSP konfigurieren ....................................................................................................
Parameter für die gesamte Webanwendung ......................................................... Parameter für ein einzelnes Servlet ........................................................................... Initialisierung mit der Annotation »@WebServlet« ............................................ Externe Ressourcen einlesen .......................................................................................
279 280
5
Asynchrone Servlets und Nonblocking I/O ............................................................................. 258 4.7.1 4.7.2
4.8
Cookies setzen .................................................................................................................. 238 Die Gültigkeitsdauer ....................................................................................................... 239 Ein Beispiel mit Cookies ................................................................................................. 239
Filter überspringen ......................................................................................................... Einen Filter in Eclipse erzeugen ..................................................................................
Initialisierung und Konfiguration ............................................................................................... 242 4.5.1 4.5.2 4.5.3 4.5.4
4.6
Die Dauer einer HTTP-Sitzung ..................................................................................... Wie eine HTTP-Sitzung funktioniert ......................................................................... Wie man eine HTTP-Sitzung nutzt ............................................................................. Das MVC-Entwurfsmuster ............................................................................................ Eine JavaBean für das Modell erstellen .................................................................... Ein Beispiel programmieren ......................................................................................... Die Gültigkeitsbereiche der Attribute .......................................................................
4.8.5 4.8.6
Cookies .................................................................................................................................................... 238 4.4.1 4.4.2 4.4.3
Formular-Parameter entgegennehmen ................................................................... Die Inhalte der Methode »doPost()« programmieren ......................................... Header-Zeilen .................................................................................................................... Die Festlegung der Zeichenenkodierung ................................................................. Einen Status-Code setzen ............................................................................................. Eine clientseitige Umleitung (Redirect) herbeiführen ........................................ Eine serverseitige Umleitung (Forward) programmieren .................................. Das Logging in einem Servlet ......................................................................................
Ein »simples« JSP-Custom-Element .......................................................................... Tag-Dateien programmieren ......................................................................................
Grundlegende Elemente ............................................................................................... String-Operatoren ........................................................................................................... Relationale Operatoren .................................................................................................
337 340 340
11
Inhalt
Inhalt
5.6.4 5.6.5 5.6.6 5.6.7 5.6.8 5.6.9 5.6.10
5.7
340 341 341 341 342 346 347
Anwendungsserver ohne JSTL ..................................................................................... core – Die JSTL-Kernfunktionalität ............................................................................ fmt – Formatierungen ................................................................................................... functions – Funktionen .................................................................................................. sql – Datenbankzugriffe ................................................................................................ xml – Die Verarbeitung von XML-Strukturen .........................................................
348 350 354 365 368 369
6
Die relationale Datenbank
6.1
Die Einrichtung der Oracle Database ......................................................................................... 376 6.1.1 6.1.2 6.1.3 6.1.4 6.1.5 6.1.6
6.2
376 381 382 384 385 387
Objekte ................................................................................................................................ Tablespaces ........................................................................................................................ Einen Datenbankbenutzer erzeugen ........................................................................ Das Berechtigungskonzept ...........................................................................................
390 390 392 393
Performance-Tuning für die Java-EE-Anwendung .............................................................. 396 6.3.1 6.3.2
6.4
Die Installation ................................................................................................................. Sprache, Land und Zeichensatz ................................................................................... Die SQL-Befehlszeile einsetzen ................................................................................... Transaktionen ................................................................................................................... Der Isolation-Level ........................................................................................................... Die Änderung des Oracle-HTTP-Ports .......................................................................
375
Datenbank-Sitzungen .................................................................................................... 396 Mit PROCESSES indirekt auch die SESSIONS steuern ........................................... 397
Die Erstellung der Datenbanktabellen ..................................................................................... 398 6.4.1 6.4.2 6.4.3 6.4.4 6.4.5
SQL- und Datenbankkenntnisse ................................................................................. Die Erstellung des Datenmodells ............................................................................... Die speziellen SQL-Datentypen der Oracle Database .......................................... Datenbanktabellen erzeugen, löschen und ändern ............................................. Bedingungen hinzufügen .............................................................................................
Die Indizierung .................................................................................................................................... 428
6.6
Das komplette Onlineshop-Beispiel .......................................................................................... 428
7
JDBC
7.1
Der direkte Zugriff per JDBC .......................................................................................................... 433
7.2
7.3
Die JDBC-Treibertypen ................................................................................................... Der JDBC-Treiber für die Oracle Database .............................................................. Die Driver Definition in Eclipse ................................................................................... Der »Data Source Explorer« in Eclipse ......................................................................
434 435 435 437
7.1.5 7.1.6
Die Driver Definition im Java-Projekt verwenden ................................................ Der Erstellung einer Datenbankverbindung ..........................................................
442 443
Der Zugriff über den Java EE Server ........................................................................................... 447
Die Datenbankverbindung über den Java EE Server besorgen ........................ Die Datenquelle durch den Web-Container injizieren lassen .......................... Das Absetzen einer SQL-Anweisung .........................................................................
457 458 460
Die Speicherung einer Entity ....................................................................................... Die Abfrage von Geschäftsdaten ...............................................................................
462 465
Das objektrelationale Mapping ................................................................................................... 468 7.5.1 7.5.2
7.6
448 449 455
Das MVC-Entwurfsmuster einsetzen ........................................................................................ 461 7.4.1 7.4.2
7.5
Die JVM-Optionsparameter für den Java EE Server ............................................. Erstellung eines JDBC-Connection Pools ................................................................. Erstellung einer »Default Data Source« ..................................................................
Die Kernfunktionalität der JDBC-API ........................................................................................ 456 7.3.1 7.3.2 7.3.3
7.4
433
7.1.1 7.1.2 7.1.3 7.1.4
7.2.1 7.2.2 7.2.3
Die Organisation der Oracle Database ..................................................................................... 390 6.2.1 6.2.2 6.2.3 6.2.4
Die Java Standard Tag Library ....................................................................................................... 347 5.7.1 5.7.2 5.7.3 5.7.4 5.7.5 5.7.6
12
Der empty-Operator ....................................................................................................... Der konditionale Operator ............................................................................................ Klammern und Semikolon ............................................................................................ Literale ................................................................................................................................. Implizite Objekte .............................................................................................................. Der Zugriff auf eine JavaBean über den Gültigkeitsbereich ............................. Funktionen .........................................................................................................................
Von SQL zu Java ................................................................................................................ Die Umwandlung der JDBC-eigenen Datentypen ................................................
Die Klasse »PreparedStatement« ...............................................................................
475
13
Inhalt
Inhalt
7.6.2 7.6.3
7.7
8.1
Die Java Persistence API
8.3
Wofür braucht man ein Persistenz-Framework? .................................................. JPA und Persistence-Provider ....................................................................................... EclipseLink .......................................................................................................................... Die ersten Arbeitsschritte bei einer einfachen JPA-Anwendung .....................
510 511 511 512
8.2.1 8.2.2 8.2.3 8.2.4
Der Aufbau der »persistence.xml« ............................................................................. Persistenz-Einheiten definieren .................................................................................. Transaktionen (mit JTA oder RESOURCE_LOCAL) ................................................. Den Bezeichner vom Namensdienst anzeigen ......................................................
8.2.5 8.2.6 8.2.7
Mit »description« eine kurze Beschreibung hinzufügen .................................... 518 Den Persistence-Provider angeben ............................................................................ 518 Die Verbindungsdaten hinterlegen ........................................................................... 519
8.8
515 515 516 517
Die Erzeugung eines EntityManagers ....................................................................... Der Persistenz-Kontext .................................................................................................. Die Transaktionen ........................................................................................................... Die zwei Ausprägungen des Persistenz-Kontextes .............................................. Wann das Persistieren tatsächlich ausgeführt wird ............................................ Die Status im Lebenszyklus einer JPA-Entity .......................................................... Die Methoden für die Datenbankoperationen ......................................................
520 524 524 529 529 530 530
JPA und Eclipse ..................................................................................................................................... 535 Ein JPA-Projekt in Eclipse erzeugen ............................................................................ 535 Beim Webprojekt mit JPA arbeiten ............................................................................ 546 Das ORM-Reverse-Engineering ................................................................................... 551
8.9
Identitätsprobleme von JPA-Entities lösen ............................................................. Zusammengesetzte Primärschlüssel ........................................................................ Die automatische Schlüsselgenerierung .................................................................
567 570 573
Zeitliche Basic-Attribute ............................................................................................... Große Datenmengen ..................................................................................................... Transiente Attribute .......................................................................................................
Grundlagen ........................................................................................................................ Die unidirektionale Many-to-one-Assoziation ...................................................... Die bidirektionale One-to-many-many-to-one-Assoziation ............................. Die unidirektionale One-to-many-Assoziation .....................................................
Den EntityManager kennenlernen ............................................................................................. 520
8.4.1 8.4.2 8.4.3
14
8.7
Der Grundaufbau einer JPA-Entity ............................................................................ Die Konfiguration einer JPA-Entity ............................................................................ Die zusätzliche Deklaration in der »persistence.xml« ........................................ Benennung des Tabellennamens .............................................................................. Benennung des Spaltennamens ................................................................................ Den Zugriffstyp ändern .................................................................................................
Von Java zu SQL ................................................................................................................ 477 Das Abrufen automatisch generierter Schlüssel .................................................. 479
Die Auswahl der Datenbanktabellen ........................................................................ Assoziationen hinzufügen ............................................................................................ Den erzeugten Quelltext nachbessern ....................................................................
Eine einfache Abfrage programmieren .................................................................... 655 Eine Criteria-Query mit einer WHERE-Bedingung ................................................ 657 Mit dem Canonical Metamodel arbeiten ................................................................ 660 Spaltenfelder auf mehrere Klassen verteilen ......................................................... Attribute auf mehrere Tabellen verteilen ............................................................... Die Spaltenfelder einer separaten Tabelle als Collection beifügen ................ Vererbung und Polymorphie ........................................................................................ Konkurrierende Zugriffe steuern ................................................................................ Native SQL-Abfragen ......................................................................................................
Die Erstellung eines JSF-Projekts ................................................................................ Die Anpassung der Konfiguration .............................................................................. Die JSF-Konfigurationsdatei »faces-config.xml« .................................................. Extra-Abschnitt: JSF mit dem Apache Tomcat ....................................................... JPA einbeziehen und eine JPA-Entity als Model anlegen ................................... Eine Backing Bean als Controller programmieren ................................................ Die Erzeugung des Facelets mithilfe von Eclipse ..................................................
Die Arbeitsphasen ........................................................................................................... Bedeutende JSF-Klassen für die Backing Bean ....................................................... Die Navigation .................................................................................................................. Die UI-Komponenten in einem Facelet ....................................................................
Templating-Grundlagen ............................................................................................... Ein umfangreiches Beispiel mithilfe von Eclipse anfertigen ............................
798 802
Die Bilder des Onlineshops einbinden ..................................................................... Die CSS-Datei aus dem Buch ....................................................................................... Die Sprache über Länderflaggen ändern .................................................................
836 838 840
Die Backing Bean programmieren ............................................................................. Die View-Komponenten erstellen .............................................................................
Die Message Bundles ..................................................................................................... Die Anzeige der übersetzten Texte ........................................................................... Internationalisierte Messages in der Backing Bean .............................................
Die Konvertierung ............................................................................................................................. 793 9.7.1 9.7.2
9.8
762 768 770 774
Die Validierung ................................................................................................................................... 781 9.6.1 9.6.2 9.6.3 9.6.4
9.7
Meldungen für eine UI-Komponente ....................................................................... Globale Meldungen ........................................................................................................ Weitere Informationen anhängen ............................................................................ Project Stages ...................................................................................................................
Die Criteria-API .................................................................................................................................... 654 8.11.1 8.11.2 8.11.3
8.12
Zeichenketten auswerten ............................................................................................. Fallunterscheidungen .................................................................................................... Datum und Zeit ................................................................................................................ Parameter setzen ............................................................................................................. Individuelle Ergebnismengen mit dem »new«-Operator ................................... Über Assoziationsattribute navigieren ................................................................... Änderungen und Löschungen .................................................................................... Named Queries ................................................................................................................
Ein Faces-Flows-Beispiel ............................................................................................... Der Aufruf eines zweiten Flows .................................................................................. Die User-Story 3 als Flow ..............................................................................................
855 861 863
Events und Listener ........................................................................................................................... 869 9.12.1 9.12.2 9.12.3 9.12.4 9.12.5
Ajax-Grundlagen .............................................................................................................. 884 Die »ajax«-Komponente von JSF ................................................................................ 887 Pass-Through-Attribute ................................................................................................. 896 Pass-Through-Elemente ................................................................................................ 898
10 Enterprise JavaBeans
10.2
10.4
916 919 921 922
10.3.1 10.3.2 10.3.3 10.3.4
Die Erzeugung des Application-Client-Projekts ..................................................... Das EJB-Modul einbinden ............................................................................................. Die Bibliothek »gf-client.jar« hinzufügen ................................................................ Die Verknüpfung über JNDI ..........................................................................................
10.3.5 10.3.6
Der JNDI-Lookup für den entfernten Aufruf ........................................................... 930 Die »jndi.properties« ...................................................................................................... 932
924 926 927 928
Der lokale EJB-Client ......................................................................................................................... 934
Die Erstellung eines lokalen Business-Interface .................................................... Ein Java-Server-Faces-Projekt erstellen .................................................................... Eine JSF-Backing Bean .................................................................................................... Ein Facelet hinzufügen ................................................................................................... JPA einsetzen .....................................................................................................................
935 936 939 940 941
10.9
JMS-Grundlagen .............................................................................................................. Die serverseitige Konfiguration .................................................................................. Die clientseitige Konfiguration ................................................................................... Die Interfaces der Classic JMS API .............................................................................. Ein einfaches Beispiel mit der Classic JMS API ....................................................... Das Classic-JMS-Queue-Beispiel optimieren ......................................................... Einen JMS-Classic-Topic-Client erstellen ................................................................. Eine Session Bean für den JMS-Versand .................................................................. Die Simplified JMS API ................................................................................................... Message Driven Beans ...................................................................................................
969 974 977 984 986 996 1007 1018 1020 1026
Der Timer-Service ............................................................................................................................... 1039 10.9.1 10.9.2
Einen Timer programmieren ....................................................................................... 1040 Der zeitplangesteuerte Timer ..................................................................................... 1046
10.10 Webservices und EJB ........................................................................................................................ 1048 10.10.1 10.10.2 10.10.3 10.10.4
JAX-WS Kurzeinführung ................................................................................................ Ein einfacher JAX-WS-Webservice in drei Schritten ............................................ Das WSDL-Dokument .................................................................................................... Der JAX-WS-Webservice-Client ..................................................................................
1049 1051 1057 1064
10.10.5 10.10.6 10.10.7 10.10.8 10.10.9 10.10.10
Weitere wichtige JAX-WS-Bestandteile ................................................................... Einen File-Uploader erstellen ...................................................................................... Big Webservices und die Business Process Execution Language .................... EJB und JAX-WS ................................................................................................................ JAX-RS-Kurzeinführung ................................................................................................. Ein REST-Beispiel mit EJB und JPA ..............................................................................
1068 1071 1074 1074 1075 1079
Index ....................................................................................................................................................................... 1087
Die Erzeugung des EJB-Projekts .................................................................................. Die Stateless Session Bean erzeugen ........................................................................ Die Business-Methode programmieren ................................................................... Das Deployment ...............................................................................................................
Der entfernte EJB-Client .................................................................................................................. 924
Session Beans mit Eclipse ............................................................................................................... 916 10.2.1 10.2.2 10.2.3 10.2.4
10.3
Was ist eine Session Bean? ........................................................................................... Die Namenskonventionen bei Session Beans ........................................................ Die Business-Methoden von Session Beans ........................................................... Der entfernte und der lokale Aufruf .......................................................................... Business-Interfaces ......................................................................................................... Die optionalen Deployment-Deskriptoren ..............................................................
