1042.book Seite 3 Dienstag, 8. Januar 2008 10:41 10 · Inhalt 9 3.6.3 Beschreibungen im...

Alfred Barzewski, Carsten Bönnen, Bertram Ganz, Wolf Hengevoss, Karl Kessler, Markus Küfer, Anne Lanfermann, Miroslav Petrov, Susanne Rothaug, Oliver Stiefbold, Volker Stiehl

Java-Programmierung mit SAP NetWeaver®

Bonn � Boston

1042.book Seite 3 Dienstag, 8. Januar 2008 10:41 10

Auf einen Blick

1 SAP NetWeaver ...................................................... 25

2 SAP NetWeaver Developer Studio im Überblick .... 55

3 SAP NetWeaver Developer Studio: Schritt für Schritt zur Beispielanwendung ............. 119

4 Java-Persistenz ....................................................... 169

5 Webservices und Enterprise Services im SAP NetWeaver Composition Environment ........... 219

6 Mit Web Dynpro Geschäftsanwendungen entwickeln .............................................................. 253

7 Verwendung von Web-Dynpro-Anwendungen im SAP NetWeaver Portal ........................................... 343

8 SAP NetWeaver Visual Composer .......................... 357

9 Entwicklung von Composite Applications .............. 391

10 SAP NetWeaver Development Infrastructure und Komponentenmodell – Konzepte ........................... 469

11 SAP NetWeaver Development Infrastructure – Konfiguration und Administration ......................... 555

12 SAP NetWeaver Development Infrastructure: Schritt für Schritt zur Beispielanwendung ............. 629

13 SAP NetWeaver Application Server Java: Architektur .............................................................. 673

14 Support-Fähigkeit des SAP NetWeaver Composition Environments .................................... 685


7

Inhalt

Vorwort zur 2. Auflage ................................................................. 17Vorwort zur 1. Auflage ................................................................. 21

1 SAP NetWeaver ........................................................ 25

1.1 Plattform für die Enterprise Service-Oriented Architecture ............................................................... 261.1.1 Enterprise-SOA-Definition ............................. 261.1.2 Vorteile einer serviceorientierten

Architektur .................................................... 271.1.3 Enterprise SOA by Design .............................. 28

1.2 Plattform für SAP ERP und die SAP Business Suite ...... 291.2.1 Enhancement Packages .................................. 321.2.2 Switch und Enhancement Framework ............ 331.2.3 Web Dynpro ABAP ........................................ 35

1.3 Plattform für Integration und Komposition ................. 351.3.1 Integration innerhalb eines Systems ............... 361.3.2 Integration durch Standards ........................... 371.3.3 Integrationsszenario Rechnungsprüfung ......... 371.3.4 SAP NetWeaver Process Integration ............... 391.3.5 SAP NetWeaver Composition Environment .... 42

1.4 Technology Map ......................................................... 451.4.1 User Productivity ........................................... 461.4.2 Information Management .............................. 491.4.3 Lifecycle Management ................................... 521.4.4 Security und Identity Management ................ 52

1.5 Ausblick ..................................................................... 53

2 SAP NetWeaver Developer Studio im Überblick ..... 55

2.1 Benutzeroberfläche ..................................................... 562.2 Workspace, Projekte und Entwicklungsobjekte ........... 592.3 Open-Source-Initiative ............................................... 61

2.3.1 Eclipse Software Development Kit .................. 632.3.2 Integration der Web Tools Platform ............... 642.3.3 SAP-spezifische Erweiterungen (Tools und

Infrastruktur) .................................................. 662.3.4 Erweiterbarkeit durch Drittanbieter ................ 70


Inhalt

8

2.4 Integrationsplattform ................................................. 712.4.1 Integration der SAP NetWeaver Develop-

ment Infrastructure ....................................... 712.4.2 Integration des SAP NetWeaver Application

Servers Java ................................................... 772.5 Tools und Perspektiven .............................................. 85

2.5.1 Development-Infrastructure-Perspektive ....... 852.5.2 Dictionary-Perspektive .................................. 882.5.3 J2EE-Perspektive ........................................... 922.5.4 Perspektive für Composite Applications ......... 962.5.5 Web-Dynpro-Perspektive .............................. 1002.5.6 Administrationsperspektive ........................... 1032.5.7 DTR-Perspektive ........................................... 105

2.6 Installation und Update – Ausblick ............................. 1072.6.1 Installations- und Update-Framework ............ 1072.6.2 Feature-Installation und Update .................... 1122.6.3 Deinstallation inaktiver Feature- und Plug-

in-Versionen ................................................. 1132.6.4 Installationsszenarien .................................... 114

3 SAP NetWeaver Developer Studio: Schritt für Schritt zur Beispielanwendung ................................ 119

3.1 Employee-Beispielanwendung .................................... 1203.2 Erste Schritte ............................................................. 1233.3 Datenmodell definieren ............................................. 125

3.3.1 Dictionary-Projekt anlegen ............................ 1253.3.2 Employee-Tabelle definieren ......................... 127

3.4 Zugriffe auf Tabellendaten realisieren ......................... 1313.4.1 EJB-Modul-Projekt anlegen ........................... 1323.4.2 Employee-Entity definieren ........................... 1333.4.3 Anwendung für Datenbankzugriffe

konfigurieren ................................................. 1403.5 Business-Logik definieren ........................................... 144

3.5.1 Session Bean anlegen .................................... 1443.5.2 Session-Bean-Klasse implementieren ............. 1463.5.3 Business-Methoden zum Business Interface

hinzufügen .................................................... 1523.6 JSP-basierte Webanwendung erstellen ....................... 154

3.6.1 Web-Modul-Projekt anlegen ......................... 1543.6.2 Benutzeroberfläche mit JSP implementieren ... 155


Inhalt

9

3.6.3 Beschreibungen im Deployment-Deskriptor web.xml ......................................................... 159

3.7 Java EE-Gesamtanwendung definieren und deployen .. 1613.7.1 Enterprise-Application-Projekt erstellen ......... 1613.7.2 Data-Source-Alias anlegen ............................. 1623.7.3 Deployment der Employee-Anwendung ......... 1643.7.4 Employee-Anwendung starten ....................... 167

4 Java-Persistenz ......................................................... 169

4.1 Open JDBC für Java .................................................... 1694.2 Persistenzinfrastruktur des SAP NetWeaver

Composition Environments zur Laufzeit ...................... 1704.2.1 Vendor JDBC ................................................. 1714.2.2 Native JDBC ................................................... 1714.2.3 Statement Pooling ......................................... 1724.2.4 SQL-Monitor ................................................. 1734.2.5 Tabellenpufferung .......................................... 1744.2.6 Administration von Datenquellen ................... 174

4.3 Java Dictionary ........................................................... 1764.4 Entwicklung einer Beispielanwendung ........................ 178

4.4.1 Projektmanagement-Szenario ......................... 1794.4.2 Implementierung des Beispielszenarios in

EJB 3.0 und JPA ............................................. 1814.5 Programmierung mit Enterprise JavaBeans 3.0/

Java Persistence API ................................................... 1854.5.1 Grundlegende Konzepte ................................ 1854.5.2 Vorbereitung des EJB 3.0-Projektes ................ 1864.5.3 Implementierung der Entitys .......................... 1904.5.4 Programmierung der Anwendungslogik .......... 2014.5.5 Einfluss von Open SQL auf die JPA Query

Language ....................................................... 2134.5.6 Einfluss der Datenbank auf die JPA Query

Language ....................................................... 2154.6 Ausblick ..................................................................... 218

5 Webservices und Enterprise Services im SAP NetWeaver Composition Environment ............ 219

5.1 Enterprise-Services-Paradigma .................................... 2215.2 Services Registry ......................................................... 222

5.2.1 UDDI-Server und Klassifizierungsservice ......... 223


Inhalt

10

5.2.2 Strukturierung von Services ........................... 2255.2.3 Service-Definitionen suchen .......................... 2285.2.4 Services klassifizieren ..................................... 230

5.3 Konsumieren eines Service ......................................... 2315.3.1 Ist der gewünschte Service bereits

vorhanden? ................................................... 2325.3.2 Anlegen des Web-Dynpro-Projektes .............. 2345.3.3 Verbindung zur Services Registry ................... 2385.3.4 Definition des Datenflusses und Anlage des

Web-Dynpro-UI ............................................ 2405.3.5 Initialisierung des Webservice-Models ........... 2425.3.6 Entwicklung von Web-Dynpro-Oberflächen ... 2445.3.7 Pflege der Webservice-Destinationen im

SAP NetWeaver Administrator ...................... 2465.3.8 Test der Enterprise-Service-Consumer-

Applikation ................................................... 2485.4 Ausblick: Bereitstellung eines Service mit dem

Enterprise Services Repository .................................... 249

6 Mit Web Dynpro Geschäftsanwendungen entwickeln ................................................................ 253

6.1 Grundlagen und Konzepte ......................................... 2556.1.1 Wesentliche Merkmale der Web-Dynpro-

UI-Technologie .............................................. 2556.1.2 Anatomie von Web-Dynpro-Komponenten ... 2616.1.3 Schnittstellen einer Web-Dynpro-

Komponente ................................................. 2656.2 Web Dynpro ruft Webservice ..................................... 267

6.2.1 Vorbereitung ................................................. 2716.2.2 Ansicht der vorbereiteten lokalen Web-

Dynpro-Development-Components ............... 2746.2.3 Importieren des Adaptive Webservice

Models .......................................................... 2786.2.4 Definition der Context-zu-Model-Bindung

im Component Controller .............................. 2876.2.5 Definition des Context-Mappings .................. 2936.2.6 View-Layout und Datenbindung .................... 2966.2.7 Controller-Implementierung .......................... 3086.2.8 Bauen, Deployen und Starten der

Anwendung .................................................. 315


Inhalt

11

6.3 Web-Dynpro-Komponente zur Suche von Ticker-Symbolen einbinden ........................................ 3166.3.1 Verwendungsbeziehung zwischen Web-

Dynpro-Development-Components definieren ...................................................... 322

6.3.2 Symbol-Search-Komponente in Stock-Quotes-Komponente einbinden ..................... 327

6.3.3 Drucktaste zur Suche von Ticker-Symbolen hinzufügen ..................................................... 332

6.3.4 Interface Controller der Symbol-Search-Komponente im View Controller verwenden ..................................................... 334

6.3.5 Aufruf der Symbol-Search-Komponente im View Controller ......................................... 336

6.3.6 Bauen, Deployen und Starten der erweiter-ten Beispielanwendung .................................. 340

7 Verwendung von Web-Dynpro-Anwendungen im SAP NetWeaver Portal ............................................. 343

7.1 Web-Dynpro-iViews im SAP NetWeaver Portal anlegen ...................................................................... 345

7.2 Anlegen einer Web-Dynpro-Seite ............................... 3477.3 Web-Dynpro-iViews zur Portalseite hinzufügen .......... 350

7.3.1 Anlegen von Rollen und Worksets ................. 3517.3.2 Web-Dynpro-Anwendungen für das Portal

entwickeln ..................................................... 3517.3.3 Personalisierbare Eigenschaften anlegen ......... 3527.3.4 Mehrere iViews von einer Web-Dynpro-

Anwendung aus aktivieren ............................. 354

8 SAP NetWeaver Visual Composer ............................ 357

8.1 Modellbasierte Entwicklung ....................................... 3578.2 Visual Composer im SAP NetWeaver Composition

Environment ............................................................... 3608.2.1 Was ist neu? .................................................. 3608.2.2 Voraussetzungen ............................................ 3618.2.3 Architektur .................................................... 3628.2.4 Anwendungserstellung ................................... 365

8.3 Beispielszenario .......................................................... 3668.3.1 Erstellen der Startseite ................................... 366


Inhalt

12

8.3.2 Mitarbeiteradressen aktualisieren .................. 3718.3.3 Persönliche Daten des Mitarbeiters

aktualisieren .................................................. 3808.3.4 Telefone des Mitarbeiters pflegen ................. 3818.3.5 Familienmitglieder des Mitarbeiters pflegen ... 3828.3.6 Abschlussarbeiten ......................................... 3828.3.7 Mitarbeiter anlegen ....................................... 3838.3.8 Mitarbeiter löschen ....................................... 3868.3.9 Zusammenfassung ......................................... 387

9 Entwicklung von Composite Applications ............... 391

9.1 Philosophie und Nutzen ............................................. 3929.2 Grundlegende Annahmen .......................................... 3949.3 Grundlegende Architektur .......................................... 395

9.3.1 Geschäftsobjekt- und Service-Schicht ............ 3969.3.2 User-Interface-Schicht ................................... 3999.3.3 Prozessschicht ............................................... 400

9.4 Beispielszenario: Projektabwicklung ........................... 4039.4.1 Modellierung von Geschäftsobjekten mit

dem Composite Application Framework ........ 4059.4.2 Modellierung von Benutzeroberflächen mit

dem SAP NetWeaver Visual Composer .......... 4269.4.3 Modellierung von Prozessen mit Guided

Procedures .................................................... 4359.4.4 Test von Composite Applications ................... 457

9.5 Installation und Einrichtung der Referenzapplikation ... 463

10 SAP NetWeaver Development Infrastructure und Komponentenmodell – Konzepte ............................ 469

10.1 Besonderheiten großer Softwareprojekte ................... 46910.1.1 Beispiel: Probleme eines typischen

Entwicklungsprozesses ohne zentrale Infrastruktur .................................................. 471

10.1.2 Softwarelogistik in der Java-Entwicklung ....... 47310.2 Elemente der SAP NetWeaver Development

Infrastructure ............................................................. 47510.2.1 Komponentenmodell ..................................... 47610.2.2 Design Time Repository ................................. 49710.2.3 Component Build Service .............................. 512


Inhalt

13

10.2.4 Change Management Service ......................... 52110.2.5 Entwicklungsprozess im Überblick .................. 531

10.3 Neuerungen der SAP NetWeaver Development Infrastructure .............................................................. 53410.3.1 Konfiguration der Verwendungsart DI nach

der Installation ............................................... 53410.3.2 Neuerungen im Design Time Repository ........ 53510.3.3 Neuerungen im Component Build Service ...... 53610.3.4 Neuerungen im Change Management

Service ........................................................... 53710.3.5 Verbesserungen im Logging der

SAP NetWeaver Development Infrastructure ... 54010.3.6 Neuerungen der Oberflächen ......................... 541

10.4 SAP NetWeaver Development Infrastructure und Komponentenmodell im Composition Environment .... 54210.4.1 Szenarien für die komponentenbasierte

Softwareentwicklung im Composition-Environment-Umfeld ...................................... 542

10.4.2 Komponentenbasierte Entwicklung mit lokaler Development-Configuration und optionaler externer Infrastruktur .................... 545

11 SAP NetWeaver Development Infrastructure – Konfiguration und Administration ........................... 555

11.1 Konfiguration der SAP NetWeaver Development Infrastructure .............................................................. 55611.1.1 Java-Entwicklungslandschaft .......................... 55711.1.2 Einrichten der SAP NetWeaver Develop-

ment Infrastructure ........................................ 56111.2 Administration der SAP NetWeaver Development

Infrastructure .............................................................. 58711.2.1 Produktdefinition im System Landscape

Directory ....................................................... 58711.2.2 Namensraumpräfix ......................................... 58911.2.3 Vorbereitung eines Tracks .............................. 59211.2.4 Entwicklungsschritte am Beispiel .................... 59911.2.5 Konsolidierungsphase .................................... 61211.2.6 Montage der Software und Qualitäts-

sicherung ....................................................... 61311.2.7 Auslieferung an die Kunden ........................... 614


Inhalt

14

11.3 Software Change Management mit der SAP NetWeaver Development Infrastructure .............. 61511.3.1 Verwaltung von Softwareprojekten für

verschiedene Zielplattform-Releases .............. 61611.3.2 Track-Design und Weiterentwicklung von

Produkten ..................................................... 61711.3.3 Modifikationskonzept der SAP NetWeaver

Development Infrastructure ........................... 61811.3.4 Nicht-ABAP-Transporte in einer gemischten

Systemlandschaft ........................................... 62111.3.5 SAP NetWeaver Development Infrastructure

in einer globalen Systemlandschaft ................ 624

12 SAP NetWeaver Development Infrastructure: Schritt für Schritt zur Beispielanwendung .............. 629

12.1 Employee-Beispielanwendung .................................... 63112.2 Erste Schritte mit der SAP NetWeaver Development

Infrastructure ............................................................. 63212.3 Entwicklungszyklus am Beispiel der Employee-

Anwendung ............................................................... 63412.3.1 Voraussetzungen eines Tracks für das SAP

NetWeaver Composition Environment als Zielplattform ................................................. 634

12.3.2 Anlegen von Produkt und Software-Component im System Landscape Directory ... 636

12.3.3 Update des Change Management Service ...... 63912.3.4 Anlage, Konfiguration und Vorbereitung

des Beispiel-Tracks ........................................ 64012.3.5 Start der Entwicklungsphase .......................... 64512.3.6 Zugriff auf Tabellendaten und Business-

Logik realisieren ............................................ 65912.3.7 Schritte im CMS nach der Entwicklung .......... 670

13 SAP NetWeaver Application Server Java: Architektur ............................................................... 673

13.1 Cluster-Architektur des SAP NetWeaver Application Servers Java ............................................................... 67413.1.1 Java-Instanz ................................................... 67513.1.2 Internet Communication Manager ................. 675


Inhalt

15

13.1.3 Central-Services-Instanz ................................. 67713.1.4 SAP Java Virtual Machine ............................... 678

13.2 Laufzeitarchitektur des SAP NetWeaver Application Servers Java ................................................................ 67913.2.1 Cluster-Kommunikation ................................. 68013.2.2 Cache-Verwaltung ......................................... 68013.2.3 Sitzungsverwaltung ........................................ 68113.2.4 Thread-Verwaltung ........................................ 682

14 Support-Fähigkeit des SAP NetWeaver Composition Environments ...................................... 685

14.1 Monitoring ................................................................. 68614.1.1 JMX-Infrastruktur ........................................... 68614.1.2 Monitore ....................................................... 68814.1.3 Hinzufügen neuer Inhalte zum Monitoring-

Framework ..................................................... 69014.1.4 Java-System-Reports ...................................... 691

14.2 Administration ............................................................ 69214.2.1 SAP NetWeaver Administrator ....................... 69314.2.2 Weitere Administrationswerkzeuge ................ 694

14.3 Fehlerbehebung ......................................................... 69714.3.1 Protokollierung und Tracing ........................... 69714.3.2 Szenarien der Fehlerbehebung ....................... 700

Die Autoren ................................................................................. 703Index ............................................................................................ 707


119

Anhand eines konkreten Beispiels werden Sie in diesem Kapi-tel an die praktische Arbeit mit dem SAP NetWeaver Develo-per Studio herangeführt. Auf dieser geführten Tour werden Sie Schritt für Schritt eine einfache Employee-Anwendung mit Mitteln des Java EE 5-Standards aufbauen, um sie dann auf dem SAP NetWeaver Application Server zu deployen und aus-zuführen. Sie werden bei dieser Gelegenheit das enge Zusam-menspiel verschiedener Tools der Entwicklungsumgebung ken-nenlernen.

3 SAP NetWeaver Developer Studio: Schritt für Schritt zur Beispiel-anwendung

VoraussetzungenDen optimalen Nutzen aus diesem Kapitel werden Sie vor allem dannziehen, wenn Sie mit der Programmiersprache Java bestens vertrautsind und darüber hinaus bereits Erfahrungen mit dem Java EE 5-Pro-grammiermodell gesammelt haben. Um alle Schritte auch praktischnachvollziehen zu können, benötigen Sie das SAP NetWeaver Deve-loper Studio und einen Zugriff auf den SAP NetWeaver ApplicationServer Java. Hierfür bietet sich das SAP NetWeaver Composition En-vironment 7.1 an, das Sie mit der DVD des vorliegenden Buches er-halten. Installieren Sie am besten diese Version, bevor es mit den ers-ten Fingerübungen losgeht.

ZielsetzungDie Beispielanwendung, die Sie Schritt für Schritt entwickeln wer-den, orientiert sich eher an didaktischen Aspekten als an dem Bemü-hen, ein realistisches Anwendungsszenario umzusetzen. Sie müssenalso weder eine Bankanwendung noch ein komplexes Warenhaussze-nario realisieren. Vielmehr sollen anhand eines leicht überschauba-ren Beispiels die Möglichkeiten vorgestellt werden, die das Develo-per Studio als Entwicklungsumgebung für Enterprise-Anwendungenauf der Grundlage der gängigen Java-Standards bietet. Im Vorder-grund stehen daher das Zusammenspiel verschiedener Toolsets und


120

SAP NetWeaver Developer Studio: Schritt für Schritt zur Beispielanwendung3

die Anbindung an Services, die den Entwicklungsprozess effizient un-terstützen und die tägliche Arbeit des Entwicklers erleichtern.

Sie können dieses Kapitel als einen Einstieg in die Arbeit mit dem De-veloper Studio ansehen. Nach Durcharbeitung aller Schritte diesesKapitels werden Sie in der Lage sein, die grundlegenden Abläufe undEntwicklungsschritte (UI- und EJB-Entwicklung, Entwurf des Daten-modells etc.) im Rahmen der Java EE-Standardentwicklung mit geeig-neten Tools im Developer Studio zu organisieren und die Aufgabenauf die passenden Projektarten und die zugehörigen Entwicklungs-objekte abzubilden.

Lokaler Entwick-lungsprozess

Alle Schritte werden lediglich aus der Sicht eines lokalen Entwick-lungsprozesses beschrieben. Die Projektressourcen werden aus-schließlich auf der lokalen Festplatte abgelegt und verwaltet. DesWeiteren wird vom SAP-Komponentenmodell in der Beispielanwen-dung abgesehen. Anders als unter Verwendung der SAP NetWeaverDevelopment Infrastructure handelt es sich bei den Projekten nichtum Development-Components. Wie Sie jedoch genau diese Beispiel-anwendung im NWDI-Kontext ins SAP-Komponentenmodell migrie-ren und unter Einbeziehung der zugehörigen Services realisierenkönnen, lernen Sie ausführlich in Kapitel 9, »Entwicklung von Com-posite Applications«.

3.1 Employee-Beispielanwendung

Die Beispielanwendung setzt auf einem vereinfachten Employee-Da-tenmodell auf und soll dem Benutzer erlauben, neue Employee-Da-tensätze anzulegen sowie Daten zu existierenden Employees auszu-geben. In der Architektur der Anwendung wird zwischen klarabgegrenzten Schichten unterschieden, so etwa zwischen der Präsen-tationsschicht, der Business-Logik, der Datenbeschaffung und derPersistenz. Dies wäre eigentlich für einen solch einfachen Fall wieden vorliegenden nicht zwingend notwendig, dennoch sollen Siesich von Beginn an mit der typischen Architektur von Geschäftsan-wendungen vertraut machen. Insbesondere erhalten Sie einen erstenEindruck, wie sich diese Architektur im Entwicklungsprozess wider-spiegelt und wie der Entwickler bei der Organisation seiner Projektevom Developer Studio unterstützt wird.


121

Employee-Beispielanwendung 3.1

Architektur der Beispielanwendung

Bei der Entwicklung der Benutzeroberfläche greifen Sie auf die inStandard-Webanwendungen gängige UI-Technologie, JavaServerPages (JSP), zu. Sie werden an einem einfachen Beispiel sehen, wiesich der Aufbau einer einfachen Oberfläche sowie die Zugriffe auf diedarunterliegenden Serverkomponenten realisieren lassen.

Die Business-Logik basiert auf Enterprise JavaBeans 3.0 undbeschränkt sich auf eine einzige Stateless Session Bean. Formal lässtsich bei der Session Bean zwischen dem Business Interface und derSession-Bean-Implementierung unterscheiden. Alle Business-Metho-den der Session Bean werden an ein korrespondierendes Business In-terface exponiert, sodass JavaServer Pages mithilfe genau dieses Inter-face auf die Session Bean zugreifen können. Zur anderen Seite hin kap-selt die Session Bean die jeweiligen Zugriffe auf die Persistence API.

Die Business-Daten modellieren Sie mithilfe einer einzigen Entity,die sowohl in der Business-Logik als auch in der PräsentationsschichtVerwendung findet. Da es sich bei Entitys um reguläre Java-Objektehandelt, können sie zugleich auch für den Datentransport zur Präsen-tationsschicht benutzt werden. Entsprechende Data-Transfer-Ob-jekte sind also nicht erforderlich. In diesem Zusammenhang ist dieEntity losgelöst (detached) vom aktuellen Transaktionskontext. Diesist in Abbildung 3.1 durch die gestrichelte Umrandung verdeutlicht.

Abbildung 3.1 Typische Architektur einer Java EE 5-Business-Anwendung

Business Interface

Session Bean

SAP JPA 1.0

JPA

JavaServer Pages

Database

Entity

Persistence Layer

Presentation Layer

Business Logic andBusiness Data

Entity


122


Business-Anwendungen kommen in aller Regel nicht ohne Persistie-rung von Daten in einer Datenbank aus. Mit Java EE 5 wurde einneues objektrelationales Persistenz-Framework, die Java PersistenceAPI (JPA), als Bestandteil des Java EE-Standards eingeführt. Ein sol-ches Framework hat im Wesentlichen die Aufgabe, für ein Mappingvon Java-Objekten auf die relationale Datenbank zu sorgen, diverseSuchabfragen sowie Manipulationen an Java-Objekten in die passen-den SQL-Anweisungen zu übersetzen und schließlich für die gesamteKommunikation mit der Datenbank aufzukommen.

Wie in Abbildung 3.1 wiedergegeben, beinhaltet der derzeitige SAPNetWeaver Application Server die konkrete JPA-Implementierungmit dem Namen SAP JPA 1.0. Die JPA liefert jedoch nicht die benö-tigten Datenbanktabellen oder Tabellendefinitionen mit, auf die diejeweiligen Entitys abgebildet werden, sondern geht bereits von vor-handenen Tabellen aus. Die erforderlichen Tabellen werden Sie mit-hilfe des Java Dictionarys bereitstellen. Mit Open JDBC lassen sichaus den Tabellendefinitionen die eigentlichen Datenbankobjekte imzugeordneten Datenbankschema anlegen.

Projektsicht auf die Beispielanwendung

Sie werden die Entwicklung der Beispielanwendung damit beginnen,dass Sie zuerst das zugrunde liegende Datenmodell erstellen. Dabeilegen Sie eine datenbankunabhängige Tabellendefinition mithilfe desJava Dictionarys an. Ausgehend von einem Dictionary-Projekt, er-stellen Sie ein SDA-Archiv (Software Delivery Archive) und deployenes auf den Applikationsserver. Nach diesem Schritt steht die Tabellephysisch auf der Datenbank zur Verfügung.

Für die Zugriffe auf Datensätze benutzen Sie JPA-Entitys. Die Imple-mentierung der Business-Logik der Anwendung (Anlegen neuer Em-ployees, Anzeige der Employee-Daten) wird von einer EJB 3.0 State-less Session Bean übernommen. Dabei dient das EJB-Modul-Projektim Developer Studio als Container für alle Enterprise JavaBeans, ein-schließlich der Entitys sowie für alle weiteren Ressourcen, wie etwafür die zugehörigen Konfigurationsdateien und Deployment-Des-kriptoren.

Für die Implementierung des Webclients ist eine einfache Oberflächemithilfe von JavaServer Pages vorgesehen. Diese soll auch die Daten


123

Erste Schritte 3.2

an die Session Bean übergeben können. Dabei werden alle Webres-sourcen in einem separaten Projekt, dem Web-Modul-Projekt ver-waltet, zusammen mit den zugehörigen Konfigurationsdateien.

In einem Enterprise-Application-Projekt führen Sie dann alle Res-sourcen zu einer Art Java EE 5-Gesamtanwendung zusammen. Dasresultierende Archiv (EAR) müssen Sie erst deployen, bevor Sie dieEmployee-Anwendung zum ersten Mal aufrufen können. Abbildung3.2 fasst die grundlegenden Abläufe zusammen und stellt die Orga-nisation der wesentlichen Entwicklungsobjekte in den jeweiligenProjektarten des Developer Studios dar.

3.2 Erste Schritte

StartparameterUm das Developer Studio zu starten, benötigt die aktivierte Platt-formlaufzeit neben dem Zugriff auf eine Java Virtual Machine (VM)auch eine Pfadangabe zur Ablage aller Metadaten für Projektinforma-tionen und benutzerspezifische Einstellungen. Eine Standard-Java-VM wird normalerweise bei der Installation des Developer Studioszugeordnet und ist als Startparameter eingetragen.

Abbildung 3.2 Organisation der Entwicklungsobjekte der Employee-Anwendung im Developer Studio

SAP NetWeaver Application Server Java

EJB Module Project

Web Module Project

Enterprise Application Project

DeploymentDescriptors

Dictionary Project

SDA

SAP NetWeaver Developer Studio

EAR

web.xml

persistence.xml

Dictionary Table

JavaServer Pages

Deploy

Deploy

SessionBean

Entity


124


Wenn Sie das Developer Studio nach erfolgter Installation zum ers-ten Mal starten,1 müssen Sie im Normalfall den Default-Workspaceangeben. Der Startvorgang wird dann unterbrochen, und es er-scheint ein Dialogfenster für die Auswahl des Workspace-Verzeich-nisses. Sie werden dann entweder den Vorschlagswert übernehmenoder ein anderes Verzeichnis für den Default-Workspace auswählen,um den Startvorgang fortzusetzen. Wenn Sie das Developer Studiowiederholt starten, wird der zugeordnete Workspace herangezogen.Der Startvorgang wird dann ohne Unterbrechung ausgeführt.

Beim ersten Aufruf zeigt die Entwicklungsumgebung eine Begrü-ßungsseite, die etwa so aussehen dürfte wie in Abbildung 3.3. Siekönnen diese Seite auch als einen Startpunkt für Ihre Entwicklungs-aktivitäten betrachten, an dem Sie mit Tutorials, einigen Beispiel-und Referenzanwendungen sowie ausgewählten Absprüngen zur Do-kumentation und weiterem Informationsmaterial versorgt werden.

1 Im Allgemeinen starten Sie das Developer Studio über den Desktop-Shortcut oderaus dem Windows-Startmenü heraus. Eine alternative und sehr flexible Optionsteht Ihnen zur Verfügung, wenn Sie Batch-Dateien verwenden. Auch mehrereBatch-Dateien lassen sich als Konfigurationsdateien verwenden, um das Develo-per Studio, je nach Bedarf, mit unterschiedlichen Parametern zu starten.

Abbildung 3.3 SAP NetWeaver Developer Studio nach erstem Aufruf – Begrüßungs-seite


125

Datenmodell definieren 3.3

Einstellungen unter Windows-Preferences

An dieser Stelle empfiehlt es sich, sich ein wenig mit den Standard-einstellungen zum Developer Studio vertraut machen und sie ge-gebenenfalls um weitere Einträge zu ergänzen. Die Preferences-Seiteerreichen Sie über den Menüpfad Windows � Preferences. BeimDurcharbeiten der Schritte dieses Kapitels werden Sie insbesonderedie Verbindung zum Java-Applikationsserver benötigen. Daher sollteein entsprechender Eintrag unter SAP AS Java vorhanden sein. Aufweitere Einstellungen, die für die Nutzung der Java Development In-frastructure erforderlich sind, wird in Kapitel 11, »SAP NetWeaverDevelopment Infrastructure – Konfiguration und Administration«,eingegangen.

3.3 Datenmodell definieren

Bevor Sie mit der Entwicklung der Employee-Anwendung beginnen,müssen Sie zunächst ein geeignetes Datenmodell definieren, das die-ser Anwendung zugrunde liegen soll. Aus didaktischen Gründenwird jedoch kein großer Wert auf ein ausgefeiltes Datenmodell miteiner Vielzahl von komplexen Tabellen und Beziehungen zueinandergelegt. Stattdessen soll das Datenmodell recht einfach gehalten wer-den, sodass Sie mit einer einzigen Tabelle auskommen, die die Ver-waltung von persistenten Employee-Daten übernehmen soll.

In diesem ersten praktischen Schritt werden Sie eine neue Tabelle imJava Dictionary anlegen und im zugehörigen Editor die gewünschtenSpalten hinzufügen. Anschließend werden Sie zu dieser Tabellende-finition ein zugehöriges Archiv anlegen. Aus dem Developer Studioheraus sind Sie dann in der Lage, dieses Archiv auf dem Applikations-server zu deployen und erreichen damit, dass die zunächst nur lokalvorliegende Tabellendefinition auch in eine physische Repräsenta-tion auf der Datenbankinstanz umgesetzt wird.

3.3.1 Dictionary-Projekt anlegen

Um Tabellen anzulegen, benötigen Sie zunächst ein passendes Pro-jekt im Developer Studio. Genau dafür sind Dictionary-Projekte vor-gesehen, die zur Design Time als Container sowohl für Dictionary-Datentypen und -Strukturen als auch für Tabellen oder auch Views inTabellen dienen. Einen initialen Projektrahmen für das neue Dictio-nary-Projekt lassen Sie mithilfe eines Wizards erstellen.


126


New ProjectWizard

1. Den Anlege-Wizard starten Sie über den Menüpfad File � New �

Project. Im angezeigten Wizard-Fenster wählen Sie die KategorieDictionary und anschließend den Eintrag Dictionary Project(siehe Abbildung 3.4) aus. Um zum nächsten Dialogschritt zugelangen, wählen Sie Next.

2. In dem nun angezeigten Wizard-Fenster werden Sie aufgefordert,einige allgemeine Projekteigenschaften zu vergeben. Dazu tragenSie im entsprechenden Eingabefeld den Namen »EmployeeDic«für das Dictionary-Projekt ein, lassen jedoch die Standardeinstel-lungen zu Project contents und Project language unverändert(siehe Abbildung 3.5).

3. Sie müssen jetzt nur noch Finish wählen und überlassen die wei-tere Arbeit dem Anlege-Wizard. Dieser generiert eine Standard-struktur für das neue Dictionary-Projekt und legt den Projektord-

Abbildung 3.4 Auswahl des Dictionary-Projektes im New Project Wizard

Abbildung 3.5 Allgemeine Angaben zum Dictionary-Projekt


127


ner namens EmployeeDic im zugeordneten Workspace-Verzeichnisan. Wenn Sie nun die Dictionary-Perspektive öffnen, ist ein gleich-namiger Projektknoten im Dictionary Explorer zu sehen.

Analog lassen sich im Developer Studio auch andere Projektarten,wie beispielsweise Web-Dynpro-Projekte oder die verschiedenenJava EE-Projektarten, mittels eines passenden Wizards erstellen.

3.3.2 Employee-Tabelle definieren

Im nächsten Arbeitsschritt erstellen Sie eine Tabelle für die Emplo-yee-Daten als Bestandteil des soeben angelegten Projektes und fügendanach die benötigten Tabellenfelder als Spalten hinzu.

1. Um eine Tabelle anzulegen, lassen Sie das Projekt EmployeeDicam besten im Dictionary Explorer anzeigen. Dort expandieren Siedie Projektstruktur und öffnen das Kontextmenü für den KnotenDatabase Tables.

2. Um den Anlege-Wizard zu starten, wählen Sie einfach den Menü-punkt Create Table aus dem Kontextmenü (siehe Abbildung 3.6)aus. Im angezeigten Dialogfenster werden Sie aufgefordert, einenNamen für die Tabelle zu vergeben.

Namenskonven-tionen für Daten-bankobjekte

Beachten Sie dabei, dass in der Regel ein Standardpräfix für denTabellennamen bereits im Eingabefeld vorgegeben ist. Wie Siesich mühelos überzeugen können, leitet sich dieses Präfix aus derVoreinstellung ab, die für die Dictionary-Objekte unter Windows� Preferences � Dictionary � Nameserver Prefix eingetragen ist. Die-ses Namenspräfix geht auf die Namenskonvention für Datenbank-tabellen zurück und ermöglicht eine eindeutige Trennung von Ent-

Abbildung 3.6 Anlegen einer Tabelle im Dictionary-Projekt


128


wicklungsobjekten, die bei Kunden, Partnern und bei SAP mitdem Ziel erstellt werden, Namenskonflikte zu vermeiden.2

Eine Sonderstellung haben die beiden Namensräume TMP_* undTEST_*. Diese können generell für Testobjekte und Prototypen ge-nutzt werden.

3. Für das vorliegende Beispiel genügt es demnach, wenn Sie das Na-menspräfix »TMP« verwenden. Für das Suffix tragen Sie denNamen »EMPLOYEES« ein und wählen schließlich Finish.

4. Als Resultat findet sich ein entsprechender Eintrag für die neue Ta-belle in der Projektstruktur unter dem Knoten Database Tables.Mit einem Doppelklick auf den Tabellennamen öffnen Sie den Ta-belleneditor und können jetzt auch die einzelnen Tabellenfelderhinzufügen.

Tabellenfelder 5. Das erste Feld soll den Namen »ID« erhalten, tragen Sie ihn unterColumn Name in der ersten Zeile der Tabellenmatrix ein. Da essich bei diesem Tabellenfeld um den Primärschlüssel der Tabellehandeln soll, kreuzen Sie auch das Feld Key an. Unter Build-InType wählen Sie den Datentyp long aus und geben die Kurz-beschreibung »Employees ID« unter Description ein. Standard-mäßig ist die Eigenschaft Not Null für jedes neue Feld gesetzt, undSie nutzen die Möglichkeit, initiale Werte für jedes Feld der Da-tenbanktabelle vorzugeben.

6. Das zweite Tabellenfeld erhält den Namen »LAST_NAME«. Fernerwerden diesem Feld ein String der Länge 30 als Datentyp3 und derKurztext »Employees last name« zugeordnet.

7. Als weitere Tabellenfelder kommen FIRST_NAME und DEPARTMENTund VERSION hinzu und werden, wie in Abbildung 3.7 dargestellt,definiert. Abschließend sichern Sie den jetzigen Stand der Tabel-lendefinition über die entsprechende Ikone aus der Toolbar.

Damit sind die grundlegenden Eigenschaften der Employee-Tabellefestgelegt. Sie sollen aber noch zwei weitere Schritte ausführen undauf etwas Allgemeines hingewiesen werden: Sie lernen, wie Sie einenIndex für eine Tabellenspalte einrichten und wie Sie darüber hinausnoch die Tabellenpufferung im Tabelleneditor aktivieren können.

2 Unter http://service.sap.com/namespaces besteht für Kunden und Partner von SAPdie Möglichkeit, ein Namenspräfix für Datenbankobjekte zu reservieren.

3 Aus den Angaben zu Build-in Type und Length resultiert die Zuordnung zumJDBC Type und wird vom Wizard automatisch umgesetzt.


129


Denn damit folgen Sie dem Grundsatz: So viele Entscheidungen wiemöglich bereits zur Design Time treffen!

SekundärindexGenerell ist zwischen Primär- und Sekundärindex bei Tabellen zu un-terscheiden – und Sie werden einen Sekundärindex verwenden. DerPrimärindex wird durch die Schlüsselfelder der Tabelle definiert undautomatisch zusammen mit der physischen Tabelle auf der Daten-bank angelegt. Normalerweise werden Datensätze nach dem Wert imPrimärschlüssel sortiert. Ist jedoch zu erwarten, dass in der Anwen-dung häufig nach einem anderen Feld auf Datensätze zugegriffenwird, so empfiehlt es sich, einen Sekundärindex für dieses Feld ein-zurichten.

1. Um beispielsweise einen Index zum Feld LASTNAME anzulegen,klicken Sie einfach auf die Registerkarte Indexes im Tabellenedi-tor, und wählen Sie dann die Pluszeichen-Ikone links in der Tool-bar.

2. Im angezeigten Wizard tragen Sie »EMPLOYEES_I1« als Suffix zumIndexnamen4 ein und beenden diesen Schritt mit Finish. Anschlie-ßend expandieren Sie die soeben generierte Baumstruktur zumneuen Index und wählen die Option Add/Edit Index Fields ausdem Kontextmenü des Fields-Knotens.

Abbildung 3.7 Definition von Spalten zur Tabelle TMP_EMPLOYEES im Tabelleneditor

4 Analog zu den Tabellennamen geht das Standardpräfix in den Indexnamen ein.Genau wie bei Tabellennamen sind auch die Indexnamen auf 18 Zeichen begrenzt.


130


3. Sie erhalten nun eine Liste der Tabellenfelder, aus der Sie dasgewünschte Feld auswählen (siehe Abbildung 3.8).

TechnischeEinstellungen

4. Auch für die Aktivierung eines Tabellenpuffers benötigen Sie nichtmehr als einige wenige Mausklicks. Dazu wählen Sie im Tabellen-editor die Registerkarte Technical Settings, markieren dort das zu-gehörige Ankreuzfeld und ordnen die Granularität5 der Pufferungwie in Abbildung 3.9 zu.

5. Im Verlauf der vorausgegangenen Prozedur wurden in diesemProjekt einige Tabellendefinitionsdaten generiert. Das gesamte Er-gebnis der bisherigen Bemühungen sichern Sie, indem Sie die ent-sprechende Ikone aus der Toolbar wählen.

Abbildung 3.8 Definition eines Indexes im Tabelleneditor

5 Mit der Granularität lässt sich bestimmen, ob die Tabelle mit allen Datensätzen(Fully Buffered) oder aber nur partiell in den Puffer geladen wird, sobald auf denersten Datensatz zugegriffen wird.

Abbildung 3.9 Aktivieren des Tabellenpuffers im Tabelleneditor


131

Zugriffe auf Tabellendaten realisieren 3.4

Damit ist die Tabelle vollständig definiert und liegt bislang als lokaleProjektressource in Form einer XML-Datei vor. Als ein wesentlichesResultat ist festzuhalten, dass die Tabelle als Bestandteil des Java Dic-tionarys über eine datenbankunabhängige Definition verfügt.

3.4 Zugriffe auf Tabellendaten realisieren

Java Persistence API

An dieser Stelle angelangt, müssen Sie sich entscheiden, wie Sie ineiner Java-Anwendung Zugriffe auf Tabellendatensätze durchführenwollen. Generell gibt es im Rahmen der Java-Entwicklung gleichmehrere Möglichkeiten für Datenpersistenz, und alle haben ihre Be-sonderheiten und Stärken. Da der SAP NetWeaver Application Ser-ver Java bereits den neueren Java EE 5-Standard unterstützt, werdenSie sich in der vorliegenden Beispielanwendung die Java PersistenceAPI (JPA) zunutze machen. Die Diskussion der verschiedenen Persis-tenzansätze im Kontext des AS Java finden Sie in Kapitel 4, »Java-Per-sistenz«, das sich ausdrücklich mit der Persistenz beschäftigt.

Die JPA ist die neue objektrelationale Persistence API für Java EE 5und als integraler Bestandteil des Java EE-Standards implementiert.Mit dieser für den Programmierer äußerst komfortablen technischenLösung werden die »leichtgewichtigen« Java-Objekte, die sogenann-ten Entitys, auf relationale Datenbanktabellen abgebildet. Entitys ba-sieren auf regulären Java-Objekten, häufig als POJOs (Plain Old JavaObject) bezeichnet, und müssen weder besondere Interfaces imple-mentieren noch spezielle Klassen erweitern. Zusätzlich zu der typi-schen Klassenimplementierung werden Sie sich jedoch um das Map-ping auf die passende Datenbanktabelle sowie der persistentenAttribute auf die jeweiligen Tabellenfelder kümmern müssen.6 Füreine Spezifizierung dieser Art von Metadaten bietet die JPA die kom-fortable Verwendung von Annotationen, die entweder manuell odermittels OR-Mapping-Tools zum Sourcecode der Entity-Klasse hinzu-gefügt werden.

6 Im Rahmen der anstehenden Auslieferung des SAP NetWeaver Composition Envi-ronments ist hier von deutlich komfortableren Lösungen auszugehen, die aufeiner engeren Integration der einzelnen Tools und Frameworks beruhen. Dem-nach sollte es möglich sein, ausgehend von Tabellendefinitionen aus dem Dictio-nary-Projekt, die korrespondierenden Entitys für das EJB-Modul zu generierenund umgekehrt.


132


3.4.1 EJB-Modul-Projekt anlegen

Um Entitys anzulegen, benötigen Sie zunächst einmal ein neues EJB-Modul-Projekt.

1. Dazu starten Sie erneut den New Project Wizard über den Menü-punkt File � New � Project. Entsprechend Abbildung 3.10 wählenSie im angezeigten Wizard-Fenster die Kategorie EJB � EJB 3.0 undanschließend EJB Project 3.0 aus.

2. Mit Next gelangen Sie zum nächsten Wizard-Fenster und tragendort »EmployeeEjb« als Namen für das neue Projekt ein. Im Übri-gen übernehmen Sie die vorgegebenen Einstellungen und be-schließen diese Prozedur mit Finish.

3. Der Anlege-Wizard generiert einen initialen Projektrahmen fürdas neue EJB-Projekt und legt einen Projektordner im Workspace-Verzeichnis an.

4. Nun starten Sie die J2EE-Perspektive, sofern dies noch nichtgeschehen ist, und lassen sich die Projektstruktur im Project Ex-plorer anzeigen. Diese Ansicht wird Ihnen von nun an als zentra-ler Ausgangspunkt für die weiteren Aktivitäten rund um die EJB3.0-Entwicklung dienen.

Im nächsten Schritt fügen Sie zu diesem Projekt eine Entity namensEmployee hinzu.

Abbildung 3.10 Auswahl des EJB-Modul-Projektes im New Project Wizard


133


3.4.2 Employee-Entity definieren

Wie bereits angesprochen, soll das Datenmodell in diesem einfüh-renden Beispiel so einfach wie möglich gehalten werden, daher sol-len Sie nur eine einzige Entity names Employee, in Übereinstimmungmit der bereits vorhandenen Tabelle TMP_EMPLOYEES, definieren.

Allgemeine Eigenschaften der Entity-Klasse

Zu diesem Zweck werden Sie im nächsten Schritt eine neue, seria-lisierbare Java-Klasse erstellen, die im Wesentlichen die passendenAttribute deklariert und die zugehörigen Setter- und Getter-Metho-den bereitstellt.

New Class Wizard1. Um eine solche Klasse zum EJB-Modul-Projekt hinzuzufügen, öff-nen Sie das Kontextmenü zu dem Projektknoten und wählen dieOption New � Class.

2. Als Namen für die neue Klasse tragen Sie »Employee« ein und ord-nen das Package com.sap.demo.entity zu. Darüber hinaus aktivie-ren Sie die Option Constructors from Superclass und fügen dasInterface Serializable zur Auswahl hinzu.

3. Sie übernehmen dann die üblichen Standardeinstellungen undlegen die Klasse mit Finish an.

4. Nach Abschluss der Anlegeprozedur öffnen Sie den Java Editorund fügen noch einige Felddefinitionen zum Klassenkörperhinzu7:

private long employeeId;private String lastName;private String firstName;private String department;private int version;

7 In Übereinstimmung mit der Spezifikation ist es empfehlenswert, ein Versionsfeld(version) zur Entity hinzuzufügen. Dieses Feld wird zur Laufzeit vom JPA-Con-tainer benutzt, um eine optimistische Verifikation durchzuführen und somitsicherzustellen, dass keine konkurrierenden Zugriffe auf ein und dieselbe Daten-quelle erfolgen. Sobald der Container Zugriffe dieser Art registriert, wird eineException an die Transaktion geworfen. Der letzte Datenzustand wird dann fest-gehalten und ein Rollback für die aktuelle Transaktion gesetzt. Mit diesem einfa-chen Mittel tragen Sie zur Datenkonsistenz bei.


134


Auf diese Weise statten Sie die Entity-Klasse genau mit den Fel-dern aus, die Sie in der korrespondierenden Employee-Tabelle alsTabellenfelder angelegt haben.

5. Dann markieren Sie im Editor alle Zeilen mit den soeben hinzu-gefügten Feldern und wählen Source � Generate Getters and Set-ters… aus dem Kontextmenü aus. Im angezeigten Auswahlfensterdrücken Sie auf die Taste Select All. Damit werden zu allen Felderndie zugehörigen Getter- und Setter-Methoden entsprechend Lis-ting 3.1 generiert.

public class Employee implements Serializable {private static final long serialVersionUID = 111L;private long employeeId;private String lastName;private String firstName;private String department;private int version;// non-arg constructorpublic Employee() {}public String getDepartment() {return department;}public void setDepartment(String department) {this.department = department;}public long getEmployeeId() {return employeeId;}public void setEmployeeId(long employeeId) {this.employeeId = employeeId;}[...]

}

Listing 3.1 Implementierung einer regulären Java-Klasse namens Employee

6. Zum Schluss sichern Sie den aktuellen Editorinhalt über die jewei-lige Ikone in der Toolbar.

Die Implementierung der Klasse Employee weist bislang keine Beson-derheiten auf. Sie definiert vier Felder employeeId, lastName,firstName, department sowie version und stellt die Getter- und Set-ter-Methoden entsprechend der Namenskonvention für JavaBeans


135


bereit. Bleibt einzig zu erwähnen, dass die JPA einen parameterlosenKonstruktor für eine Entity verlangt. Weitere Konstruktoren könnenjedoch hinzugefügt werden.

Da es sich hier nicht um eine abstrakte Klasse handelt, die zudemüber einen public-Konstruktor verfügt, haben Sie es bislang einzigmit einem POJO zu tun, das bereits instanziert werden kann. Dane-ben implementiert die Klasse das Interface java.io.Serializable,damit Entity-Objekte über remote Aufrufe bzw. in Webservice-Auf-rufen serialisiert werden können.

In diesem Zusammenhang folgen Sie der allgemeinen Empfehlung,und deklarieren explizit für die serialisierbare Klasse eine Ver-sionsnummer8 namens serialVersionUID. Aus diesem Grund wurdeein gleichnamiges Feld, das static, final und vom Typ long ist, imDeklarationsteil nachträglich hinzugefügt.

Objektrelationales Mapping

Streng genommen, liegt hier noch keine Entity vor, sondern nur eineinfaches JavaBean-Objekt. Was noch fehlt, ist eine Art Meta-Infor-mation9, die ein Mapping des Java-Objektes auf die relationale Da-tenbank beschreibt. Mittels der JPA lässt sich das recht einfach errei-chen, nämlich durch Hinzufügen der Annotationen zum Quelltextder Java-Klasse.

Mit dem einfachen Zusatz @Entity zur Klassendefinition identifizie-ren Sie die Klasse Employee als eine EJB 3.0 Entity. Mit diesem Schrittfordern Sie auch ein, dass die Entity auf eine Datenbanktabelle pas-send abgebildet wird. Zusätzlich benötigt das Persistenz-Frameworknoch die Informationen, wie die Entity auf die relationale Daten-banktabelle abgebildet wird.

8 Die Versionsnummer serialVersionUID wird von der Serialisierungslaufzeit fürjede serialisierbare Klasse für die Verifikation benötigt. Falls eine serialisierbareKlasse nicht explizit eine serialVersionUID deklariert, wird von der Laufzeit einDefault-Wert für diese Versionsnummer berechnet. Dieser Default-Wert kannjedoch von der Compiler-Implementierung abhängen. Um eine konsistente Ver-sionsnummer über alle Compiler hinweg zu garantieren, wird daher empfohlen,explizit eine serialVersionUID für die Klasse zu deklarieren.

9 Mit der JPA können Meta-Informationen zur Entity-Klasse nach wie vor mittelsDeployment-Deskriptoren in Form einer separaten XML-Datei abgelegt werden.Die Verwendung von Annotationen ist jedoch aus vielen Gründen vorzuziehen,unter anderem auch, weil sie im Standard Java SE 5.0 üblich ist.


136


Zu beachten bleibt, dass die JPA dem Anwendungsentwickler einensehr komfortablen Weg bietet, um, basierend auf einem Satz vonplausiblen Default-Regeln, ein solches objektrelationales Mapping zurealisieren. Falls keine expliziten Angaben, etwa zum Namen der Ta-belle oder der einzelnen Tabellenfelder, gemacht werden, geht dieJPA von bestimmten plausiblen Annahmen aus.

So würde in diesem Beispiel eine Entity mit dem Namen Employee ge-mäß diesen Regeln auf eine Datenbanktabelle namens EMPLOYEE abge-bildet werden. Da sich die Namen im vorliegenden Fall jedoch unter-scheiden sollen, haben Sie die Möglichkeit, mittels der Annotation@Table diese zu überschreiben. Analog verfahren Sie beim Mappingder persistenten Felder der Entity auf die korrespondierenden Tabel-lenfelder. Weicht ein persistentes Feld vom Namen des Tabellenfel-des ab, auf das es abgebildet werden soll, so wird schlicht die Anno-tation @Column unter Angabe des korrespondierenden Tabellenfeld-namens hinzugefügt. Dies trifft in diesem Fall zum Beispiel beim FeldEmployeeId zu, das auf das Tabellenfeld namens ID abgebildet wird.Anders verhält es sich dagegen beim persistenten Feld department,das auf ein gleichnamiges10 Tabellenfeld abgebildet wird, ohne dassSie hierfür eine explizite Angabe machen müssen. Um das Versions-feld als solches zu kennzeichnen, ist es erforderlich, die entspre-chende Annotation @Version zum Feld version hinzuzufügen.

1. Fügen Sie nun die benötigten Annotationen zum Java-Quellcodeder Klasse Employee wie in Listing 3.2 hinzu.

@Entity@Table(name="TMP_EMPLOYEES")public class Employee implements Serializable {

@Column(name="ID")private long employeeId;@Column(name="LAST_NAME")private String lastName;@Column(name="FIRST_NAME")

10 Die JPA-Spezifikation macht keine Angaben zur Beachtung von Groß- und Klein-schreibung bei Tabellen- und Feldnamen. In der Implementierung von SAP JPA1.0 gilt daher die folgende Regel: Ist der Name der Tabelle oder des Tabellenfel-des explizit mittels der Annotation aufgeführt, dann wird die Groß- und Klein-schreibung berücksichtigt. Wenn dagegen der Tabellenname oder das Tabellen-feld gemäß der Default-Regel generiert wird, wird die Großschreibungangewendet.


137


private String firstName;private String department;@Versionprivate int version;[...]

}

Listing 3.2 Annotationen im Quellcode der Employee-Klasse

2. Sofern dies noch nicht geschehen ist, fügen Sie schließlich nochdie fehlenden Imports zur Employee-Klasse hinzu. Dazu klickenSie auf eine beliebige Position im Java Editor und wählen Source �Organize Imports aus dem Kontextmenü aus.

3. Die fehlenden Importzeilen werden dann, wie in Listing 3.3 wie-dergeben, hinzugefügt, und es dürften jetzt keine Fehler mehr imQuellcode der Bean-Klasse angezeigt werden.

import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.Table;import javax.persistence.Version;

Listing 3.3 Ergänzung einiger Importzeilen zur Klasse Employee

Primärschlüssel generieren

Damit jede Instanz einer Entity eindeutig identifiziert werden kann,muss die Entity-Klasse über einen Identifikator verfügen, der zugleichin der zugeordneten Tabelle als Primärschlüssel dienen kann. Aus die-sem Grund ist bereits ein Feld namens EmployeeId angelegt, und Siewerden es als Identifikator für die Employee-Entity einsetzen. DieSpezifizierung des Identifikator-Feldes erfolgt schlicht mit der Anno-tation @Id, die dem Feld vorangestellt wird. In diesem Fall wird durchdas Mapping auf das Tabellenfeld ID dieses Feld mit dem Primär-schlüssel der korrespondierenden Datenbanktabelle identifiziert.

Als Nächstes stellt sich die Frage, welche Generierungsmethode zurErzeugung des Primärschlüssels heranzuziehen ist. Zugegeben,hierzu gibt es viele Lösungen und Strategien, doch diese alle zu erläu-tern, würde den Rahmen dieser Ausführungen überschreiten. Nur soviel: Generell können Schlüsselfelder mithilfe der Datenbank odermit Mitteln des Server-Containers oder auch durch die Anwendungselbst bereitgestellt werden. Die JPA-Spezifikation kommt dem Ent-wickler wieder entgegen und bietet verschiedene Strategien für eine


138


automatische ID-Generierung an. Der Entwickler selbst muss keineID-Generierungslogik implementieren, sondern kann mittels der An-notation @GeneratedValue eine automatische Primärschlüsselgene-rierung veranlassen und sich dabei die verschiedenen Strategien derGenerierung zunutze machen.

Tabelle fürID-Generierung

Sie werden im Folgenden sehen, wie die Tabellenstrategie eingesetztwird, bei der eine spezielle Tabelle für die Generierung der ID-Werteherangezogen wird. Zunächst muss allerdings eine entsprechendeTabelle erzeugt werden, da sie nicht von vornherein als eine Art Sys-temtabelle vom Framework bereitgestellt wird. Ein solcher Arbeits-schritt bereitet jedoch keine Mühe.

1. Öffnen Sie erneut die Dictionary-Perspektive, und fügen Sie eineweitere Tabellendefinition namens TMP_ID_GEN zu dem bereitsbestehenden Projekt EmployeeDic hinzu.

2. Die neue Tabelle soll genauso wie in Abbildung 3.11 definiert wer-den und die beiden Felder GEN_KEY und GEN_VALUE enthalten.11

Das Feld GEN_KEY definiert den Tabellenschlüssel und wird zurLaufzeit den voll qualifizierten Klassennamen enthalten. Das FeldGEN_VALUE ist für die Speicherung des zuletzt generierten ID-Wer-tes vorgesehen.

11 Die beiden Tabellenspalten GEN_KEY und GEN_VALUE bezeichnen die Standard-namen der SAP-JPA-Implementierung für Tabellen zur ID-Generierung. Abwei-chend davon können Sie für die ID-Tabelle auch andere Spaltennamen definie-ren, müssen in diesem Fall aber für ein entsprechendes Mapping in derAnnotation für den Tabellengenerator (@TableGenerator) sorgen.

Abbildung 3.11 Anlegen einer weiteren Tabellendefinition für die ID-Generie-rung im Dictionary-Projekt EmpoyeeDic


139


Annotation für den ID-Generator

3. Wie in Listing 3.4 wiedergegeben, lässt sich mithilfe dieser neuenTabelle ein passender ID-Generator definieren. Im Sourcecode derEmployee-Klasse fügen Sie daher noch die entsprechende Annota-tion @TableGenerator hinzu, indem Sie sie dem Klassennamen vo-ranstellen. Das Element table referenziert hier die soeben an-gelegte Tabelle für die ID-Generierung, während das Element namezur Identifikation des Generators verwendet wird. Der Name desGenerators wiederum wird über das Element generator mittelsder Annotation @GeneratedValue spezifiziert. Wie in Listing 3.4fügen Sie diese Annotation noch zum Klassenattribut employeeIdhinzu. Über das weitere Element strategy weisen Sie den Contai-ner an, zur Laufzeit die Generierungsmethode mit der Strategievom Typ TABLE zu verwenden.

@TableGenerator(name="idGenerator", table="TMP_ID_GEN",pkColumnName="GEN_KEY", valueColumnName="GEN_VALUE")public class Employee implements Serializable {@Id@GeneratedValue (strategy=GenerationType.TABLE,

generator="idGenerator")@Column(name="ID")private long employeeId;[...]

Listing 3.4 Definition eines Primärschlüssels für die Employee-Entity

Query-Abfrage mittels EJB-QL-Anweisung formulieren

Suchabfragen in Findermethoden

Bei der Realisierung von Zugriffen auf Datenbankdaten wird häufigvon Suchabfragen, den sogenannten Querys, Gebrauch gemacht. DieSpezifikation für EJB 3.0 hat vielfältige Möglichkeiten vorgesehen,wie Querys eingesetzt werden können. Ein wichtiger Bestandteilhierbei sind die benannten Parameter, die sowohl in statischen alsauch in dynamischen Querys Verwendung finden.

Möglicherweise erinnern Sie sich noch daran, wie für die früherenEJB-Versionen statische Querys im EJB Deployment Descriptor zudefinieren und dann in einem weiteren Schritt das Verhalten der Fin-dermethoden mittels der EJB-QL-Anweisungen zu spezifizieren wa-ren. EJB 3.0 führt diesen Ansatz fort und bietet hierzu eine verein-fachte Realisierung an. Es erlaubt dem Programmierer, statischeQuerys mittels der Annotation @NamedQuery innerhalb des Java-Sour-cecodes hinzuzufügen. Hierbei handelt es sich um eine vordefinierte


140


Query, die durch ihren Namen identifiziert wird. Wie bei Finderme-thoden üblich, wird das Verhalten der Methode nicht mittels Java-Sourcecode spezifiziert, sondern durch EJB-QL-Anweisungen,12 mitdenen sich geeignete Suchabfragen formulieren lassen.

Genau dies werden Sie an dieser Stelle nachholen und die benötigteEJB-QL-Anweisung für eine Query namens Employee.findAll for-mulieren.

1. Fügen Sie die Annotation @NamedQuery im Java Editor hinzu, undzwar vor der Definition der Klasse Employee.

2. Das Element name dient der Identifikation der Query mittels einesString-Wertes. Das Element query nimmt die EJB-QL-AnweisungSELECT e FROM Employee e auf (siehe Listing 3.5).

@NamedQuery(name="Employee.findAll",query="SELECT e FROM Employee e")

@Entity@Table(name="TMP_EMPLOYEES")public class Employee implements Serializable {

[...]

Listing 3.5 Definition einer Query-Abfrage für die Ausgabe aller Employee-Objekte

3.4.3 Anwendung für Datenbankzugriffe konfigurieren

Damit der EJB-Container die Datenbankzugriffe überhaupt behan-deln kann, muss er einige globale Einstellungen zur Persistenz, wieetwa den Namen der Data-Source, kennen, die für die Verbindung zurDatenbank erforderlich ist. In der Regel werden Konfigurationsaufga-ben vom Server übernommen, es gibt allerdings einige Ausnahmen.Daher ist im Folgenden beschrieben, wie diese wenigen Konfigurati-onsaufgaben einmalig für das EJB-Projekt vom Entwickler auszufüh-ren sind. Diese manuelle Konfiguration der Java-Persistenz erfolgt ineinem speziellen Persistenz-Deskriptor namens persistence.xml.

12 Bei EJB-QL handelt es sich um eine standardisierte Query-Sprache, mit der dasVerhalten von Findermethoden unabhängig von der eingesetzten Datenbankdeklarativ beschrieben wird. EJB-QL-Anweisungen haben eine gewisse Ähnlich-keit mit SQL-Anweisungen. Unter anderem finden Sie hier die SELECT-Anwei-sung wieder. Mit EJB 3.0 ist der Funktionsumfang der Query Language nocherweitert worden. Sie können praktisch alle Suchabfragen formulieren, wie diesauch mit Native SQL möglich ist.


141


Persistenz-Unit definieren

In einer typischen EJB-Anwendung besteht das Datenmodell meistaus mehreren, einander referenzierenden Entitys, die gemeinsam aufein und dasselbe Datenbankschema abzubilden sind. Sie haben nundafür Sorge zu tragen, dass alle zusammengehörigen Entity-Klassenauch für den EJB-Container zur Laufzeit eine logische Einheit bilden,vom Entity-Manager als solche verwaltet werden und auf ein unddieselbe Data-Source zurückgreifen. Eine solche logische Einheitwird als Persistenz-Unit bezeichnet.

Persistenz-Unit fasst Entitys zusammen

Sie umfasst also diejenige Menge von Entitys einer Applikation, diezur Laufzeit über den Entity-Manager adressiert werden. BeachtenSie dabei, dass eine Persistenz-Unit auch dann explizit gesetzt wer-den muss, wenn wie hier nur eine einzige Entity in Betracht kommt.

Alle zusammengehörigen Entitys, die eine Persistenz-Unit bilden,können in der Konfigurationsdatei explizit aufgelistet werden. Diesist jedoch nicht zwingend erforderlich, da das Persistenz-Frameworkanderenfalls die Anwendung nach Entitys durchsucht und diese au-tomatisch aufspürt. In dieser Beispielanwendung soll lediglich derName und eine Kurzbeschreibung für die Persistenz-Unit angegebenwerden, gemäß dem Motto: Konfiguration nur im Ausnahmefall.Darüber hinaus sind noch zwei weitere Angaben zu machen, einmalzur JTA Data Source sowie zum Versionsgenerator.

Konfiguration in persistence.xml

Da eine solche Konfigurationsdatei noch nicht im vorliegenden EJB-Projekt enthalten ist, erstellen Sie die Datei persistence.xml, und zwarausgehend vom passenden XML-Schema.

1. Wählen Sie dazu im Project Explorer das EJB-Projekt aus, undnavigieren Sie zum Ordner META-INF.

2. Aus dem Kontextmenü zu diesem Ordner wählen Sie denMenüpfad New � Other � XML � XML und navigieren mit Next zumfolgenden Schritt.

3. Auf der angezeigten Wizard-Seite selektieren Sie die Option Cre-ate XML file from an XML schema file und drücken erneut auf dieTaste Next.

4. Auf der folgenden Wizard-Seite geben Sie »persistence.xml« alsDateinamen ein und wählen wieder Next.


142


5. Wie in Abbildung 3.12 wiedergegeben, entscheiden Sie sich fürdie Option Select XML Catalog entry und dann für persistence_1_0.xsd aus dem angezeigten XML-Katalog.

6. Auf der darauffolgenden Wizard-Seite bestätigen Sie die Auswahlmit Finish.

7. Um den Inhalt des Persistenz-Deskriptors zu vervollständigen,bedienen Sie sich der Design-Ansicht (siehe Abbildung 3.13) undfügen über das Kontextmenü zum letzten Eintrag einige zusätz-liche Tags hinzu. Die benötigten Konfigurationsangaben finden Siein Tabelle 3.1.

8. Der Name der Persistenz-Unit ist generell frei wählbar und wirdzur XML-Source innerhalb des Elements <persistence-unit>hinzugefügt. Auf die Persistenz-Unit ist erneut zurückzukom-men, wenn in der Session Bean auf die Instanz der Entity mittelsdes Entity-Managers zugegriffen werden soll.

9. Innerhalb des Elements <persistence-unit> nutzen Sie den Tag<jta-data-source>, um den Data-Source-Alias einzutragen.Auch darauf wird zu einem späteren Zeitpunkt noch genauer ein-gegangen werden.

Abbildung 3.12 Auswahl des XML-Schemas beim Hinzufügen von persistence.xml zum EJB-Projekt

Abbildung 3.13 Hinzufügen weiterer Tags in der Design-Ansicht von persistence.xml


143


10. Schließlich fügen Sie noch eine <property> hinzu, um eine Ver-sionierung der Data-Source zu ermöglichen. Diese Angabe ist ausdem folgenden Grund erforderlich:

Um eine Versionierung der Data-Source überhaupt nutzbar zumachen, verlangt die JPA-Spezifikation, dass die Data-Source denIsolation-Level READ_COMMITTED verwendet. Um jedoch die Diffe-renz zwischen dieser Anforderung und dem tatsächlichen Isola-tion-Level READ_UNCOMMITTED aufzulösen, wird ein passenderVersionsgenerator benötigt. Einen solchen Generator adressiertman in persistence.xml über eine bestimmte Eigenschaft der Per-sistenz-Unit. Diese Eigenschaft spezifizieren Sie über das Na-menselement aus Tabelle 3.1.

Darüber hinaus benötigt ein Versionsgenerator eine geeigneteDatenbanktabelle. Hierfür eignet sich eine beliebige Generatorta-belle, die über die Feldnamen GEN_KEY und GEN_VALUE verfügt.Ohne Weiteres eignet sich die vorhin angelegte Tabelle TMP_ID_GEN auch zu diesem Zweck, deshalb ordnen Sie sie als Property-Wert zu.

11. Die generierte XML-Source entspricht dann den Zeilen in Listing3.6:

<?xml version="1.0" encoding="UTF-8"?><persistence xmlns="http://java.sun.com/xml/ns/persistence" [...]><persistence-unit name="EmployeePU">

<description>Sample Application Persistence Unit

</description>

XML-Tag Zugeordneter Wert

persistence-unit | name EmployeePU

persistence: descriptrion Sample Application Persistence Unit

persistence: jta-data-source TMP_EMPLOYEES_DATA

persistence: properties

property | name com.sap.engine.services.orpersis-tence.generator.versiontablename

property | value TMP_ID_GEN

Tabelle 3.1 Angaben zur Persistenz-Unit in persistence.xml


144


<jta-data-source>TMP_EMPLOYEES_DATA</jta-data-source><properties><property name = "com.sap.engine.services.

orpersistence.generator.versiontablename"value= "TMP_ID_GEN">

</property></properties>

</persistence-unit></persistence>

Listing 3.6 Resultierende XML-Source von persistence.xml

3.5 Business-Logik definieren

Nachdem Sie in Abschnitt 3.4, »Zugriffe auf Tabellendaten realisie-ren«, die Datenzugriffe mittels einer JPA-Entity realisiert haben,wenden Sie sich nun der Business-Logik zu. Da EJBs benutzt werden,sind Session Beans13 normalerweise der beste Weg, die Business-Logik zu kapseln.

StatelessSession Bean

Sie werden zu diesem Zweck eine Stateless Session Bean namensEmployeeServices anlegen, die erforderlichen Business-Methodenhinzufügen und implementieren. Mittels der Business-Methodensollten beliebige Clients in der Lage sein, die vom Benutzer einge-gebenen Employee-Registrierungsdaten aufzunehmen und sieschließlich zum Speichern an die Entity Employee weiterzugeben.Darüber hinaus sollten alle bestehenden Datensätze zu allen vorhan-denen Employees an Clients für die reine Anzeige weitergereichtwerden können.

3.5.1 Session Bean anlegen

Um eine Session Bean namens Employee Services anzulegen, startenSie den passenden Anlege-Wizard.

13 In verteilten Anwendungen implementieren Session Beans die anwendungsrele-vanten Prozesse und Aufgaben, realisieren das Transaktionsmanagement undvermitteln Zugriffe auf Low-Level-Komponenten, wie etwa auf Entitys oder aufandere Datenzugriffskomponenten sowie auf Hilfsklassen. Ein derartiger Einsatzvon Session Beans entspricht dem Session-Façade-Design-Pattern und dienteiner klaren Separation der verschiedenen Schichten (Datenzugriffe und Busi-ness-Logik) mit dem Ziel einer Performanceerhöhung zur Laufzeit.


145

Business-Logik definieren 3.5

1. Öffnen Sie das Kontextmenü auf dem Projektknoten EmployeeEjbim Project Explorer, und wählen Sie den Menüpunkt New � EJB �EJB 3.0 � EJB Session Bean 3.0.

2. Im angezeigten Dialogfenster ordnen Sie entsprechend zur Auf-stellung in Tabelle 3.2 einige elementare Eigenschaften zu.

3. Da keine weiteren Optionen für die anzulegende Session Bean er-forderlich sind, wählen Sie Finish und stoßen somit die Generie-rungsprozedur an.

4. Wie in Abbildung 3.14 wiedergegeben, legt der Wizard eine Bean-Klasse EmployeeServicesBean sowie das zugehörige Business In-terface mit dem Namen EmployeeServicesLocal an.

Da Sie beim Anlegen der Session Bean den Typ Stateless zugeordnethaben, wird diese Meta-Information in der generierten Bean-Klassedurch Voranstellen der entsprechenden Annotation @Stateless vordem Klassennamen abgelegt. Im Gegensatz zu stateful Session Beans

Feldbezeichnung Zugeordneter Wert

EJB Class Name EmployeeServices

EJB Project EmployeeEjb

Default EJB Package com.sap.demo.session

Session Type Stateless

Transaction Type Container

Create Business Interface Ankreuzfeld Local aktiviert

Tabelle 3.2 Allgemeine Eigenschaften beim Anlegen der Session Bean EmployeeServices

Abbildung 3.14 Session Bean EmployeeServices im Project Explorer


146


soll diese Session Bean nicht in der Lage sein, ihren Zustand in ihrerInstanzvariablen zu speichern. Die Anwendung sieht keine Speiche-rung von benutzerspezifischen Informationen vor; die Methoden derSession Bean werden sich demzufolge zustandslos verhalten.

Die Deklaration des Business Interface als lokales Interface bedingtwiederum, dass die Annotation @Local zu dem Interface-Namengeneriert wird. Wie bereits erwähnt, werden Business-Methoden derSession Bean an dieses Business Interface exponiert, sodass ein Clientmithilfe genau dieses Interface auf die Session Bean zugreifen kann.Bei einem lokalen Interface ist davon auszugehen, dass sich die EJBund der Client auf ein und demselben Server befinden.

3.5.2 Session-Bean-Klasse implementieren

Business-Methoden

Nach der bisher weitgehend deklarativen Vorgehensweise folgt nundie Implementierung der spezifischen Service-Funktionalität der Bei-spielanwendung. Mithilfe der sogenannten Business-Methoden wer-den Sie genau die Funktionen realisieren, die auch der Client-Anwen-dung zur Verfügung gestellt werden. Bei den Business-Methodenhandelt es sich um spezielle Methoden der Session Bean, die ihre spe-zifische, von außen verfügbare Service-Funktionalität implementie-ren.

Generell werden Business-Methoden als reguläre Java-Methoden inlokalen, in remote oder gegebenenfalls in beiden Business Interfacesdeklariert und in der zugehörigen Session-Bean-Klasse implemen-tiert. In Abhängigkeit vom Business Interface, das die entsprechendeBusiness-Methode zur Verfügung stellt, ist diese Methode entwederfür lokale oder Remote-Clients oder für beide verfügbar.

In den nachfolgenden Ausführungen werden Sie sehen, dass Sie le-diglich lokale Clients zu versorgen und einige Business-Methoden zuimplementieren haben, die bereits exemplarisch zeigen, wie einigeder Grundoperationen an persistenten Objekten zu realisieren sind:So werden Sie mithilfe der Methode createEmployee() lernen, wieein neuer Datensatz angelegt und dauerhaft in der Datenbank gespei-chert wird und wie mithilfe der Methode getEmployeeById()

die Suche nach einem Datensatz anhand des Primärschlüssels reali-siert werden kann. Ein weiterer lesender Zugriff steht in Verbindungmit einer Query-Ausführung und definiert die dritte Business-Me-thode getAllEmployees() für die Beispielanwendung.


147


Instanz des Entity-Managers erhalten

Entity-Manager als Schnittstelle zur Datenbank

Da die Business-Methoden in der Lage sein sollen, neue Datensätzeanzulegen, bestehende zu manipulieren und anschließend die Ände-rungen mit der Datenbank zu synchronisieren, benötigen Sie eineArt lokale Schnittstelle für die Interaktion mit der Datenbank. DieJPA stellt dem Anwendungsentwickler mit dem Entity-Manager einesolche Schnittstelle zur Verfügung. Denn die Aufgabe des Entity-Ma-nagers besteht genau darin, den Lebenszyklus von Entity-Objektenzu steuern und deren Zustand zu verändern. Mithilfe des Entity-Ma-nagers können Sie alle Datenbankoperationen an Entitys durchfüh-ren und so Objekte auf der Datenbank anlegen, verändern, lesen, su-chen oder löschen. Wie Sie, ausgehend von der Session Bean, auf diePersistenz-Unit zugreifen und den Entity-Manager für diese Persis-tenz-Unit definieren, ist in Listing 3.7 wiedergegeben.

@Statelesspublic class EmployeeServicesBean implementsEmployeeServicesLocal {

@PersistenceContext (unitName = "EmployeePU")private EntityManager eManager;

[...]}

Listing 3.7 Zugriff auf den Entity-Manager innerhalb der Session Bean

Wie Sie Listing 3.7 entnehmen können, deklariert die Session Beaneine Variable vom Typ EntityManager, ohne dass ihr ein bestimmterWert zugeordnet wird. Zwei Aspekte sind daran von Interesse sein:Zunächst einmal ist der Sourcecode ein Teil der Session Bean undwird auf dem Applikationsserver ausgeführt. Zum anderen ist die Va-riable mit der Annotation @PersistenceContext versehen. Zusätzlichenthält diese Annotation das Element unitName. Über diesen Parame-ter geben Sie den Namen der Persistenz-Unit an, auf der der Entity-Manager operiert. Sie erinnern sich sicher, dass der eingetrageneWert genau dem Namen entspricht, den Sie in der Konfigurationsda-tei persistence.xml bereits eingetragen haben.

Dies ist interessant, da die Session Bean hier eine Technik namensResource Injection verwendet. Mittels der Annotation wird es demServer überlassen, die Variable (hier: eManager) mit einerEntityManager-Instanz zu belegen. Somit wird gewährleistet, dass


148


diese Variable stets richtig initialisiert ist, wenn eine Business-Me-thode zum ersten Mal aufgerufen wird.

Neuen Employee-Datensatz auf der Datenbank anlegen

Nachdem Sie gesehen haben, wie Sie in der Bean-Klasse auf den En-tity-Manager zugreifen können, werden Sie im nächsten Schritt an-hand der Business-Methode createEmployee() sehen, wie einfachein neuer Datensatz auf der Datenbank angelegt werden kann. Zu-nächst einmal wird eine Instanz der Entity Employee über einen Kon-struktor angelegt. Die zur Spezifizierung eines Employees benötigtenDaten werden als Methodenparameter übergeben. Die Zugriffe aufdie persistenten Felder werden mithilfe der Setter-Methoden reali-siert. Das nun vollständig spezifizierte Objekt employee wird schließ-lich über die Methode persist() an den Entity-Manager übergeben,der ein dauerhaftes Speichern auf der Datenbank veranlasst. AlsResultat liefert die Business-Methode eine ID vom Typ long zurück.

Die vollständige Implementierung dieser Methode können Sie Lis-ting 3.8 entnehmen.

public long createEmployee(String lastName, StringfirstName, String department) {

long result = 0;Employee employee = new Employee();employee.setFirstName(firstName);employee.setLastName(lastName);employee.setDepartment(department);eManager.persist(employee);result = employee.getEmployeeId();return result;

}

Listing 3.8 Quellcode zur Business-Methode createEmployee()

Datensatz anhand einer ID suchen

Häufig muss eine Anwendung in der Lage sein, erst einmal einenbestimmten Datensatz auf der Datenbank zu identifizieren, bevor sieeine Operation auf diesen Daten ausführen kann. Eine Suche nacheinem bestimmten Employee-Datensatz anhand der ID (also des Pri-märschlüssels) ist in Listing 3.9 exemplarisch dargestellt.


149


public Employee getEmployeeById(long empId) {Employee employee =eManager.find(Employee.class, Long.valueOf(empId));return employee;

}

Listing 3.9 Quellcode zur Business-Methode getEmployeeById()

Der Aufruf erfolgt hier mittels der find()-Methode des Entity-Mana-gers. Diese Methode enthält zwei Argumente: Beim ersten Argumenthandelt es sich um die Entity-Klasse des zu suchenden Objektesselbst, während das zweite Argument die Objektrepräsentation desEntity-Identifizierers, also des Schlüsselfeldes, ist. Die find()-Me-thode liefert die gefundene Entity-Instanz oder aber null zurück,falls keine solche Entity in der Datenbank gefunden wurde. Da diefind()-Methode generisch implementiert wurde, ist ein Casting desResultatwertes in diesem Fall nicht erforderlich. Mit anderen Wor-ten, die find()-Methode ist so parametrisiert, dass der Typ des zu-rückgelieferten Resultats mit dem des ersten Arguments des Metho-denaufrufs übereinstimmt. Es wird also in jedem Fall eine Instanzvom Typ Employee zurückgegeben.

Query-Anfrage ausführen

Eine weitere Business-Methode getAllEmployees() soll nunmehr le-diglich der Demonstration dienen, wie Sie eine Query-Anfrage zumAuslesen einer Ergebnismenge verwenden können. Sicher erinnernSie sich, wie Sie in Abschnitt 3.4.2, »Employee-Entity definieren«,eine benannte Query (»Named Query«) mittels einer Select-Klauselformuliert haben. Dabei wurde eine Suchanfrage mit dem symbo-lischen Namen Employee.findAll im Sourcecode der Employee-En-tity hinterlegt. Diese Query sollen Sie nun zum Auslesen der Daten-bankdatensätze verwenden. So soll eine Liste zu allen existierendenEmployees an einen Client14 zurückgeliefert werden können.

14 Bei den Clients kann es sich um Java Server Faces, JSPs, Servlets, Java-Klassen,eine andere EJB oder aber um einen Webservice-Client handeln. Dabei kommtClients – insbesondere in großen Anwendungen – der Vorteil zugute, dass siekeine Suchanfragen selbst definieren müssen. Auch Änderungen und Anpassun-gen der Query-Form können zentral, ohne Einfluss auf den Client, vorgenom-men werden.


150


Wie Sie der Implementierung dieser Findermethode in Listing 3.10entnehmen können, lassen sich Query-Objekte über den Entity-Ma-nager erzeugen. Dies erfolgt schlicht mit dem Aufruf der MethodecreateNamedQuery(). Als Parameter wird ein Platzhalter übergeben,der lediglich den Namen der definierenden Query enthält. Das Aus-führen der Anfrage an die Datenbank und das Auslesen der Ergebnis-menge erfolgt mittels der Query-Methode getResultList().

@SuppressWarnings("unchecked")public List<Employee> getAllEmployees() {

Query query =eManager.createNamedQuery("Employee.findAll");

List<Employee> result =(List<Employee>) query.getResultList();return result;

}

Listing 3.10 Quellcode der Business-Methode getAllEmployees()

Um die Anzahl der Warnungen zum Compiler-Zeitpunkt zu minimie-ren, fügen Sie zusätzlich zum Sourcecode eine entsprechende Anno-tation hinzu. @SuppressWarnings dient lediglich zur Unterdrückungbestimmter Compiler-Warnungen im Zusammenhang mit dieserMethode.

Transaktionsverhalten der Business-Methoden festlegen

Bisher haben Sie an keiner Stelle irgendwelche spezifischen Angabenzum Transaktionsverhalten der Business-Methoden gemacht. Ledig-lich beim Anlegen der Session Bean haben Sie mit dem Attribut Con-tainer den Transaktionstyp bestimmt. Dies bedeutet, dass in einemsolchen Fall der EJB-Container die Steuerung der Transaktionenübernimmt. Sie haben bereits im Zusammenhang mit dem Entity-Manager gesehen, dass der EJB-Container dem Programmierer wich-tige Standardaufgaben abnimmt.

Bei diesem Transaktionstyp ist es demnach nicht erforderlich, dassdie Commit- oder Rollback-Methoden gesetzt werden, diese Aufgabeüberlassen Sie vollständig dem EJB-Container. Zwar gibt es bei EJBsgrundsätzlich die Möglichkeit, die Transaktionslogik programm-gesteuert in der Bean-Klasse selbst zu implementieren, aber die Ent-scheidung über das Transaktionsverhalten zugunsten des container-


151


gestützten Ansatzes beim Anlegen der Session Bean ist bereitsgefallen.

Transaktions-attribute

Das gewünschte Transaktionsverhalten zu den einzelnen Business-Methoden der Applikation bestimmen Sie mithilfe von Transaktions-attributen und tragen dabei der Tatsache Rechnung, dass alle Opera-tionen, die über die lesenden Zugriffe auf Datensätze hinausgehen,innerhalb einer Transaktion stattfinden müssen. Da es sich bei Trans-aktionsattributen um Metadaten handelt, benutzen wir, wiegewohnt, vordefinierte Annotationen. Die notwendigen Ergänzun-gen im Sourcecode finden Sie in Listing 3.11.

@Stateless@TransactionManagement(value=TransactionManagementType.CONTAINER)

public class EmployeeServicesBeanimplements EmployeeServicesLocal {

[...]public long createEmployee(String lastName, StringfirstName, String department) {[...]}@TransactionAttribute(TransactionAttributeType.SUPPORTS)public Employee getEmployeeById(long empId) {[...]}@TransactionAttribute(TransactionAttributeType.SUPPORTS)public List<Employee> getAllEmployees() {[...]}

[...]}

Listing 3.11 Transaktionsattribute der Business-Methoden der Session Bean EmployeeServices

Zunächst einmal legt die Annotation @TransactionManagement fest,dass die Transaktionskontrolle für die gesamte Session Bean an denContainer delegiert wird. Eine weitere Annotation @TransactionAttribute erlaubt es, den Transaktionskontext individuell an jedeeinzelne Methode anzupassen. Beachten Sie, dass zur MethodecreateEmployee() keine Annotation hinzugefügt wurde. Dies hateinzig und allein damit zu tun, dass für die zugrunde liegende Ope-ration das Default-Verhalten wirksam werden soll. Das zugehörige


152


Transaktionsattribut heißt REQUIRED und bedingt, dass eine neueTransaktion immer dann gestartet wird, wenn es erforderlich ist. Istetwa zum Zeitpunkt des Methodenaufrufs keine Transaktion aktiv, sostartet der Applikationsserver automatisch eine neue Transaktion,führt die Business-Methode aus und setzt einen Transaktions-Com-mit unmittelbar danach. Ist anderenfalls eine Transaktion bereits ver-fügbar, wird sie herangezogen. Daran erkennen Sie, dass das Anlegeneines neuen Employee-Datensatzes auf jeden Fall eine Transaktionerfordert, wenn auch nicht unbedingt eine exklusive. Hierfür ist dasTransaktionsattribut REQUIRED genau passend.

Anders verhält es sich bei den Methoden getEmployeeById() undgetAllEmployees(). Beide Methoden implementieren nur lesendeZugriffe. Da keine Änderungen an den Datensätzen resultieren, isteine Transaktion eigentlich nicht erforderlich. Falls jedoch eineTransaktion zum Zeitpunkt des Methodenaufrufs aktiv ist, wird sieauch verwendet. Eine neue Transaktion wird dagegen nicht gestartet.Aufgrund dieser Toleranz gegenüber den Transaktionen wird das De-fault-Verhalten mit dem Transaktionsattribut SUPPORTS überschrie-ben. Damit ist der Sourcecode der Bean-Klasse vollständig. Sofernnoch nicht geschehen, fügen Sie noch die fehlenden Importe zurBean-Klasse hinzu. Dazu klicken Sie auf eine beliebige Position imJava Editor und wählen Source � Organize Imports aus dem Kontext-menü aus. Die fehlenden Importzeilen werden dann hinzugefügt, esdürften nun keine Fehler mehr im Quellcode der Bean-Klasse ange-zeigt werden. Zum Schluss passen Sie nur noch die Formatierung derneuen Zeilen an, indem Sie aus dem Kontextmenü des EditorsSource � Format wählen und den Editorinhalt über die entspre-chende Ikone aus der Toolbar speichern.

3.5.3 Business-Methoden zum Business Interface hinzufügen

Da die in der Bean-Klasse bereits definierten Business-Methodennicht automatisch auch zum zugehörigen Business Interface hinzu-gefügt werden, müssen Sie diesen Schritt noch manuell nachtragen.

1. Um einzelne Business-Methoden aus der Bean-Klasse an dasBusiness Interface zu propagieren, wählen Sie die Bean-Klasse imProject Explorer mit einem Doppelkick aus. Falls keine Outline-


153


Ansicht in der aktuellen Perspektive angezeigt wird, öffnen Siediese zuerst.

2. Wie in Abbildung 3.15 gezeigt, markieren Sie alle Business-Me-thoden innerhalb der Outline-Ansicht, öffnen Sie das Kontext-menü, und wählen Sie dann die Option EJB methods � Add toLocal Interfaces.

3. Listing 3.12 gibt den resultierenden Sourcecode des Business In-terface wieder.

import javax.ejb.Local;import java.util.List;import com.sap.demo.entity.Employee;

@Localpublic interface EmployeeServicesLocal {

public List<Employee> getAllEmployees ();public Employee getEmployeeById (long empId);public long createEmployee (String lastName, String

firstName, String department);}

Listing 3.12 Business-Methoden im Business Interface EmployeeServicesLocal

Abbildung 3.15 Propagieren der Business-Methoden an das Business Interface, ausgehend von der Outline-Ansicht


154


3.6 JSP-basierte Webanwendung erstellen

Das Developer Studio sieht für die Verwaltung von Webressourcen,wie JavaServer Pages, JavaServer Faces, Servlets, statischen HTML-Seiten, Custom-Tag-Librarys sowie Bild- und Grafikdateien, eine spe-zielle Projektstruktur vor. Um den initialen Projektrahmen bereitzu-stellen, werden Sie zu Beginn ein entsprechendes Projekt, das heißt,ein Web-Modul-Projekt, anlegen.

Um auch die Webanwendung so einfach wie möglich zu halten,fügen Sie als einzige Ressource eine JSP zum Projekt hinzu und imp-lementieren mit ihr die Benutzeroberfläche des Webclients. Dabeisollen neben der reinen Präsentationsaufbereitung auch die Zugriffeauf die Business-Methoden der Session Bean EmployeeServices imp-lementiert werden. Exemplarisch nehmen Sie einige Informationenzur Konfiguration der Webanwendung im zugehörigen Deployment-Deskriptor auf.

3.6.1 Web-Modul-Projekt anlegen

Container fürWebressourcen

Um ein Web-Modul-Projekt anzulegen, führen Sie die folgendenSchritte durch:

1. Starten Sie erneut den New Project Wizard über den MenüpunktFile � New Project.

2. Im angezeigten Wizard-Fenster wählen Sie die Kategorie Web �

Web 2.5 und anschließend Dynamic Web Project 2.5 aus.

3. Mit Next gelangen Sie zum nächsten Wizard-Fenster und tragendort »EmployeeWeb« als Projektnamen ein. Ansonsten überneh-men Sie die vorgegebenen Einstellungen und beschließen dieseProzedur mit Finish.

4. Das Projektgerüst können Sie sich am besten im Project Exploreranschauen. Da Sie in einer JSP auch auf die Ressourcen aus demEJB-Modul-Projekt zugreifen wollen, müssen Sie diese Projekt-abhängigkeit zusätzlich berücksichtigen. Dazu klicken Sie auf denProjektnamen EmployeeWeb und wählen den Menüpunkt Pro-perties aus dem Kontextmenü aus.

5. Entsprechend den Angaben in Abbildung 3.16 selektieren Sie dieEigenschaft Java Build Path, klicken das Register Projects an undordnen das gewünschte Projekt zu.


155

JSP-basierte Webanwendung erstellen 3.6

3.6.2 Benutzeroberfläche mit JSP implementieren

Nun können Sie mit der Implementierung der Benutzeroberfläche imJSP Editor beginnen.

1. Um dem neuen Projekt eine JSP hinzuzufügen, klicken Sie denEintrag WebContent im Project Explorer an und wählen denMenüpunkt New � JSP....

2. Ein Wizard, in dem Sie den Namen »index.jsp« eintragen, er-scheint.

3. Weitere Angaben werden nicht verlangt, und Sie schließen denVorgang mit Finish ab.

Generell lassen sich im Quellcode der JSP zwei Anteile unterschei-den:

� ein HTML-Grundgerüst, das im Wesentlichen ein statisches Einga-beformular der Webanwendung definiert

� ein dynamischer, Java-basierter Anteil, mit dem die Zugriffe aufdie Business-Logik realisiert werden

HTML-Grundgerüst

Das Formular für die Registrierung neuer Employees könnte kaumeinfacher sein. Es enthält neben den beiden Eingabefeldern für die

Abbildung 3.16 Java Build Path zum Projekt EmployeeWeb zuordnen


156


Namen eine Auswahlliste mit den zugehörigen Abteilungen und eineDrucktaste, mit der der Benutzer eine Registrierungsaktion auslösenkann. All diese Oberflächenelemente sind innerhalb einer HTML-Tabelle angeordnet. Das vollständige Grundgerüst können Sie Listing3.13 entnehmen.

<%@ page language="java" [...] %><!DOCTYPE html PUBLIC [...] ><html>[...]

<body style= "font-family:Arial;" bgcolor="D2D8E1"><h2>Register New Employee</h2><form method="GET"><table border=0 align=center><tr><td width="150" >First name: <td><input type="text" name="firstname" value = "" size="20"><tr><td width="150" >Last name: <td><input type="text" name="lastname" value = "" size="20"><tr><td width="150" >Department: <td>

<select name="department" ><option value="DEVELOPMENT">Development</option><option value="TRAINING"> Training</option><option value="MANAGEMENT"> Management</option><option value="ARCHITECTURE"> Architecture</option>

</select><tr><td><td><br><input type="submit" value="Create" name="create"></table><br></form><!— Invoke business method --></body></html>

Listing 3.13 HTML-Grundgerüst für die JSP

157


Zugriffe auf die Session Bean

Entsprechend Listing 3.14 ergänzen Sie erst einmal den JSP-Quell-code mit einigen Page-Direktiven, deren Importattribute das benö-tigte Package für JNDI Lookup sowie das Business Interface enthalten.

Um die Referenz auf die Session Bean zu erhalten, wird ein JNDILookup auf der Kontextvariablen context ausgeführt. Beachten Siedabei, dass Sie mit EmployeeRegister in Listing 3.14 einen symbo-lischen Namen für die Session Bean verwenden. Dieser Name mussals Referenzname im Deployment-Deskriptor der Webanwendungnoch spezifiziert werden. Das Resultat des Lookups wird nach erfolg-tem Casting auf das Business Interface dem lokalen Employee-ObjektemployeeService zugewiesen.

<%<%@ page import="javax.naming.*" %><%@ page import=

"com.sap.demo.session.EmployeeServicesLocal" %>

<%!private EmployeeServicesLocal employeeService;private void lookup() {

try {InitialContext context = new InitialContext();employeeService = (EmployeeServicesLocal)context.lookup("java:comp/env/EmployeeRegister");

} catch (Exception ex) {System.out.println("Couldn't find bean"+

ex.getMessage());}

}

public void jspDestroy() {employeeService = null;

}%>

Listing 3.14 Dynamischer Anteil der JSP – Zugriff auf die Session Bean

Aufruf der Business-Methode

Im Folgenden sollen nicht alle Business-Methoden innerhalb diesereinfachen Webanwendung aufgerufen, sondern es soll nur exempla-

158


risch gezeigt werden, wie, ausgehend von einer JSP, die Business-Methode createEmployee() aufgerufen werden kann, um einenneuen Datensatz auf der Datenbank anzulegen. Auch dies ist einebewusste Vereinfachung, denn normalerweise besteht eine JSP-ba-sierte Webanwendung aus einer Kombination von JSPs und Servletsund eventuell weiteren JavaBeans als Hilfsklassen, um eine klareTrennung zwischen der reinen Präsentations- und der Controller-Schicht zu erreichen. Während JSPs für die Präsentationsaufberei-tung und somit als View-Komponente vorgezogen werden, agierenServlets oder JavaBeans meist als Controller und bilden die Anwen-dungslogik ab.

Um sich allerdings ein wenig Tipparbeit zu sparen, ist der Aufruf derMethode createEmployee() direkt in die JSP-Source eingebettet,ließe sich jedoch mühelos auf ein Servlet oder eine JavaBean in derRolle eines Controllers übertragen. Wie Sie Listing 3.15 entnehmenkönnen, geht dem eigentlichen Aufruf der Session-Bean-Methode einJNDI Lookup voraus, der zuvor in einer separaten Methode lookup()gekapselt wurde. Daher ruft das lokale Session-Bean-ObjektemployeeService die Business-Methode createEmployee() auf. AlsParameter werden dabei die lokalen Variablen lName, fName undeDepartment übergeben. Sie wurden in den ersten Zeilen des Quell-code-Auszugs definiert und nehmen die aktuell vom Benutzer ein-gegebenen Werte auf. Immer dann, wenn die Business-Methode er-folgreich im EJB-Container ausgeführt wird, liefert sie eine gültigeEmployeeID zurück. Anderenfalls wird eine Exception geworfen,und ein entsprechender Text wird auf der Benutzeroberfläche aus-gegeben.

<%lookup();if(this.employeeService == null) {throw new IllegalStateException("Bean not available!");

}

String fName = request.getParameter("firstname");String lName = request.getParameter("lastname");

String eDepartment = request.getParameter("department");if(lName == null || fName == null|| lName.length() == 0 || fName.length() == 0) return;

long empID = employeeService.createEmployee(lName, fName,


159


eDepartment);if(empID == 0)

out.println("<H3> Failed! </H3>");elseout.println("<H3> Success! </H3>");

%>

Listing 3.15 Dynamischer Anteil der JSP – Aufruf der Business-Methode

3.6.3 Beschreibungen im Deployment-Deskriptor web.xml

Die Informationen zur Konfiguration der Webanwendung nehmenSie im Deployment-Deskriptor web.xml auf. Die dort enthaltenenEinträge werden zum Deployment-Zeitpunkt vom Webcontainerausgewertet. Zum einen erhält der Webcontainer auf diesem Wegalle Informationen darüber, wie die einzelnen Ressourcen des Pro-jektes zueinander passen. Zum anderen ist die Zuordnung von Secu-rity-Rollen, über die sich die Zugriffsberechtigung für die Weban-wendung als Ganzes zur Laufzeit steuern lässt, in web.xml enthalten.

Hier werden jedoch nur einige Mapping-Informationen im Deskrip-tor hinterlegt. Im folgenden Schritt werden Sie exemplarisch eine Re-ferenz auf die benötigte Session Bean mittels eines symbolischen Na-mens definieren, aber auf weitere Angaben zur Konfiguration derWebanwendung verzichten.

Symbolischer Name für die Session Bean

Referenz auf die Session Bean

Für den Zugriff auf die Session Bean wurde im JSP-Quellcode (sieheListing 3.14) nicht der echte Bean-Name, sondern ein symbolischerName verwendet. Damit der Webcontainer einen solchen Namenauch zur Laufzeit korrekt zuordnen kann, muss eine entsprechendeAbbildungsvorschrift im Deployment-Deskriptor hinterlegt werden.

1. Um einen symbolischen Namen für eine Referenz auf die SessionBean zu definieren, öffnen Sie den Deployment-Deskriptor web.xml. Dort klicken Sie auf das Register Design und fügen einen wei-teren Tag für die EJB-Referenz hinzu.

2. Analog zu den Angaben in Abbildung 3.17 setzen Sie den EJB-Namen »EmployeeRegister«, sodass er mit dem Eintrag im JNDILookup im JSP-Quellcode aus Listing 3.14 übereinstimmt.


160


3. Die neuen Einträge werden automatisch zur XML-Source an pas-sender Stelle hinzugefügt. Sie können sich davon überzeugen,indem Sie auf das Register Source klicken und dann in der an-gezeigten XML-Source zum Element <ejb-local-ref> navigieren(siehe Listing 3.16).

<?xml version="1.0" encoding="UTF-8"?><web-app id="WebApp_ID" version="2.5" [...]"><display-name> EmployeeWeb</display-name><welcome-file-list>

[...]</welcome-file-list><ejb-local-ref><ejb-ref-name>EmployeeRegister</ejb-ref-name><ejb-ref-type>Session</ejb-ref-type><local>com.sap.demo.session.EmployeeServicesLocal

</local></ejb-local-ref>

</web-app>

Listing 3.16 Generierte XML-Source für die Referenz auf die Session Bean

4. Mit diesem Eintrag haben Sie nun eine Abbildung zwischen einemfrei wählbaren Referenznamen (symbolischen Namen) und demechten Bean-Namen definiert. Damit kann der einmal im Quelltextder JSP vergebene Referenzname für die Session Bean verwendetwerden und bleibt dort unverändert, selbst wenn sich der Bean-Name ändern sollte.

Abbildung 3.17 Setzen der EJB-Referenz auf die Session Bean in web.xml


161

Java EE-Gesamtanwendung definieren und deployen 3.7

3.7 Java EE-Gesamtanwendung definieren und deployen

Während mit dem EJB-Modul die Business-Funktionalität bereit-gestellt wird, sind mit dem Web-Modul auch die passenden Web-komponenten hinzugekommen. An dieser Stelle müssen nur alleKomponenten zu einer Java EE-Gesamtanwendung zusammengestelltwerden. Das Developer Studio bietet dazu eine spezielle Projektart,nämlich ein Enterprise-Application-Projekt, an.

Um die Employee-Gesamtanwendung zu erstellen, legen Sie zu-nächst ein Enterprise-Application-Projekt namens »EmployeeEar«an. Hier richten Sie noch eine Konfigurationsdatei für den Data-Source-Alias ein, bevor Sie das entsprechende EAR für die Gesamtan-wendung generieren und dieses schließlich auf den Application Ser-ver Java deployen.

3.7.1 Enterprise-Application-Projekt erstellen

Um das Projekt anzulegen, gehen Sie folgendermaßen vor:

1. Starten Sie erneut den New Project Wizard über den MenüpunktFile � New Project.

2. Im angezeigten Wizard-Fenster wählen Sie die Kategorie J2EE �

Java EE und anschließend Enterprise Application Project 5 aus.

3. Mit Next gelangen Sie zum anschließenden Wizard-Fenster undtragen dort »EmployeeEar« als Projektnamen ein. Im Übrigenübernehmen Sie die vorgegebenen Einstellungen und wechselnmit Next zum folgenden Wizard-Fenster.

4. Entsprechend den Angaben in Abbildung 3.18 ordnen Sie das EJB-Modul EmployeeEjb.jar und das Web-Modul EmployeeWeb.wardem EAR-Projekt zu, bevor Sie diese Prozedur mit Finish beenden.

Abbildung 3.18 Hinzufügen der Module Ejb und Web zum EAR-Projekt


162


3.7.2 Data-Source-Alias anlegen

Wie Sie sich sicherlich erinnern, haben Sie im Deployment-Deskrip-tor persistence.xml einen Namen für den Data-Source-Alias eingetra-gen. Ein solcher Data-Source-Alias wurde allerdings bisher an keinerStelle angelegt. Dies holen Sie jetzt nach. Bevor Sie jedoch weitereSchritte unternehmen, soll in einem kurzen Exkurs die Bedeutungdes Data-Source-Alias verdeutlicht werden.

Data-Source-Aliasals Bindeglied zwi-schen Anwendung

und Datenbank

Da eine entsprechende Konfigurationsdatei für den Data-Source-Alias noch nicht im vorliegenden Projekt enthalten ist, erstellen Siediese, vom passenden XML-Schema ausgehend, zuerst.

1. Wählen Sie im Project Explorer das Projekt aus, und navigierenSie zum Folder META-INF.

2. Aus dem Kontextmenü dieses Folders selektieren Sie denMenüpfad New � Other � XML � XML und drücken dann auf die

Exkurs: Datenbankzugriffe und Data-Source-Alias

Der Data-Source-Alias wird benötigt, um die Kommunikation zur Daten-bank für Tabellenzugriffe aus der Anwendung heraus zu ermöglichen. Beieinen Data-Source-Alias handelt es sich um einen logischen Namen für dieserverseitige Adressierung einer Datenbankressource (in diesem Fall derTabelle). Der Connection-Pool auf dem Applikationsserver verfügt überdie Kenntnis des Pfades zur Datenbanktabelle, das heißt, die eigentlicheData-Source, die auf dem Server bereits vorhanden sein muss.

Eine besondere Rolle spielt dabei die Default-Data-Source (auch System-Data-Source bezeichnet), die automatisch bei der Installation des AS Javaangelegt und nicht mit einer spezifischen Anwendung assoziiert wird. DieDefault-Data-Source ist als Default-Connection-Pool für die Verwendungdurch mehrere Anwendungen vorgesehen.

Wenn Sie nun im Enterprise-Application-Projekt den Data-Source-Aliasanlegen, dann werden Sie ihn mit der Default-Data-Source assoziieren.Die Verwendung eines Alias hat hier gleich mehrere Vorteile:

� Der Entwickler muss nicht den physischen Pfadnamen für die Daten-bankressource angeben. Nur das Datenbanksystem benötigt die Infor-mationen zur Verwaltung der eigenen Ressourcen.

� Darüber hinaus wird der Alias im Developer Studio vergeben undeinem spezifischen Projekt zugeordnet. Damit entfällt für den Entwick-ler die sonst erforderliche administrative Aufgabe, die er in einemseparaten Administrationstool vornehmen müsste.

� Nicht zuletzt ermöglicht die Verwendung eines Data-Source-Alias, diegesamte Anwendung portabel zu halten.


163


Taste Next. Auf der angezeigten Wizard-Seite wählen Sie die Op-tion Create XML file from an XML schema file und drücken dannwieder die Taste Next.

3. Auf der folgenden Wizard-Seite geben Sie data-source-aliases.xmlals Dateinamen ein und wählen erneut Next.

4. Wie in Abbildung 3.19 wiedergegeben, entscheiden Sie sich fürdie Option Select XML Catalog entry und suchen dann data-source-aliases.xsd aus dem angezeigten XML-Katalog aus.

5. Auf der darauffolgenden Wizard-Seite treffen Sie die Auswahldata-source-aliases für das Root element und bestätigen dies mitFinish. Mit diesem Schritt wird die XML-Datei namens data-source-aliases.xml angelegt, die nun auch in der Projektstruktursichtbar ist.

6. Öffnen Sie nun den XML-Editor, und tragen Sie die System-Data-Source »${com.sap.datasource.default}« und den Namen »TMP_EMPLOYEES_DATA« für den Alias ein.

Der Aliasname wird beim Deployment der System-Data-Source zu-geordnet. Das können Sie leicht nachvollziehen, indem Sie sich diegenerierte XML-Source anschauen. Sie entspricht den Zeilen in Lis-ting 3.17.

<?xml version="1.0" encoding="UTF-8"?><data-source-aliases [...]><aliases><data-source-name>${com.sap.datasource.default}

</data-source-name>

Abbildung 3.19 Hinzufügen eines Data-Source-Alias zum EAR-Projekt


164


<alias>TMP_EMPLOYEES_DATA</alias></aliases>

</data-source-aliases>

Listing 3.17 com.sap.datasource.default als Repräsentant für die System-Data-Source auf dem AS Java

3.7.3 Deployment der Employee-Anwendung

Vorbereitungen fürdas Deployment

Vor dem Beginn des Deployments der Anwendung, sollten Sie sichvergewissern, dass der Serverprozess gestartet wurde und die Daten-bank online ist. Voraussetzung hierfür ist jedoch, dass der AS Java imDeveloper Studio registriert wurde.

Wie in Abbildung 3.20 zu sehen ist, werden auf der Preferences-Seitezwei verschiedene Optionen angeboten.

Je nachdem, ob der zugeordnete AS Java auf dem lokalen Host oderunter einer beliebigen Adresse im LAN installiert wurde, ist zwischender Option für die remote Installation und für die lokale Installationzu unterscheiden. Die benötigten Einträge entnehmen Sie der System-information, die Sie auf der Server-Welcome-Seite finden.

Dictionary-Tabellendefinitionen deployen

Um die Tabellendefinitionen aus dem aktuellen Dictionary-Projektauch auf eine Datenbankinstanz übertragen zu können, ist eine

Abbildung 3.20 Registrieren des Applikationsservers Java unter Preferences


165


Archivdatei erforderlich. Ein solches Dictionary-Archiv stellt einetransportfähige Einheit des Dictionary-Projektes dar und fasst alleDictionary-Definitionen des Projektes aus den generierten Metada-ten zusammen. Erst wenn das erstellte Archiv auf den Applikations-server deployt ist, wird auf der zugeordneten Datenbank mit CREATETABLE auch die physische Repräsentation der entsprechenden Tabel-len auf der Datenbankinstanz generiert.

1. Um das Archiv anzulegen, wählen Sie im Dictionary Explorer denProjektknoten, öffnen das Kontextmenü und suchen die OptionCreate Archive aus.

2. Anschließend wählen Sie Deploy aus dem Kontextmenü des Pro-jektknotens (siehe Abbildung 3.21).

3. Über die Deploy View Console (siehe Abbildung 3.22) erhalten Sieunmittelbar eine Rückmeldung darüber, ob der Deploy-Vorgangerfolgreich verlaufen ist oder nicht. Aus dieser Ansicht herauskann auch die zugehörige Log-Datei direkt eingesehen werden.

Abbildung 3.21 Deployen der Tabelle aus dem Dictionary-Projekt

Abbildung 3.22 Ausgabe im Deploy Output View nach erfolgreichem Deployment


166


SQL Studio 4. Falls Sie die MaxDB als Datenbanksystem einsetzen und das SQLStudio installiert haben, können Sie sich nun leicht davon über-zeugen, dass die beiden Tabellen auf der Datenbankinstanz kor-rekt angelegt wurden. Dazu brauchen Sie sich nur über das SQLStudio am Datenbankserver anzumelden und in der Liste aller aufdem aktuellen Server deployten Tabellen nach TMP_EMPLOYEES undTMP_ID_GEN zu suchen. Vorausgesetzt, Sie verfügen über SQL-Kenntnisse, können Sie auch einige Datensätze für die neue Emp-loyee-Tabelle im SQL Studio anlegen.

Enterprise Application Archive erstellen und deployen

Das Enterprise Application Archive (EAR) fasst die Archive JAR undWAR mit den Informationen aus den zugehörigen Deployment-Des-kriptoren zu einem Archiv zusammen. Das EAR enthält also nebenden Business-Logik-Komponenten auch die Präsentationskomponen-ten und kann aus dem Developer Studio heraus einfach mithilfe desServers Views in einem Schritt erstellt und deployt werden.

1. Öffnen Sie dazu den Servers View. Hier sollte bereits der EintragSAP Server angezeigt werden.

2. Aus dem Kontextmenü wählen Sie die Option Add and RemoveProjects. Entsprechend Abbildung 3.23 selektieren Sie dann dasEAR-Projekt und bestätigen dies mit Finish. Damit werden ineinem einzigen Schritt die deploybaren Projekte zum Servers Viewhinzugefügt, die entsprechenden Archive WAR, JAR und EARgeneriert (und zur Projektansicht im Project Explorer hinzugefügt)und unmittelbar auch das Deployment angestoßen.

Abbildung 3.23 EAR-Deployment mithilfe des Servers Views


167


3. Ein erfolgreich abgeschlossener Deploy-Vorgang wird mit derNachricht »Deploy finished successfully« übermittelt.

3.7.4 Employee-Anwendung starten

Unter der Voraussetzung, dass der Server mit localhost bezeichnetwird und unter dem Port 50100 zu erreichen ist, können Sie die Em-ployee-Anwendung mit der URL http://localhost:50100/EmployeeWeb/index.jsp starten (siehe Abbildung 3.24).

Abbildung 3.24 Starten der Employee-Anwendung im Browser


707

Index

@Column 136@Entity 135@GeneratedValue 138, 194@Id 192@JoinColumn 198@JoinTable 198@ManyToMany 199@NamedQuery 140, 205@OneToMany 198@OneToOne 201@PersistenceContext 203@Table 136@TableGenerator 139, 194@Temporal 192@Version 136, 1951:1-Beziehung 2001:n-Beziehung 197

A

ABAP 30ABAP Dictionary 31Access Control Entity (ACE) 510Access Control List (ACL) 487, 510, 566

Klassendiagramm 510Action Editor 375Action-Bindung 254Activation View 87Activity 503

anlegen 653Eigenschaft 654offene und geschlossene 503

Adaptive RFC Model 102, 236Adaptive Webservice Model 236, 268

Import 278Klasse 283logische Destination 281Objekt 283

Administration 692Administrationsperspektive 103Administrationswerkzeug 694Administrator-Plug-in

DTR 581Aggregation 209Alias 175, 212

ÄnderungsspeicherungActivity 652

Annotation 136, 140Anwendung

Aufruf in Browser 666Deployment 665

Application Context 591Application Service 97Assembly 613Auslieferung 614

B

B2B 37Integration 37

Backward Mapping 181Barrierefreiheit 256Bean-Klasse

implementieren 146Beispielanwendung

Struktur 632Beispiel-Entwicklungslandschaft 561Benutzerverwaltung 632Berechtigung 567

Administrator 568CMS User 568Projektleiter 567

BerechtigungsvererbungDTR 510

BSP 30Build

ANT-basierter Prozess 491CBS-Prozess 516Prozess 76, 494, 515Skript 515Variante 519

Build-AuslösungActivation 667

Buildspace 514, 598Build-Time-Dependency

Verwendungsbeziehung 486Business Information Warehouse 50Business Interface 121, 146Business Process Engine 42Business Process Management 40


708

Index

Business Server Pages � BSPBusiness to Business � B2BBusiness-Logik 121, 144, 158

Realisierung 659Business-Methode 146, 152

aufrufen 158Business-Objekt 96, 227

C

CacheVerwaltung 680

CAF 405Build-Vorgang 420Deployment 421Dictionary-Projekt 407EJB-Projekt 407Entwicklungsprojekt 407Erstellung deploybarer Archive 420Generierung einer Composite Application

420Geschäftsobjekt anlegen 407Kompilierung 420Metadaten-Projekt 407Permissions-Projekt 407Projekt anlegen 406SAP NetWeaver Developer Studio 405Service Browser 423vordefinierter Datentyp 411

CBS 72, 473, 512, 556, 557, 558, 667Architektur 513Build-Prozess 515JEE-Version 5.0 635Parameter 585Server 558, 583

Central-Services-Instanz 674, 677Change and Transport System

Software Change Management 621Change Management Service � CMSCheck-in

Änderung 667Check-in-/Check-out-Mechanismus 500Check-in-Konflikt 507Client

Abstraktion 255, 257Unabhängigkeit 253

ClusterKonfiguration 80

Cluster-Architektur 674

Cluster-Kommunikation 680CMS 72, 521, 556, 557, 558, 639

Architektur 521Build-Option Composition Environment

643Check-in SCA-Version 644Content-Update 639Domain 585, 587Entwicklungsschritt 670User 568

Collaboration 48com.sap.jdk.home_path_key 644Common Model Interface 260Compartment

Buildspace 514Component

Browser 86, 649Modeler 101, 254, 267Property 87

Component Build Service � CBSComponent Controller Context 243Component Usage Lifecycle

createOnDemand 330manual 331

Component-Interface-View 265Composite Application 27, 361

Anforderung 392Anpassbarkeit 393Architektur 395Beispielszenario 403, 404Definition 394Eigenschaft 394Entwicklung 391Geschäftsobjekt 397Geschäftsobjektschicht 396Lebenszyklus 395modellgetriebene Entwicklung 395Philosophie und Nutzen 392Prozessmodellierungsschritt 401Prozessschicht 400Schichtenmodell 396Service-Schicht 396Test 457User-Interface-Schicht 399

Composite Application Explorer 407Composite Application Framework

Design Time 66, 96Composite View 367


709

Index

Config-Tool 683Aufruf 585

Configuration Wizardautomatische Konfiguration 556NWDI-Installation 534

Connector Framework 365Container 60Content Administrator 353Context Editor 101Context-Mapping 254Context-zu-Model-Bindung 254Controller 254

D

Dali 181Data Modeler 57, 101, 254Data polled by the Monitor 690Data pushed by the Resource 690Data Transfer Objects � DTODatabase Explorer 187Data-Source 143

Alias 162Daten

aktiv bereitstellen 690passiv bereitstellen 690

DatenbankobjektNamenskonvention 127

DatenbanktabelleDefinition 177relationale 135

Datenbindung 254Datenmodell 649

definieren 125Datenredundanz

Vermeidung 570DC-Projekt 489, 605Debugging 79

Ablauf 83Tool-Unterstützung 81

Debug-Knoten 80Debug-Modus 79Dependency

Software-Component 588, 638Typ 663Wizard 663

Deploy Controller 537Deploy Output View 165Deploy View Console 165

Deployment 164Ablauf 84Vorbereitung 659

Deployment Unit 227Deployment-Deskriptor 140

web.xml 159Deploy-Time-Dependency

Verwendungsbeziehung 486Design Board 368Design Time

Datenbankverbindung 187Design Time Repository � DTRdetached Entity 210Detailed Navigation Panel 344Developer Studio � SAP NetWeaver

Developer StudioDevelopment-Component 367, 479

anlegen 649Parameter 651Property 654Schachtelung 483Schnittstelle 484technische Grundlage 492Typ 488Verwendungsbeziehung 485

Development-Configuration 531, 634Export 550Import 603, 647lokale 546, 550

Development-Configuration-Perspektive 85

Development-Infrastructure-Perspektive 87

Development-Server 364Search & Browse 364VC Builder 364VC Server 364

Dictionary 176Archiv 658DC-Projekt 649lokales 102

Dictionary Explorer 89Dictionary-Archiv 165Dictionary-Perspektive 88, 91, 177Dictionary-Projekt 89, 125, 126, 649

allgemeine Angaben 126Domäne 522DTO 179


710

Index

DTR 71, 359, 473, 497, 508, 556, 557, 558Administrator-Plug-in 508, 579Architektur 498Aufgabe 497Berechtigungskonzept 510, 511Client 71, 509, 580DTR-Client 580DTR-Server 575Initialzugriffsrecht 578Kommandozeilen-Client 509Permissions-View 581Perspektive 105, 107, 496, 579Principal 582Quelldateienverwaltung und Versionie-

rung 558User Interface 508Vorrangregel 577Workspace 501Zugriffsrecht 582

Dynamic Expression Editor 368, 369

E

EAR 93, 123deployen 166

Eclipse 55Entwicklungsobjekt 59Plattform 63, 111Produkt 107SDK 62Workspace 59WTP 65

Editor 57Einstiegsnavigation 344EJB

DC-Projekt 659EJB 3.0 121Modul-DC anlegen 659Modul-Projekt 122, 132, 142, 155Projekt 92

EJB-QL 139Employee-Anwendung 119, 166, 167,

631Employee-Entity

definieren 133Eigenschaft 133

Employee-Tabelledefinieren 655

Enqueue Service 674, 678Enterprise Application

Projekt 92Enterprise Application Archive � EAREnterprise JavaBeans � EJBEnterprise Service 219, 361

konsumieren 231Enterprise Service Protocol 365Enterprise Services Repository 249Enterprise Services Workplace 231Enterprise SOA 26, 219Enterprise-Application-Projekt 161Enterprise-Services-Paradigma 221Entity 121, 133, 185

detached 210Manager 141, 147, 185, 202

Entwicklunglokale 74modellbasierte 357

Entwicklungsgeschwindigkeit 359Entwicklungsinfrastruktur

Anforderung 470, 471, 472Entwicklungsobjekt 60

Java 482zentral verfügbar machen 666

Entwicklungsobjekttyp 591Entwicklungsprozess 75

Beispiel 471Entwicklersicht 531JDI 532Rolle 633Team 74

Entwicklungsumgebung 124Existenzbedingung 213Extension-Point 64

F

Fast Channel Architecture 675Feature 108

Installation 112Version 111

Fehlerbehebung 697Szenario 700

Feinnavigation 344Feld

persistentes 136Findermethode 139, 140Folgeauftrag 608


711

Index

Forward Mapping 181Fremdschlüsselbeziehung 197, 200Fremdschlüsselspalte 200Fusion

Versionierung 535

G

Generic Modeling Language Document Object Model � GML+ DOM

Generic Modeling Language � GMLGeneric Portal Application Layer 345Geschäftsobjekt 397

Attribut 410CRUD-Methode 413Datentyp zuweisen 410Findermethode 413Implementierung 418Kardinalität von Attributen 410Lebenszyklus-Methode 408, 413Methodenbereitstellung von Webser-

vices 419Persistenz 416Persistenzattribut 416Relation zwischen Geschäftsobjekten

412remote Persistenz 416, 417Suchmethode 413, 414Test 421Zugriffsrecht 415

Global Version History 508GML 364GML+ 364GML+ DOM 364Guided Procedures

Administrator 455Aktion 436Block 439Blocktyp 440Callable Object 436, 442Callable-Object-Typ 443Context 400Contextual Navigation Panel 436Design Time 435Einbinden des Visual Composers 441Einbinden eines Webservice 446Entwicklungsobjekt 436Gallery 435Instanzierung 457, 458

Guided Procedures (Forts.)Laufzeitumgebung 459Modellierung von Prozessen 435Overseer 455Owner 455Parameterkonsolidierung 402, 448,

449, 453Parameterkonsolidierungsplan 451Parameter-Mapping 449Prozesseditor 436Prozessflussmodellierung 401, 439, 441Prozessrolle 401Rolle 401Rollenkonsolidierung 455Rollenzuordnung 454Runtime Work Center 458Screenflow 461Sequential Block 439Starten des Frameworks 435Übergabemöglichkeit von Parametern

457Umbenennung von Rollen 454WD4VC 443, 445WD4VC Application 443WD4VC-Callable-Object 444Webservice 446Webservice-Callable-Object 447Werkzeugleiste des Prozesseditors 437Workitem 458

H

Heap SizeJVM 563

Hypertext Markup Language (HTML) 363

I

ICM 674, 675IDE 56

Architektur 63ID-Generierung 138, 193idleStart

CBS-Zustand 562Ignored Resource 646Import

SCA-Datei 645Index 183


712

Index

InfoCube 51Information Integration 46initiale ACL 577Installation

Offline 115Online 115

Integrated Development Environment � IDE

IntegrationDTR-Workspace 506

Integration Directory 42Integrationskonflikt 106, 507Integrationsszenario 37Internet Communication Manager �

ICMIsolations-Level

Read Committed 195, 210Read Uncommitted 210

ISO-StandardSQL-92 169

iView 47, 345, 355anlegen 345Portal-iView 361

IWDComponentUsage-API 331

J

J2EE 56, 65, 94Engine-View 82, 85Gesamtanwendung 664Perspektive 92, 94, 132

JAR 92Java

Instanz 78Standardentwicklung 63

Java Archive � JARJava Database Connectivity � JDBCJava Development Infrastructure

konfigurieren 74Tool 71

Java Dictionary 89, 122, 176Java EE 56, 65, 94

Gesamtanwendung definieren 161Java Management Extension � JMXJava Persistence API � JPAJava Persistence Query Language � JPQLJava Virtual Machine � JVMJavaBean Model 236Java-Entwicklungsobjekt 497

Java-Entwicklungsprozess 474Java-Instanz 674, 675Java-Package-Explorer-View 496Java-Persistence-Perspektive 187JavaServer Pages � JSPJava-System-Report 691, 692JDBC 169, 563

Connection Pool Size 563Datentyp 176Native 171Treiber 174Vendor 171

JDK 1.5.0_xxCBS 635

JDK_1.5.0_Home-Parameter 644JMX 686

Agent 686Organisationsmodell 687

JNDI Lookup 157Join Operation 207Join Table 197JPA 122, 131, 169

Annotation 186Entity 185Spezifikation JSR 220 185

JPQL 204JSP 154, 155JSR 220 185JVM 562

K

Kategorisierung 225Klasse

serialisierbare 135Klassifizierungsservice 223Knowledge Management 48Kommandozeilenwerkzeug

komponentenbasierte Entwicklung 552komponentenbasierte Softwareentwick-

lungSzenario 624

Komponentenhierarchie 476Komponenteninstanz 328Komponenten-Interface 260

Definition 266externes 265lokales 265


713

Index

Komponentenmodell 67, 256, 476, 481, 512, 631

KomponentisierungArchitektur 260lose Kopplung 260

KonfigurationsassistentLaufzeitsystem 537

Konfigurationsdatenbank 177Konflikt

Versionskontrolle im DTR 506Konnektor 687Konsolidierungsphase 612Kopplung

lose 260

L

LANSzenario 79

Landscape Configurator 523, 524, 639Landscape Directory 646Layout Board 368Lebenszyklusstatus 227Lifecycle Management 359Local Area Network � LANLocking 218Log Viewer 699Log Viewer Work Center 699logische Destination

anlegen 466logisches System 522

M

m:n-Beziehung 199Mapped Superclass 192Mapping 40

Backward 181Forward 181objektrelational 195

Massenänderung 213Master Component Repository Data 572MaxDB 166MBean 686MBean-Server 686Merge 507

Versionszusammenführung 536Message Service 674, 678Messaging 39

Metadatenvon Tabellen 178

Model-Abstraktion 256Model-Import 278Model-Klasse

ausführbare 284Relation 284

Modellgemeinsame Sprache 358

modellbasierte Entwicklung 357Model-Objektgraf 287Model-View-Controller � MVCModifikation

ausgelieferte Software 618MOLAP 51Monitor 688, 689Monitor-Browser-Report 692Monitoring 686

Framework 688, 690Infrastruktur 689, 691Monitoring-Baum 688, 689Report 692

MontageSoftware 613

Multidimensional Online Analytical Processing � MOLAP

MVC 253, 255, 256, 261

N

Name Server 559, 574Named Query 149, 204Namensraumkonzept 559Namensraumpräfix

Name-Server-Eintrag 590Reservierung 589

Namensreservierungskonzept 575Native JDBC 171Navigation Modeler 101Navigator View 60Netzwerkantwortzeit

globale Entwicklungslandschaft 624New Class Wizard 133New Project Wizard 126, 161Nicht-ABAP-Transport

gemischte Systemlandschaft 621Nightly Build 76, 471NWDI 322, 359, 361, 469, 473, 555

Administration 587


714

Index

NWDI (Forts.)Einrichtung 556, 561Element 475Entwicklung 602NWDI.Administrators 633NWDI.Developers 633NWDI_CMSADM 586Perspektive 647

NWDI-InstallationVerwendungsart DI 556

O

OASIS 222Object Server 571objektrelationales Mapping 135, 195Offline Configuration Tool 696OLAP-Anwendung 50Online Transaction Processing (OLTP)

System 50Open Activity 87Open JDBC 169Open Source 61Open SQL 169

Datenquelle 210Organization for the Advancement of

Structured Information Standards � OASIS

P

Page Builder 351People Integration 46Persistence Context 202Persistence Unit 186persistence.xml 141, 187Persistenz

Deskriptor 140Persistenzinfrastruktur 170Persistenz-Unit 141, 142Personalisierung 345, 351Perspektive 56, 495

Development Configuration 648DTR 496komponentenbasierte Entwicklung 494SAP NetWeaver Developer Studio 85Web Dynpro 496

Plain Old Java Object � POJOPlug-in-Technologie 64

POJO 131Port 267Portal Content Catalog 350Portal Content Directory 345, 351Portal Content Studio 346Portal-iView 361Portalrolle 48Portalseite 344, 348, 350

anlegen 347Eigenschaft 346Layout 349

Präsentationsschicht 122Prerequisite Software Component 638Primärschlüssel 129, 137Problem Management 701Problembereich 697Produkt 477Programmiermodell 253, 256Project

Explorer 93Project Explorer 132Projektion 208Propagation-List 506Protokolladapter 687Protokollierung 697

Aufzeichnung 699Infrastruktur 697Konfiguration 698Meldung 699

Prozessintegration 39Prozesskomponente 227Public Part 323, 485, 656

Definition 323Development-Component hinzufügen

657Entity 658Entity hinzufügen 657Parameter 657

Q

Qualitätssicherung 613Quelldatei

Aktivierung 517Aktivierung, CBS und DTR 517

Query 150, 204Query-Abfrage 139


715

Index

R

Referenzapplikation 427Aufruf 463Import ins NWDS 464Installation und Einrichtung 463Installationsbeschreibung 465

Relational Online Analytical Processing � ROLAP

Remote Function Call � RFCRepository Browser 105, 106Resource Injection 147Ressourcen-MBean 690RFC 99Robustheit 679ROLAP 51Rolle 351Routing 40Run-Modus 79Runtime-Dependency

Verwendungsbeziehung 486Runtime-System 559, 594

S

SAP Developer Network � SDNSAP Java Virtual Machine 673, 678SAP Logging API 69SAP Management Console 82, 103, 677,

695Funktion 695

SAP Master Component Repository 571SAP NetWeaver 25

Komponentensicht 46SAP NetWeaver Administrator 246, 693

Configuration Wizard 556Schicht 693Work Center 694

SAP NetWeaver Application ServerCluster-Architektur 77Java 68

SAP NetWeaver Business Client 362SAP NetWeaver Business Intelligence 49SAP NetWeaver Composition Environ-

ment 114Monitoring-Framework 688

SAP NetWeaver Developer Studio 55, 119, 532Architektur 62, 63

SAP NetWeaver Developer Studio (Forts.)Benutzeroberfläche 56Entwicklungsprozess 630Installationsszenario 114Konfiguration 646Oberfläche 56Perspektive 56, 85Plattform 109Serverintegration 77, 81Start 646starten 123Tool und Perspektive 85Überwachung zentraler Builds 667Update 110, 116View 58Windows-Preferences 125

SAP NetWeaver Development Infrastruc-ture � NWDI

SAP NetWeaver Master Data Manage-ment 51

SAP NetWeaver Portal 343, 345, 350, 362Einstiegsnavigation 344Feinnavigation 344Portalseite 344Rolle 343Rolle anlegen 351

SAP NetWeaver Portal Client 362SAP NetWeaver Process Integration 41SAP NetWeaver Scheduler for Java 68SAP NetWeaver Visual Composer 426

Abhängigkeit 359Aktion 370Anlegen eines Endpunktes 430Architektur 362Basic Control 368Bildschirm-Layout 429Button 373Compiler 364Composite View 426Connector 367Custom Action 370Data Store Connector 375Datendefinition für einen Endpunkt 431Deployment 432Endpunkt 430, 434Ereignis 431, 434Form View 367, 429


716

Index

SAP NetWeaver Visual Composer (Forts.)Freestyle Kit 363, 364Hinzufügen von User-Interface-Elemen-

ten 428Hyperlink 370Input Field 371Integration mit Guided Procedures 430Kompatibilität 359Konsumierung von Webservices 427Layout Freestyle Kit 363Layout-Board 429Mapping 432Modellierung des Datenflusses 430Navigate Connector 370Paketierung 359Plain Text 368Popup Connector 387SAP NetWeaver 7.0 360Sichtbarkeitsbedingung 376Start 426Start Point Connector 385Startpunkt 432, 433Storyboard 363System Action 379Table View 373, 428Tabstrip Container 372Toolbar 373Transition 379UserData Connector 367Versionierung 359View 367Voraussetzung 361

SAP Service Marketplace 589SCA-Download 633

SAP-BasisArchitektur 30Werkzeug 31

SAP-Komponentenmodell 73SAP-Security 68SCA 613SCA-Datei

Import 600Scalable Vector Graphics � SVGSDN 109Second Level Navigation 343Secure Socket Layer

HTTP 560Sekundärindex

Tabelle 129

Server Development Infrastructure Client 365

Serverprozess 78Knoten 83

Servers View 85, 94, 166Service

externer 97NWDI 629

Service Browser 423, 424Service-Consumer 222Service-Definition

suchen 228Service-Interface 227Service-Operation 227Service-Provider 222Services Registry 222

Strukturierung von Services 225Session Bean 121, 144

anlegen 144Business-Methode 148stateless 144symbolischer Name 159

Sicherheit 68Single-Server-Konfiguration 79Sitzungsverwaltung 681SLD 41, 556, 557, 558, 559, 570

Data Supplier 573Initialdatenimport 571Produktdefinition 587Serverparameter 571Software Catalog 588

SLD-Update 635SOAP 221Software Catalog

SLD 636Software Change Management 555Software Component Archive � SCASoftware Landscape Directory 73Software-Component 476, 637

benötigte 638finaler Test 671Freigabe 671

Softwareentwicklungkomponentenbasierte 542Szenario 542

Software-Komponentenversion 228Softwarelogistik 473, 523Software-Unit 637SQL Query 217


717

Index

SQL Studio 166SQL Trace 173, 701SQL-Monitor 173Subquery 213Summary 688Support-Fähigkeit 685SVG 363Sync 500System Landscape Directory � SLDSystem-Data-Source 163Systemdatenbank 175Systemdatenquelle 175, 210Systemnachricht 540

T

Tabelledefinieren 127, 655Metadaten 178

Tabelleneditor 90, 128Tabellenfeld 128Tabellenpuffer 130, 174, 178Technologieunabhängigkeit 358Thread-Verwaltung 682Tool Integration Framework 69Top Level Navigation 343TopLevelDC 479Trace-Meldung 698, 699Tracing 697Track 522, 524, 561, 593, 634

Konsolidierungsphase 612Projektphase 593releasespezifischer 634Softwarekomponente importieren 598

Track DataCMS 640

Track-ParameterCMS 640

Transaktion 202Transaktionsattribut 150Transaktions-Commit 152Transaktionsverhalten 150Transport 595Transport Studio 523, 528

CMS 644Transportfreigabe 610Transportroute 593, 595

Typ 595Transportverzeichnis 586

U

UDDI 221Server 223

UME 560, 565, 632Universal Description Discovery Integra-

tion � UDDIUpdate

Framework 107Manager 113Policy 111Prozess 107SAP NetWeaver Developer Studio 107

Update CMS 640Update-Site 108

URL 108Use-Dependency 485, 662

Development-Component hinzufügen 662

User Interface 29JSP-basiertes 661

User Management Engine � UMEUser-Interface-Paradigma 56

V

ValidierungDC-Projekt 664

Value Set 226Vendor 636Vendor JDBC 171Vererbung 190Version Graph

Design Time Repository 508Versioned Resources 498Versionierung 195, 210, 218Versionsfeld

bei Entities 133Verwendungsbeziehung 632Verwendungszweck

Assembly 485Compilation 485

View 58Java-Package-Explorer 496

View Controller Context 243View Designer 101View-Layout 263

User Interface entwickeln 244Visual Administrator 569


718

Index

W

WANSzenario 81

Web Archive (WAR) 92Web Dynpro 234, 248, 253, 361

Action 301, 313Anwendung 346, 354Applikation 275Beispielanwendung 253, 267, 316Benutzeroberfläche 270Binding Chain 306Client-Unabhängigkeit 258Codegenerierung 257Component Controller 262Component Lifecycle 330Component Modeler 254, 275Component Usage 254, 327, 328Content Administrator 343, 356Context 268Context-Mapping 257, 269, 293Context-zu-Model-Bindung 259, 268,

287, 289Controller 261, 263Controller-Implementierung 270, 308Controller-Schnittstelle 264, 314Controller-Verwendung 314Custom Controller 263Data Link 293Data Modeler 240, 254, 276, 278, 279Datenbindung 296Datentransport 305Development Component 271, 322, 323dynamische Programmierung 256Explorer 58, 61, 100Flex 361, 364Formular-Template 297Generierungs-Framework 262, 283,

308generischer UI-Service 259HTML 361, 364inverse Suche 331iView 355Komponente 260Komponente einbetten 321Komponentenarchitektur 261Komponenten-Interface 254, 265Komponentisierung 318Model 235, 266

Web Dynpro (Forts.)Model-Abstraktion 259Model-Bindung 257, 269, 309Model-Instanz 308Navigation 277Navigation Modeler 277Oberflächenelement 255, 259Organize Imports 311Parameter-Mapping 302Perspektive 100, 496Portalseite 346Projekt 235serverseitiges Eventing 338Service-Controller 291Table-Wizard 303View Designer 277, 304View-Layout 270, 303Web Dynpro Explorer 274Werkzeug 254, 257Window-Plug 277Zielsetzung 255

Web Dynpro ABAP 30Web Service Inspection Language 247Web Services Description Language �

WSDLWeb Tools Platform � WTPWebanwendung

JSP-basierte 154Web-Dynpro-Komponente 254, 316

Anatomie 261Component Controller 262Component Usage 328Component-Interface-Controller 265,

329Component-Interface-View 265, 275,

329Custom Controller 263externes Context-Mapping 338Komponenteninstanz 330Komponenten-Interface 318lose Kopplung 319Message-Pool 262programmatische Entität 262Schnittstelle 265, 318visuelle Entität 261Wiederverwendbarkeit 260, 318Window Controller 262

Web-Dynpro-KomponentendiagrammComponent-Interface-Controller 267


719

Index

Web-Dynpro-Komponentendiagramm (Forts.)Component-Interface-View 267

Web-Dynpro-ModelEntwurfszeit 286Laufzeit 286Model-Objektgraf 287

Web-Modul-DC-Projekt 661Web-Modul-Projekt 154Webservice 99, 219, 268

Destination 246logische Destination 237Test 424

Webservice-Model 242Webservice-Navigator 424, 425, 446Wide Area Network � WANWiederverwendbarkeit 359Window 56Window Controller 263Window-Preferences 646Wizard 94Workset 48, 344, 351

Workspace 59, 124, 598Änderung übernehmen 505Design Time Repository 501Eclipse 503Folder 502

WSDL 221WTP 62

X

Xgraph Language (XGL) 364

Z

zentrale Benutzerverwaltung 560, 564Zielplattform 634Ziel-Release 558Zugriffskontrollliste 510Zuordnungstabelle 197zyklische Abhängigkeit

Verbot 488


1042.book Seite 3 Dienstag, 8. Januar 2008 10:41 10 · Inhalt 9 3.6.3 Beschreibungen im...

Documents

Transcript of 1042.book Seite 3 Dienstag, 8. Januar 2008 10:41 10 · Inhalt 9 3.6.3 Beschreibungen im...