Anwendungsentwicklung unter Lotus Domino Notes 7

Anwendungsentwicklung unter Lotus Notes Domino 7

IBM Software Press In Zusammenarbeit mit der IBM Deutschland GmbH verlegt Addison-Wesley diese Reihe professioneller Bücher. Die Reihe deckt die Software WebSphere, DB2, Tivoli und Lotus ab. Die Funktionalitäten, Tools, Anwendungen und Entwicklungsumgebungen der jeweiligen Software werden von Autoren beschrieben, die sich beruflich mit der Software befassen.

Diese Neuauflage des Notes/Domino Administrationshandbuchs stellt die Version 7 mit deutlichem Fokus auf den Fragen und Problemen der täglichen Administrationspraxis vor. Neben den Neuerungen der Version 7 im Vergleich zur Vorgängerversion 6.5 beschreibt die Autorin alle Facetten des Betriebs einer Domino-Infrastruktur und gibt dem Leser wichtige Hilfsmittel an die Hand wie Checklisten, Fragenkataloge und eine FAQ-Aufstellung mit Standard-Problemen. So erhalten auch Einsteiger einen schnellen Start in das Thema und in die Arbeit mit Lotus Notes Domino. Natürlich kommen auch die Installation und Konfiguration, die Optimierung und das Thema Sicherheit nicht zu kurz!

Dieses Buch bietet, was viele Lotus Notes-Entwickler suchen: Workarounds, Best Practices und Problemlösungen für den täglichen Einsatz in der Anwendungsprogrammierung. Autor Klatt setzt dort an, wo Notes-Dokumentation und Grundlagen-Bücher aufhören. Er zeigt nach einem Überblick über die Sprache, wie sich mit LotusScript objektorientiert programmieren lässt, wie sich die Beschränkungen von LotusScript durch die Einbindung von C- und Java-Code überwinden lassen und wie man professionelle Fehlerbehandlung betreibt.

Matthias Knäpper Markus Donskoj

Anwendungsentwicklung unter Lotus Notes Domino 7 Konzepte, Technologien, Realisierung

An imprint of Pearson Education München • Boston • San Francisco • Harlow, England Don Mills, Ontario • Sydney • Mexico City Madrid • Amsterdam

Bibliografische Information Der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.ddb.de abrufbar.

Die Informationen in diesem Produkt werden ohne Rücksicht auf einen eventuellen Patentschutz veröffentlicht. Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt. Bei der Zusammenstellung von Texten und Abbildungen wurde mit größter Sorgfalt vorgegangen. Trotzdem können Fehler nicht vollständig ausgeschlossen werden. Verlag, Herausgeber und Autoren können für fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung übernehmen. Für Verbesserungsvorschläge und Hinweise auf Fehler sind Verlag und Herausgeber dankbar. Alle Rechte vorbehalten, auch die der fotomechanischen Wiedergabe und der Speicherung in elektronischen Medien. Die gewerbliche Nutzung der in diesem Produkt gezeigten Modelle und Arbeiten ist nicht zulässig. Fast alle Hardware- und Softwarebezeichnungen und weitere Stichworte und sonstige Angaben, die in diesem Buch verwendet werden, sind als eingetragene Marken geschützt. Da es nicht möglich ist, in allen Fällen zeitnah zu ermitteln, ob ein Markenschutz besteht, wird das ® Symbol in diesem Buch nicht verwendet. Umwelthinweis: Dieses Buch wurde auf chlorfrei gebleichtem Papier gedruckt. Die Einschrumpffolie – zum Schutz vor Verschmutzung – ist aus umweltverträglichem und recyclingfähigem PE-Material.

10 9 8 7 6 5 4 3 2 1 09 08 07

ISBN 978-3-8273-2345-3

© 2007 by Addison-Wesley Verlag, ein Imprint der Pearson Education Deutschland GmbH Martin-Kollar-Straße 10–12, D-81829 München/Germany Alle Rechte vorbehalten

Lektorat: Korrektorat: Fachlektorat: Umschlaggestaltung: Herstellung: Satz und Layout: Druck und Verarbeitung: Printed in Germany

Boris Karnikowski, [email protected] Friederike Daenecke, Zülpich Peter Gloor, Monika Gersser, www.notesdev.ch Barbara Thoben, Köln Monika Weiher, [email protected] mediaService, Siegen Bercker Graph. Betrieb, Kevelaer

Inhaltsübersicht 1

Domino: Einführung und Überblick ...........................................................

23

2

Arbeiten mit dem Domino Designer ..........................................................

47

3

Arbeiten mit Domino-Datenbanken...........................................................

61

4

Arbeiten mit Seiten........................................................................................

79

5

Arbeiten mit Masken und Dokumenten ....................................................

105

6

Fortgeschrittene Features in Domino-Masken .........................................

135

7

Arbeiten mit Ansichten und Ordnern ........................................................

177

8

Ansichten und Ordner im Web ...................................................................

209

9

Arbeiten mit Navigatoren ............................................................................

227

10 Gliederungen verwenden .............................................................................

239

11 Arbeiten mit Rahmengruppen ....................................................................

255

12 Arbeiten mit Bildern ......................................................................................

273

13 Tabellen ...........................................................................................................

291

14 Anwendungen mit interaktiven Elementen und Agenten automatisieren ...............................................................................

313

15 Anbindung von Domino an relationale Datenbanken ...........................

371

16 Formeln in Notes/Domino ...........................................................................

377

17 Verwendung von »@Command«-Befehlen ...............................................

439

18 Einführung in LotusScript .............................................................................

457

19 Mit Notes/Domino-Klassen in LotusScript arbeiten ...............................

513

20 LotusScript und COM ....................................................................................

553

21 Einführung in die Java-Programmierung...................................................

557

22 Konzepte der Objektorientierung in Java .................................................

587

23 Spezielle Java-Konzepte ................................................................................

607

24 Java mit Lotus Notes und Lotus Domino ..................................................

617

25 Agenten in Java ..............................................................................................

633

26 API-Programmierung mit Java .....................................................................

641

27 Grafische Oberflächen mit Java ...................................................................

651

28 Java-Servlets und JavaServer Pages ............................................................

679

IBM SOFTWARE PRESS

6

Inhaltsübersicht

29 Remote-Applikationen mit Domino ...........................................................

693

30 JavaScript .........................................................................................................

711

31 LiveConnect-Protokoll ...................................................................................

747

32 Ajax und Web-Services ..................................................................................

759

33 Volltextsuche ..................................................................................................

781

34 Hilfe in Domino-Anwendungen ..................................................................

817

35 Domino und Sicherheit auf der Anwendungsentwicklungsebene .......

829

36 Domino-URL-Syntax ......................................................................................

857

37 Domino und XML ...........................................................................................

875

38 Arbeiten mit DHTML .....................................................................................

891

Stichwortverzeichnis .....................................................................................

909

Inhaltsverzeichnis Vorwort ............................................................................................................

21

1

Domino: Einführung und Überblick.................................................................. 1.1 Was ist eigentlich Lotus Notes/Domino? .................................................. 1.1.1 Eine kleine Geschichte ............................................................... 1.2 Grundkonzepte von Domino.................................................................... 1.2.1 Datenbank-Managementsystem ................................................ 1.2.2 Replikation................................................................................. 1.2.3 Mail-Routing.............................................................................. 1.2.4 Information-Retrieval ................................................................. 1.2.5 Integration mit anderen Systemen ............................................. 1.2.6 Internet-Kompatibilität............................................................... 1.2.7 Sicherheit .................................................................................. 1.2.8 Unterschiedliche Möglichkeiten des Informationszugriffs ........... 1.3 Architektur von Domino........................................................................... 1.4 Anwendungsentwicklung mit Domino ..................................................... 1.4.1 Warum Lotus Domino? .............................................................. 1.4.2 Programmierkonzepte von Notes...............................................

23 23 23 25 25 26 27 28 29 29 30 31 31 39 40 41

2

Arbeiten mit dem Domino Designer ................................................................ 2.1 Was ist Domino Designer? ....................................................................... 2.2 Domino Designer installieren ................................................................... 2.3 Domino Designer starten ......................................................................... 2.4 Arbeitsbereich .......................................................................................... 2.5 Bearbeiten von Gestaltungselementen ..................................................... 2.6 Kontextsensitive Oberfläche ..................................................................... 2.7 Arbeiten mit Hilfe-Datenbanken ............................................................... 2.8 Integration von externen Werkzeugen .....................................................

47 47 49 50 51 54 56 58 60

3

Arbeiten mit Domino-Datenbanken ................................................................. 3.1 Über Domino-Datenbanken ..................................................................... 3.2 Aufbau einer Domino-Datenbank............................................................. 3.3 Arbeiten mit Domino-Datenbanken ......................................................... 3.3.1 Datenbanken öffnen .................................................................. 3.3.2 Datenbanken erstellen ............................................................... 3.3.3 Neue Kopie erstellen .................................................................. 3.3.4 Datenbank löschen .................................................................... 3.3.5 Datenbankeigenschaften ........................................................... 3.3.6 Datenbank umbenennen ........................................................... 3.3.7 Datenbank komprimieren .......................................................... 3.3.8 Mit Schablonen arbeiten............................................................ 3.3.9 Startoptionen für eine Datenbank festlegen ............................... 3.3.10 Volltextsuche einrichten.............................................................

61 61 63 66 66 67 68 68 68 70 70 71 75 76

IBM SOFTWARE PRESS

8

Inhaltsverzeichnis

4

Arbeiten mit Seiten ........................................................................................... 4.1 Was sind Seiten? ...................................................................................... 4.2 Seitenelemente ........................................................................................ 4.3 Neue Seiten anlegen ................................................................................ 4.4 Arbeiten mit der Textformatierung........................................................... 4.4.1 Zeichen formatieren .................................................................. 4.4.2 Absätze formatieren ................................................................... 4.4.3 Absatzumrandung ..................................................................... 4.4.4 Verbergen von Absätzen ............................................................ 4.4.5 Arbeiten mit Textstilen............................................................... 4.5 Berechneter Text...................................................................................... 4.6 Horizontaler Strich ................................................................................... 4.7 Mit Verknüpfungen arbeiten .................................................................... 4.7.1 Überblick ................................................................................... 4.7.2 Erstellen von URL-Verknüpfungen .............................................. 4.7.3 Eigenschaften: Hotspot-Ressourcenverknüpfung ........................ 4.7.4 Erstellen von Verknüpfungen zu benannten Elementen .............. 4.7.5 Erstellen einfacher Verknüpfungen ............................................. 4.7.6 Löschen von Verknüpfungen...................................................... 4.8 HTML einbetten ....................................................................................... 4.8.1 Bestehende HTML-Seiten importieren ........................................ 4.8.2 Seiteninhalt als HTML behandeln ............................................... 4.8.3 Durchgangs-HTML .................................................................... 4.8.4 -Tag .............................................................................. 4.8.5 -Tag.............................................................................. 4.8.6 HTML-Attribute anderer Elemente manipulieren ........................ 4.9 Platzieren von Dateianhängen.................................................................. 4.10 Mit Ebenen arbeiten.................................................................................

79 79 80 81 83 83 84 86 86 88 89 90 91 91 92 93 94 95 95 96 96 96 97 97 99 99 101 102

5

Arbeiten mit Masken und Dokumenten ........................................................... 5.1 Masken und Dokumente .......................................................................... 5.2 Maskenfunktionalität im Überblick .......................................................... 5.3 Masken erstellen ...................................................................................... 5.4 Arbeiten mit Masken: ein erster Versuch .................................................. 5.4.1 Maske benennen ....................................................................... 5.4.2 Maske testen.............................................................................. 5.5 Arbeiten mit Feldern ................................................................................ 5.5.1 Felder erstellen........................................................................... 5.5.2 Einsatz von Feldern in der Praxis ................................................ 5.5.3 Arbeiten mit Feldformeln ........................................................... 5.5.4 Aktualisieren von Feldwerten...................................................... 5.5.5 Gemeinsame Felder ...................................................................

105 105 107 108 109 111 113 113 115 118 131 132 133

Inhaltsverzeichnis

9

6

Fortgeschrittene Features in Domino-Masken ................................................. 6.1 Arbeiten mit Maskeneigenschaften........................................................... 6.1.1 Maskentyp festlegen .................................................................. 6.1.2 Masken und Dokumente kombinieren ....................................... 6.1.3 Feldwerte zwischen Masken austauschen ................................... 6.1.4 Komplette Dokumente übernehmen.......................................... 6.1.5 Mit der Versionsverwaltung arbeiten.......................................... 6.1.6 Autostart-Optionen einer Maske bestimmen .............................. 6.1.7 Kopfzeile gestalten..................................................................... 6.1.8 Hintergrundeigenschaften einer Maske festlegen ....................... 6.1.9 Druckeinstellungen festlegen ..................................................... 6.1.10 Fenstertitel festlegen .................................................................. 6.2 Arbeiten mit Teilmasken........................................................................... 6.2.1 Teilmasken erstellen................................................................... 6.2.2 Einfügen von Teilmasken ........................................................... 6.3 Arbeiten mit Layout-Bereichen ................................................................. 6.3.1 Erstellen eines Layout-Bereichs ................................................... 6.3.2 Erstellen neuer Layout-Objekte................................................... 6.3.3 Felder im Layout-Bereich............................................................ 6.4 Masken im Web ....................................................................................... 6.4.1 Übersetzung von Feldern ........................................................... 6.4.2 Anpassung von Notes-Feldern an die HTML-Umgebung ............ 6.5 Verarbeitung von Dokumenten auf der Server-Seite ................................. 6.5.1 Bereitstellung von Dokumenten ohne JavaScript ........................ 6.5.2 Bereitstellung der Seite mit JavaScript-Generierung.................... 6.6 Domino und CGI ..................................................................................... 6.6.1 Einbindung von CGI-Scripts in Domino...................................... 6.6.2 Der Einsatz von CGI-Variablen in Domino .................................. 6.6.3 Maskeneigenschaften im HTML-Umfeld ..................................... 6.6.4 Beschränkungen von Masken im HTML-Umfeld ......................... 6.7 Autosave .................................................................................................. 6.7.1 Einrichtung im Notes-Client....................................................... 6.7.2 Einstellung in der Maske ............................................................

135 135 135 137 139 140 141 143 144 145 147 148 149 149 151 152 152 153 153 154 154 155 158 159 165 167 167 168 170 172 174 174 175

7

Arbeiten mit Ansichten und Ordnern............................................................... 7.1 Ansichten – das Fenster in die Datenbank................................................. 7.1.1 Was sind Ansichten? .................................................................. 7.1.2 Erstellen von Ansichten .............................................................. 7.1.3 Ansichten gestalten.................................................................... 7.1.4 Arbeiten mit Eigenschaften: Ansicht ........................................... 7.1.5 Ansichtsoptionen festlegen ........................................................ 7.1.6 Ansichten formatieren................................................................ 7.2 Arbeiten mit Spalten ................................................................................ 7.2.1 Überblick ................................................................................... 7.2.2 Anzeigen von Antwortdokumenten............................................

177 177 177 178 184 185 185 186 189 189 195

IBM SOFTWARE PRESS

10

Inhaltsverzeichnis

7.3

Gemeinsame Spalten verwenden ............................................................. 7.3.1 Gemeinsame Spalten in Ansichten verwenden ........................... Dynamisches Zuweisen von Masken zu Dokumenten ............................... Arbeiten mit Kalenderansichten................................................................ Arbeiten mit Ansichtenindizes .................................................................. Arbeiten mit Ordnern ..............................................................................

197 198 198 201 203 207

8

Ansichten und Ordner im Web ......................................................................... 8.1 Ansichten in HTML................................................................................... 8.2 Einbindung von Durchgangs-HTML in Ansichten ..................................... 8.2.1 HTML im Ansichtsnamen ........................................................... 8.2.2 HTML in Spaltenüberschriften.................................................... 8.2.3 HTML in Spaltenformeln ............................................................ 8.2.4 Festlegen der Spaltenbreite mittels HTML .................................. 8.2.5 Ansichten als HTML behandeln .................................................. 8.2.6 Farbgebung von HTML-Verknüpfungen anpassen ...................... 8.3 Ansichten als Java-Applet darstellen.......................................................... 8.4 Einbetten von Ansichten in Masken.......................................................... 8.4.1 Dynamisches Einbetten von Ansichten ....................................... 8.4.2 Mit Standardvorlagen arbeiten .................................................. 8.4.3 Standardvorlage mit einer »$$ViewTemplateDefault«-Maske ..... 8.4.4 Eigene Ansichtsaktionen definieren ............................................ 8.5 Einschränkungen beim Einsatz von Ansichten im Web.............................. 8.5.1 Einschränkungen bei Standard-HTML-Ansichten ........................ 8.5.2 Einschränkungen bei der Verwendung von Ansichts-Applets ......

209 209 211 212 213 214 215 215 216 217 218 219 220 221 221 223 224 225

9

Arbeiten mit Navigatoren ................................................................................. 9.1 Einsatz von Navigatoren im Notes-Client.................................................. 9.1.1 Navigatoren erstellen................................................................. 9.1.2 Neue Navigatorelemente erstellen ............................................. 9.1.3 Arbeiten mit Objekteigenschaften .............................................. 9.1.4 Arbeiten mit Hotspots................................................................ 9.1.5 Navigatorelementen eine Aktion zuweisen................................. 9.1.6 Beispiel: Erstellen eines Notes-Navigators .................................. 9.1.7 Arbeiten mit Navigatoreigenschaften ......................................... 9.2 Navigatoren im Web ................................................................................ 9.2.1 Navigatoren als Imagemaps....................................................... 9.2.2 Einbindung von Navigatoren in Masken .................................... 9.2.3 Einschränkungen beim Einsatz von Navigatoren im Web ...........

227 228 228 229 230 231 232 233 234 235 236 237 238

10 Gliederungen verwenden ................................................................................. 10.1 Gliederung erstellen ................................................................................. 10.1.1 Vorgehensweise bei der Erstellung einer Gliederung .................. 10.1.2 Struktur und Funktionalität einer Gliederung festlegen............... 10.1.3 Gliederung formatieren..............................................................

239 240 240 240 247

7.4 7.5 7.6 7.7

Inhaltsverzeichnis

11

11 Arbeiten mit Rahmengruppen.......................................................................... 11.1 Vor- und Nachteile von Rahmen .............................................................. 11.2 Rahmen in Domino verwenden................................................................ 11.2.1 Grundlagen .............................................................................. 11.2.2 Mit Rahmengruppen arbeiten .................................................... 11.2.3 Mit Rahmen arbeiten ................................................................. 11.2.4 Rahmen vs. Tabellen – ein Vergleich .......................................... 11.3 Rahmen in HTML ..................................................................................... 11.3.1 Ein Blick hinter die Kulissen ... .................................................... 11.3.2 Rahmen referenzieren ................................................................ 11.3.3 Anzeigen von Seiten mit Rahmen in älteren Browsern................

255 257 258 258 258 260 266 267 267 270 271

12 Arbeiten mit Bildern.......................................................................................... 12.1 Einsatzbereiche von Bildern...................................................................... 12.2 Bilder erstellen ......................................................................................... 12.3 Verwaltung von Bildressourcen ................................................................ 12.3.1 Bildressourcen erstellen.............................................................. 12.3.2 Arbeiten mit Bildeigenschaften .................................................. 12.4 Bilder im Webeinsatz................................................................................ 12.4.1 Konvertierung von Bildern: GIF oder JPEG? ................................ 12.4.2 Umgang mit der Farbpalette...................................................... 12.4.3 Bilder mit HTML referenzieren....................................................

273 273 274 275 278 280 285 285 287 288

13 Tabellen ............................................................................................................. 13.1 Einsatzbereiche von Tabellen.................................................................... 13.1.1 Textgestaltung........................................................................... 13.1.2 Layout-Kontrolle ........................................................................ 13.1.3 Registerkarten ........................................................................... 13.1.4 Tabellen mit Titelzeilen .............................................................. 13.1.5 Animierte Tabellen..................................................................... 13.1.6 Programmgesteuerte Tabellen ................................................... 13.2 Tabellen erstellen ..................................................................................... 13.2.1 Tabellen bearbeiten ................................................................... 13.2.2 Tabellen formatieren.................................................................. 13.2.3 Mit Zeileneffekten arbeiten ........................................................ 13.3 Tabellen in HTML..................................................................................... 13.3.1 Tabellen – Einschränkungen im Webbrowser .............................

291 291 291 291 292 292 293 293 293 294 295 302 307 312

14 Anwendungen mit interaktiven Elementen und Agenten automatisieren...... 14.1 Automatisierung mit interaktiven Elementen ............................................ 14.1.1 Aktions-Hotspots........................................................................ 14.1.2 Schaltflächen ............................................................................. 14.1.3 Aktionsschaltflächen .................................................................. 14.1.4 Gemeinsame Aktionen ............................................................... 14.2 Interaktive Elemente programmieren........................................................ 14.2.1 Programmiermethoden im Überblick ......................................... 14.2.2 Die Wahl des Clients: Notes-Client oder Web............................. 14.2.3 Einfache Aktionen ......................................................................

313 314 314 316 323 331 333 333 334 336

IBM SOFTWARE PRESS

12

Inhaltsverzeichnis

14.2.4 Aktionen mit der Formelsprache gestalten ................................. 14.2.5 Aktionen mit LotusScript programmieren................................... 14.2.6 Aktionen mit JavaScript programmieren..................................... Arbeiten mit interaktiven Elementen im Web............................................ 14.3.1 Einschränkungen beim Einsatz interaktiver Funktionen im Web.. Agenten ................................................................................................... 14.4.1 Private und gemeinsame Agenten.............................................. 14.4.2 Agenten erstellen ....................................................................... 14.4.3 Agenten gestalten...................................................................... 14.4.4 Agenten und Sicherheit ............................................................. 14.4.5 Agenten erstellen – ein Beispiel .................................................. Einsatz von Agenten im Web.................................................................... 14.5.1 Starten von Agenten im Web ..................................................... 14.5.2 WebQueryOpen- und WebQuerySave-Agenten ......................... 14.5.3 Erstellen von WebQueryOpen- und WebQuerySave-Agenten ..... 14.5.4 LotusScript-Agenten im Webeinsatz ........................................... 14.5.5 HTML-Ausgabe in LotusScript-Agenten ...................................... 14.5.6 Auslesen von CGI-Variablen mit LotusScript-Agenten ................. 14.5.7 Die Übergabe von Parameterwerten an Agenten........................ 14.5.8 Einschränkungen beim Einsatz von Agenten im Web ................. 14.5.9 Agentensicherheit im Web .........................................................

337 338 340 341 345 345 346 347 348 355 362 363 363 364 365 366 366 367 367 368 369

15 Anbindung von Domino an relationale Datenbanken ..................................... 15.1 Definition einer Maske .............................................................................

371 373

16 Formeln in Notes/Domino ................................................................................ 16.1 Neuerungen in Release 7.......................................................................... 16.2 Formeln verwenden ................................................................................. 16.2.1 Grundbestandteile von Formeln................................................. 16.2.2 Konstanten und Variablen.......................................................... 16.2.3 Operatoren ................................................................................ 16.2.4 Schlüsselwörter .......................................................................... 16.2.5 Funktionen ................................................................................ 16.2.6 Formelsprache und Ereignisse .................................................... 16.3 Weitere Neuerungen................................................................................ 16.3.1 Neue @-Functionen in Release 7 ................................................ 16.3.2 Obsolete Funktionen..................................................................

377 377 378 378 378 383 387 389 426 435 438 438

17 Verwendung von »@Command«-Befehlen ....................................................... 17.1 Über »@Command«-Befehle .................................................................... 17.2 Verwendung von »@Command«-Befehlen ............................................... 17.2.1 Schaltflächen ............................................................................. 17.2.2 Aktionsschaltflächen .................................................................. 17.3 »@Command«-Befehle mit Parameterwerten verwenden ......................... 17.3.1 Erstellen von Dokumenten ......................................................... 17.3.2 Wechsel zwischen unterschiedlichen Dokumentmodi.................

439 439 440 441 442 446 446 447

14.3 14.4

14.5

Inhaltsverzeichnis

17.4

13

Praktisches Beispiel: Anwendungssteuerung mit Profildokumenten........... 17.4.1 Datenbankspezifische Profildokumente ...................................... 17.4.2 Benutzerspezifische Profildokumente ......................................... »@Command«- und »@PostedCommand«-Befehle................................... »@Command-Befehle« finden .................................................................. Neuerungen im Release 6 ........................................................................ 17.7.1 Neue »@commands« ................................................................. 17.7.2 Redundante »@command«-Befehle............................................ 17.7.3 Erweiterte Befehle ...................................................................... Neuerungen in Release 7..........................................................................

449 450 452 453 453 454 454 455 456 456

18 Einführung in LotusScript ................................................................................. 18.1 LotusScript als prozedurale Sprache ......................................................... 18.2 Variablen und Konstanten ........................................................................ 18.2.1 Variablen ................................................................................... 18.2.2 Konstanten ................................................................................ 18.2.3 Gültigkeit und Sichtbarkeit von Variablen und Konstanten ......... 18.3 Operatoren in LotusScript ........................................................................ 18.4 Bedingungsreaktionen ............................................................................. 18.4.1 If-Anweisung.............................................................................. 18.4.2 »Select Case«-Anweisung........................................................... 18.5 Schleifenverarbeitung............................................................................... 18.5.1 For-Schleife ................................................................................ 18.5.2 ForAll-Schleife ............................................................................ 18.5.3 While-Schleife ............................................................................ 18.5.4 Do-Schleife ................................................................................ 18.6 Modularisieren von LotusScript ................................................................ 18.6.1 Eigene Funktionen erstellen ....................................................... 18.6.2 Erstellen von Prozeduren............................................................ 18.6.3 Wiederverwendung von Funktionen und Prozeduren................. 18.7 Ein- und Ausgabe mit LotusScript............................................................. 18.7.1 Überblick ................................................................................... 18.7.2 Messagebox-Funktionalität anpassen ......................................... 18.7.3 Dateieingabe mit Inputbox ........................................................ 18.8 LotusScript in Ereignissen ......................................................................... 18.8.1 Ereignisse................................................................................... 18.8.2 Ereignisse in Masken .................................................................. 18.8.3 Ereignisse von Teilmasken .......................................................... 18.8.4 Ereignisse von Feldern................................................................ 18.8.5 Ereignisse in Schaltflächen ......................................................... 18.8.6 Ereignisse in Ansichten............................................................... 18.8.7 Datenbankereignisse..................................................................

457 458 461 461 465 465 467 468 468 471 472 473 474 477 480 481 482 491 493 496 496 496 500 500 500 501 505 506 507 507 509

19 Mit Notes/Domino-Klassen in LotusScript arbeiten......................................... 19.1 Objektorientierung und Lotus/Domino .................................................... 19.1.1 Zur Bedeutung der Objektorientierung ...................................... 19.1.2 Objekte in Lotus Notes/Domino.................................................

513 513 513 514

17.5 17.6 17.7

17.8

IBM SOFTWARE PRESS

14

Inhaltsverzeichnis

19.2

Zugriffe über das Back-End....................................................................... 19.2.1 Zugriff auf Datenbanken mit der NotesDatabase-Klasse ............. 19.2.2 Klasse »NotesSession« ................................................................ 19.2.3 NotesDB-Directory – Verwenden des Datenverzeichnisses.......... 19.2.4 Zugriff auf Ansichten.................................................................. 19.2.5 Zugriff auf Dokumente .............................................................. 19.2.6 Zugriff auf Feldwerte.................................................................. Zugriffe über das Front-End...................................................................... 19.3.1 Die Darstellungsweise »Picklist_Custom«.................................... 19.3.2 Die Auswahl aus dem öffentlichen Adressbuch über »Picklist_Names« ....................................................................... 19.3.3 Die Formate »Picklist_Rooms« und »Picklist_Resources« ............. 19.3.4 Die Methode »Picklistcollection«................................................ 19.3.5 Die Klasse »NotesUIDocument« ................................................. Vom Front-End zum Back-End .................................................................. XML-Klassen ............................................................................................ 19.5.1 Vollständiger XML-Export ..........................................................

540 541 541 543 545 547 549

20 LotusScript und COM........................................................................................

553

21 Einführung in die Java-Programmierung.......................................................... 21.1 Die Entstehung von Java .......................................................................... 21.2 Wichtige Konzepte von Java ..................................................................... 21.3 Java mit Lotus Notes/Domino .................................................................. 21.3.1 Agenten..................................................................................... 21.3.2 Java-Applets ............................................................................... 21.3.3 API-Programme ......................................................................... 21.3.4 Java-Servlets............................................................................... 21.3.5 Java-Server-Pages ....................................................................... 21.3.6 Web-Services ............................................................................. 21.3.7 Fazit........................................................................................... 21.4 Java-Entwicklungsumgebungen................................................................ 21.5 Arbeiten mit der Java 2 Standard Edition (J2SE) ........................................ 21.5.1 Download des J2SE SDK............................................................. 21.5.2 Installation des J2SE SDK............................................................ 21.5.3 Einrichtung der Java-Einstellungen ............................................. 21.6 Java-Sprachgrundlagen ............................................................................ 21.6.1 Eine erste Java-Anwendung........................................................ 21.6.2 Daten und Variablentypen ......................................................... 21.6.3 Operatoren ................................................................................ 21.6.4 Konstanten und Literale ............................................................. 21.7 Java-Programmsteuerung ......................................................................... 21.7.1 if-Bedingung.............................................................................. 21.7.2 »switch«-Verzweigung ............................................................... 21.7.3 while-Schleife............................................................................. 21.7.4 do/while-Schleife ....................................................................... 21.7.5 for-Schleife.................................................................................

557 557 559 560 560 560 561 561 562 562 562 562 563 563 564 564 567 567 569 572 575 576 577 578 579 580 581

19.3

19.4 19.5

517 517 519 521 524 525 532 537 539

Inhaltsverzeichnis

21.8

15

Erweiterte Programmkontrolle.................................................................. 21.8.1 break-Anweisung ....................................................................... 21.8.2 »continue«-Anweisung............................................................... Arrays.......................................................................................................

582 582 583 584

22 Konzepte der Objektorientierung in Java......................................................... 22.1 Klassendefinition ...................................................................................... 22.1.1 Eigenschaften ........................................................................... 22.1.2 Methoden.................................................................................. 22.1.3 Instanziierung von Objekten ...................................................... 22.1.4 Konstruktoren ............................................................................ 22.1.5 Sichtbarkeit und Gültigkeit......................................................... 22.1.6 Vererbung ................................................................................. 22.1.7 Gültigkeitsbereiche und Vererbung ............................................ 22.1.8 Polymorphie .............................................................................. 22.1.9 Die interne Modellierung von Instanzen..................................... 22.1.10 Destruktoren.............................................................................. 22.2 Schnittstellen ........................................................................................... 22.2.1 Überblick ................................................................................... 22.2.2 Deklaration von Schnittstellen.................................................... 22.2.3 Implementieren von Schnittstellen .............................................

587 587 588 588 590 590 592 594 597 598 600 603 604 604 604 605

23 Spezielle Java-Konzepte .................................................................................... 23.1 Fehlerbehandlung in Java ......................................................................... 23.1.1 Über Exceptions......................................................................... 23.1.2 Selbst definierte Exceptions........................................................ 23.1.3 Auslösen von Exceptions ............................................................ 23.1.4 Abfangen von Exceptions........................................................... 23.1.5 Weitergeben von Exceptions...................................................... 23.2 Die Java API.............................................................................................. 23.3 Java Packages ........................................................................................... 23.3.1 Über Java Packages .................................................................... 23.3.2 Java Packages verwenden........................................................... 23.3.3 Eigene Packages erstellen...........................................................

607 607 607 608 609 609 611 613 614 614 615 616

24 Java mit Lotus Notes und Lotus Domino ......................................................... 24.1 Notes/Domino-Objektmodell ................................................................... 24.1.1 Vergleich LotusScript/Java .......................................................... 24.1.2 Ausgewählte Java-Klassen im Überblick ...................................... 24.1.3 Auf Feldwerte zugreifen .............................................................

617 617 618 620 628

25 Agenten in Java ................................................................................................. 25.1 Grundgerüst für Domino-Agenten ........................................................... 25.2 Agenten im Domino Designer.................................................................. 25.3 Anwendungsbeispiel: Java-basierter Agent................................................ 25.3.1 Importierte Agenten ..................................................................

633 633 634 636 639

21.9

IBM SOFTWARE PRESS

16

Inhaltsverzeichnis

26 API-Programmierung mit Java .......................................................................... 26.1 Thread-Initialisierung................................................................................ 26.2 Anwendungsbeispiel: Lokale textbasierte Applikation ...............................

641 641 645

27 Grafische Oberflächen mit Java ........................................................................ 27.1 Java-Applets ............................................................................................. 27.1.1 Applets erstellen ........................................................................ 27.1.2 Testen eines Java-Applets ........................................................... 27.1.3 Grundstruktur von Applets......................................................... 27.2 Arbeiten mit AWT-Komponenten ............................................................. 27.2.1 AWT-Komponentenklassen ........................................................ 27.2.2 Einsatz von AWT-Komponenten in einem Java-Applet ................ 27.2.3 Arbeiten mit Layout-Managern .................................................. 27.2.4 Mit AWT-Komponenteneigenschaften arbeiten .......................... 27.2.5 AWT-Events ............................................................................... 27.2.6 Parameterübergabe an Applets .................................................. 27.3 Grafische Oberflächen in Java-Applikationen ............................................

651 651 652 652 654 656 656 658 658 662 664 669 670

28 Java-Servlets und JavaServer Pages................................................................... 28.1 Konfiguration des Servlet-Managers ......................................................... 28.2 Mit Servlets arbeiten ................................................................................ 28.3 Servlets mit Domino-Klassen verwenden .................................................. 28.3.1 Servlets und Domino ................................................................. 28.3.2 Anwendungsbeispiel: Servlet mit Domino .................................. 28.4 JavaServer Pages....................................................................................... 28.4.1 Elemente eines JSPs.................................................................... 28.4.2 Domino und JSPs .......................................................................

679 680 682 683 683 685 689 690 691

29 Remote-Applikationen mit Domino.................................................................. 29.1 Remote-Zugriff mit CORBA ...................................................................... 29.1.1 Über CORBA .............................................................................. 29.1.2 Server-Konfiguration für CORBA................................................. 29.2 Stand-alone-Applikationen mit CORBA..................................................... 29.2.1 Besonderheiten der Stand-alone-Applikationen in Domino......... 29.2.2 Speicherfreigabe in CORBA-Applikationen ................................. 29.2.3 Anwendungsbeispiel: Eine CORBA-basierte Stand-alone-Applikation............................................................. 29.3 Java-Applets mit CORBA........................................................................... 29.3.1 Besonderheiten der Verwendung von Java-Applets mit CORBA .. 29.3.2 Anwendungsbeispiel: CORBA-basiertes Applet ........................... 29.4 RMI-Protokoll ........................................................................................... 29.5 HTTP und XML ........................................................................................

693 693 693 695 697 697 698 698 702 702 704 709 709

30 JavaScript........................................................................................................... 30.1 Über JavaScript......................................................................................... 30.1.1 Entstehung von JavaScript.......................................................... 30.1.2 JavaScript-Unterstützung in Lotus Notes und Domino................ 30.1.3 Funktionsweise von JavaScript....................................................

711 711 711 711 712

Inhaltsverzeichnis

30.2 30.3

17

Das Dokumenten-Objekt-Modell.............................................................. Syntax von JavaScript ............................................................................... 30.3.1 Einfache Sprachelemente und Grundregeln ............................... 30.3.2 Verzweigungen und Anweisungsblöcke ..................................... 30.3.3 Schleifen .................................................................................... 30.3.4 Funktionen ................................................................................ 30.3.5 Vordefinierte Funktionen............................................................ Zugriff auf Objekte in JavaScript ............................................................... Ereignisse in JavaScript ............................................................................. Gültigkeitsbereiche und Bibliotheken ....................................................... Anwendungsmöglichkeiten von JavaScript ............................................... 30.7.1 Szenario..................................................................................... 30.7.2 Automatische Feldbelegung....................................................... 30.7.3 Feldüberprüfung........................................................................ 30.7.4 Eingabefenster ........................................................................... 30.7.5 Einblenden und Ausblenden von Bereichen ............................... 30.7.6 Dynamische Ausgaben............................................................... 30.7.7 Frames ansprechen .................................................................... 30.7.8 Cookies verwenden....................................................................

713 715 717 720 722 723 725 726 730 731 732 732 733 735 738 741 742 744 746

31 LiveConnect-Protokoll....................................................................................... 31.1 Überblick ................................................................................................. 31.2 LiveConnect aus JavaScript....................................................................... 31.3 LiveConnect aus Java................................................................................ 31.4 LiveConnect mit CORBA ..........................................................................

747 747 747 750 752

32 Ajax und Web-Services...................................................................................... 32.1 Überblick ................................................................................................. 32.2 Ajax ......................................................................................................... 32.2.1 Problemstellung......................................................................... 32.2.2 Der Ansatz von Ajax................................................................... 32.2.3 Umsetzung bei Domino ............................................................. 32.3 Web-Services............................................................................................ 32.3.1 Idee ........................................................................................... 32.3.2 Web-Services mit Java in Domino............................................... 32.3.3 Web-Services mit LotusScript .....................................................

759 759 759 759 759 761 764 764 766 770

33 Volltextsuche ..................................................................................................... 33.1 Grundlagen der Volltextsuche .................................................................. 33.2 Features der Domino-Search-Engine......................................................... 33.3 Volltextindizierung in Notes ..................................................................... 33.3.1 Erstellung eines Volltextindex..................................................... 33.3.2 Volltextindexdatei...................................................................... 33.3.3 Suche nach Informationen ......................................................... 33.4 Datenbankübergreifende Volltextsuche .................................................... 33.4.1 Eine Site-Abfrage-Datenbank erstellen........................................ 33.4.2 Den Umfang der Indizierung festlegen....................................... 33.4.3 Den Umfang der Indizierung nachträglich bearbeiten ................

781 781 782 783 783 785 785 788 789 789 791

30.4 30.5 30.6 30.7

IBM SOFTWARE PRESS

18

Inhaltsverzeichnis

33.4.4 Einfache und fortgeschrittene Volltextsuche............................... 33.4.5 Formatierung der Suchergebnisse .............................................. Volltextsuche im Web .............................................................................. 33.5.1 Volltextsuche in Ansichten ......................................................... 33.5.2 Datenbankübergreifende Volltextsuche...................................... 33.5.3 Anpassen der Suchmaske ........................................................... 33.5.4 Anpassen der Suchergebnisse mit $$SearchTemplate................. 33.5.5 Paginierte Ausgabe von Ergebnissen .......................................... 33.5.6 Abfragefunktion im Web simulieren ........................................... Domänen-Suche ..................................................................................... 33.6.1 Vorteile der Domänen-Suche .................................................... 33.6.2 Client-Kompatibilität und Domänen-Suche ............................... 33.6.3 Komponenten der Domänen-Suche .......................................... 33.6.4 Einrichtung der Domänen-Suche ............................................... 33.6.5 Domänen-Suche anpassen......................................................... 33.6.6 Aufruf der Domänen-Suche aus dem Webbrowser ..................... 33.6.7 Anpassung der »ResultEntry/DetailedResultEntry«-Maske ........... 33.6.8 Domänen-Suche und Sicherheit.................................................

792 792 793 794 796 797 798 799 802 804 804 805 805 806 811 811 813 814

34 Hilfe in Domino-Anwendungen ........................................................................ 34.1 Datenbank-Hilfe-Dokumente.................................................................... 34.1.1 Erstellung der Hilfe-Dokumente ................................................. 34.1.2 Automatische Anzeige des »Über diese Datenbank«-Dokuments ............................................................ 34.2 Arbeiten mit kontextbezogener Hilfe ........................................................ 34.2.1 Funktionsweise der kontextsensitiven Hilfe ................................. 34.2.2 Ein kleines Beispiel ..................................................................... 34.3 Pop-Ups ................................................................................................... 34.3.1 Was sind Pop-Ups? .................................................................... 34.3.2 Pop-Ups erstellen ....................................................................... 34.3.3 Feldhilfe.....................................................................................

817 817 819 820 821 821 822 825 825 826 827

35 Domino und Sicherheit auf der Anwendungsentwicklungsebene................... 35.1 Domino-Sicherheitsmodell ....................................................................... 35.1.1 Netzwerk ................................................................................... 35.1.2 Server ........................................................................................ 35.1.3 Datenbank................................................................................. 35.1.4 Sicherheit auf der Anwendungsebene mit Rollen ....................... 35.1.5 Zugriffsbeschränkung auf Ansichten .......................................... 35.1.6 Zugriffsbeschränkung auf Masken.............................................. 35.1.7 Zugriffsbeschränkung auf Dokumente ....................................... 35.1.8 Zugriffsbeschränkung auf Abschnitte ......................................... 35.1.9 Zugriffsbeschränkung auf Felder ................................................ 35.1.10 Dokumente verschlüsseln...........................................................

829 829 830 831 831 835 837 838 840 841 842 843

33.5

33.6

Inhaltsverzeichnis

35.2 35.3 35.4

19

Datenbankverschlüsselung ....................................................................... Sicherheit im Web.................................................................................... HTTP-Sicherheit und Domino................................................................... 35.4.1 HTTP-Sicherheitsarchitektur ....................................................... 35.4.2 HTTP-Zugriffsrechte auf der Serverebene ................................... 35.4.3 HTTP-Zugriffsrechte auf der Datenbankebene ............................ 35.4.4 Erzwingen der Authentifizierung ................................................

847 848 848 849 851 852 854

36 Domino-URL-Syntax .......................................................................................... 36.1 Über die URL-Referenzierung.................................................................... 36.2 URL-Referenzierung von Domino ............................................................. 36.2.1 Syntax der URL-Referenzierung in Domino ................................ 36.2.2 Arbeiten mit URL-Anweisungen.................................................. 36.3 Anwendung der Domino-URL-Referenzierung anhand praktischer Beispiele ................................................................................. 36.3.1 Öffnen von Servern.................................................................... 36.3.2 Öffnen von Datenbanken........................................................... 36.3.3 Öffnen von Ansichten ................................................................ 36.3.4 Öffnen von Masken ................................................................... 36.3.5 Öffnen von Navigatoren ............................................................ 36.3.6 Öffnen von Rahmengruppen ..................................................... 36.3.7 Öffnen von Seiten...................................................................... 36.3.8 Öffnen von Agenten .................................................................. 36.3.9 Öffnen von Bildern, Dateianhängen und OLE-Objekten ............. 36.3.10 Öffnen von Bildressourcen ......................................................... 36.3.11 Öffnen sonstiger Datenbankelemente ........................................ 36.3.12 Erzwingen der Authentifizierung ................................................ 36.3.13 Arbeiten mit Dokumenten ......................................................... 36.3.14 Domino-URLs und Volltextsuche ................................................

857 857 858 858 862 864 865 865 865 866 867 867 868 868 868 870 870 871 871 874

37 Domino und XML .............................................................................................. 37.1 Einführung ............................................................................................... 37.2 Was ist XML? ........................................................................................... 37.3 Domino und XML .................................................................................... 37.3.1 Überblick ................................................................................... 37.3.2 Anwendung von XML in Masken ............................................... 37.3.3 Anwendung von XML in Ansichten ............................................ 37.4 XML-Werkzeuge in Domino ..................................................................... 37.4.1 Überblick ................................................................................... 37.4.2 Exporter .................................................................................... 37.4.3 Betrachter.................................................................................. 37.4.4 Transformer ...............................................................................

875 875 875 884 884 885 886 887 887 888 888 889

IBM SOFTWARE PRESS

20

Inhaltsverzeichnis

38 Arbeiten mit DHTML ......................................................................................... 38.1 Überblick ................................................................................................. 38.2 Was ist DHTML?....................................................................................... 38.2.1 Bestandteile von DHTML ........................................................... 38.2.2 HTML 4.x................................................................................... 38.2.3 Cascading Style Sheets .............................................................. 38.2.4 Scripting .................................................................................... 38.3 DHTML in Domino................................................................................... 38.3.1 Überblick ................................................................................... 38.3.2 HTML 4.0 .................................................................................. 38.3.3 Cascading Style Sheets .............................................................. 38.3.4 Scripting ....................................................................................

891 891 891 891 892 893 899 900 900 901 902 906

Stichwortverzeichnis .........................................................................................

909

Vorwort Seit vielen Jahren ist Notes/Domino Marktführer als Basis für Groupware-Anwendungen. In Umgebungen mit einem hohen Anspruch auf Sicherheit und Zuverlässigkeit hat sich das Produkt bewährt. Die Server-gestützten Dienste bieten eine Vielfalt, die über das Zustellen von E-Mails oder die Verwaltung von Kalendern weit hinausgeht. Dabei hat sich Domino als attraktive Integrationsplattform erwiesen. Die konsequente Weiterentwicklung liefert immer bessere Möglichkeiten, um Anwendungen für die Unterstützung der Zusammenarbeit von Personen zu entwickeln. Durch diese Weiterentwicklung zeigt der Hersteller, dass er diese Technologie weiter ausbauen und noch stärker in seine Software-Produktstrategie integrieren will. Dabei wird insbesondere das Zusammenspiel mit anderen IBM-Produkten wie dem WebSphere- und dem Portal Server weiter ausgebaut. Hinzu kommt die Integration anderer unternehmenskritischer Anwendungen wie SAP oder den unterschiedlichen relationalen Datenbank-Management-Systemen. Hinzu kommen außerdem Konzepte und Standards aus dem eigenen Hause: Sametime als Instant Messaging-Lösung, Quickr/Quickplace als schnelle Lösung für webbasiertes Teamwork oder die enormen Möglichkeiten zur Nutzung von Ajax und zur Implementierung von Web-Services. Das vorliegende Buch will einen Beitrag dazu leisten, einen Einstieg und einen Überblick für diejenigen zu bieten, die unter Verwendung von Notes/Domino eigene Anwendungen schreiben wollen. Dabei wird Wert auf eine verständliche Einführung in die verschiedenen Aspekte der Notes-Entwicklung gelegt, darüber hinaus werden Perspektiven für das Zusammenspiel mit anderen Standards aufgezeigt. Auf der beiliegenden CD ist ein großer Teil der in diesem Buch verwendeten Beispiele zu finden. Sie wurden nach bestem Wissen getestet und decken aus unserer Sicht viele Teile der oft sehr speziellen Anwendungsfälle in Unternehmen ab, die Notes intensiv nutzen. Außerdem haben wir der CD eine Reihe von nützlichen Werkzeugen beigelegt, die für einige der Beispiele wichtig sind. So findet sich zum Beispiel eine Version von Eclipse auf der CD, neben einer Reihe weiterer Werkzeuge, die größtenteils der Open Source-Community entstammen, der daher auch ein großer Dank gebührt. Beim Schreiben eines solchen Buches müssen sich Autorinnen und Autoren immer auch Fragen nach Stil und Schreibweise stellen. Einige dieser Fragen berühren dabei gesellschaftliche Konventionen und Denkweisen. So wurde zum Beispiel auch die Frage erörtert, ob dieses Buch grundsätzlich nur weibliche, männliche oder beide Formen verwenden solle. Wir haben uns nach reiflicher Überlegung dazu entschlossen, zu Gunsten einer einfacheren und eingängigeren Lesbarkeit, uns auf die maskuline Form zu beschränken. Es sei aber an dieser Stelle ausdrücklich darauf hingewiesen, dass bei all unseren Ausführungen alle Leser unabhängig von ihrem jeweiligen Geschlecht von uns angesprochen werden.

IBM SOFTWARE PRESS

22

Vorwort

Unser Dank gilt all denen, die zur Erstellung dieses Buches beigetragen haben. Damit seien vom Verlag insbesondere Herrn Karnikowski für sein Engagement und seine Ausdauer und Frau Friederike Daenecke gedankt, die als sprachliche Lektorin aus »einem kruden Batzen Lehm« doch noch einen Satz gemacht hat. Ebenfalls möchten wir uns bedanken bei Peter Gloor und Monika Geisser für ihren Eifer, die Texte und besonders die Beispiele, Scripte und Programme auf Plausibilität und Funktionalität geprüft und darüber hinaus eine Vielzahl sehr nützlicher Hinweise gegeben zu haben. Leider konnte bei diesem Buch unser werter Kollege Primoz Perc nicht mehr mitarbeiten. Berufliche Gründe haben verhindert, dass er sich in gewohnter Weise bei der Erstellung des Manuskripts einbringen konnte. Wir hoffen, seine Arbeit in seinem Sinne fortgesetzt zu haben. Außerdem bedanken wir uns bei ihm ausdrücklich dafür, dass er uns sein Manuskript zur weiteren Bearbeitung zur Verfügung gestellt hat. Im Rahmen dieser Veränderungen entstand natürlich auch eine Diskussion über den Sinn eines verspäteten Erscheinens dieses Buches. Es ist aber die Erfahrung der Autoren, dass am Markt aktuell sowohl die Versionen 6.x als auch 7.x weit verbreitet sind. Wir erwarten eine solche Koexistenz auch, wenn die neue Version 8 auf den Markt kommt, und denken, dass dieses Buch trotz allem wieder Informationen liefert, die für die tägliche Arbeit nützlich sind. Neben den hier bereits namentlich genannten Personen ist die Arbeit an einem solchen Buch nicht denkbar ohne anonyme Helfer, die wir vielleicht manchmal vergessen zu erwähnen. Da die Arbeit an einem solchen Buch-Projekt fast ausschließlich in der Freizeit und damit zu Hause stattfindet, sind an dieser Stelle auch die wichtigsten und wesentlichen Stützen zu suchen. Somit gilt unser besonderer Dank den Partnerinnen und Kindern, die an vielen Wochenenden auf die Gesellschaft und Unterstützung der Ehemänner und Väter verzichten mussten. Somit geht unser besonderer Dank an Christiane, Constantin, Hannah, Leonie, Regula und Sarah. Matthias Knäpper Markus Donskoj

Domino: Einführung und Überblick 1.1

Was ist eigentlich Lotus Notes/Domino?

Die Diskussion der Frage »Was ist eigentlich Notes?« endet nicht selten wie manch ein philosophischer Diskurs über den Sinn des Lebens. Es gibt unzählige Antworten, und in allen steckt ein Körnchen Wahrheit, aber keine bringt die Sache so richtig auf den Punkt. Es dürfte nicht zuletzt am mangelnden Verständnis des Konzepts von Notes/Domino liegen, dass es häufig am falschen Ort zur falschen Zeit eingesetzt wird. Wenn Sie Notes/Domino bereits kennen, dann wissen Sie, dass man damit einfache Textverarbeitung betreiben kann und die eingebaute Formelsprache sogar einfache Tabellenkalkulation erlaubt. Notes kann von allem ein bisschen, wird aber letztendlich in keiner Kategorie mit Anwendungen mithalten können, die speziell für den jeweiligen Zweck entwickelt wurden. Um den Sinn und Zweck sowie die Philosophie von Notes/Domino zu verstehen, dürfte ein Blick auf die Geschichte des Systems hilfreich sein. Mal ganz abgesehen davon, dass es eine schöne Geschichte ist, leistet sie einen ersten Beitrag zum Verständnis und für den Überblick über das mittlerweile recht bunte Gemisch an Funktionalitäten, die von Notes/Domino angeboten werden.

1.1.1

Eine kleine Geschichte

Die Geschichte beginnt, wie im IT-Bereich so oft, in den Vereinigten Staaten, an der Universität in Illinois, wo ein junger Student namens Ray Ozzie Ende der 1970er Jahre ein System namens PLATO Notes weiterentwickelte, das in einer Projektstudie bereits existierte. Dieses hostbasierte Bulletin-Board-System sollte es den Studenten ermöglichen, Nachrichten in elektronischer Form auszutauschen, also eine Art elektronisches Diskussionsforum darstellen. Nach dem Abgang von der Universität (die Legende überliefert nicht, ob Ray Ozzie seinen Studienabschluss geschafft hatte) betätigte er sich recht erfolgreich als Anwendungsentwickler. Er war unter anderem bei Lotus maßgeblich an der Entwicklung des integrierten Office-Pakets Symphony beteiligt. Nebenher gründete er sein eigenes Unternehmen namens Iris, das sich ausschließlich der Weiterentwicklung des alten PLATO-Notes-Gedankens, nämlich der elektronischen Unterstützung von Teamarbeit, widmen sollte. Mit maßgeblicher Hilfe eines anderen Visionärs, des Lotus-Gründers Mitch Kapor, erblickte das offizielle Produkt Lotus Notes 1989 das Licht der Welt und sorgte in der IT-Szene für einige Aufregung. Ein insbesondere für Microsoft schmerzlicher Teil der Legende besagt, dass Bill Gates Notes als die »beste Windows-Anwendung, die er je gesehen hatte«, bezeichnete und – wen wundert’s – bald daraufhin ein ähnliches Produkt in Auftrag gab, das damals noch Information Exchange Server hieß und heute als Exchange dem Unternehmen Lotus die Marktführerschaft im Groupware-Bereich streitig machen will.

IBM SOFTWARE PRESS

24

Domino: Einführung und Überblick

Interessanterweise enthielt bereits die erste Version eine Vielzahl von »klassischen« Notes-Konzepten, wie E-Mail-Funktionalität, Replikation, Formelsprache und Verschlüsselung. Doch erst die erweiterte Skalierbarkeit sowie zahlreiche Neuigkeiten wie z.B. die Volltextsuche in der Version 3 verschafften 1993 Lotus Notes den endgültigen kommerziellen Durchbruch und die endgültige Etablierung einer neuen Software-Kategorie namens Groupware, in der Lotus Notes lange Zeit als das einzige ernst zu nehmende Produkt galt. Trotz der unangefochtenen Markterfolge von Notes kämpfte Lotus in anderen Märkten mit Schwierigkeiten: Die zahlreichen Flops (z.B. das bereits angesprochene Office-Paket Symphony nebst einer ähnlichen Lösung für die Macintosh-Plattform namens Jazz) sowie die mächtige Konkurrenz – vor allem Microsoft – führten dann 1995 zur Übernahme von Lotus durch IBM. Seit diesem Zeitpunkt wird unter IBMs Fittichen Notes/Domino konsequent als der Mittelpunkt der betrieblichen IT-Landschaft ausgebaut. Bleibt schließlich die Frage: Notes oder Domino? Ganz abgesehen vom etwas eigenwilligen Konzept, das Sie im Laufe dieses Buches noch kennenlernen werden, fängt die Verwirrung eines Notes-Anfängers meistens schon beim Produktnamen an: Bis zur Version 4.5 waren die Dinge einfach: »Notes« war einfach »Notes«, und damit hatte es sich! Doch mit dem Aufkommen des Internets wurden die Dinge zunehmend komplexer. Der Begriff »Domino« machte die Runde. Anschließend war in der Version 4.6 plötzlich von »Domino (Notes?) Designer« die Rede. An dieser Stelle soll für etwas Klarheit gesorgt werden: Domino war ursprünglich der »Codename« einer einzelnen Teilanwendung, nämlich des HTTP-Übersetzers, der ab der Notes-Version 4.5 (erschienen 1996) dafür sorgen sollte, dass die Inhalte von Notes-Datenbanken transparent in HTML übersetzt werden. Da die zu jener Zeit unangefochtene Position des Groupware-Marktführers Lotus zusehends von den aufkommenden Intranet-Technologien in Frage gestellt wurde, war es für das Unternehmen unbedingt notwendig, Zeichen in Richtung einer klaren InternetVision zu setzen. Also entschied man sich kurzerhand, nicht nur die HTTP-Task, sondern das gesamte Server-Bundle in »Domino« umzubenennen. Der Name sollte hierbei die schrittweise Migration der ehemals proprietären Plattform in Richtung Internet-Standards signalisieren – ein Prozess, der in den folgenden Versionen konsequent weiterentwickelt wurde. Diese Konzept wurde dann in der Version 5 von Lotus Notes/ Domino weiter forciert. Während in der Version 5 sowohl der Notes-Client als auch der Domino-Server um eine Vielzahl zusätzlicher Funktionen und Werkzeuge erweitert wurde, diente die anschließende Version 6 weitgehend zur stärkeren Integration der Software in das Gesamtkonzept der Unternehmen. In Lotus Notes/Domino 6 wurden zudem Funktionen überarbeitet oder vollständig auf eine neue Code-Basis gestellt, die sich entweder in der oder den vorhergehenden Version(en) als fehlerbehaftet oder schlecht skalierend herausgestellt hatten. So wurde zum Beispiel zwischen der Version 5 und Version 6 eine der zur Verfügung stehenden Programmiersprachen auf der Basis von C++ vollständig neu implementiert, was erhebliche Geschwindigkeitsvorteile brachte. Zudem konnten so einige Erweiterungen durchgeführt werden, die vorher undenkbar waren.

Grundkonzepte von Domino

25

In der Version 7 wurde schließlich das Augenmerk verstärkt auf den Bereich der besseren Wartbarkeit innerhalb großer Organisationen gelegt und so eine bessere Administration in large-scale-enterprises gelegt. Durch eine zum Teil dramatische Erweiterung der maximalen Userzahlen pro Server auf den verschiedenen Plattformen kann jetzt auch der Wunsch der Unternehmen zu einer verstärkten Serverkonsolidierung erfüllt werden. In der Version 7 sind nun auch auf den Plattformen Windows und Linux Userzahlen denkbar, die vorher nur im Mainframe – Umfeld möglich ware (bis zu ca. 15.000 konkurrierende User pro Server). Hinzu kamen einige graduelle Verbesserungen sowohl am Client als auch an der Entwicklungsumgebung. Die Entscheidung, auf der Client-Seite die Bezeichnung »Notes« beizubehalten, mag auf den ersten Blick unverständlich erscheinen, ist aber nur konsequent, wenn man bedenkt, dass das gesamte Produktbündel »Domino« eine Vielzahl von Clients unterstützt: alle Arten von Internet-Clients (Webbrowser), sowohl internetmail-fähige (POP3, SMTP, IMAP4) als auch proprietäre Mail-Clients (cc:Mail), Terminplaner (Organizer), News-Clients (NNTP) usw. Dem »klassischen« Notes-Client kommt hierbei nur insofern eine besondere Rolle zu, als dass er als einziger in der Lage ist, sämtliche Funktionalitäten des Domino-Bündels vollständig auszuschöpfen. Abschließend sei noch gesagt, dass die eben dargestellte Unterteilung in den Büchern und Artikeln zum Thema Notes/Domino nicht einheitlich verfolgt wird.

1.2

Grundkonzepte von Domino

Nun können wir die Antwort auf die Frage »Was ist Lotus Notes/Domino?« etwas konkreter formulieren: Es handelt sich um eine Ansammlung von (Infrastruktur-) Diensten und Programmen zur Unterstützung der Verteilung und Auffindung von Informationen (z.B. via E-Mail oder im firmeninternen Intranet) und der Zusammenarbeit (collaboration), z.B. in Form von elektronischen Diskussionsforen und Workflows. Wir wollen uns im Folgenden die wichtigsten Dienste in einem kurzen Überblick ansehen und anschließend auf die Rolle der Anwendungsentwicklung zu sprechen kommen.

1.2.1

Datenbank-Managementsystem

Im Kern der Domino-Funktionalität steht das Datenbank-Managementsystem (DBMS), der sogenannte secure object store. Hierbei handelt es sich um kein relationales DBMS wie etwa bei Oracle oder Sybase, sondern um ein Repository zur Verwaltung unstrukturierter Informationen. Schauen wir uns dieses Konzept etwas genauer an: Wenn Sie bereits Erfahrung in der Welt der relationalen Datenbanken haben, dürften Ihnen die meisten Konzepte von Domino-Datenbanken vertraut vorkommen: So gibt es die elementaren Bausteine, die sogenannten NOTES (Dokumente), die in etwa einem relationalen RECORD entsprechen. Es gibt auch VIEWS (Ansichten), die eine bestimmte Sichtweise auf die Datenbankinhalte ermöglichen. Der wesentliche Unterschied zwischen Notes und einem relationalen DBMS ist jedoch, dass man die Struktur der »Tabellen« – also die Zusammensetzung der Spalten und die Größe der »Felder« – nicht von vornherein kennen muss. Noch besser: So etwas wie eine explizite Tabellendefinition existiert in Notes gar nicht! Diese wird vielmehr über ein elektronisches Formular vorgegeben, das zur Eingabe von

IBM SOFTWARE PRESS

26

Domino: Einführung und Überblick

Daten verwendet wird. Wenn Sie dem Formular im Laufe der Zeit weitere Felder hinzufügen, werden die zusätzlichen Informationen von Notes/Domino in allen daraufhin erstellten Dokumenten stillschweigend akzeptiert. Diese Flexibilität wird ergänzt durch die Fähigkeit des Notes-DBMS, auch komplexe Objekte zu verwalten (z.B. Bilder, Klänge, ausführbare Objekte) – und das Ganze noch schnell und effizient. Nicht zuletzt kommen diese Fähigkeit des secure object store auch dem Anwendungsentwickler zugute: Seit der Version 6.0 können auch Bestandteile der Applikation wie etwa Cascading Style Sheets, JavaScript-Codefragmente, Dateien und Bilder direkt in der Datenbank verwaltet werden. Selbstverständlich muss die fehlende Struktur im Vergleich zu einer klassischen Datenbank irgendwie »erkauft« werden. Der Haken ist, dass das dynamische Datenmodell in Notes keinerlei Prüfung von Integritätsregeln ermöglicht, wie man sie in der Welt der relationalen Datenbanken kennt. Das Aufspüren von Inkonsistenzen und Redundanzen in der Datenbank bleibt somit eine Sache des Anwendungsentwicklers. Das dürfte sich für manchen Kenner von Oracle und Co. nach einem fatalen Knock-out-Kriterium anhören, ist jedoch aus der Sicht des Anwenders viel intuitiver zu handhaben, zumindest wenn es sich um die Verwaltung von papierähnlichen Informationen handelt; oder kennen Sie jemanden, der seine Korrespondenz zunächst einmal mit der Schere in die 2. Normalform bringt?

1.2.2

Replikation

Bleiben wir noch einen Augenblick beim Thema Datenbank. Eine herausragende Fähigkeit von Domino ist die sogenannte Replikation von Datenbanken. Bei diesem Verfahren können eine Vielzahl von Datenbanken (die sogenannten Repliken) auf geografisch verteilten Rechnern automatisch bzw. periodisch synchronisiert werden. Ein Beispiel: Stellen Sie sich vor, ein Unternehmen hat drei Verkaufsniederlassungen, eine in Berlin, eine in Frankfurt und eine in München. Nun sollen die in einer Domino-Datenbank verwalteten Kundendaten eines Standorts den beiden anderen Standorten zugänglich gemacht werden. Anstatt mühsam die Daten per Diskette oder per FTP hin- und herzuschieben und die an allen Orten vorgenommenen Änderungen manuell abzugleichen, bietet sich der Mechanismus der Replikation an. Dieser ist gewissermaßen »intelligent«: Alle Modifikationen, die zwischen zwei Repliziervorgängen an Repliken vorgenommen wurden, werden automatisch abgeglichen, indem die neueste Modifikation »gewinnt« (Abbildung 1.1). Kann der Replikationsmechanismus einen Konflikt nicht auflösen, wird dieser gesondert gekennzeichnet und kann manuell beseitigt werden. Neben dem oben geschilderten Beispiel gibt es mindestens zwei andere Einsatzgebiete der Replikation: zum einen den mobilen Einsatz, bei dem beispielsweise ein Verkäufer in der Lage ist, alle für ihn relevanten Kunden- und Produktinformationen auf einen mobilen Rechner zu replizieren, zu bearbeiten und anschließend mit der Hauptdatenbank abzugleichen; zum anderen den Fall der Anwendungsentwicklung: Da auch die Gestaltungselemente (vgl. nächstes Kapitel) einer Domino-Datenbank repliziert werden können, können Domino-Anwendungen ohne Weiteres verteilt entwickelt werden, indem jeder Entwickler mit seiner eigenen Replik arbeitet. Wird anschließend repliziert, bekommt jeder Entwickler automatisch alle Neu-

Grundkonzepte von Domino

27

erungen der anderen Teammitglieder. Der zweite Vorteil betrifft die Verteilung von Anwendungen: Basierend auf dem Replikationsmechanismus ist es ein Leichtes, eine Version der Anwendungen weltweit über Nacht zu verteilen.

Abbildung 1.1 Prinzip der Replikation

1.2.3

Mail-Routing

Eine andere, recht populäre Methode des Informationsaustauschs ist E-Mail. Das Messaging gehört von Anfang an zum Kern von Notes/Domino und ist zugleich in den meisten Unternehmen die am häufigsten in Anspruch genommene (oftmals sogar die einzige) Funktion eines Domino-Systems. Notes/Domino beherrscht zwei Standards zur Darstellung bzw. zum Routing von E-Mail: zum einen das proprietäre Notes-Mail-Format (die passende Darstellungsform hierzu heißt Notes Rich-Text) und zum anderen das internet-kompatible SMTP mit MIME-basierter E-Mail-Darstellung. Der zu verwendende E-Mail-Standard ist von einem Systemadministrator beliebig wählbar, der Übergang von der einen in die andere Welt ist für den Nutzer transparent. Auch im Bereich der E-Mail-Sicherheit verfolgt Lotus momentan noch eine doppelgleisige Strategie. Wird SMTP-Mail-Routing verwendet, unterstützt Domino SSL (zur sicheren Übertragung) sowie X-509-Zertifikate (zum Verschlüsseln und Signieren von Nachrichten), anderenfalls kommen proprietäre NotesZertifikate zum Einsatz. Darüber hinaus bietet Notes nach wie vor die Möglichkeit, mittels sogenannter Message Transfer Agents auch ältere E-Mail-Systeme (wie X.400 und cc:Mail) anzubinden. Interessant ist aus der Sicht der Anwendungsentwicklung die Beziehung zwischen dem Datenbank-Managementsystem und dem Mail-Routing. Domino bedient sich sowohl beim Zwischenlagern als auch beim Zustellen von E-Mails der Datenbankfunktionalität; eine E-Mail ist in der Notes-Welt – unabhängig davon, ob sie im Notes Rich-Text- oder MIME-Format vorliegt – nichts anderes als ein Dokument (NOTE).

IBM SOFTWARE PRESS

28

1.2.4

Domino: Einführung und Überblick

Information-Retrieval

Bisher haben wir beschrieben, wo Informationen verwaltet werden und wie sie verteilt werden können. Was aber ist mit der Suche nach Informationen? Das »unstrukturierte« Datenbankkonzept, das wir in Abschnitt 1.2.1 kennengelernt haben, impliziert natürlich auch, dass den klassischen Abfragesprachen wie SQL (man beachte: »Structured« Query Language) im Notes-Umfeld Grenzen gesetzt sind. Um dieses Manko auszubügeln, entwickelte Lotus alternative Mechanismen der Informationssuche, die mit jeder weiteren Version konsequent weiter ausgebaut wurden. An erster Stelle stehen die sogenannten Ansichten. Im Gegensatz zu ihren Pendants bei einer relationalen Datenbank sind die Ansichten in Notes nicht einfach vordefinierte Mechanismen der Selektion und Projektion, sondern vielmehr echte »Objekte«, die auf bestimmte Ereignisse reagieren und vom Benutzer aktiv manipuliert werden können. Letzteres umfasst beispielsweise die dynamische Sortierung und Kategorisierung, wie sie in Abbildung 1.2 dargestellt ist.

Abbildung 1.2 Ansichten als Methode des Information Retrieval

Die Informationssuche in den Ansichten setzt natürlich voraus, dass der Suchende über den Inhalt und die Struktur der Inhalte recht gut informiert ist. Ist dies nicht der Fall, ist eine Volltextsuche sinnvoller, wie sie auch im World Wide Web zum Einsatz kommt. Domino verfügt standardmäßig über eine Volltextsuchmaschine, die einzelne Datenbanken, Server und sogar ganze Domänen (Gruppen von Servern und Dateisystemen) indizieren und dem Benutzer zur Verfügung stellen kann.

Grundkonzepte von Domino

29

Bleibt schließlich noch die dritte Methode: die sogenannten Agenten. Hierbei handelt es sich um kleine, eigenständige Programme, die zur Automatisierung bestimmter, routinemäßig anfallender Aufgaben eingesetzt werden. Der Einsatzbereich von Agenten geht zwar weit über das bloße Information Retrieval hinaus, dennoch stellen sie in diesem Bereich eine interessante Alternative zu den zuvor genannten Methoden dar. Das Schöne an Agenten ist, dass man die Informationen nicht nur automatisch suchen (lassen) kann, sondern dass die Ergebnisse der Suche als Eingabe für weitreichendere Aktionen eingesetzt werden können.

1.2.5

Integration mit anderen Systemen

Es gehört zur erklärten Strategie von Lotus, dass Domino die Rolle der zentralen Middleware-Plattform im Unternehmen einnehmen sollte. Der Aspekt der Integration mit anderen Systemen ist hierbei aus zwei Gründen von Bedeutung: Zum einen werden die richtig wichtigen Daten in den meisten Unternehmen bereits in anderen Systemen vorliegen, beispielsweise in betriebswirtschaftlichen Standardsoftware-Paketen wie SAP R/3, relationalen Datenbanken wie Oracle oder IBM DB2 oder in guten alten Host-Anwendungen. Zum anderen ist das Notes-DBMS aus bereits in Abschnitt 1.2.1 dargestellten Gründen nicht immer die beste Lösung, beispielsweise wenn es sich um große Mengen strukturierter Daten handelt oder die Abwicklung von Transaktionen eine wichtige Rolle spielt. Auch die Integration mit anderen Systemen kommt bei Domino in vielfältiger Weise vor. Auf der einfachsten Ebene können die gängigsten Dateitypen mittels einfacher Import- und Export-Funktionen ausgetauscht werden, wie man das aus den meisten Office-Anwendungen kennt. Eine Ebene darüber ist die Anbindung relationaler Datenbanken über die Open Database Connectivity (ODBC-)Spezifikation angesiedelt, die recht einfach auszulesen sind und mit etwas mehr Kenntnissen auch beschrieben werden können. Richtig luxuriös ist jedoch die Anbindung, die über den sogenannten Domino Enterprise Connectivity Server (DECS) oder den LEI (Lotus Enterprise Integrator) erfolgt. Hierbei kann man als Systemadministrator »Echtzeitbeziehungen« zwischen Domino und einer beliebigen externen Quelle definieren, d.h., die Daten werden in Echtzeit zwischen den beiden Systemen ausgetauscht.

1.2.6

Internet-Kompatibilität

Die bisher genannten Dienste sind für einen erfahrenen Notes-Anwender über lange Zeit hinweg ein alter Hut gewesen. Richtig interessant wird es jedoch, wenn man bedenkt, dass in Domino ein Großteil der genannten Dienste konsequent auch aus einem Internet-Client (Webbrowser, Internetmail- und News-Client) heraus genutzt werden können, ohne dass aus der Sicht des Systembetreibers hierfür ein merklicher Zusatzaufwand erforderlich wäre. Geschah dies in einem ersten Schritt noch über Gateway-Dienste (z.B. SMTP-Router), die zwischen der proprietären Notes- und der Internet-Welt vermitteln mussten, macht sich zunehmend der Trend bemerkbar, dass reine Internet-Funktionen gleichberechtigt neben alten proprietären Notes-Standards auftreten. Auf lange Sicht ist davon auszugehen, dass alte Notes-Standards wohl nur noch als Altlasten unterstützt werden bzw. zunehmend zugunsten der Internet-kompatiblen Technologien aufgegeben werden.

IBM SOFTWARE PRESS

30

Domino: Einführung und Überblick

1.2.7

Sicherheit

Immer mehr wichtige Informationen liegen nicht mehr in Papierform vor, sondern werden elektronisch gespeichert und verteilt, wodurch sich für einen potenziellen Angreifer völlig neue Möglichkeiten ergeben. Unternehmen werden sich nach und nach des potenziellen wirtschaftlichen Schadens bewusst, der mit Entwendung, Manipulation oder Beschädigung von Informationen bzw. Informationssystemen verbunden ist. Bei Domino spielte das Thema Sicherheit schon immer eine große Rolle. Um Angriffe auf Informationen auf allen Ebenen abzuwehren, bietet Domino vier unterschiedliche Arten von Sicherheitsmaßnahmen:
Bidirektionale Authentifizierung: Wann immer ein Datenaustausch zwischen

Client und Server stattfindet, müssen beide Parteien der jeweils anderen ihre Identität nachweisen. Dies geschieht auf der Basis der asymmetrischen Verschlüsselung.
Digitale Unterschriften garantieren die Echtheit elektronischer Nachrichten

und Dokumente. Dies beinhaltet zum einen den Nachweis der Identität des Unterschreibenden und zum anderen, dass eine Nachricht bzw. ein Dokument seit der letzten Unterschrift nicht verändert wurde.
Zugriffskontrolle gewährt im Zusammenspiel mit der Authentifizierung einem

Benutzer (oder einer Benutzergruppe) die Berechtigung für eine bestimmte Operation. Dies kann auf der Server-Ebene erfolgen, aber auch auf der Ebene einer einzelnen Datenbank oder sogar eines einzelnen Datenbankelements.
Verschlüsselung stellt sicher, dass eine Nachricht oder bestimmte Datenbank-

inhalte nur von den Personen gelesen werden dürfen, die im Besitz eines entsprechenden Geheimcodes sind. Die Verschlüsselung kommt in Notes in mehreren unterschiedlichen Formen zum Einsatz: auf der Ebene des E-Mail-Verkehrs, beim Datenaustausch über Netzwerke, zum Schutz von Datenbanken auf mobilen Rechnern sowie als Verschlüsselung von einzelnen Feldern in Dokumenten. Domino-Verzeichnis Eine zentrale Rolle im Bereich der Sicherheit (aber auch darüber hinaus) spielt das sogenannte Domino-Verzeichnis. Hierbei handelt es sich um das zentrale Repository, in dem sämtliche Informationen über Benutzer, Gruppen und Server sowie sonstige System- und Sicherheitseinstellungen gesammelt und verwaltet werden. Das Domino-Verzeichnis ist etwa mit der Benutzerverwaltung unter Windows, UNIX oder Novell NDS vergleichbar. Aus Gründen der Plattformunabhängigkeit ist das Domino-Verzeichnis jedoch vom entsprechenden Pendant auf der Ebene des Betriebssystems entkoppelt (so müssen beispielsweise Benutzer sowohl im Unternehmens Directory (z.B. Microsoft Active Directory oder Novell NDS)- als auch im Domino-System doppelt verwaltet werden), es kann jedoch in dieses integriert bzw. mit ihm synchronisiert werden. Grundsätzlich gehören die Kenntnisse des Domino-Verzeichnisses zwar in den Bereich der Systemadministration, doch auch als Anwendungsentwickler kommt man nicht darum herum, es zu verwenden – spätestens beim Thema Sicherheit.

Architektur von Domino

1.2.8

31

Unterschiedliche Möglichkeiten des Informationszugriffs

Als zentrale Plattform der elektronischen Zusammenarbeit ist die Plattform Lotus/ Domino einer der Vorreiter auf dem Gebiet der Integration unterschiedlicher Client-Typen sowie unterschiedlicher Modi des Informationszugriffs. Die Philosophie der Plattform bewegt sich an dieser Stelle ganz klar weg von dem proprietären Notes-Client hin zu beliebigen Client-Typen, insbesondere natürlich zu dem Webbrowser, aber auch zu mobilen Zugriffsgeräten (z.B. mobilen Telefonen und PDAs) und sogar zu Produkten der Konkurrenz (z.B. Microsoft Outlook). Im Hinblick auf unterschiedliche Modi des Informationszugriffs unterstützt Notes/Domino den klassischen Online-Zugriff des Clients auf den Server, bietet aber zugleich die Möglichkeit einer vom Netzwerk abgekoppelten Offline-Informationsbearbeitung (im Lotus-Notes-Client oder im Webbrowser durch die sogenannten Domino Offline Services). Zudem gewinnt immer mehr auch die Informationsverteilung in Echtzeit in Form des sogenannten Instant Messaging an Bedeutung.

1.3

Architektur von Domino

Notes/Domino ist ein verteiltes System. Das Prinzip der Verteilung nimmt in Notes/ Domino zahlreiche Formen an: Beispielsweise werden in großen Unternehmen mit mehreren Tausend Arbeitsplätzen Notes/Domino-Installationen geografisch verteilt. Eine solche Verteilung ermöglicht einen prompten Zugriff auf die gewünschten Informationen bei geringen Kommunikationskosten. Eine andere Form der Verteilung ist die redundante Verteilung, mittels der die Performance-Last von einem auf mehrere funktionsgleiche Systeme umdisponiert wird. Die Art der Verteilung, der wir uns im Folgenden widmen werden, ist jedoch die funktionale Verteilung, bei der ein System in mehrere Module aufgeteilt wird, die jeweils auf einen speziellen Aufgabenbereich abgestimmt sind und untereinander kommunizieren. Client/Server-Prinzip Für diese Art der Architektur etablierte sich in der DV-Branche die Bezeichnung Client/ Server (C/S). Das Prinzip hinter Client/Server ist recht einfach zu verstehen: Anstatt die gesamte Funktionalität einer Anwendung in einen einzigen monolithischen Block zu packen, wird diese in mindestens zwei logische Schichten unterteilt: den Client und den Server. Ein Server ist dazu da, auf die Anfragen eines oder mehrerer Clients hin eine bestimmte Funktion bereitzustellen. Geläufige Beispiele sind Druck-, Datei- und Datenbankserver. Die Vorteile einer solchen Architektur liegen zum einen in der erhöhten Effizienz der Ressourcennutzung – man denke beispielsweise an die Auslastung des Druckers, der von mehreren Mitarbeitern einer Abteilung benutzt wird – und zum anderen in der erhöhten Flexibilität des Systems, da jeder SoftwareProzess auf dem System ablaufen kann, das dafür am besten prädestiniert ist. Führt man den Client/Server-Gedanken weiter, so wird irgendwann die Frage auftauchen, ob es eine allgemeine Regel gibt, wie denn eine Anwendung optimal in unterschiedliche logische Schichten unterteilt werden kann. Eine klassische Antwort auf diese Frage ist in Abbildung 1.3 dargestellt.

IBM SOFTWARE PRESS

32

Domino: Einführung und Überblick

Abbildung 1.3 Client/Server-Architektur

3-Tier-Architektur Hiernach wird eine Anwendung typischerweise in drei Schichten unterteilt (man spricht in diesem Zusammenhang dann auch von einer 3-Tier-Architektur):
Die Datenschicht umfasst alle Funktionen, die auf die Datenhaltung ausge-

richtet sind.
Die Anwendungsschicht umfasst die eigentlichen »Regeln« zur Verarbeitung von

Daten.
Die Präsentationsschicht stellt dem Benutzer die Ergebnisse der Verarbeitung vor.

Jede der genannten Schichten kann – je nach Situation – sowohl als Client als auch als Server fungieren. Man stelle sich vor, ein Benutzer formuliert in einer Bildschirmmaske eine Datenbankanfrage. In diesem Fall wird die Präsentationsschicht zunächst einmal eine »Anfrage« an die Anwendungsschicht leiten und diese wiederum an die Datenschicht. Doch auch der umgekehrte Weg ist möglich, nämlich dass Daten – das Ergebnis der Anfrage – auf dem Rückweg in eine entsprechende visuelle Form übersetzt werden. In diesem Fall kann die Präsentationsschicht als Server fungieren1.

1

Ein bekanntes Beispiel eines Präsentationsservers ist das X Window System unter UNIX.

Architektur von Domino

33

Lotus Notes/Domino ist ein echtes Client/Server-System, das jedoch das in Abbildung 1.3 dargestellte dreistufige Client/Server-Modell in zwei Stufen zusammenfasst. Die erste Schicht besteht aus Domino-Datenbanken und -Programmen (diese werden wir uns im nächsten Kapitel genauer ansehen), und die zweite Schicht stellt die Präsentation über den Notes-Client dar (oder einen anderen Client, z.B. Webbrowser). Eine Domino-Datenbank umfasst nicht nur den Aspekt der Datenhaltung, sondern zugleich die Anwendungslogik – also die Regeln, nach denen Daten verarbeitet werden. Anwendungslogik außerhalb einer Datenbank gibt es bei Domino nicht, es sei denn, man greift auf externe Systeme zurück. Notes-Client Ein Domino-System ist prinzipiell auf die Arbeit mit mehreren verschiedenen ClientTypen ausgerichtet. Beispielsweise können Teile der Domino-Funktionalität von POP3- oder IMAP4-fähigen E-Mail-Clients, einem NNTP-Newsreader oder auch dem Lotus Organizer genutzt werden. Doch es gibt nur einen Client, der in der Lage ist, sämtliche Domino-Funktionalitäten zu übernehmen: den Notes-Client. Notes-Client als Personal Information Manager Der Notes-Client ist zunächst einmal ein grafischer Personal Information Manager (PIM) mit integriertem Webbrowser, der in der Lage ist, spezielle, für das NotesUmfeld entwickelte Anwendungen auszuführen. Basierend auf dieser Fähigkeit bietet der Notes-Client eine Reihe von Grundfunktionalitäten, wie z.B. E-Mail, Calendaring und Scheduling, Task-Management und elektronische Formulare. Doch die wahren Fähigkeiten des Notes-Clients kommen erst dann zur Geltung, wenn die genannten Grundfunktionalitäten im Rahmen der Anwendungsentwicklung auf völlig neuartige Weise miteinander verknüpft werden (vgl. Abbildung 1.4).

Abbildung 1.4 Notes-Client-Oberfläche (hier dargestellt am Beispiel von TeamRoom, einer Anwendung zur Unterstützung von virtuellen Teams)

IBM SOFTWARE PRESS

34

Domino: Einführung und Überblick

Der Notes-Client muss nicht unbedingt zusammen mit dem im folgenden Abschnitt beschriebenen Domino-Server eingesetzt werden, sondern kann vielmehr auch als eigenständige Anwendung betrieben werden. In der Tat gibt es eine ganze Reihe von Domino-Server-Funktionen, die in einer vereinfachten lokalen Version auch im Notes-Client zur Verfügung stehen. Hierzu gehören beispielsweise Volltextsuche, Replikation, Komprimierung von Datenbanken, Agenten und Offline-Retrieval von Webseiten. Dennoch kommt er nur selten als Einzelplatzanwendung zum Einsatz. Vielmehr ist die Implementierung lokaler Dienste als ein Zugeständnis an mobile Benutzer anzusehen, die nicht immer in der Lage sein werden, die entsprechenden Funktionalitäten eines Domino-Servers zu nutzen. Domino Designer Darüber hinaus gibt es eine weitere Fähigkeit, die den Notes-Client von allen weiteren Client-Typen abhebt: die Anwendungsentwicklung. Ursprünglich gehörte diese zum integralen Bestandteil des herkömmlichen Notes-Clients. Doch mit der zunehmenden Komplexität von Domino – schließlich muss die Entwicklungsumgebung sowohl alle »Legacy«-Notes-Konzepte als auch die neueren Webkonzepte unterstützen – entschied man sich dann doch, die Entwicklungskomponente vom übrigen Teil zu trennen und in einen speziellen Typus des Notes-Clients auszulagern: den Domino Designer. Der Domino Designer (übrigens das Werkzeug, mit dem wir uns im Großteil des vorliegenden Buchs beschäftigen werden) stellt eine integrierte Entwicklungsumgebung zum Entwurf von Domino-Anwendungen bereit. Integriert bedeutet in diesem Zusammenhang zunächst einmal, dass der gesamte Prozess der Anwendungsentwicklung vom Entwurf über die Implementierung, das Debugging und die Dokumentation im Rahmen einer einheitlichen grafischen Benutzeroberfläche durchgeführt werden kann. Integriert bedeutet aber auch, dass man in eben dieser Entwicklungsumgebung verschiedene Programmiertechniken (von einer einfachen Makrosprache bis hin zur ausgefeilten Java-Anwendung) nutzen kann (vgl. Abschnitt 1.4.2). Domino Designer ist am ehesten mit einem stark erweiterten HTML-Editor zu vergleichen. Wie bei diesem ist die Arbeitsweise in Anlehnung an das Notes/DominoObjektmodell zunächst einmal dokumentorientiert: Man entwirft zunächst eine aus zahlreichen Elementen bestehende Seite und versieht diese in einem zweiten Schritt mit der erforderlichen Programmlogik (vgl. Abbildung 1.5). Wir werden im Laufe dieses Kapitels noch einmal auf das Thema Domino Designer zu sprechen kommen und uns mit den Details dieser Entwicklungsumgebung im nächsten Kapitel ausführlich auseinandersetzen.

Architektur von Domino

35

Abbildung 1.5 Domino Designer

Domino-Server Den Kern des Domino-Servers stellt der Datenbank-Server dar. Vergleichbar mit einem relationalen Datenbank-Server ermöglicht der Datenbank-Server die gleichzeitige Verwendung einer Datenbank durch mehrere Benutzer. Im Notes-Jargon ist der Datenbank-Server jedoch nur eine der TASKS, die auf einem Domino-System ablaufen. Neben dieser Kernfunktionalität bietet der Domino-Server nämlich eine ganze Reihe weiterer Module, die als separate Anwendungen implementiert sind und nach Belieben gestartet oder beendet werden können. Grob lassen sich diese TASKS wie folgt aufteilen:
Erweiterungen der Kernfunktionalität: Einige der Kernfunktionalitäten von

Domino sind in Form separater Server-Tasks realisiert. Einige Beispiele hierfür sind die Volltextindizierung, der Replikationsprozess, der Agent-Manager, die Calendaring- und Scheduling-Dienste, die Integration in relationale Datenbanken und Legacy-Systeme und – last but not least – der Mail-Router.
Administrationsfunktionen: Eine komplexe Umgebung verlangt einem System-

administrator einiges an Aufgaben ab. Zum Glück lässt sich eine Reihe von Administrator-Tätigkeiten in Form von Server-Tasks fast vollständig automatisieren. Einige Beispiele für solche Tasks sind der Administrationsprozess, das automatische Monitoring von Server-Prozessen und die darauf aufbauende Generierung von Statistiken, das Komprimieren sowie das Reparieren und die Verwaltung von Datenbanken.

IBM SOFTWARE PRESS

36

Domino: Einführung und Überblick


Internet-Tasks: Schließlich gibt es eine Reihe von Tasks, deren Aufgabe primär

darin besteht, die Domino-Funktionalität auch Internet-Clients zur Verfügung zu stellen. Hierzu gehören allen voran die HTTP-Task, aber auch der Mail-Zugriff (POP3- und IMAP4-Task), der LDAP-Server sowie der CORBA-konforme Object Request Broker. Eine vollständige Auflistung der Server-Tasks von Domino 7 sehen Sie in Tabelle 1.1. Task

Beschreibung

Activity Trends Collector

Speichert Aktivitäten Daten und stellt sie zu Analysezwecken zur Verfügung.

Administrationsprozess

Automatisiert die im Zusammenhang mit der Administration anfallenden Aufgaben

Agent-Manager

Verwaltet die server-seitigen Domino-Agenten

Billing

Ermöglicht eine kostenmäßige Erfassung der Nutzung von Domino-Diensten

CA process

Ermöglicht die Einrichtung von Notes und InternetZertifizierungsstellen

Calendar Connector

Ist für den Calendaring-Zeitabgleich mit mehreren Servern verantwortlich

Cataloger

Verwaltet den sogenannten Datenbankkatalog

Change Manager

Ermöglicht die bessere Integration in Tivoli (Ergänzungsprodukt für große Umgebungen) zur einfacheren Administration von Lotus Notes.

Chronos

Führt die periodische Aktualisierung von Volltextindizes durch

Cluster-Administrationsprozess (Nur R4/R5)

Kontrolliert eine aus mehreren Domino-Servern bestehende Cluster-Umgebung

Cluster-Datenbankverzeichnismanager

Verwaltet die Datenbanken mit cluster-spezifischen Eigenschaften

Cluster-Replikator

Führt die Replikation innerhalb eines Clusters durch

Datenbank-Komprimierungsprogramm

Führt periodisch die Komprimierung aller auf dem Server befindlichen Datenbanken durch

Datenbank-Fixup

Sucht und repariert beschädigte Datenbanken

Designer

Aktualisiert die Gestaltung der auf dem Server befindlichen Datenbanken, die auf einer sogenannten Schablone basieren

DIIOP

CORBA Object Request Broker

Directory Cataloger

Füllt Verzeichniskataloge mit Daten und hält die Kataloge auf dem neuesten Stand

Domain Indexer

Erstellt einen Index über alle Datenbanken einer Domäne, die für die Mehrfachdatenbankindizierung vorgesehen sind. Dieser Prozess setzt den Domänenkatalog voraus.

Event Monitor

Überwacht die Ereignisse auf einem Server

Tabelle 1.1 Domino-Server-Tasks

Architektur von Domino

37

Task

Beschreibung

HTTP-Server

Konvertiert die Domino-Datenbanken in HTML und leitet die Inhalte an den Webbrowser weiter

IMAP-Server

Ermöglicht den IMAP-Zugriff auf die Server-Mail

Indexer

Aktualisiert alle geänderten Masken und/oder Volltextindizes aller Datenbanken

Internet Cluster Manager (ICM)

Bietet Clustering für den http-Zugriff auf den Dominoserver mit Lastverteilung und Failover Funktionalität.

Ispy

Überprüft Server und Mail und speichert die Statistiken

LDAP-Server

Ermöglicht den LDAP-Zugriff auf Domino-Verzeichnisse

MTC

Stellt die zur Mail-Verfolgung relevanten Informationen zusammen

Objektspeicher-Manager

Führt die Wartung von Datenbanken und Mail-Dateien aus, die gemeinsame Mail verwenden

POP3-Server

Ermöglicht den POP3-Zugriff auf die Server-Mail

Remote Debugger

Dieser Prozess ermöglicht es Entwicklern, auf dem Server laufende Agenten von ihrem Arbeitsplatz aus mit einem Debugger zu verarbeiten.

Replikator

Führt die Replizierung der Datenbanken durch

Reporter

Meldet Statistiken für einen Server

Räume-/RessourcenManager

Erlaubt die Verwendung der Raum- und Ressourcen-Datenbank in einer Clusterumgebung

Router

Ist für das Mail-Routing verantwortlich

Schedule Manager

Liefert die Kalenderinformationen über die zeitliche Verfügbarkeit von Personen

SMTP listener

Wartet auf eingehende SMTP-Verbindungen, damit Domino Mail von anderen SMTP-Hosts empfangen kann.

SNMP

Das Simple Network Management Protocol ermöglicht die Überwachung des Servers durch externe Werkzeuge, die das snmp-Protokoll unterstützen.

Statistic Collector

Erfasst Statistiken für mehrere Server

Statistik

Zeichnet Datenbankaktivitäten in der Protokolldatei auf

Stats

Erzeugt auf Anforderung Statistiken für einen Remote-Server

Web-Retriever

Implementiert das HTTP-Protokoll, damit Webseiten aufgerufen und in Notes-Dokumente konvertiert werden können

Tabelle 1.1 Domino-Server-Tasks (Forts.)

Der Domino-Server verfügt aus Performance-Gründen über keine grafische Benutzeroberfläche. Vielmehr erfolgt die Ansteuerung des Domino-Servers durch Eingabe einfacher Befehle an einer sogenannten Konsole. Hier können Sie beispielsweise einzelne Server-Tasks manuell starten oder beenden, die aktiven Tasks und Benutzer anzeigen oder die Replikation von Datenbanken anstoßen (vgl. Abbildung 1.6).

IBM SOFTWARE PRESS

38

Domino: Einführung und Überblick

Abbildung 1.6 Domino-Server-Konsole

Beispielsweise können Sie mit dem Befehl tell bestimmte Nachrichten an die einzelnen Server-Tasks übergeben. So bewirkt der Befehl tell http quit

das Anhalten des HTTP-Servers (falls dieser aktiv ist). Um den HTTP-Server erneut zu starten, genügt der folgende Befehl: load http

Weiterhin können Sie sich mit show tasks

alle aktiven Tasks anzeigen lassen. Verwirrt? help

dürfte da Abhilfe schaffen. Mit diesem Befehl können Sie sich die wesentlichen Konsolenbefehle des Domino-Servers in komprimierter Form anzeigen lassen. Selbstverständlich sind diese Beispiele nicht viel mehr als das sprichwörtliche Kratzen an der Oberfläche einer kleinen Wissenschaft, die da Domino-Administration heißt. Allein die dem Domino-Server beigelegte Dokumentation dürfte mit ihren etwa 2000 Seiten die Komplexität des Themas klarmachen. Domino-Administrator Ein wenig Erleichterung schafft hier die grafische Administrationsbenutzeroberfläche – der Domino-Administrator –, die die einzelnen Administrationsaufgaben in Form mehrerer Bildschirme und Registerkarten übersichtlich anordnet und überdies die Fernadministration von einem oder mehreren Domino-Servern ermöglicht. Abbildung 1.7 verdeutlicht, wie die oben dargestellten Beispiele in der grafischen Umgebung nachgestellt werden können.

Anwendungsentwicklung mit Domino

39

Abbildung 1.7 Domino-Administrator

Nicht zuletzt sollte die Möglichkeit erwähnt werden, Domino-Server auch über eine webbasierte Oberfläche zu administrieren. Die Administration eines Systems über den Webbrowser wurde vor allem durch die Netscape-Server-Produkte populär und bietet den Vorteil, dass man nicht die Spezifika der Notes-Benutzeroberfläche kennen muss, um das System zu verwalten.

1.4

Anwendungsentwicklung mit Domino

Der Bereich der Anwendungsentwicklung nimmt in Domino eine zentrale Stellung ein, denn ohne entsprechende Anwendungen ist Domino nicht mehr als eine – zugegebenermaßen leistungsfähige – Ansammlung von Infrastrukturdiensten. Kombiniert man diese jedoch im Rahmen der Anwendungsentwicklung, ist das Spektrum der möglichen Lösungen fast unbegrenzt. Diese Vielfalt ist mit Sicherheit einer der Gründe für die Vielzahl von Domino-Definitionen. Eine Workflow-Anwendung verwandelt Domino in ein Workflow-Managementsystem. Eine Dokumentbibliothek ermöglicht Dokumentverwaltung. Im betrieblichen Bereich, wo Notes in der Regel eingesetzt wird, kommt diese Vielfalt noch etwas konkreter zum Ausdruck: Hier ist von der Auftragsbearbeitung über die Genehmigung von Urlaubsanträgen bis hin zum Aufbau kompletter Websites alles möglich. Die Stärke von Domino liegt in der Integration verschiedener Systeme: Ergebnisse, die Sie mit anderen Anwendungen erstellen, Daten, die Sie in anderen Systemen verwalten und, ja, sogar Anwendungen, die Sie mit anderen Tools entwickeln, werden in Domino auf Dokumentebene zusammengestellt, verwaltet und im Rahmen einer einheitlichen Benutzeroberfläche – Notes-Client oder Webbrowser – dem Benutzer präsentiert.

IBM SOFTWARE PRESS

40

Domino: Einführung und Überblick

1.4.1

Warum Lotus Domino?

Für Sie als Entwickler mag sich dennoch zunächst das Problem stellen, dass die Nutzung der Vorteile einer ehemals proprietären Plattform in der Regel auch das Erlernen einer proprietären Technologie erfordert: neue Konzepte, Programmiersprachen, Datenformate usw. Lohnt sich das? Wenn Sie dieses Buch in den Händen halten, kann man davon ausgehen, dass Sie auf diese Frage, zumindest in Bezug auf Domino, mit Ja antworten. Wenn nicht, werden vielleicht folgende Vorteile Sie überzeugen: Vorteile von Notes/Domino als Entwicklungsplattform
Integrierte Umgebung: Dies bezieht sich zum einen auf die Entwicklungsum-

gebung, von der aus sich sämtliche Domino-Dienste einheitlich ansprechen lassen, zum anderen aber auch auf die zahlreichen Features, die in der gelben Schachtel bereits von Haus aus mitgeliefert werden: eine Volltextsuchmaschine, ein Mail-System, die Anbindung an relationale Datenbanken und das umfassende Sicherheitskonzept. Das sind alles Funktionalitäten, die bei anderen Herstellern in der Regel erst durch das mühsame Zusammenstellen mehrerer Programmpakete zur Verfügung stehen.
Prototyping-orientierte Entwicklung: Die integrierte Entwicklungsumgebung

ermöglicht eine schnelle prototypische Entwicklung von Anwendungen (Rapid Application Development). Sie zeichnet sich darüber hinaus durch ein breites Angebot an unterstützten Programmierkonzepten (einfache Aktionen, Formeln, JavaScript, LotusScript, Java) und eine Reihe von bereits eingebauten Funktionalitäten aus, die bei anderen Webservern manuell programmiert werden müssen.
Datenbanken: Ein besonderer Vorteil des Domino-Datenbankmodells ist darin

zu sehen, dass die Gestaltungselemente ebenso wie die eigentlichen Datenbankinhalte zum festen Bestandteil der Datenbank gehören. Somit können auch die fortgeschrittenen Dienste wie z.B. die granulierte Zugriffsbeschränkung bzw. die Replikation im Rahmen der Anwendungsentwicklung voll genutzt werden.
Rich-Text-Storage: HTML-Dokumente können – wie bei herkömmlichen Web-

servern – bei Domino auch im Dateisystem abgelegt werden, doch noch viel interessanter ist die Verwendung von Domino-Datenbanken. Diese sind darauf ausgelegt, unstrukturierte Inhalte aller Art zu verwalten, und haben dem herkömmlichen Dateisystem gegenüber Vorteile wie das fein granulierte Sicherheitskonzept, Replikation und automatische Indizierung.
Wiederverwendung durch Schablonen und gemeinsame Elemente: Eine

Schablone ist das Gerüst einer Domino-Datenbank. Sie ermöglicht zum einen den Aufbau eines Repository von Gestaltungselementen und vereinfacht zum anderen die Verteilung von Anwendungen. Darüber hinaus sind im Lieferumfang von Domino eine Reihe von Schablonen enthalten, die bereits fertige Anwendungen darstellen, z.B. eine Diskussionsdatenbank und eine Dokumentenverwaltung.

Anwendungsentwicklung mit Domino

41

Auch auf der Ebene einer einzelnen Datenbank wird Wiederverwendung großgeschrieben: Eine Reihe von Gestaltungselementen (sogenannte gemeinsame Elemente) unterstützen explizit den Einsatz in unterschiedlichen Situationen.
Plattformunabhängigkeit und Offenheit: Lotus verhält sich im ewigen Krieg

zwischen verschiedenen Technologien und Plattformen nach eigener Aussage höchst pragmatisch: Sind Sie ein eingeschworener Java-Entwickler? Kein Problem. Sind Sie mit COM/DCOM aufgewachsen? Sie können gleich loslegen. Sie mögen UNIX/Host, aber kein Windows/OS400? Wie es Ihnen gefällt. Kurz: wenn sich eine Technologie/Plattform am Markt behaupten kann, dauert es nicht lange und sie wird auf die eine oder andere Weise in das Domino-Konzept integriert. Vom religiösen Fanatismus einiger anderer Hersteller gibt es bei Lotus trotz oder gerade wegen der Affinität zu IBM keine Spur. Jüngste Beispiele für vielversprechende Technologien, die in Domino integriert werden, sind: Macromedia Shockwave, Internet Information Server, COM/DCOM, CORBA und, und, und ...
Internet-Kompatibilität: (Fast) alles, was Sie mit Domino tun können, können

Sie auch im Internet tun. Sprich: Alle Domino-Funktionalitäten können (mit geringen Einschränkungen) auch in Internet-Clients genutzt werden. Dies bedeutet für Sie als Anwendungsentwickler ein breites Spektrum an Funktionen und Schnittstellen, die die Grundlage für unterschiedliche Arten von dynamischen Internet-Anwendungen bieten, deren Funktionalität über die klassische Kombination »statische HTML-Seiten und CGI« weit hinausgeht.
Integration mit externen Werkzeugen: Seit der Version 6 besteht im Domino

Designer die Möglichkeit, externe Werkzeuge, die im Rahmen der Anwendungsentwicklung verwendet werden, direkt in die Entwicklungsumgebung einzubinden. So kann man als Entwickler unterschiedliche Editoren, Werkzeuge zu Performance-Analysen u.a. direkt aus der Domino-Entwicklungsumgebung aufrufen.

1.4.2

Programmierkonzepte von Notes

Was unter frischgebackenen Domino-Entwicklern häufig für Verwirrung sorgt, ist, dass es grundsätzlich mehrere Möglichkeiten gibt, Anwendungen im DominoUmfeld zu entwickeln. Bei der Auswahl einer der nachstehend aufgeführten Alternativen sollten grundsätzlich Kriterien wie Einfachheit, Portabilität, Ablaufgeschwindigkeit, Wartungsaufwand und notwendiger Schulungsaufwand in Betracht gezogen werden.

IBM SOFTWARE PRESS

42

Domino: Einführung und Überblick

Mächtigkeit und Flexibilität

APIProgrammierung

Java JavaScript/ LotusScript

Notes-Formeln

Einfache Aktionen

Erforderliche Programmierkenntnisse Abbildung 1.8 Programmierkonzepte in Lotus Notes/Domino

Die in Abbildung 1.8 dargestellten Entwicklungsmethoden lassen sich in zwei Gruppen aufteilen: native Domino-Methoden (einfache Aktionen, Formeln, JavaScript, LotusScript und Java) sowie externe Methoden, bei denen die Entwicklung außerhalb der Entwicklungsumgebung von Notes erfolgt, wie im Falle der API-Programmierung. Wir wollen im Folgenden nur die nativen Methoden einer näheren Betrachtung unterziehen. Einfache Aktionen Bei einfachen Aktionen handelt es sich um vordefinierte Bausteine, aus denen sich teilweise recht komplexe Befehlssequenzen mit wenigen Mausklicks zusammenstellen lassen. So können Sie mit einfachen Aktionen beispielsweise ausgewählte Dokumente löschen, verschieben oder senden, Feldwerte verändern oder Hintergrundabläufe – sogenannte Agenten – starten. Einfache Aktionen richten sich aufgrund des leicht verständlichen Umgangs mit ihnen in erster Linie an Endbenutzer, lassen sich jedoch auch im Rahmen der professionellen Anwendungsentwicklung zeitsparend einsetzen. Mehr über einfache Aktionen erfahren Sie im Kapitel 14 über die Automatisierung von Anwendungen. Notes-Formeln Notes-Formeln lassen sich in etwa mit dem Konzept eines programmierbaren Taschenrechners vergleichen: Sie erlauben die Auswertung von einfachen bis hin zu sehr komplexen Ausdrücken und ermöglichen darüber hinaus die Ausführung von Notes-spezifischen Befehlen. Einige Sprachkonstrukte rücken das Formelkon-

Anwendungsentwicklung mit Domino

43

zept in die Richtung einer »richtigen« Programmiersprache. Beispielsweise lassen sich mit Formeln Wenn-dann-Bedingungen und sogar einfache strukturierte Programmierung verwirklichen. Weitere Informationen über Notes-Formeln finden Sie im Kapitel 16 über die Einführung in die Formelsprache. LotusScript Im Gegensatz zu Notes-Formeln ist LotusScript eine waschechte Programmiersprache. Es handelt sich hierbei um ein objektorientiertes Basic-Derivat, das, mit einer Fülle von Notes-spezifischen Klassen ausgestattet, sehr umfangreiche Möglichkeiten zur Manipulation von Notes-Ressourcen bietet. LotusScript unterstützt zwei Programmierparadigmen: Zum einen lassen sich ohne Weiteres Anwendungen im Sinne der strukturierten Gestaltung entwickeln, zum anderen unterstützt LotusScript das Konzept der Objektorientierung. Hinsichtlich der Einhaltung des Letzteren ist LotusScript jedoch bei Weitem nicht so streng wie etwa Smalltalk oder Java und lässt sich somit nur bedingt als »pure« Objektsprache bezeichnen. Weiterhin bildet LotusScript die Grundlage für die fortgeschrittene Kommunikation zwischen Notes und eingebetteten Anwendungen (OLE). Mehr Informationen zu LotusScript finden Sie im Kapitel 18 über die Einführung in LotusScript. JavaScript JavaScript stellt eine Art lingua franca der Scripting-Sprachen im Web dar. Sie bietet eine bequeme Möglichkeit, einen bestimmten Teil der Webanwendung (z.B. die Überprüfung der Feldeingaben) nicht, wie üblich, auf der Server-, sondern auf der Client-Seite auszuführen und somit den Server zu entlasten. Trotz ihrer unangefochtenen Popularität im Web führte die Sprache bis zur Notes/Domino-Version 4.6 eher ein Schattendasein – der JavaScript-Code konnte nämlich nur als sogenannter Durchgangs-HTML-Code »durchgeschleust« werden, was zwar für einen geübten Entwickler nicht allzu schwer, jedoch bisweilen recht unübersichtlich war. Seit der Version 5.0 wurde JavaScript zum festen Bestandteil der Entwicklungsumgebung des Domino Designers1. Dies bedeutet, dass die Verwendung von Durchgangs-HTMLCode für diesen Zweck entfällt. Vielmehr können in der Entwicklungsumgebung des Domino Designers bequem zu jedem einzelnen Seitenelement die betreffenden JavaScript-Codefragmente direkt eingegeben werden. Die Entwicklungsumgebung unterstützt hierbei den Programmierer durch die automatische Anzeige der relevanten Events, die Syntax-Prüfung, die farbliche Kennzeichnung des Codes sowie durch einen Referenzbrowser zur Anzeige des Domain-Object-Modells. Darüber hinaus ist der Notes-Client nun ebenfalls in der Lage, den JavaScript-Code auszuführen. Dies spart Entwicklungszeit – da man nun für beide Clients nur noch eine Codebasis entwickeln muss. Einige interessante Möglichkeiten bietet JavaScript insbesondere auch in Verbindung mit Java. Die sogenannte LiveConnectSpezifikation von Netscape, die nun neben Microsoft Internet Explorer und Netscape Navigator unterstützt wird, ermöglicht den Zugriff auf alle öffentlichen Methoden eines in der Seite eingebetteten Java-Applets, analog zur Steuerung von ActiveX-Controls mit LotusScript im bisherigen klassischen Notes-Umfeld. 1

Die unterstützte Sprachversion ist JavaScript 1.3 (Lotus lizenzierte den JavaScript-Interpreter von Netscape). Das unterstützte Domain-Object-Modell ist eine Teilmenge von HTML 4.0.

IBM SOFTWARE PRESS

44

Domino: Einführung und Überblick

Der Nachteil von JavaScript ist vor allem darin zu sehen, dass unterschiedliche Browser recht unterschiedliche JavaScript-Dialekte »sprechen«. Dies betrifft nicht nur die Sprache selbst, sondern insbesondere das ihr zugrunde liegende DocumentObject-Modell (DOM). Hier hat man mit LotusScript (insbesondere im NotesUmfeld) nach wie vor die besseren Karten in der Hand. Java Java ist eine plattformunabhängige objektorientierte Sprache zur Entwicklung von netzwerkorientierten Anwendungen. Die Architektur der Sprache sowie einige Features der Laufzeitumgebung machen Java insbesondere für den Einsatz im Internet interessant, und zwar sowohl auf der Client- als auch auf der Server-Seite: Auf der Client-Seite können Java-Programme in Form sogenannter Applets auftreten, d.h. als kleine Anwendungen, die nur innerhalb einer dedizierten Laufzeitumgebung ablauffähig sind (z.B. ein Webbrowser), oder aber als Stand-alone-Anwendungen, wobei in diesem Fall die Laufzeitumgebung durch den Java-Interpreter java bereitgestellt wird. Auf der Server-Seite gilt Analoges: Zum einen können Java-Anwendungen die Form von Servlets annehmen. Diese sind das server-seitige Pendant zu Applets, d.h., sie sind nur im Kontext eines Webservers ablauffähig und erweitern diesen um zusätzliche Funktionen. Auch auf der Server-Seite besteht selbstverständlich die Möglichkeit, Stand-alone-Java-Anwendungen auszuführen. Ferner kann auf der ServerSeite Java eingesetzt werden, um Notes-Agenten zu programmieren. Mehr Informationen zu Java finden Sie in den entsprechenden Kapiteln 21-23. Notes-APIs Die Notes-APIs ermöglichen eine plattformübergreifende und (weitgehend) versionsunabhängige Methode des Zugriffs auf die Funktionalität von Notes/Domino. Darüber hinaus stellen die Notes-APIs die einzige Möglichkeit dar, die Funktionalitäten von Notes/Domino auch von C/C++-Programmen aus anzusteuern, was insbesondere für bestimmte Low-Level-Anwendungen von Vorteil ist. Es gibt drei Notes-APIs:
Notes C-API – kurz und bündig formuliert: Die C-API ist Notes. Genauer gesagt:

Sie legt einen großen Teil der Notes-Funktionalität in Form von mehr als 900 C-Funktionen offen und ermöglicht somit auch die Entwicklung von Standalone-Anwendungen, die die Funktionalitäten von Notes nutzen, ohne dass Notes selbst laufen muss1.
HiTest C-API: Ursprünglich vom Unternehmen Edge Development entwickelt,

baut diese API auf der Notes C-API auf, ist allerdings eine Abstraktionsebene höher angesiedelt und objektorientiert aufgebaut, was für den Notes-Programmierer zunächst einmal weniger Funktionen bedeutet, aber naturgemäß auch mit Performance-Einbußen verbunden ist. Die Unterstützung der HiTest C-API wurde zum Release 6 hin beendet.
Notes C++ ist ebenfalls objektorientiert, jedoch im Vergleich zur HiTest-API in

C++ entwickelt. Die API umfasst etwa 200 Klassen. 1

Notes muss allerdings installiert sein.

Anwendungsentwicklung mit Domino

45

Tabelle 1.2 enthält eine Zusammenfassung der Notes-APIs. API

Sprache

Plattformen

Anzahl Klassen/ Funktionen

Notes C-API

C

Alle

ca. 500

HiTest C-API (bis Release 5)

C (objektorientiert)

Windows, OS/2, UNIX