J2EE und JBoss Grundlagen und Profiwissen (eBook)

Torsten Langner, Daniel Reiberg (Autoren)

eBook Download: PDF

2006 | 1. Auflage
734 Seiten
Carl Hanser Fachbuchverlag
978-3-446-40837-1 (ISBN)

Infos

Gemeinsam stark!



Java-Enterprise-Anwendungen benötigen heutzutage einen leistungsstarken Applicationserver. Mit JBoss steht den J2EE-Entwicklern ein Applicationserver zur Verfügung, der nicht nur leistungsstark, sondern auch kostenlos ist.



Dieses Buch zeigt Ihnen, wie Sie mit J2EE und JBoss eine komplette Unternehmensanwendung entwickeln können. Ausführlich stellen die Autoren die einzelnen J2EE-Technologien vor und zeigen, wie sie im Zusammenspiel mit JBoss funktionieren. Sie erläutern, wie eine J2EE-Anwendung angepasst werden muss, damit sie innerhalb eines JBoss Applicationservers lauffähig ist.



So profitieren Sie!



- Sie erhalten umfassende Informationen über das Zusammenspiel von J2EE und JBoss

- An der kompletten Beispielapplikation können Sie alle Aspekte der J2EE/JBoss-Entwicklung unmittelbar nachvollziehen.

- Verwendet werden Open-Source-Werkzeuge für die Entwicklung, wie z. B. Eclipse, XDoclet und Ant

- Topaktuell: In einem Abschnitt zu EJB 3.0 erfahren Sie schon heute, wie mit JBoss noch effizientere J2EE Applikationen entwickelt werden können.



Die Themen:



- JBoss Konfigurationen & Tuning

- JDBC & JCA

- Sockets, RMI, CORBA & Web Services

- EJBs: Session Beans, Entity Bean, Message Driven Beans & Timer

- Migration zu EJB 3.0

- Web-basierte Anwendungen: JSP, Servlets, Struts & JSF - JMS

- JMX



Die Autoren



Torsten Langner und Daniel Reiberg sind erfahrene Java-Entwickler der ersten Stunde, die ihr Wissen, das sie in zahlreichen Großprojekten gesammelt haben, in Form von Seminaren, Büchern und Artikeln weitergeben. 

Inhalt

Inhalt 6
1 Einführung 22
1.1 Motivation 22
1.2 Grundlage von J2EE: die 4-Tier- Architektur 24
1.2.1 2-Tier-Architekturen 24
1.2.2 3-Tier-Architekturen 25
1.2.3 4-Tier-Architektur einer webbasierten Anwendung 26
1.2.4 Webbasierte Anwendungen mit J2EE 28
1.3 Vorgehensweise im Buch 29
2 JBoss, Eclipse und XDoclet 32
2.1 JBoss 32
2.1.1 Download & Installation
2.1.2 Start des Servers 33
2.1.3 Die JMX-Console 34
2.1.4 Anhalten des Servers 35
2.1.5 Basis-Konfigurationen 35
2.2 Eclipse, XDoclet & die JBoss-IDE
3 JCA 42
4 JDBC 46
4.1 Datenbanktreiber 46
4.1.1 Laden des Treibers über den ClassLoader 47
4.1.2 Festlegen des Treibers über Systemparameter 48
4.2 Aufbau einer Verbindung 48
4.3 Einen SQL-Befehl ausführen 50
4.3.1 PreparedStatement: Einen vorbereiteten SQL-Befehl ausführen 50
4.3.2 Statement: Einen unvorbereiteten SQL-Befehl ausführen 55
4.4 Transaktionen 55
4.5 BLOBs auslesen 56
4.6 Metadaten auslesen 57
4.6.1 Metadaten einer Datenbank auslesen 57
4.6.2 Metadaten einer Tabelle auslesen 57
4.7 Datenbanken innerhalb eines Containers erfragen 58
5 JMX 60
5.1 Beispiel 1: TableCopyMBean 61
5.1.1 Das Interface 61
5.1.2 Die MBean-Klasse 62
5.1.3 Der Delegat 64
5.1.4 Der Deployment-Deskriptor 65
5.2 Beispiel 2: SimpleCacheMBean 66
5.2.1 Das Interface 66
5.2.2 Die MBean-Klasse 67
5.2.3 Der Deployment-Deskriptor 68
5.2.4 Ein MBean-Connector 69
5.3 Verpacken & Deployen der MBeans
6 Socketprogrammierung 72
6.1 Grundlagen 73
6.1.1 Zeichensatzgebundenes Lesen und Schreiben von Daten 73
6.1.2 Socket-Verbindungen herstellen 75
6.1.3 SocketTools: Eine Ansammlung nützlicher Socket- Routinen 78
6.1.4 Eine POST-Anfrage an eine Webseite senden 79
6.2 Eine einfache Client/Server- Applikation 81
6.2.1 Vorgehensweise 81
6.2.2 Der Client 82
6.2.3 Der Server 83
6.3 Ein Framework für eine Client/Server- Applikation 85
6.3.1 Die grundlegende Architektur 85
6.3.2 MultiClientServer 86
6.3.3 MultiClientNonBlockingServer 88
6.3.4 AbstractClientHandler 89
6.4 Anwendung des Frameworks am Beispiel 90
6.4.1 KursabfrageClient 91
6.4.2 KursabfrageHandler 92
6.4.3 StartKursabfrageClient & StartKursabfrageServer
6.5 Der C#/.NET-Client 95
7 RMI & CORBA
7.1 Was ist Middleware? Was ist RMI? 98
7.2 RMI mit JRMP 101
7.2.1 Schritt 1: Interface definieren 102
7.2.2 Schritt 2: Server schreiben 103
7.2.3 Schritt 3: Server am Broker anmelden 105
7.2.4 Der Client 106
7.3 RMI mit IIOP 107
7.3.1 Schritt 1: Interface definieren 107
7.3.2 Schritt 2: Server schreiben 109
7.3.3 Schritt 3: Server am Broker anmelden 111
7.3.4 Der Client 113
7.4 Implementierung einer RMI/JRMP& IIOPApplikation
7.4.1 Schritt 1: Interface definieren 115
7.4.2 Schritt 2: Servermethoden implementieren 115
7.4.3 Schritt 3: Erstellen der Delegaten 116
7.5 Performance-Vergleich RMI/IIOP < >
7.6 CORBA 119
7.6.1 Grundlagen 119
7.6.2 CORBA-IDL: Eine Sprache zur Definition von Interfaces 120
7.7 CORBA über RMI 127
7.7.1 Schritt 1: IDL in Java übersetzen 127
7.7.2 Schritt 2: Client schreiben 128
7.8 Ein RMI/IIOP-Server & ein .NET-Client
7.8.1 Übersetzung der IDL-Dateien 130
7.8.2 Der .NET-Client 130
8.1 Grundlagen 132
8.1.1 Was sind EJBs? 132
8.1.2 Welche Aufgaben übernimmt der Applicationserver? 134
8.2 Die einzelnen EJB-Typen im Überblick 136
8.2.1 Session Beans 136
8.2.2 Entity Beans 136
8.2.3 Message Driven Beans 138
8.3 Timer 140
8.4 Interfaces und Klassen 140
8.5 Deployment 143
8.5.1 Deployment-Verzeichnis des JBoss 143
8.5.2 Deployment-Deskriptoren 143
8.6 Client-Zugriff auf die EJBs 147
8.7 Lebenszyklen von EJBs 148
8.7.1 Session Beans 148
8.7.2 Entity Beans 149
8.7.3 Message Driven Beans 150
8.8 Namenskonventionen 151
8.9 Verpacken und Deployen des EJB- Archivs 151
8.9.1 Generierung der Deployment-Deskriptoren und Java- Dateien 151
8.9.2 Verpacken und Deployen des Archivs 153
9 Session Beans 156
9.1 Allgemeines 156
9.2 Vorüberlegung: MasterSessionBean 157
9.2.1 Remote-Interface 157
9.2.2 Local-Interface 158
9.2.3 EJB-Klasse 158
9.3 Erstellung einer Stateless Session Bean 161
9.3.1 Home-Interface 161
9.3.2 Remote-Interface 162
9.3.3 EJB-Klasse 162
9.3.4 ejb-jar.xml 165
9.3.5 jboss.xml 165
9.3.6 Ein geeigneter Client 166
9.4 Erstellung einer Stateful Session Bean 167
9.4.1 Home-Interface 168
9.4.2 Remote-Interface 168
9.4.3 EJB-Klasse 169
9.4.4 ejb-jar.xml 171
9.4.5 jboss.xml 171
9.4.6 Ein geeigneter Client 171
9.5 Erstellung einer lokalen Session Bean 172
9.5.1 LocalHome-Interface 173
9.5.2 Local-Interface 173
9.5.3 EJB-Klasse 174
9.5.4 ejb-jar.xml 174
9.5.5 jboss.xml 175
9.5.6 Ein geeigneter Client 175
9.6 Vorüberlegung: EJBEnv 175
9.7 Nutzung einer lokalen Session Bean 178
9.7.1 Home-Interface 178
9.7.2 Remote-Interface 178
9.7.3 EJB-Klasse 179
9.7.4 ejb-jar.xml 181
9.7.5 jboss.xml 181
9.8 Verwendung des IIOP-Protokolls 182
9.8.1 Generierung von Stub- und Tie-Klassen 182
9.8.2 Abänderung des Deployment-Deskriptors 183
9.8.3 Ein IIOP-Client 184
9.9 Konfigurationen 185
9.9.1 Standard-Konfigurationen 185
9.9.2 Individuelle Session Bean-Konfigurationen 187
9.9.3 Konfiguration mittels XDoclet 189
10 CMP Entity Beans 192
10.1 Vorbereitung 194
10.1.1 Vorstellung des Datenbankschemas 194
10.1.2 Zentrale Registrierung der Datenbank in JBoss 195
10.1.3 CMPs: Lokal oder Remote? 197
10.2 Vorüberlegung: CMPMasterBean 198
10.2.1 EJB-Klasse 199
10.2.2 Local-Interface 201
10.2.3 LocalHome-Interface 201
10.3 CMP: Kunde 202
10.3.1 EJB-Klasse 202
10.3.2 Local-Interface 206
10.3.3 LocalHome-Interface 206
10.3.4 ejb-jar.xml 207
10.3.5 jboss.xml 208
10.3.6 jbosscmp-jdbc.xml 209
10.3.7 Nutzung seitens eines lokalen Clients 210
10.4 CMP: Konto 212
10.4.1 Local-Interface 212
10.4.2 EJB-Klasse 212
10.5 Spezifikation der Datenbankanbindung 214
10.5.1 Standard-Datenbank 215
10.5.2 Individuelle Datenbank 217
10.6 Das 219
Value Object“-Pattern 219
10.6.1 Motivation 219
10.6.2 Kennzeichnung der Klasse 220
10.6.3 Kennzeichnung der Getter 220
10.6.4 Spezifikation des Clientzugriffs 221
10.6.5 Der Ant-Task 222
10.6.6 Die VO-Klasse 222
10.7 1:1 Relation: Kunde – Konto 223
10.7.1 Local-Interface: Kunde 223
10.7.2 Local-Interface: Konto 224
10.7.3 EJB-Klasse: Kunde 224
10.7.4 EJB-Klasse: Konto 227
10.7.5 ejb-jar.xml 228
10.7.6 jbosscmp-jdbc.xml 230
10.8 Die CMPs: Quote, Kategorie und Wette 231
10.8.1 Quote 231
10.8.2 Kategorie 232
10.8.3 Wette 233
10.9 1:N-Relationen: Quote-Wette-Kategorie 234
10.9.1 Local-Interfaces 234
10.9.2 EJB-Klassen 235
10.9.3 ejb-jar.xml 239
10.9.4 jbosscmp-jdbc.xml 241
10.10 CMP: Tipp 242
10.10.1 Primärschlüsselklasse 242
10.10.2 LocalHome-Interface 243
10.10.3 Local-Interface 243
10.10.4 EJB-Klasse 244
10.10.5 ejb-jar.xml 246
10.11 M:N-Relation: Konto-Tipp-Wette 247
10.11.1 Local-Interfaces 247
10.11.2 EJB-Klassen 248
10.11.3 ejb-jar.xml 252
10.11.4 jbosscmp-jdbc.xml 254
10.12 Die EJB-QL 255
10.12.1 Finder 256
10.12.2 Selektoren 261
10.13 Suchfunktionen mit EJB-QL 263
10.13.1 Beispiel 1: Login-Mechanismus 264
10.13.2 Beispiel 2: Alle Datensätze 266
10.13.3 Beispiel 3: Die wertgrößte Kundennummer 268
10.14 Suchfunktionen mit SQL 269
10.14.1 LocalHome-Interface 270
10.14.2 EJB-Klasse 270
10.14.3 ejb-jar.xml 271
10.14.4 jbosscmp-jdbc.xml 272
10.15 Optimierung des Datenbankzugriffs 272
10.15.1 Standardzugriff von JBoss 273
10.15.2 Load Groups 274
10.15.3 Read-Ahead-Strategien 275
10.15.4 Lazy Load Groups 278
10.15.5 Relationen 279
10.16 Automatische Primärschlüsselerzeugung 281
10.16.1 JBoss-spezifisch 281
10.16.2 Herstellerübergreifend 283
10.17 Konfigurationen 287
10.17.1 Standard-Konfigurationen 287
10.18 Konfiguration mittels XDoclet 290
11.1 Grundlagen einer BMP 292
11.2 BMP: Kunde 293
11.2.1 Kapselung der Datenbankzugriffe 293
11.2.2 EJB-Klasse 300
11.2.3 Local-Interface 308
11.2.4 LocalHome-Interface 309
11.2.5 ejb-jar.xml 309
11.2.6 jboss.xml 310
11.3 BMP: Konto 310
11.3.1 Kapselung der Datenbankzugriffe 311
11.3.2 EJB-Klasse 313
12 Timer 318
12.1 TimedObject 318
12.2 Timer 319
12.3 TimerService 319
12.4 Beispiele 321
12.4.1 Zusammenspiel der einzelnen Applikationsbestandteile 321
12.4.2 Session Bean: Auftragsloeschung 321
12.4.3 Singleton: TimerActivator 325
12.4.4 CMP: Auftrag 327
13 Message Driven Beans 332
13.1 Grundlagen 332
13.2 Hilfsklassen 334
13.2.1 MessageDrivenMasterBean 334
13.2.2 QueueConnection 335
13.2.3 QueueConnectorSingleton 336
13.3 Queue-Beispiel: UserdataChange 339
13.3.1 Architektonische Vorgehensweise 339
13.3.2 Interface: UserdataChangeOperations 339
13.3.3 Stub: UserdataChangeStub 341
13.3.4 Delegat: UserdataChangeDelegate 342
13.3.5 EJB-Klasse: UserdataChangeBean 344
13.3.6 Deployment-Deskriptoren 346
13.4 Topic-Beispiel: EMailService 348
13.4.1 Architektonische Vorgehensweise 348
13.4.2 Interface: EMailServiceOperations 349
13.4.3 Stub: EmailServiceStub 349
13.4.4 Delegat: EMailServiceDelegate 351
13.4.5 EJB-Klasse: EmailServiceBean 352
13.4.6 Deployment-Deskriptoren 355
13.4.7 Schwachstellen der Architektur 357
14 JTA 358
14.1 Beispiel-Szenarien 358
14.1.1 Szenario 1 359
14.1.2 Szenario 2 360
14.1.3 Szenario 3 360
14.1.4 Szenario 4 361
14.2 Container Managed Transactions (CMTs) 362
14.2.1 Architektur des Beispiels 363
14.2.2 Beispiel: CMP 364
14.2.3 Beispiel: Stateless Session Bean 367
14.3 Bean Managed Transactions (BMTs) 371
14.3.1 Beispiel 1 371
14.3.2 Beispiel 2 379
15 Gesamtapplikation: EJBs 386
15.1 CustomerService 386
15.1.1 Skelett der Stateful Session Bean „CustomerService“ 387
15.1.2 Use Case: Login 392
15.1.3 Use Case: Nutzerdaten abfragen 393
15.1.4 Use Case: Logindaten ändern 393
15.1.5 Use Case: Wette abschließen 394
15.1.6 Use Case: Wettkonto anzeigen 396
15.1.7 Use Case: Nutzerdaten ändern 397
15.1.8 Deployment-Deskriptoren 399
15.2 AdminService 401
15.2.1 Architektur 402
15.2.2 Session Bean: AdminService 402
15.2.3 MDB: Gewinnermittlung 406
15.3 WebAppClient 410
16 Web Services mit AXIS und JBoss 412
16.1 Was ist AXIS? 412
16.2 Von AXIS nach JBoss 414
16.2.1 WS4EE alias JBossWS 414
16.3 Web Service Enabling einer EJB 416
16.3.1 Schritt 1: Implementation der EJB-Klasse 416
16.3.2 Schritt 2: ServiceEndpoint-Interface spezifizieren 419
16.3.3 Schritt 3: WSDL-Datei erstellen 419
16.3.4 Schritt 4: Deployment-Deskriptoren erstellen 421
16.3.5 Schritt 5: Verpacken & Deployen
16.4 Ant- Tasks 427
16.4.1 Classpath anpassen 427
16.4.2 Ant-Tasks bekannt machen 427
16.4.3 ejbdoclet-Task anpassen 428
16.4.4 Java2WSDL ausführen 428
16.4.5 ws4ee-Task anpassen 428
16.5 Generierung eines Web Service Clients 429
16.5.1 .NET Client 429
16.5.2 Java Client 431
16.6 Handler 434
16.6.1 Was sind Handler? 434
16.6.2 Wie funktionieren Handler? 435
16.6.3 LoggingHandler 436
16.6.4 AnalysingHandler 438
16.6.5 SigningHandler 440
16.7 Web Service Enabling eines Servlets 448
16.7.1 Schritt 1: ServiceEndpoint-Interface spezifizieren 448
16.7.2 Schritt 2: Servlet implementieren 448
16.7.3 Schritt 3: Java2WSDL ausführen 449
16.7.4 Schritt 4: Deployment-Deskriptoren erstellen 449
17 Clustering mit JBoss 452
17.1 Überblick 452
17.2 Ausfallbehandlung und Lastverteilung 453
17.2.1 HTTP und EJBs 453
17.2.2 JNDI 455
17.2.3 Proxies und Partitionen 457
17.3 Konfiguration von JBoss 458
17.3.1 Kennzeichnung der EJBs 458
17.3.2 Feintuning 460
17.4 Clustern der einzelnen EJB-Typen 463
17.4.1 Stateless Session Beans 463
17.4.2 Stateful Session Beans 463
17.4.3 Entity Beans 466
17.5 Der Client 466
18 JSPs und Servlets 468
18.1 Grundlagen webbasierter Anwendungen 468
18.1.1 Datenübertragung an die JSPs und Servlets 470
18.1.2 Übertragung mittels GET 471
18.1.3 Übertragung mittels POST 473
18.2 Laufzeitumgebung für JSPs und Servlets: Der Web- Container 476
18.3 Entwicklungsumgebung für JSPs und Servlets 476
18.4 Grundlagen: JSPs 477
18.4.1 Scriplets 477
18.4.2 Ausdrücke 478
18.4.3 Deklarationen 478
18.4.4 Kommentare 479
18.4.5 Schlüsselvariablen 479
18.4.6 HttpServletRequest: Auswertung der vom Browser gesendeten Daten 480
18.4.7 HttpServletResponse: Senden der Antwort an den Browser 481
18.4.8 Direktiven 482
18.4.9 Aktionen oder „BuildIn-Taglibs“ 484
18.4.10 Codeseparation durch JavaBeans 485
18.4.11 Tag-Libs 487
18.5 Grundlagen: Servlets 489
18.6 Kombination von JSPs und Servlets 492
18.6.1 Ein Master-Servlet 493
18.6.2 Beispiel 494
18.7 Cookies 496
18.7.1 Cookies setzen 496
18.7.2 Cookies auslesen 496
18.7.3 Status eines Cookies ändern 497
18.8 Deployment-Deskriptoren 498
18.9 Verpacken und Deployen des Web- Archivs 500
18.9.1 Generierung der Deployment-Deskriptoren 501
18.9.2 Verpacken und Deployen des Archivs 501
19 Das Web-Framework „Struts“ 504
19.1 Probleme bei der Realisierung des Web-Tiers mittels JSPs 504
19.2 Das MVC-Pattern 509
19.3 Was ist Struts? 509
19.3.1 Installation 509
19.3.2 Struts-Grundlagen 510
19.3.3 Implementierung des UseCases „Benutzerdaten ändern“ mit Struts 511
19.4 Das ActionForm 524
19.4.1 Map-backed / List-backed ActionForms 525
19.4.2 DynaActionForms 526
19.5 Der Validator 526
20 JavaServer Faces 528
20.1 Was sind JavaServer Faces? 528
20.1.1 Das MVC-Pattern 528
20.1.2 Internationalisierung 529
20.1.3 Events 529
20.2 Download und Installation 529
20.2.1 Mitgelieferte Beispiele 529
20.3 Eine einfache JSF- Applikation 530
20.3.1 Das Modell: Eine einfache JavaBean 530
20.3.2 View: Eine JSP zur Eingabe 532
20.3.3 Datenbindungs-Syntax 534
20.3.4 View: Eine Ausgabe-JSP 534
20.3.5 Aktionen 535
20.3.6 Der Controller: Ein Servlet 536
20.3.7 Einbinden in die Applikation 538
20.3.8 Erstellen einer Startseite 539
20.4 Navigationsregeln 540
20.4.1 Verwendung von Wildcards 541
20.4.2 Standard-Verhalten 542
20.4.3 Prioritäten der Verarbeitung 543
20.5 Internationalisierung 543
20.5.1 Erstellen der Ressourcen 543
20.5.2 Verwendung in JSPs 544
20.5.3 Verwendung in JavaBeans 546
20.6 Initialisieren von Managed Beans 547
20.6.1 String-Properties 547
20.6.2 Zahlen 548
20.6.3 Boolesche Properties 549
20.6.4 Map-Properties 549
20.6.5 Array- oder List-Properties 550
20.6.6 Initialisierung per Web Deployment-Descriptor 550
20.6.7 Initialisierung über Referenzen 551
20.7 Validieren von Daten 552
20.7.1 Standard-Validatoren 552
20.7.2 Pflichtfelder deklarieren 553
20.7.3 Validierungsfehler ausgeben 553
20.7.4 Überschreiben der vorgefertigten Fehlermeldungen 555
20.7.5 Validieren innerhalb der FormBean 557
20.7.6 Implementieren eines eigenen Validators 559
20.8 Arbeiten mit Events 562
20.8.1 ActionEvents 562
20.8.2 ValueChangeEvents 565
20.8.3 Events: Verwenden der JavaBean 565
20.9 Konverter 568
20.9.1 Das Converter- Attribut 569
20.9.2 Das Converter-Tag 569
20.10 Ein umfangreiches Beispiel 572
20.10.1 Die rudimentäre FormBean 572
20.10.2 Die Login-Seite 574
20.10.3 Die Methode processLogin() 575
20.10.4 Die Customer-Service-JSP 577
20.10.5 Ändern der Benutzerdaten 580
20.10.6 Ändern der Login-Informationen 583
20.11 Zusammenfassung 583
21 Java Message Service Grundlagen 586
21.1 Remote Procedure Calls vs. Messaging 586
21.1.1 Remote Procedure Calls (RPC) 586
21.1.2 Messaging 588
21.2 JMS Messaging-Modelle 589
21.2.1 Publish-Subscribe-Modell (one-to-many Messaging) 589
21.2.2 Point-to-Point-Modell (one-to-one) Messaging 590
21.3 Architektur von JMS- Applikationen 590
21.4 Basiskomponenten der JMS API 591
21.4.1 Administrierte Objekte 595
21.4.2 Connections 598
21.4.3 Sessions 599
21.4.4 Message Producer 599
21.4.5 Message Consumer 601
21.4.6 Messages 603
22 JMS Message: Typen und Struktur 606
22.1 Header 607
22.1.1 Automatisch gesetzte Header 607
22.1.2 Manuell gesetzte Header 613
22.2 Properties 618
22.2.1 Applikationsspezifische Properties 618
22.2.2 Durch JMS definierte Properties 619
22.2.3 Provider-spezifische Properties 620
22.2.4 Property-Beispiel 621
22.3 Message Selektoren 622
22.4 MessageTypen 625
22.5 Der ComplexChatClient 631
23 Verlässliche und performante Messaging- Applikationen 638
23.1 Acknowledgement & Persistenz
23.1.1 AUTO_ ACKNOWLEDGE 644
23.1.2 DUPS_OK_ ACKNOWLEDGE 645
23.1.3 CLIENT_ ACKNOWLEDGE 646
23.2 Weitere Mechanismen zum Aufbau verlässlicher Messaging- Applikationen 647
23.2.1 Dead Letter Queue 647
23.2.2 ExceptionListener 649
23.3 Transaktionen 651
23.3.1 Lokale Transaktionen 653
23.3.2 Verteilte Transaktionen 654
23.4 Performante und skalierbare Messaging- Applikationen 658
23.4.1 Wahl des Invocation Layers 658
23.4.2 Caching & Loadbalancing
24 Die JMS- Applikation 662
24.1 Der WettInfoService (Publish-and-Subscribe- Modell) 662
24.1.1 Interoperabilität/Schnittstelle 664
24.1.2 Architektur 664
24.1.3 Erweiterung des ValueObjects WetteVO 665
24.1.4 Die Hilfsklasse TopicConnectorSingleton 666
24.1.5 Der ObjectMessageDelegate 670
24.1.6 Der MapMessageDelegate 671
24.1.7 Der erweiterte AdminService 673
24.2 Die TippAnnahme (Point-to-Point-Modell) 676
24.2.1 Architektur der TippAnnahme 677
24.2.2 MessageDrivenMasterBean 677
24.2.3 Der TippAnnahmeDelegate 679
24.2.4 Das TippAnnahmeServiceBean 680
24.2.5 Der DeploymentDescriptor 682
25 Die JBossMQ Konfiguration 684
25.1 Initialisierung des JBossMQ 685
25.2 Der DestinationManager 687
25.3 Der SecurityManager 688
25.4 Der StateManager 690
25.5 Die Konfiguration von Destination 693
25.6 Der MessageCache 696
25.7 Der PersistenceManager 697
25.8 Konfiguration des Invocation Layers 699
25.8.1 Der JVM Invocation Layer 699
25.8.2 Der Unified Invocation Layer 2 700
25.8.3 Der HTTP Invocation Layer 702
Anhang 704
A. 1 Annotations 704
A. 2 EJB 3.0 705
A. 3 Implementation der Geschäftslogik 706
A. 3.1 Session Beans 706
A. 3.2 Message Driven Beans 711
A. 4 Implementation von MBeans 712
A. 5 Implementation der Persistenzschicht 715
A. 5.1 O/R-Mapping 715
A. 5.2 Zugriff auf Entities 719
A. 6 Deployment 722
Register 724
Mehr eBooks bei www.ciando.com 0

Textauszug

6 Socketprogrammierung (S. 51-52)

Damit zwei Rechner miteinander kommunizieren können, bedarf es keiner Middleware- Technologien wie zum Beispiel RMI, CORBA oder Web Services. Auch sind keine Komponentenmodelle wie zum Beispiel EJB notwendig. Damit zwei Rechner miteinander kommunizieren können, bedarf es lediglich eines sog. Sockets.

Bei einem Socket handelt es sich um einen Verbindungspunkt in einem TCP/IP-basierten Netzwerk. Vergleicht man einen Socket mit einer Telefonnummer, dann wäre die Vorwahl die eindeutige IP-Adresse des Rechners und die Rufnummer wäre der Port des Rechners. Bei einer Socket-Kommunikation handelt es sich um das klassische Client/Server-Modell. Ein Client sendet Daten an einen Server und empfängt wiederum Daten von diesem. Ein Webserver ist beispielsweise solch ein Server. Der passende Client für den Webserver ist ein Browser. Hierbei wählt der Browser die IP-Adresse und den Port des Webservers an. Standardmäßig „lauscht" ein Webserver auf dem Port 80. Auf Grund dieses Standards entfällt die direkte Eingabe der gesamten Webadresse samt Port in einem Webbrowser. Einen Webserver entwickelt man heutzutage jedoch nicht mehr selbst. Hierzu bietet beispielsweise Apache schon einen perfekten Webserver an: Tomcat. Socket-Programmierung ist vielmehr in denjenigen Unternehmen vorzufinden, die noch mit den von vielen als „Altlasten" 1 bezeichneten Systemen (Großrechner) kämpfen müssen. Diese Maschinen haben jedoch gegenüber den „neuen" PC-basierten Systemen fantastische Performance-Vorteile.

Da die heutigen Systeme in Großunternehmen wie zum Beispiel der Lufthansa derart entwickelt werden, dass die neuen Technologien (Applicationserver mit EJBs) als Schnittstelle für Clients angeboten werden – wobei die neuen Technologien immer noch auf die alten Applikationen zurückgreifen –, wird die Socket-Programmierung auch dann benötigt, wenn ein Applicationserver eingesetzt wird. Mit JCA wird beispielsweise ein J2EE-Komponentenmodell vorgestellt, mit dessen Hilfe u. a. solche Zugänge zu Altsystemen strukturiert entwickelt werden können. Das am Ende dieses Kapitels vorgestellte Nicht-Java-System ist ein einfacher .NET-Client, der mit der Programmiersprache C# geschrieben wurde. Hierbei wurde explizit C# gewählt, da der Code zu ungefähr 85% mit dem des äquivalenten Java-Client identisch ist.

6.1 Grundlagen

Mit der Java 2 Standard Edition Version 1.4 wurde das Paket java.nio.* eingeführt. In diesem Paket befinden sich zahlreiche Neuerungen, mit deren Hilfe die Netzwerkprogrammierung einfacher und sicherer durchzuführen ist. Das „n" steht dabei für „new", wodurch Sun die Abwärtskompatibilität zu früheren Java-Programmen gewährleisten möchte. Zentrale Neuerungen innerhalb des java.nio.* Paketes sind:

- Buffers, als Datencontainer.
- Charsets, die – vergleichbar mit XML – mit Hilfe von Encodern und Decodern aus zu übertragenden Bytes die korrekten Zeichen formen, bspw. ein „ü".
- Channels, als Repräsentanten von Akteuren (z. B. Clients, Server oder Dateien), die I/OOperationen durchführen können.
- Selectors und SelectionKeys, die multiple und nicht-blockende I/O-Operationen durchführen können.

Anzumerken ist, dass die Klassen der java.nio.* Pakete noch auf die Klassen der alten Pakete (zum Beispiel java.io.* oder java.net.*) zurückgreifen. Im Wesentlichen wurden die neuen Klassen einfach um die alten herumgebaut.

Die Klassen der java.nio.* Pakete nutzen jedoch folgende zwei Klassen, die nicht Bestandteil des java.nio.* Pakets sind, die aber ebenfalls mit der Java Version 1.4 eingeführt wurden:

java.net.SocketAddress: Diese Klasse repräsentiert eine Socket-Adresse ohne genauere Details bezüglich des zu verwendenden Protokolls. Diese Klasse ist abstrakt und wird von spezifischen Klassen (in der Version 1.4 und 1.5 ist dies nur InetSocketAddress) implementiert.

java.net.InetSocketAddress: Die spezifische Implementierung einer SocketAddress. Sie besitzt eine IP-Adresse und einen Port. Alternativ können auch ein Hostname und ein Port angegeben werden.

6.1.1 Zeichensatzgebundenes Lesen und Schreiben von Daten

6.1.1.1 Byteweises Schreiben und Lesen von Daten

Damit beliebige Daten byteweise geschrieben und gelesen werden können, bietet Java ab der Version 1.4 das Paket java.nio.charset an. Die in diesem Paket enthaltenen Klassen Charset, CharsetDecoder und CharsetEncoder reichen vollkommen aus, um Daten zeichensatzgebunden zu schreiben bzw. zu lesen.

Die Klasse Charset wurde nach dem Factory-Pattern entworfen und erzeugt über die statische forName-Methode eine neue Instanz von Charset. Möchte man nun Daten mit einem bestimmten Zeichensatz schreiben, so wird ein CharsetEncoder benötigt. Zum Lesen zeichensatzgebundener Daten wird ein CharsetDecoder benötigt. Beide können über das instanzierte Charset erzeugt werden:

Produkt-Details

• Erscheint lt. Verlag: 1.1.2006
• Sprache: deutsch
• Themenwelt: Informatik ► Programmiersprachen / -werkzeuge ► Java
• ISBN-10: 3-446-40837-1 / 3446408371
• ISBN-13: 978-3-446-40837-1 / 9783446408371