Entwicklung von Unternehmenskomponenten mit der Enterprise JavaBeans-Technologie

Trainingsziel

Dieser Kurs vermittelt folgende Kenntnisse und Fähigkeiten:

• Implementieren von Unternehmensfunktionen mithilfe der EJB-Technologie



• Darstellen von Best Practices und anderen komplexen Sachverhalten bei der Entwicklung von Unternehmenskomponenten mit EJB.



• Erstellen und Implementieren von EJB-Komponenten der Enterprise-Klasse auf Anwendungsservern.



• Integration von EJB-basierten Anwendungen mithilfe der Java Messaging Service API.



• Erstellen und Verwenden von Query-Objekten mithilfe der Java-Persistenz-Abfragesprache (Persistence Query Language)

Teilnehmerkreis

Dieser Kurs richtet sich an Entwickler von Unternehmenskomponenten mit EJB(tm)-Technologie, die mit folgenden Aufgaben betraut sind: Analysieren, Entwerfen, Entwickeln und Testen von EJB-Anwendungen, Bereitstellen von EJB-Anwendungen, Integrieren von EJB-Anwendungen in eine Legacy-Anwendung.

Voraussetzungen

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

• Nachgewiesene Erfahrung mit der Programmiersprache Java.



• Integrieren von vorhandenem Java-Code (z. B. Wiederverwenden von anderen Teammitgliedern bereits erstellten Klassen).



• Entwurf von Java-Anwendungen.



• Obgleich nicht erforderlich, ist Erfahrung mit Konzepten des verteilten Computings in Java von Vorteil.

Im Vorfeld

SL-275-SE6: Java Programmierung

FJ-310-EE5: Anwendungsentwicklung für die Java EE-Plattform

Im Anschluss

SL-425: Entwicklung von Architekturen für Enterprise Java Anwendungen

SL-500-EE5: Java(TM) EE Patterns

Überblick über den Inhalt des Trainings

Der Kurs "Entwicklung von Unternehmenskomponenten mit der Enterprise

JavaBeans-Technologie" vermittelt Kenntnisse und Fähigkeiten zur

Entwicklung von robusten Back-End-Komponenten mit Enterprise JavaBeans

(EJB[TM]), Version 3.0. Am Beispiel eines Online-Auktions-Szenarios

wird aufgezeigt, wie sich Probleme aus der Praxis einer

E-Commerce-Anwendung durch Container-gestützte Services mit Session und

Message Beans sowie Entity-Klassen lösen lassen. Der Kurs vermittelt

hauptsächlich praktische Codiererfahrung in der EJB-Technologie, wobei

auch Entwicklungsoptionen und Best Practices erörtert werden, die

Probleme in den Bereichen Transaktionen, Messaging und Sicherheit

lösen. Der Kurs setzt die Java-Plattform, Enterprise Edition 5 (Java EE

5), ein und verwendet das Java EE 5 SDK. Die Teilnehmer führen die

praktischen Übungen mithilfe der NetBeans Integrated Development

Environment (IDE) 5.5 durch. In der praxisorientierten Übungsumgebung

kommt ein Server mit einer Referenzimplementierung von Java EE zum

Einsatz, sodass den Teilnehmern eine nicht-vendorspezifische

Lernerfahrung vermittelt wird.

Untersuchen von EJB-Anwendungen

• Einführung in die Java-Plattform, Enterprise Edition (Java EE)
• Untersuchen der Java EE-Anwendungsarchitektur.
• Untersuchen des Java EE-Anwendungserstellungsprozesses.

Einführung in die Auktionsanwendung

• Beschreiben der Auktionsanwendung.
• Definieren des Domänenobjekts der Auktionsanwendung.
• Beschreiben des Implementationsmodells für das Auktionssystem.

Implementieren von EJB 3.0 Session Beans

• Erstellen von Session Beans: Wesentliche Aufgaben
• Erstellen von Session Beans: Hinzufügen von Lebenszyklusereignis-Handlern
• Packen und Bereitstellen von Session Beans.
• Erstellen eines Session Bean-Clients.

Implementieren von Entity-Klassen: Grundlagen

• Definieren von Entity-Klassen: Wesentliche Aufgaben
• Verwalten des Lebenszyklus einer Entity-Instanz.
• Definieren von Entity Beans: Hinzufügen von Lebenszyklusereignis-Handlern
• Packen und Bereitstellen von Entity Beans.

Implementieren von Entity-Klassen: Modellieren von Datenassoziationsbeziehungen

• Untersuchen von Assoziationsbeziehungen in den Daten- und Objektmodellen.
• Verwenden von Beziehungseigenschaften zum Definieren von Assoziationen.
• Implementieren unidirektionaler und bidirektionaler Assoziationen.

Implementieren von Entity-Klassen: Modellieren von Vererbungsbeziehungen

• Untersuchen der Entity-Klassenvererbung.
• Erben von einer Entity-Klasse.
• Erben von einer abstrakten Entity-Klasse.
• Erben von einer Nicht-Entity-Klasse.
• Erben unter Verwendung einer eingebetteten Superklasse.
• Untersuchen von Vererbungszuordnungsstrategien.
• Definieren von Entity-Klassen: Verwenden einer eingebetteten Klasse
• Definieren von Entity-Klassen: Verwenden eines zusammengesetzten Primärschlüssels

Verwenden der Java-Persistenz-Abfragesprache (Query Language, QL)

• Untersuchen der Java-Persistenz-Abfragesprache (Query Language, QL).
• Erstellen und Verwenden der SELECT-Anweisung.
• Erstellen und Verwenden der BULK UPDATE-Anweisung.
• Erstellen und Verwenden der DELETE-Anweisung.
• Erstellen und Verwenden von Query-Objekten.

Entwickeln von Java EE-Anwendungen mit Hilfe von Messaging

• Beschreiben der Funktionen der Teilnehmer an einem JMS API-Messaging-System.
• Schreiben eines Nachrichtenerzeugers.
• Schreiben eines asynchronen Nachrichten-Listeners.
• Schreiben eines synchronen Nachrichten-Listeners.
• Aufführen der Messaging-Funktionen und -Einschränkungen von Session, Entity und Message-Driven Beans.

Entwickeln von Message-Driven Beans

• Beschreiben der Eigenschaften und des Lebenszyklus von Message-Driven Beans.
• Erstellen einer JMS Message-Driven Bean.
• Erstellen einer Nicht-JMS Message-Driven Bean.

Implementieren von Interceptor-Klassen und -Methoden

• Erstellen einer Unternehmens-Interceptor-Methode in der Enterprise Bean-Klasse.
• Erstellen einer Interceptor-Klasse.
• Verknüpfen mehrerer Unternehmens-Interceptor-Methoden mit einer Enterprise Bean.
• Aufnehmen von Lebenszyklus-Rückruf-Interceptor-Methoden in eine Interceptor-Klasse.
• Erstellen von Entity-Lebenszyklus-Rückrufmethoden.

Implementieren von Transaktionen

• Beschreiben der Transaktionsabgrenzungsaufgabe (demarcation).
• Implementieren von container-verwalteten Transaktionen (Container-Managed Transaction, CMT).
• Programmiertes Interagieren mit einer laufenden CMT-Transaktion.
• Implementieren von Bean-verwalteten Transaktionen (Bean-Managed Transaction, BMT).
• Anwenden von Transaktionen auf das Messaging.

Behandlungsausnahmen

• Einführen von Ausnahmen in Java EE-Anwendungen.
• Beschreiben des Ausnahmepfads in einer J2EE-Anwendungsumgebung.
• Beschreiben der Ausnahmebehandlung bei EJB-Containern.
• Ausnahmebehandlung bei den Methoden einer Enterprise Bean.
• Ausnahmebehandlung beim Clientcode einer Enterprise Bean.
• Prüfen spezieller Probleme im Zusammenhang mit der Ausnahmebehandlung EJB-Anwendungen.

Verwenden von Timer-Diensten

• Erstellen einer Timer-Rückrufbenachrichtigung.
• Verarbeiten einer Timer-Rückrufbenachrichtigung.
• Verwalten von Timer-Objekten.

Implementieren von Sicherheit

• Kenntnis der Java EE-Sicherheitsarchitektur.
• Authentifizieren des Aufrufenden.
• Untersuchen von Java EE-Autorisierungsstrategien.
• Verwenden von deklarativer Autorisierung.
• Verwenden von programmierter Autorisierung.
• Untersuchen der Aufgaben des Bereitstellers.

Verwenden von Best Practices für die EJB-Technologie

• Definieren von Best Practices und Formulieren der Vorteil der Verwendung von Best Practices für EJB.
• Auswählen und Anwenden bekannter Muster auf das Design von Java EE-Anwendungen.

Kurssprache deutsch, Unterrichtsmaterial überwiegend in englischer Sprache.