Anwendungsentwicklung für die Java EE-Plattform

Trainingsziel

Dieser Kurs vermittelt folgende Kenntnisse und Fähigkeiten:

• Beschreiben des Anwendungsmodells für die Java EE-Plattform und des Kontexts für dieses Modell.



• Entwickeln und Ausführen einer EJB-Anwendung.



• Entwickeln einer webbasierten Benutzeroberfläche für eine EJB-Anwendung.



• Entwickeln einfacher Web Services für die Java EE-Plattform.



• Konfigurieren der Java EE-Diensteschicht.

Teilnehmerkreis

Der Kurs richtet sich an Sun Certified Java Programmer, die Unternehmensanwendungen entwickeln wollen, die mit Standards der Java EE-Plattform kompatibel sind.

Voraussetzungen

Um diesen Kurs erfolgreich absolvieren zu können, sollten Sie über folgende Vorkenntnisse verfügen:

• Erfahrung im Umgang mit der Programmiersprache Java.



• Vertrautheit mit verteilter Programmierung (mehrschichtige Architektur).



• Vertrautheit mit der Theorie relationaler Datenbanken und den Grundlagen von SQL (Structured Query Language).



• Vertrautheit mit der Komponententechnologie.

Im Vorfeld

SL-275-SE6: Java Programmierung

OO-226: OO-Analyse und -Design mit UML

Im Anschluss

SL-314-EE5: Programmierung von Web-Komponenten mit Servlets und JSP(TM)

SL-351-EE5: Entwicklung von Unternehmenskomponenten mit der Enterprise JavaBeans-Technologie

Überblick über den Inhalt des Trainings

Der Kurs "Anwendungsentwicklung für die Java EE-Plattform" vermittelt die nötigen Kenntnisse für die Entwicklung und Bereitstellung von Unternehmensanwendungen, die mit den Standards der Java-Plattform, Enterprise Edition 5 (Java EE 5), kompatibel sind. Die Enterprise-Komponenten, die in diesem Kurs besprochen werden, reichen von Enterprise JavaBeans (EJB), der Java-Persistenz-API (JPA), Servlets und JavaServer Pages (JSP) bis zu Web Services und den Java-Clients, die diese Technologien verwenden. Die Teilnehmer erwerben praktische Erfahrung im Rahmen von Übungen, in denen eine verteilte End-to-End-Unternehmensanwendung entwickelt wird. Die Übungen behandeln Session EJBs, die die Session-Facade-Muster implementieren und die mit Hilfe der Java-Persistenz-API ein Front-End für Entity-Komponenten bereitstellen. Darüber hinaus werden in den Übungen Message-Driven EJB-Komponenten behandelt, die als Nutzer des Java Message Service (JMS) fungieren. Die Teilnehmer verwenden Web- und Java-Clients für den Zugriff auf Java-basierte Enterprise-Services, und zwar mit Hilfe von Servlets und Seiten, die mit JSP erstellt wurden. Die Teilnehmer lernen das Erstellen von Anwendungen aus wiederverwendbaren Komponenten sowie die Bereitstellung einer Anwendung in einer Java EE-Laufzeitumgebung. Die Teilnehmer führen die praktischen Übungen mit Hilfe der NetBeans(TM) Integrated Development Environment (IDE) 5.5 durch.



Einordnen des Java EE-Modells in einen Kontext.

• Beschreiben der Ansprüche von Unternehmensanwendungen und Beschreiben, wie Java EE 5-Technologie damit umgeht.
  
  
• Beschreiben der APIs (Application Programming Interface) der Java EE 5-Plattform und der unterstützenden Dienste.
  
  
• Beschreiben der Java EE-Plattformschichten und -architekturen.
  
  
• Beschreiben der Vorgehensweise zur Vereinfachung der Java EE-Anwendungsentwicklung mit Hilfe von Architekturmustern.

Java EE-Komponentenmodell und Entwicklungsschritte

• Beschreiben der Prinzipien eines komponentenbasierten Entwicklungsmodells.
  
  
• Beschreiben des asynchronen Kommunikationsmodells.
  
  
• Beschreiben des beim Entwickeln und Ausführen einer Java EE-Anwendung verwendeten Prozesses sowie der beteiligten Funktionen.
  
  
• Vergleichen der unterschiedlichen Methoden und Tools, die zur Entwicklung einer Java EE-Anwendung und dazugehöriger Komponenten zur Verfügung stehen.
  
  
• Beschreiben des Konfigurierens und Packens von Java EE-Anwendungen.

Webkomponentenmodell

• Beschreiben der Funktion von Webkomponenten in einer Java EE-Anwendung.
  
  
• Definieren des HTTP-Anforderung/Antwort-Modells (request-response).
  
  
• Vergleichen von Java-Servlets und -Komponenten mit JSP-Komponenten.
  
  
• Beschreiben der grundlegenden Sitzungsverwaltungsstrategien.
  
  
• Verwalten von Thread-Sicherheitsproblemen in Webkomponenten.
  
  
• Beschreiben des Zwecks von Web-Tier-Designmustern.

Entwickeln von Servlets

• Beschreiben der Servlet-API.
  
  
• Verwenden der Anforderungs- und Antwort-APIs (request/response).
  
  
• Weitergeben der Kontrolle und Übergeben von Daten.
  
  
• Verwenden der Sitzungsverwaltungs-API.

Entwickeln mit JavaServer Pages-Technologie

• Beurteilen der Funktion der JSP-Technologie als Präsentationsmechanismus.
  
  
• Schreiben von JSP-Seiten.
  
  
• Verarbeiten von Daten, die von Servlets in einer JSP-Seite empfangen wurden.
  
  
• Beschreiben der Verwendung von Tag-Bibliotheken.

EJB-Komponentenmodell

• Beschreiben der Funktion von EJB-Komponenten in einer Java EE-Anwendung.
  
  
• Beschreiben des EJB-Komponentenmodells.
  
  
• Identifizieren der ordnungsgemäßen Terminologie, die bei der Beschreibung von EJB-Komponenten und deren Elementen zu verwenden ist.

Implementieren von EJB 3.0 Session Beans

• Vergleichen von Stateless- und Stateful-Verhalten.
  
  
• Beschreiben der Betriebseigenschaften einer Stateless Session Bean.
  
  
• Beschreiben der Betriebseigenschaften einer Stateful Session Bean.
  
  
• Erstellen von Session Beans.
  
  
• Packen und Bereitstellen von Session Beans.
  
  
• Erstellen eines Session Bean-Clients.

Die Java-Persistenz-API

• Beschreiben der Funktion der Java-Persistenz-API (JPA) in einer Java EE-Anwendung.
  
  
• Beschreiben der Grundlagen der objektrelationalen Zuordnung.
  
  
• Beschreiben der Elemente und Umgebung einer Entity-Komponente.
  
  
• Beschreiben des Lebenszyklus und der Betriebseigenschaften von Entity-Komponenten.

Implementieren einer Transaktionsrichtlinie

• Beschreiben der Transaktionssemantik.
  
  
• Vergleichen der Geltungsbereichfestlegung von Transaktionen durch Programmierung und durch Deklaration.
  
  
• Verwenden der Java-Transaktions-API (JTA) zum Festlegen des Geltungsbereichs von Transaktionen durch Programmierung.
  
  
• Implementieren einer container-verwalteten Transaktionsrichtlinie.
  
  
• Unterstützen von Optimistic Locking durch Versionsverwaltung von Entity-Komponenten.
  
  
• Vorhersagen der Auswirkungen des Transaktionsgeltungsbereichs auf die Anwendungsleistung.
  
  
• Beschreiben der Auswirkung von Ausnahmen auf den Transaktionsstatus.

Entwickeln von Java EE-Anwendungen mit Hilfe von Messaging

• Beschreiben der JMS-Technologie.
  
  
• Erstellen eines Warteschlangen-Nachrichten-Erzeugers.
  
  
• Erstellen eines synchronen Meldungskonsumenten.
  
  
• Erstellen eines asynchronen Meldungskonsumenten.
  
  
• Auflisten der Funktionen und Einschränkungen von EJB-Komponenten als Messaging-Clients.

Entwickeln von Message-Driven Beans

• Beschreiben der Eigenschaften und des Lebenszyklus von Message-Driven Beans.
  
  
• Erstellen einer JMS Message-Driven Bean.
  
  
• Erstellen eines Lebenszyklusereignis-Handlers für eine JMS Message-Driven Bean.

Web Service-Modell

• Beschreiben der Funktion von Web Services.
  
  
• Auflisten der zum Herstellen der Unabhängigkeit von Web Service-Plattformen verwendeten Spezifikationen.
  
  
• Beschreiben der für die XML-Verarbeitung und für Web Services verwendeten Java-APIs.

Implementieren von Java EE Web Services mit JAX-WS

• Beschreiben von durch die Java EE 5-Plattform unterstützten Endpunkten.
  
  
• Beschreiben der Anforderungen von JAX-WS-Servlet-Endpunkten.
  
  
• Beschreiben der Anforderungen von JAX-WS-EJB-Endpunkten.
  
  
• Entwickeln von Web Service-Clients

Implementieren einer Sicherheitsrichtlinie

• Ausnutzen von container-verwalteter Sicherheit.
  
  
• Definieren von Benutzerfunktionen und -aufgaben.
  
  
• Erstellen einer funktionsbasierten Sicherheitsrichtlinie.
  
  
• Verwenden der Sicherheits-API.
  
  
• Konfigurieren von Authentifizierung in der Web-Tier.

Kurssprache deutsch, Unterrichtsmaterial überwiegend in englischer Sprache.