Lektion 13: Gebrauch von CORBA/IIOP

Lektion 13: Gebrauch von CORBA/IIOP
Zugriff auf Domino-Objekte mit Java.
● Kodierung von CORBA befähigten Java-Applets.
● Domino-Implementierung.
●
1
Leitlinien dieser Lektion
Während dieser Lektion führt der Kursleiter das CORBA-Applet vom Server vor –
dies gibt dem Kurs eine realistischen Eindruck der Arbeit von CORBA. Teilnehmer
schließen dann die Übung ab, indem sie wegen der Bequemlichkeit und der
Einfachheit des Umgangs mit den Ressourcen die Vorschau im Web-Browser
nutzen.
Deshalb brauchen die Teilnehmer nicht den Server zu benutzen, um die Übungen
abzuschließen. Sie müssen aber unter den Benutzervorgaben im Register Allgemein
“CORBA-SERVER (DIIOP) bei Vorschau im Web-Browser starten” aktiviert
haben.
Die Teilnehmer brauchen Zugriff auf das Java Developer’s Kit 1.1.8 für den
Abschluss der Übungen.
Diese Lektion enthält die folgenden Übungen:
!
!
Übung 13.1: Erweiterung des CorbaCatalogue-Applet.
Fortgeschrittene Übung 13.2: Erstellen des CorbaHello-Applet.
R5 Courseware-Anwendungs-Referenzen
Auf die folgenden Dokumente wird sich in der Lektion bezogen:
!
!
!
!
Dokument 13.1 Corba Catalogue Applet.
Dokument 13.2 Corba Catalogue (Completed), dies ist die Lösung für Übung 13.1.
Dokument 13.3 CorbaHello Applet, die Lösung für die fortgeschrittene Übung 13.2.
Dokument 13.4 CorbaCatalog Applet Demonstration, dieses Applet läuft auf dem Server.
Modul C: Fortgeschrittene Programmierung
256
Lektion 13: Einsatz von CORBA
Diese Lektion erweitert den Java-Code, den wir in der vorherigen Lektion untersuchten.
Weiterhin erläutert sie das Schreiben von Applets, die Zugriff auf das Domino Object Model
via CORBA nehmen.
Lernziele
Nach dem Abschluss dieses Lektions sollten Sie:
!
!
Vertrauter mit Java und der Art seiner Interaktion mit Domino sein.
Wissen, wie Sie einem Applet ermöglichen, das in eine Maske, Seite oder Dokument
importiert oder eingebettet ist, CORBA zu nutzen.
Weitere Referenzen
Das Java-Handbuch des Programmierers ist jetzt in der Domino-Designer-Hilfe-Datenbank
zur Dokumentation der Java-Klassen integriert. Die gesonderte Datenbank ist auch erhältlich
unter www.notes.net/notesua.nsf. Sie enthält eine vollständige Liste der lotus.domino-JavaKlassen mit unterstützender Dokumentation und Beispielen.
Domino R5 and Corba, von John E. Martin, sorgen für eine gute Erklärung der
Interaktion von Domino und CORBA. Dieser Artikel ist erhältlich unter
www.lotus.com
Zeitschätzung
Für die Bearbeitung dieser Lektion sind ungefähr 60 Minuten vorgesehen.
Modul C: Fortgeschrittene Programmierung
257
Java und Domino-Objekte
Alle Java-Programme nutzen die Domino-JavaKlassen, um Code zu erstellen der Domino-Objekte
instantiiert.
● lotus.domino.* ist ein Java-Paket, das JavaProgrammierern Zugriff auf das Domino Object
Model gibt.
● Das Paket umfasst nicht die Front-end-Klassen - da ein
Java-Programm nicht an Front-end-Objekte wie
Masken-Events (ungleich LotusScript) angehängt
werden kann.
● Dieses Paket wird in Java-Applets, -Anwendungen
26
und -Agenten genutzt.
●
Später in der Lektion werfen wir einen genaueren Blick auf die lotus.domino-Klassen. Die Folie
soll verdeutlichen, wo sie in das Java und Domino-Modell hineinpassen.
Heben Sie die folgenden Punkte hervor:
!
Dies ist ähnlich dem, wie LotusScript und OLE auf das Domino Object Model zugreifen.
Beispielsweise nutzt LotusScript, das in BASIC geschrieben ist, die LotusScript-Klassen für
den Zugriff auf Domino-Objekte.
!
Der Domino-Kern ist in C++ geschrieben – keine andere Programmiersprache kann
direkt mit dem Domino Object Model kommunizieren. Alle Programmiersprachen außer
C++ müssen über ein API in C++ umgewandelt werden, bevor Sie auf ein DominoObjekt zugreifen können.
Der Domino-Server mit dem passenden API (entsprechend ein Adapter) schließt diese
Umwandlung ab. Beispielsweise wird LotusScript (BASIC-Code) in C++ vom
LotusScript-Adapter umgewandelt; Java-Agenten werden vom Server-Java-API
umgewandelt (auf das sich auch als JVM oder Java-Adapter bezogen wird); OLE-Befehle
werden auch bearbeitet.
Dasselbe gilt für CORBA-Objekt-Anforderungen. Der Unterschied zu CORBA liegt darin,
dass es tatsächlich eine Schnittstelle (die IDL) zwischen der Sprache, in der die
Anforderung codiert ist (gewöhnlich Java - wie in einem Java Applet), und der DominoKern-Sprache (C++) gibt.
!
!
Modul C: Fortgeschrittene Programmierung
258
Über Java und Domino
Ein Java-Programm muss zur Instantiierung und für den Zugriff auf Domino-Objekte die
lotus.domino-Klassen importieren, was wir später in dieser Lektion genauer behandeln.
Ein Java-Programm, dass das lotus.domino.*-Paket importiert, kann Instanzen von DominoObjekten erstellen. Beispielsweise kann es Instanzen der aktuellen Datenbank erstellen und
anschließend eine Instanz des ersten Dokuments in dieser Datenbank. Jedoch können diese
Java-Anweisungen nicht direkt mit dem Domino-Kern kommunizieren. Effektiv macht der
Java-Code nur eine Anforderung zur Instantiierung des Domino-Objekts. Ein Java-Programm
kann selbst keine Domino-Objekte bekommen, da es in Java geschrieben ist, während
Domino-Objekt-Klassen in C++ geschrieben sind. Java kann nicht ohne eine erste
Umwandlung mit C++ kommunizieren.
Wie Java-Code auf Domino-Objekte zugreift
Deshalb muss für jedes Java-Programm, um ein Domino-Objekt zu bekommen, die Anweisung
des Java-Programms von einem anderen Programm interpretiert werden. Gewöhnlich ist es ein
API, das Java in C++ umwandeln kann.
In Domino gibt es jetzt zwei verschiedene Wege, auf denen dies für Java-Programme geschieht:
!
Java-Code, der auf lokale Domino-Daten zugreift, wird in C++ umgewandelt, und auch
von der entsprechenden Domino-Java-API zurückgewandelt. Die Umwandlung wird
entweder von der Local-API (Client-JVM) oder der Server-API (Server-JVM) ausgeführt
und hängt vom Typ des Programmes ab und wo und wie es läuft.
!
Java-Code, der auf entfernte Domino-Daten zugreift, tut dies via CORBA. CORBA
wandelt die Java-Befehle in IDL, sendet das IDL an den Server, und wandelt dann das IDL
(entsprechend kein Java mehr) zu C++ und auch umgekehrt.
Modul C: Fortgeschrittene Programmierung
259
Java mit entfernten Domino-Objekten
Ein Java-Programm, dass lotus.domino.*-Pakete
importiert, kann Domino-Objekte instantiieren.
Aber dies bedeutet nicht, dass das Programm zum
Domino-Kern “spricht” .
● Domino-Objekte sind C++-Klassen - eine Methode
zur Anpassung anderer Sprachen an C++ ist für die
Kommunikation notwendig.
● Java-Applets greifen auf entfernte Domino-Objekte
via CORBA mit der IDL-Schnittstelle zu. CORBA
wandelt die Java-“Anfrage” in IDL, sendet die IDL
zum Domino-Server und wandelt Sie dann in C++. 2
●
Nutzen Sie das Diagramm in den Teilnehmernotizen, um zu erklären wie Java mit Domino
zusammenarbeitet.
Heben Sie die folgenden Punkte hervor::
!
!
!
!
Die mittlere Ebene (IDL) macht CORBA so vielseitig. Ist die Anfrage erst einmal in IDL
gewandelt, unbeachtet der Sprache, in der die Anfrage erfolgt (es muss nicht Java sein),
spielt es keine Rolle mehr für den Server, der die Aufgabe des Austauschs der Anfrage auf
der Grundlage von IDL vornimmt.
CORBA arbeitet grundsätzlich so: Auf dem Client wandelt CORBA Java zu IDL. Das
IDL wird an den Server mit dem IIOP-Protokoll für TCP/IP gesandt. Auf dem Server
wandelt CORBA das IDL zu C++, dass dann mit dem Domino-Kern direkt
zusammenarbeiten kann.
Beachten Sie, wie sich dies von der Art und Weise wie Java-Agenten und Applets auf dem
Client mit dem Domino Object Model zusammenarbeiten unterscheidet. CORBA spielt
dabei keine Rolle.
Der Server nutzt ein separates Port, um auf CORBA-Anforderungen zu achten und zu
antworten.
Modul C: Fortgeschrittene Programmierung
260
Domino-Prozess-Architektur
Das folgende Diagram erklärt, wie Java-Applets mit entfernten Domino-Objekten via CORBA
zusammenarbeiten.
Browser
Domino Server
(entfernt)
HTTP Server
HTTP
Port
Applet
Client ORB
(wandelt
Java zu IDL)
Sendet
IDL via
IIOP
zum
Server
Port
Domino Object Server
CORBA
Adapter
IIOP
Port
LS
Adapter
Java
Adapter
OLE
Adapter
Domino
Object
Model
= Domino
CORE
(C++)
Java und die JVM
Wie Sie aus dem obigen Diagramm ersehen können, nutzen Java-Applets, die aus der Ferne auf
das Domino Object Model zugreifen, nicht das JVM. Stattdesse wird der Java-Code des Applet
tatsächlich in IDL gewandelt und dies wird an den Server zur Umwandlung in C++ gesendet.
Java-Anwendungen, die entfernt auf Domino-Daten zugreifen, nutzen auch CORBA-Klassen.
Die JVM wird immer noch für den Zugriff auf lokale Domino-Daten genutzt. Die
folgenden Java-Programme greifen auf Domino-Daten mit der JVM zu:
!
!
!
Java-Applets, die auf dem Notes-Client laufen. Die AppletBase-ClassDatei umfaßt Java-Code, der dynamisch bestimmt, wo das Applet läuft
und macht CORBA ferne Aufrufe, wenn das Applet in einem Browser
läuft. Wenn nicht ruft es die Lokale API (die Client-JVM).
Java-Anwendungen, die auf einer Maschine mit installiertem Notes-Client
oder Domino-Server laufen. Es sei denn eine Anwendung macht entfernte
Aufrufe via CORBA , dann muss die Domino-JVM installiert sein, um auf
Domino-Daten lokal zuzugreifen.
Java-Agenten nutzen immer die JVM für den Zugriff auf Domino-Daten –
entweder auf dem Server oder auf dem Notes-Client. Agenten benutzen
kein CORBA.
Modul C: Fortgeschrittene Programmierung
261
Die Java-Klassen von Domino
●
Java-Klassen-Namen für Domino-Objekte stimmen
mit den Namenskonventionen von Java überein.
– Weshalb sie sich leicht von den entsprechenden
LotusScript-Klassen-Namen unterscheiden.
●
Die Namen sind immer noch den LotusScript-Namen
sehr ähnlich:
– Entfernen Sie das Wort “Notes” vom Namensanfang der
LotusScript-Klasse und Sie haben den Java-Namen.
– Beispielsweise wird NotesDocument zu Document.
●
Strenge Anwendung des Containment Model - jedes
Objekt muß ein Super-Objekt haben mit Ausnahme
von Session.
2
Hervorzuhebende Punkte
!
Java-Klassen-Namen = entfernen Sie das Wort “Notes” vom LotusScript-Namen. Der
vollständige Name lautet lotus.domino.ClassName – doch ist erst einmal das
lotus.domino.*-Paket importiert, so gibt keine Notwendigkeit mehr, lotus.domino im
Namen aufzuführen.
!
Java-Klassen-Namen beginnen immer mit einem Großbuchstaben.
!
Im Gegensatz müssen sich LotusScript-Programmierer an das strenge Containment-Model
in Java halten. Beispielsweise, um Zugriff auf eine Ansicht zu nehmen, muss ein Session-,
dann ein Database- und schließlich ein View-Objekt erstellt werden. Auf das View-Objekt
wird über das Database-Objekt (entsprechend. View v = db.getView()) zugegriffen, auf das
über das Session-Objekt (entsprechend Database db = session.getDatabase(server,
dbname)) zugegriffen wird.
!
Auf Session muss nicht über ein anderes Objekt zugegriffen werden, da es das oberste
Domino-Objekt ist. Sie brauchen ein Session-Objekt, bevor sie auf irgend etwas anderes
Zugriff nehmen können.
Über das lotus.notes.*-Paket
Dies ist das R4.6 Domino-Java-Paket – es arbeitet immer noch für R4.6-Programme, doch es
wird nicht aktualisiert, um die R5-Klassen zu enthalten.
Modul C: Fortgeschrittene Programmierung
262
Über die lotus.domino-Klassen
Die folgende Tabelle listet die lotus.domino-Klassen, die für öffentl. Nutzung verfügbar sind:
Java-Class-Datei
Domino-Objekt, auf das zugegriffen wird
lotus.domino.ACL
stellt eine Sammlung aller Einträge in die
Zugriffskontrolliste einer Datenbank dar.
lotus.domino.ACLEntry
stellt einen einzelnen
Zugriffskontrolliste dar.
lotus.domino.Agent
stell die Attribute eines Agenten dar.
lotus.domino.AgentContext
stellt den Kontext des aktuellen Agenten dar, wenn
das Programm als Agent läuft.
lotus.domino.Database
stellt eine Notes-Datenbank dar.
lotus.domino.DateRange
stellt einen Bereich von Datum und Zeit dar.
lotus.domino.DateTime
stellt in Notes Datum oder Zeit dar.
lotus.domino.DbDirectory
stellt die Datenbank-Datei auf einem Server oder
einer lokalen Maschine dar.
lotus.domino.Document
stellt ein Dokument in einer Datenbank dar.
lotus.domino.DocumentCollection
stellt eine Sammlung von Dokumenten dar.
lotus.domino.EmbeddedObject
stellt eingebettete Objekte, Links und Dateianhänge
dar.
lotus.domino.Form
stellt die Maske einer Datenbank dar.
lotus.domino.International
stellt die internationalen Voreinstellungen des
Betriebssystems dar.
lotus.domino.Item
repräsentiert ein Item in einem Dokument.
lotus.domino.Log
stellt Aktionen oder Fehler bei der Ausführung
eines Scipts dar.
lotus.domino.Name
stellt den Namen eines Bentuzers oder Servers dar.
Lotus.domino.NewsLetter
repräsentiert eine Zusammenfassung, die Inhalte
und Links zu anderen Dokumenten enthält.
Lotus.domino.Registration
stellt die Erstellung oder Administratin einer IDDatei dar.
Lotus.domino.RichTextItem
stellt ein Rich-Text-Item dar.
Lotus.domino.Session
stellt den Kontext des aktuellen Programm dar.
Diese Klasse ist die Grundlage der NotesDatenbank-Objekte.
Lotus.domino.View
stellt eine Ansicht oder einen Order in einer
Datenbank dar.
Lotus.domino.ViewColumn
stellt eine Säule in einer Ansicht dar.
Modul C: Fortgeschrittene Programmierung
Eintrag
in
eine
263
Die Java-Klassen von Domino...
METHODEN:
● Methoden von Java sind mit denen von LotusScript
identisch. Sie beginnen nur mit Kleinbuchstaben.
EIGENSCHAFTEN:
● In Java sind Eigenschaften auch Methoden, so müssen
die LotusScript-Eigenschaften in entsprechende
Methoden gewandelt werden:
– Boolsche Eigenschaften haben zwei gleichwertige
Methoden, eine zum Setzen beginnt mit dem Wort “set”
und die andere zum Lesen mit “is”.
– Andere Eigenschaften wandeln sich zur “get”-Methode
2
in Java.
Heben Sie die folgenden Punkte hervor:
!
Die Namen der Java-Methoden sind identisch mit den Namen der LotusScriptMethoden jeder Klasse. Sie werden nur mit Hilfe der Java-Namenskonventionen
formatiert. So wird die GetFirstDatabase-Methode als getFirstDatabase-Methode in Java
geschrieben.
!
Eigenschaften sind komplexer, weil Java keine “Eigenschaften” besitzt. Daher müssen
Java- Methoden geschrieben werden, die die gleiche Funktionalität erfüllen.
!
Boolean Read-only Eigenschaften sind grundsätzlich das selbe wie LotusScript
Eigenschaften mit der Ausnahme, dass sie mit Kleinbuchstaben “is” beginnen.
Bespielsweise wird die NotesSession.IsOnServer-Eigenschaft zur Session.isOnServer() in
Java.
!
Boolean-Eigenschaften, die nicht read-only sind, besitzen zwei Methoden in Java. Eine
Methode erlaubt das Auslesen der Eigenschaft. Diese Methode ist dieselbe wie die readonly- Methode (entsprechend beginnt sie mit dem Wort “is”). Eine neue Methode wird
auch erstellt, die die Veränderung der Eigenschaft erlaubt und diese beginnt gewöhnlich
mit dem Wort “set”. Beispielsweise wird die NotesDocument.SaveMessageOnSendEigenschaft von LotusScript zu Document.isSaveMessageOnSend() zum Lesen und zu
Document.setSaveMessageOnSend() zur Veränderung.
!
Non-Boolean-Eigenschaften werden zu “get”-Methoden gewandelt. Beispielsweise
wird die NotesDocument.NoteID-Eigenschaft zur Document.getNotesID()-Methode in
Java.
Modul C: Fortgeschrittene Programmierung
264
Java-Klassen-Eigenschaften und Methoden
Java-Klassen haben alle dieselben Eigenschaften und Methoden wie die LotusScript-Klassen,
jedoch sind sie aufgrund der Konventionen in Java-Programmen ein wenig verschieden codiert.
Die Ähnlichkeiten und Unterschiede werden hier mit einigen der Eigenschaften und Methoden
des NotesDocument-Objekts illustriert.
Java-Methoden
Der einzige Unterschied zwischen Java- und LotusScript-Methoden liegt darin, dass die
Entsprechung in Java mit einem Kleinbuchstaben beginnt:
LotusScript-Methoden für
Notes-Dokumente
Entsprechende Java-Methode für
Dokumente
GetItemValue(itemName$)
getItemValue(String name)
HasItem(itemName$)
hasItem(String name)
ReplaceItemValue(itemName$, value)
replaceItemValue(String name, Object value)
Java-Methoden für LotusScript-Eigenschaften
Die Umwandlung von LotusScript-Eigenschaften nach Java war komplexer, weil Java nicht
über ein äquivalentes Konzept verfügt. Deshalb müssen Methoden geschrieben werden, die
dieselben Funktionen erfüllen wie die Eigenschaften.
LotusScript- Eigenschaft für NotesDokumente
Entsprechende Java-Methode für
Dokumente
Authors
getAuthors()
EncryptOnSend
To read use: isEncryptOnSend()
To set use: setEncryptOnSend(Boolean flag)
IsResponse
isResponse()
SaveMessageOnSend
To read use: isSaveMessageOnSend()
To set use: setSaveMessageOnSend(Boolean
flag)
NoteID
Modul C: Fortgeschrittene Programmierung
getNotesID()
265
Beispiel Domino-Java-Klassen
●
lotus.domino.Session
– getDatabase
●
lotus.domino.Database
– getView
●
lotus.domino.View
– getFirstDocument()
– getNextDocument(Object document)
5
Vorführung
Nutzen Sie diese Vorführung, um einige der gebräuchlichsten Java-Klassen anzuschauen und
um die Ähnlichkeiten mit den LotusScript-Klassen zu wiederholen.
1. Öffnen Sie die Dokumentation GetDatabase in der Designer Hilfe (Bereich
LotusScript, Session-Klasse). Dieses Dokument ist mit dem Dokument 13.0
Using CORBA in der R5Courseware-Anwendung verknüpft.
2. Nutzen Sie dieses Dokument zur Illustrationen der Ähnlichkeiten zwischen
den LotusScript-Klassen (wie in der Notes-Hilfe beschrieben) und den JavaKlassen – die in den Teilnehmernotizen dokumentiert sind.
3. Sie können auf Wunsch das selbe für die GetView und GetDocumentMethoden zeigen.
Modul C: Fortgeschrittene Programmierung
266
Über getDatabase()
Diese Methode ist in lotus.domino.Session definiert. Sie erstellt ein lotus.domino.DatabaseObjekt, dass die Datenbank auf dem von Ihnen spezifizierten Server findet (spezifizieren Sie
null, um eine lokale Datenbank anzuzeigen) und öffnet.
Syntax:
sessionName.getDatabase(String server, String db);
Beispiel:
Database db = s.getDatabase(null, "R5Courseware");
Das Databank-Objekt hat Zugriff auf dieselben Eigenschaften und Methoden wie das
LotusScript NotesDatabase-Objekt.
Um auf die Eigenschaften der Objekte zuzugreifen und deren Methoden aufzurufen, beziehen
Sie sich auf den Namen der Methode in der Java-Klassen-Dokumentation und wenden die
Standardreferenz von Java an.
Syntax:
databaseObjectName.methodName();
Dies ist weiter unten für die getView()-Methode illustriert.
Über getView()
Diese Methode ist in lotus.domino.Database definiert. Sie erstellt ein lotus.domino.ViewObjekt, dass eine durch eine Zeichenkette spezifizierte Ansicht darstellt.
Syntax:
databaseName.getView(String);
Beispiel:
db.getView(“ViewName”);
Das Ansichts-Objekt hat Zugriff auf dieselben Eigenschaften und Methoden wie das
LotusScript NotesView-Objekt.
Über getFirstDocument()
Diese Methode ist definiert in lotus.domino.View. Sie erstellt ein lotus.domino.DocumentObjekt, dass das erste Dokument einer Ansicht darstellt.
Syntax:
viewName.getFirstDocument();
Beispiel:
Document doc = view.getFirstDocument();
Das Dokument-Objekt hat Zugriff auf dieselben Eigenschaften und Methoden wie das
LotusScript NotesDokument-Objekt.
getNextDocument(doc), getLastDocument(doc) werden mit der selben Syntax aufgerufen.
Wenn Sie erst einmal das lotus.domino.*-Paket in Ihr Java-Programm importiert
haben, dann ist die “lotus.domino”-Referenz, die sonst vor dem DominoKlassennamen steht, unnötig und kann weggelassen werden.
Die einzige Ausnahme für die Session-Class besteht dort, wo das Programm andere
Typen des Session-Objekts einfügt. In diesem Fall müssen Sie zwischen ihnen
unterscheiden, indem Sie den vollständigen Klassennamen benutzen.
Modul C: Fortgeschrittene Programmierung
267
Handhabung von Domino-Exceptions
●
●
Java handhabt Exceptions wie folgt:
– Trifft Java auf eine Exception, so erstellt es ein
Exception-Objekt zur Beschreibung.
– Das Exception-Objekt wird an das Laufzeit-System
weitergegeben, was für das Finden des Codes zur
Handhabung der Exception verantwortlich ist. Es
wird throw an exception genannt.
– Das Runtime-System findet den passenden
Exception-Handler. Dies wird catch an Excepttion
genannt.
Domino-Exceptions werden in der gleichen Weise
behandelt.
6
Nutzen Sie diese Möglichkeit zur Erklärung der in Java vorhandenen Techniken zur
Handhabung von Exceptions.
Behandeln Sie die folgenden Punkte:
!
Domino-Exception-Handler erkennen grundsätzlich die Ursache von Exceptions, geben
die Nummer an die Konsole oder Log-Datei weiter und halten das Programm von der
weiteren Ausführung ab.
!
Um die Fehlermeldung als auch die Nummer im Exception-Bericht zu erfassen, nutzen Sie
die NotesException text public-Variable.
!
Eine vollständige Liste der Fehler, die in der NotesError-Klasse definiert sind, ist in der
Java-Classes-Dokumentation der Designer-Hilfe enthalten – beziehen Sie sich auf das
Link in der Zusammenfassung der Lektion.
Modul C: Fortgeschrittene Programmierung
268
Catching Exceptions in Java
Die try-Anweisung enthält eine Bedingung zum Catching , die zur Verarbeitung der Exceptions
genutzt wird, die bei der Ausführung des Code in der Anweisung vorkommen. Die Anweisung
hat folgende Syntax:
try {
//functional code which might throw exceptions goes here;
} catch(ThrowableObjectName e) {
//exception-handling code goes here;
}
Das Exception-Objekt besitzt Methoden, die aufgerufen werden können, um mehr
Informationen über die Exception zur Verfügung zu stellen. So druckt die printStackTrace()Methode den Pfad, den das Programm zur Laufzeit nahm, um den Exception-Handler zu
finden.
Catching von Domino-Exceptions
Beim Catching von Domino-Exceptions lautet der ThrowableObjectName im Catch-Block
“NotesException”. Die NotesException-Class enthält die folgenden öffentlichen Variablen:
!
int NotesException.id: dies enthält den Fehler-Code;
!
String NotesException.text: enthält die Fehlermeldungen.
Das folgende Beispiel eines Catch-Codes druckt Fehlernummer und Meldung der Exception,
die beim Zugriff auf die ID und Texteigenschaften des thrown-Objekts, als “e” benannt,
angetroffen wurde. Dieser Code zeigt, wie einzelne Exceptions mit der NotesError-Klasse
herausgenommen werden können:
try {
//functional code goes here;
} catch(NotesException e) {
if (e.id == NotesError.NOTES_ERR_SEND_FAILED)
System.out.println("Mail send was unsuccessful");
else {
System.out.println(e.id + " " + e.text);
e.printStackTrace();;
}
}
Die NotesException Java-Class definiert Methoden zur Handhabe von DominoExceptions.
Die NotesError Java-Class definiert mögliche Fehler als Konstanten, um
Exception-Handler wie zuvor gezeigt auf bestimmte Fehler zu testen.
Schlagen Sie bei den Links in der Zusammenfassung der Lektion nach, die auf die
Designer-Hilfe mit einer vollständige Liste der in der NotesError-Class enthaltenen
Fehler verweisen.
Modul C: Fortgeschrittene Programmierung
269
Codierung von CORBA-Applets
●
Importieren Sie das lotus.domino.*-Paket in die
Applet-Source-Datei:
import lotus.domino.*;
●
Erweitern Sie die AppletBase-Class und übergehen
Sie die notesAppletXXXX()-Methoden:
public class myApplet extends AppletBase {
public void notesAppletInit()
●
Nutzen Sie die getSession()-Methode zur Instantiierung und Initialisierung von CORBA im Applet:
Sessions = this.getSession();
6
Hervorzuhebende Punkte
!
!
!
Applets, die lotus.domino-Klassen verwenden, werden erstellt durch die Erweiterung der
lotus.domino.AppletBase-Class anstatt durch die java.applet.Applet-Class.
Sessions müssen in einer try{ }-Anweisung eingegeben werden, da es bei ihnen zu
Exceptions kommen kann.
Es ist nicht möglich, CORBA-Applets durch die Vorschau im IE zu testen. Zum richtigen
Test der Funktionalität des Objekts mit dem Applet müssen Sie darauf über den Server
zugreifen.
Vorführung...
4. Starten Sie Ihren Domino-Server und Laden Sie den IE – Sie werden später
auf die R5Course.nsf-Datenbank über den IE zugreifen.
5. Führen Sie das Corba Catalogue-Applet ein und erklären Sie , was es leistet.
Wir werden dieses Applet zur Demonstration des Schreibens eines CORBAbefähigten Applets in dieser Lektion nutzen.
6. Im Internet Explorer öffnen Sie das Dokument 13.4 CorbaCatalog Applet
Demonstation, und zeigen wie das Applet arbeitet. Das Applet braucht einen
Moment zum Laden, da es das lotus.domino-Paket lädt – Sie sollten dies in der
Statusleiste des IE sehen. Öffnen Sie die Java-Konsole und kehren Sie zurück
in den IE.
7. Erklären Sie, anstatt nur die Bilder zu zeigen, dass deren URLs in der AppletClass-Datei festgelegt sind und dieses Applet die Details der Bild-Dateien
von der ObjectsByLektion-Ansicht in der R5Courseware-Datenbank liest.
Modul C: Fortgeschrittene Programmierung
270
Einführung der AppletBase-Class
Applets, die auf Domino-Daten zugreifen, müssen AppletBase erweitern und nutzen
notesAppletInit(), notesAppletStart(), und notesAppletStop() als Eingabepunkte ihres
funktionellen Codes.
Die öffentlichen Methoden der AppletBase-Class sind folgende:
public
class
AppletBase
DominoAppletBase {
extends
Applet
implements
public Session getSession() throws NotesException;
public Session getSession(String user, String pwd) throws
NotesException;
public final void init();
public void notesAppletInit();
public final void start();
public void notesAppletStart();
public final void stop();
public void notesAppletStop();
public final void destroy();
public void notesAppletDestroy();
public Boolean isNotesLocal();
}
CORBA-befähigtes Catalogue-Applet
Im Rest dieser Lektion werden wir ein Applet ähnlich dem Catalogue-Applet der vorherigen
Lektion nutzen. Dieses Applet wurde so verändert, dass es auf Domino-Daten via CORBA
zugreifen kann. In der CORBA-Version des Catalogue-Applet werden die angezeigten Bilder
aus einer Domino-Ansicht gespeist.
Modul C: Fortgeschrittene Programmierung
271
Über das CORBA-Applet
NUTZEN SIE FOLGENDE METHODEN FÜR
DEN ZUGRIFF AUF DAS SESSION-OBJEKT:
● Nutzen Sie notesAppletInit(): wenn eine
Session rechtzeitig etabliert und kontinuierlich
gebraucht wird.
● Nutzen Sie notesAppletStart(): wenn der Start
eines Applet durch den Benutzer den Zugriff
auf eine Session bedingt.
● Nutzen Sie eine eventHandler()-Methode,
wenn eine Session nur beim Vorkommen
eines besonderen Events notwendig ist.
6
Im CorbaCatalogue-Applet wird die dritte Methode für den Zugriff auf den Domino-Server
genutzt. Erklären Sie kurz, wann die anderen Methoden zum Einsatz kommen. Vermerken Sie,
dass auf eine Session, die in einer Methode erstellt wurde, in einer darauf folgenden Methode
zugegriffen werden kann, wenn der Gültigkeitbereich korrekt festgelegt oder klar
weitergegeben wurde.
Vorführung…
8. Betrachten Sie den Java-Code (der in den Teilnehmernotizen dargestellt ist)
und heben Sie die wichtigsten Stellen des Code hervor. Diese werden später
noch genauer in der Vorführung betrachtet.
9. Beachten Sie im besonderen, dass sich dieses Applet vom Catalogue-Applet
der Lektion 12 unterscheidet. Es erweitert die lotus.domino.AppletBase-Class
und nicht die java.applet.Applet-Class. Dies ist der Grund, warum die Standard
Applet-Methoden eher als notesAppletInit() benannt werden anstatt einfach als
init(),doch sind die Methoden dieselben.
Modul C: Fortgeschrittene Programmierung
272
Das Corba Catalogue-Applet
Das Vorführ-Applet dieser Lektion baut auf dem Catalogue-Applet von Lektion 12 auf und
erweitert seine Funktionalität. Es nutzt CORBA für den Zugriff auf das Domino Object
Model. Die Class-Datei definiert die folgenden Methoden und Variablen:
class
CorbaCat
extends
AppletBase
implements
1 public
2 ActionListener {
3 Image baseImage;
4 Image prodImage;
5 int n=0;
6 Button nextProduct;
7 View v;
8 public void notesAppletInit() {
9
setSize(250,250);
10
baseImage = getImage(getCodeBase(),"product1.jpg");
11
//Create the Button and add it to the applet
12
nextProduct = new Button("Next Product");
13
nextProduct.addActionListener(this);
14
add(nextProduct);
15
validate();
16 }
17 public void paint(Graphics g) {
18
g.drawImage(baseImage, 75, 45, this);
19
validate();
20
System.out.println("The paint method has executed");
21 }
22
public void notesAppletStart() {
23
try { functional code to get View object goes
24 here}
25
}
26 public void actionPerformed (ActionEvent ae) {
27
try { functional code to get image goes here}
28
repaint();
29 }
30 public void update(Graphics g){
31
g.drawImage(prodImage, 75, 45, this);
32
validate();
33
System.out.println("The update method was executed"); }}
Zeilenweise Erklärung des Code:
1-5
6
7-15
16-20
21-23
24-27
28-33
Klassen- und Variablendeklarationen.
Die Variable View wird hier deklariert, so ihr Gültigkeitsbereich den Zugriff durch
Methoden erlaubt.
Die notesAppletInit()-Methode speichert das Anfangsbild in einem Bild-Objekt und
erstellt eine Schaltfläche, die dem Layout hinzugefügt wird.
Die paint()-Methode zeigt das Anfangs-Bild im Applet.
Die notesAppletStart()-Methode etabliert eine beständige Session und findet die Ansicht
ObjectsByLektion, die genutzt wird, um durch die Produkt-Dokumente zu springen.
Die actionPerformed()-Method enthält den funktionellen Code des Applet. Klickt der
Benutzer auf die Schaltfläche NextProduct, dann greift diese Methode auf das nächste
Produktbild einer Domino-Ansicht zu, handhabt Fehler und zeichnet das Applet neu.
Die update()-Methode wird vom repaint()-Aufruf in actionPerformed() zum
Neuzeichnen aufgerufen.
Modul C: Fortgeschrittene Programmierung
273
Zugriff auf eine Domino-Ansicht
●
Der funktionelle Code in der notesAppletStart()
-Methode bewirkt folgendes:
– Bekommt eine Sitzung mit dem Server.
– Instantiiert ein Database-Objekt.
– Nutzt das Database-Objekt, um die
ObjectsByLesson-Ansicht zu lokalisieren.
Auf das View-Objekt, v, kann mit jeder Methode in der CorbaCat1.class zugegriffen werden.
● Der Try {}-Block enthält die notwendigen
Catch-Anweisungen.
●
7
Heben Sie den folgenden Punkt hervor::
!
Die notesAppletStart()-Methode wird automatisch vom Browser aufgerufen, nachdem die
notesAppletInit()-Methode die Ausführung beendet.
Vorführung…
10. Erklären Sie, dass bei Erstellung der Session in der notesAppletStart()-Methode
die Session nur einmal erstellt wird und in der actionPerformed()-Methode
immer wenn notwendig nutzbar ist.
11. Wenn einmal auf die Session zugegriffen ist, dann sind der Zugriff auf die
Datenbank und die Ansicht fast identisch mit dem in LotusScript.
12. Erklären Sie, dass die Catch-Anweisung die Fehlermeldung und Nummer für
jede Notes-Exception anzeigt, die auf der Java-Konsole vorkommt. Mit
stacktrace() wird die Methode verfolgt, die ausgeführt wurde als der Fehler
auftrat.
13. Öffnen Sie die ObjectsByLektion-Ansicht, um zu zeigen von wo die
Katalogbilder gewonnen werden.
Modul C: Fortgeschrittene Programmierung
274
Das Corba Catalogue-Applet …
Der Try {} Anweisungsblock der notesAppletStart()-Methode lautet wie folgt:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
try {
Session s = this.getSession();
System.out.println("Session is on platform"+s.getPlatform());
Database db = s.getDatabase(null,"R5Course");
v = db.getView("ObjectsByLektion");
System.out.println("View name is: "+v.getName());
}
catch(NotesException ne) {
System.out.println(ne.id + “ “ + ne.text);
ne.printStackTrace();
}
catch(Exception e) {
e.printStackTrace();
}
Zeilenweise Erklärung des Code::
Anfang des try-Anweisungsblocks
Instantiierung der Session-Class and Zurückgabe der aktuellen Session (die von der
AppletBase-Class-Datei etabliert wurde). Die folgende Debugging-Nachricht greift auf
eine Methode der Session-Class zu, um zu bestätigen, dass auf sie im Applet Zugriff
möglich ist.
4
Instantiierung der Database-Class und Zuweisung der R5Course-Datenbank auf dem
Server.
5-6 Festlegen des view-Objekts, genannt v, auf die ObjectsByLektion-Ansicht in der
R5Course-Datenbank. Die Debugging –Nachricht greift auf die getName()-Methode
der View-Class zu, um zu bestätigen, dass auf dieses Objekt im Applet zugegriffen
werden kann.
8-11 Diese Catch-Anweisung wird aktiviert, falls eine Exception in Notes während der
Ausführung der try-Anweisung erfolgt. Die Debugging –Nachricht gibt die Nummer
des Fehlers und die Fehlermeldung wieder. Der printStackTrace()-Aufruf zeigt eine
Liste der Klassen, die ausgeführt wurden, als der Fehler vorkam.
12- Diese Catch-Anweisung wird aktiviert, falls es zu einer anderen als einer Notes14 Exception während der Ausführung der try-Anweisung kommt. Es druckt einfach eine
Stack-Spur.
1
2-3
Modul C: Fortgeschrittene Programmierung
275
Zugriff auf Objekte in einer Ansicht
●
Der funktionelle Code in der actionPerformed()
Methode macht das folgende:
– Erstellt einen Java-Vector, der zum Suchen eines
View-Objekts von zwei Schlüsselwerten, der
Kategorie (“CatalogueImages”) und dem Namen
der Bilder (z.B.: “product1.jpg”), genutzt werden
kann.
– Findet das Dokument, indem er den Vektor als den
Schlüssel zum Aufruf der getDocumentByKey()Methode nutzt.
– Erstellt eine Domino-URL, die genutzt wird, um die
Bilder von der Dokument-URL zu bekommen.
7
Vorführung…
14. Die getDocumentByKey()-Methode nutzt ein Java-Vector-Objekt zum
Speichern der “Schlüssel”, dass die richtigen Dokumente anhand der Werte für
die ersten beiden Säulen in dieser Ansicht erkennt.
15. Erklären Sie den URL-Umwandlungs-Code wie folgt. Die getURL()Methode gibt die Domino-URL des DOKUMENTS zurück, dass die Bilddatei
als Anhang enthält. Wir brauchen tatsächlich die URL für den Anhang, um
durch die Veränderung der URL des Dokuments den $FILE -Tag am Ende
anzuhängen.
16. Erklären Sie, dass in Domino die Handhabung von Bildern schwieriger ist als
die von Text, da Bilder keine Domino-Objekte sind. Die Teilnehmer werden
eine TextArea-Komponente dieses Applets in der Übung programmieren.
Modul C: Fortgeschrittene Programmierung
276
Das Corba Catalogue-Applet…
Der Try {}-Anweisungsblock der actionPerformed()-Methode ist folgend wiedergegeben:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
try {
//Create a vector to store document "key":
java.util.Vector vr=new java.util.Vector();
vr.addElement("CatalogueImages");
n = n+1;
vr.addElement("product" + n +".jpg");
Document doc = v.getDocumentByKey(vr);
//Convert the current Document's URL into a Domino URL:
URL docUrl = new URL(doc.getURL());
String conversionString = new String(docUrl.toString());
int x=conversionString.indexOf("?");
conversionString = conversionString.substring(0,x)+"/$FILE/";
docUrl= new URL(conversionString);
System.out.println(docUrl);
//Get the image for product1.
prodImage = getImage(docUrl,"product"+ n +".jpg");
}
catch(NotesException ne) {
System.out.println(ne.id + “ “ + ne.text);
ne.printStackTrace();
}
catch(Exception e) {
e.printStackTrace();
}
repaint();
}
Zeilenweise Erklärung des Code:
1
2-7
8-9
10-14
15-16
17-24
25-26
Anfang des Blocks der try-Anweisung
Dieser Code findet das Dokument mit dem Titel “productn.jpg” in der
ObjectsByLektion-Ansicht. Die zwei Schlüsselwerte werden in dem Java Vector,
benannt vr, gespeichert.
Dieser Code bekommt die URL des Dokuments, dass das Produktbild als Anhang
enthält.
Java kann die anghängte Datei nicht von der URL des Dokuments öffnen. Deshalb
muss die URL in eine Domino-URL umgewandelt werden, so dass die angehängte
Datei geöffnet werden kann. Die Debugging Nachricht zeigt die umgewandelte
URL.
Dieser Code bekommt die Bilddatei mit der URL des Dokuments und den
Dateinamen mit einem getImage()-Aufruf. getImage() ist eine Methode der
java.applet.Applet-Klasse.
Notes- und Java-Exception-Handling-Code – wie für die notesAppletStart()Methode.
repaint() ruft die update()-Methode auf, die das neue Bild in das Applet zeichnet.
Modul C: Fortgeschrittene Programmierung
277

Download Report