Skip to main content

Lotus Notes and Domino 6 Programming Bible

Lotus Notes and Domino 6 Programming Bible

Brian Benz, Rocky Oliver

ISBN: 978-0-764-52611-4

May 2003

1032 pages

Select type: Paperback

Product not available for purchase


* Covers all the programming techniques, concepts, and languages used with Notes and Domino, as well as the many new features of Domino 6
* Thoroughly examines the Notes and Domino role with Java, XML, Web services, and other IBM products and technologies
* Provides extensive code and examples, many geared to the needs of administrators
* High-profile authors, known to their audience through conferences and articles
* Companion Web site shows example applications from the book running on a live Domino server and provides code download


Part I: Introduction to Lotus Notes and Domino.

Chapter 1: The History of Notes and Domino.

Chapter 2: A Simple Application.

Chapter 3: The Notes Storage Model.

Chapter 4: Application Building Blocks.

Part II: Domino Designer.

Chapter 5: The Designer IDE.

Chapter 6: Managing and Deploying Application Projects.

Chapter 7: Standard Templates.

Part III: Application Architecture.

Chapter 8: Page and Form Basics.

Chapter 9: Views and Folders.

Chapter 10: Database Security.

Chapter 11: Framesets and Outlines.

Chapter 12: Advanced Form Design.

Chapter 13: Database Properties.

Chapter 14: Sharing Code with Libraries.

Part IV: Automating Applications.

Chapter 15: Formulas In Forms and Views.

Chapter 16: Actions, Buttons, and Action Hotspots.

Chapter 17: Form, View, and Database Events.

Chapter 18: Agents.

Chapter 19: Web Applications.

Chapter 20: Mail-Enabled Applications.

Chapter 21: Document Security.

Chapter 22: Workflow Management.

Part V: Formula Language Techniques.

Chapter 23: Introduction to the Formula Language.

Chapter 24: Working with @Functions.

Chapter 25: Introduction to @Commands.

Chapter 26: Using the Formula Language to Retrieve Data.

Chapter 27: User Interaction through the Formula Language.

Chapter 28: Advanced Formula Techniques.

Part VI: LotusScript Language Techniques.

Chapter 29: Introduction to LotusScript.

Chapter 30: Working with the Domino Object Model in LotusScript.

Chapter 31: Advanced LotusScript Techniques.

Part VII: Java Techniques.

Chapter 32: Java and Domino Designer.

Chapter 33: Java Classes and Methods.

Chapter 34: Accessing Domino from Java Applications.

Chapter 35: Java Servlets for Domino.

Chapter 36: Java Servlets Using Third-Party Developer Tools.

Chapter 37: Domino Custom JSP Tags.

Chapter 38: Domino and WebSphere.

Part VIII: JavaScript Techniques.

Chapter 39: JavaScript Basics.

Chapter 40: Using JavaScript Events.

Chapter 41: DHTML and Domino.

Chapter 42: Combining Domino and Java Applets Using JavaScript.

Part IX: Relational Database Integration.

Chapter 43: Integrating Enterprise Data with Domino Applications.

Chapter 44: Developing Domino Applications for Data Integration.

Chapter 45: LEI Retrievals and Updates.

Part X: XML.

Chapter 46: XML and Domino.

Chapter 47: XML, DXL, and Domino Data.

Chapter 48: LotusScript and XML.

Chapter 49: Using Domino to Serve Relational XML.

Chapter 50: Developing Java Applications with XML and Domino.

Chapter 51: Generating XML with Domino Java Agents and Servlets.

Chapter 52: Getting XML into Domino.

Chapter 53: Transforming XML with XSLT.

Chapter 54: XML Data Islands.

Part XI: Web Services.

Chapter 55: Web Services Introduction.

Chapter 56: SOAP, WSDL, and UDDI.

Chapter 57: Serving Web Services from Domino.

Chapter 58: Consuming Web Services in Notes Client Applications.


Download Chapter 2 Code in ZIP format

You will need a program like WinZip or WinRAR to decompress the files to your hard drive.

Download Chapter 9 in ZIP format
Download Chapter 12 Code in ZIP format
Download Chapter 14 Code in ZIP format
Download Chapter 15 Code in ZIP format
Download Chapter 16 Code in ZIP format
Download Chapter 17 Code in ZIP format
Download Chapter 19 Code in ZIP format
Download Chapter 20 Code in ZIP format
Download Chapters 21 and 22 Code in ZIP format
Download Chapters 29 and 30 Code in ZIP format
Download Chapter 31 Code in ZIP format
Download Chapter 33 Code in ZIP format
Download Chapter 34 Code in ZIP format
Download Chapter 35 Code for Diagnostic Servlet in ZIP format
Download Chapter 35 Code for Java Servlet in ZIP format
Download Chapter 35 Code for Newsletter Distribution in ZIP format
Download Chapter 37 Code in ZIP format
Download Chapter 39 Code in ZIP format
Download Chapter 40 Code in ZIP format
Download Chapter 41 Code in ZIP format
Download Chapter 42 Code in ZIP format
Download Chapter 43 Code in ZIP format
Download Chapter 45 Code in ZIP format
Download Chapter 47 Code in ZIP format
Download Chapter 48 Code in ZIP format
Download Chapter 49 Code in ZIP format
Download Chapter 50 Code in ZIP format
Download Chapter 51 Code in ZIP format
Download Chapter 52 Code in ZIP format
Download Chapter 53 Code in ZIP format
Download Chapter 57 Code in ZIP format

Welcome to the Companion Web Site

Welcome to the Lotus Notes® and Domino 6 Programming Bible Web Site!
The Lotus Notes® and Domino 6 Programming Bible is a collaboration between Brian Benz and Rocky Oliver, two well-known Notes and Domino professionals.

The book is a comprehensive guide to programming concepts and techniques for Lotus Notes and Domino 6. It covers advanced programming techniques used in the development of Notes and Domino applications. Brian and Rocky weave together concept explanations, working examples, and reference information in a logical progression, from basic concepts to advanced topics.

The material in the book is therefore useful for all developer skill levels, from beginning to advanced. The material does not assume any previous exposure to Notes and Domino, but the presentation of the examples and techniques is not “dumbed down” either. The authors understand the fundamental concepts of Notes and Domino better than most advanced developers, and they have extensive experience writing about and teaching these topics. They make the material understandable for beginners while at the same time “shedding new light” on it for experienced professionals.

The book makes extensive use of examples, which are — as much as possible — constructed incrementally. In other words, examples build on one another within a chapter, as well as across chapters. By following the examples, readers see several applications developed from scratch, with illustrative features added in contexts that are themselves instructive. Some of the examples are provided in the context of “toolbox” applications, and many of the tools will be of interest to Domino Administrators as well as developers.

The Introduction will tell you more information about how the book and the site are structured. Parts I-V and Part VI-XI list the description and outline for each chapter of the book. Downloads, examples, and updates are also available.

About the Authors

About the Authors
Brian Benz, CLI, PCLP, has more than 15 years of experience designing and deploying systems infrastructures, designing and developing applications, migrating messaging systems and applications, and managing projects. He has established his expertise and reputation in the Domino, Web, and e-business application development marketplace since 1992 through hands-on experience in various projects and by making frequent contributions as a writer for industry publications, including the IBM Redbook XML: Powered by Domino, Lotus Notes and Domino 6 Programmer's Bible, Lotus ADVISOR, e-Business ADVISOR, WebSphere ADVISOR, and e-Pro magazine. He is also a frequent presenter of technical seminars for IBM, Advisor Media and the View at venues worldwide. Brian is CEO of Benz Technologies (, and a proud member of the Penumbra Group ( Brian's speaking engagements include IBM DeveloperWorks Live 2002 and 2003, Lotusphere 2001, 2002, and 2003, Lotus ADVISOR and WebSphere ADVISOR developer conferences, and View conferences worldwide since 1998.

Rocky Oliver, PCLP, is a wizened veteran of Lotus technologies. Rocky began his Lotus geek existence with Lotus Development's Word Processing Division in 1992. Since then, he has led the development team of a large, national consultancy, opened a new branch for a startup, started his own company, and along the way found time to conceive five great kids (with a little help from his wife, of course). Rocky is the founder of Sapphire Oak Technologies (, a collaborative technology consultancy that is a member of the Penumbra Group ( Rocky co-authored Teach Yourself LotusScript for Notes/Domino 4.6 (MIS Press, 1997). He is also a writer for WebSphere ADVISOR and a technical editor and writer for Lotus ADVISOR magazine, as well as serving on their Advisory Board. Rocky loves to share his knowledge and experience by speaking often at Lotus technology conventions, including Lotusphere, IBM DeveloperWorks Live, and ADVISOR Devcon, as well as conferences in Europe such as DNUG. You can reach Rocky at


The book begins with a chapter that provides an overview of the book’s format, followed by a What is Notes and Domino?” chapter that discusses the technology, its purposes, its positioning against other technologies, and its history. The next chapter shows a very simple application. The next two chapters provide a detailed look at storage and programming components of a Notes database. We've broken the content up into two sections: Parts 1-5 and Parts 6-10. Parts 1-5 contain Chapters 1-28 and Parts 6-11 contain Chapters 29-58.

Parts I-V

Parts I-V

Part I — Introduction to Lotus Notes and Domino.

In Part I, we provide a general introduction to Lotus Notes and Domino. We briefly cover the history and evolution of the products and their uses. Next, we describe a very simple Notes and Domino application. We introduce the NSF file, which is the foundation of all Notes and Domino applications. Finally, we briefly describe the building blocks that Notes and Domino developers put into NSF files to create applications.

Chapter 1 — The History of Notes and Domino
by Richard Schwartz

This chapter describes Notes and Domino, focusing in particular on their history, what they are used for, their positioning in the market, and Release 6.


  • The Notes vision
  • Realizing the vision
  • The evolution of Notes into Domino
  • Notes and Domino 6

Chapter 2 — A Simple Application
by Richard Schwartz

Download the example files

This chapter describes how to create a simple "Hello World" application with one form, one computed field, one editable field, and one view.


  • The purpose of this example
  • Creating the application
  • Creating a form
  • Creating a view
  • Creating a page
  • Setting the application’s home page
  • Testing the application

Chapter 3 — The Notes Storage Model
by Richard Schwartz

This chapter describes the concept of the server or local database, NSF files, replica ids, notes, types of notes; ACL notes; data notes; design notes, forms versus documents; unids; note ids; finding notes; collections (view, folder, search), rep/save conflicts; items; items versus fields; data types; rich text; paragraphs; sections; tables; objects; attachments.


  • The NSF file
  • Inside the NSF
  • Finding a note
  • Inside a note

Chapter 4 — Application Building Blocks
by Rocky Oliver

Domino databases are made up of data, and many design elements enable you to build applications that work with that data. Over the years, more of these design elements, such as Web-enabled databases, data integration, and so on, have been added to the database structure to support the ever-changing demands of the market. This chapter introduces you to these application building blocks, providing a brief introduction to each element.


  • Introducing design elements
  • Understanding data entry and display elements
  • Working with navigation elements
  • Working with code elements
  • Working with resource elements

Part II — Domino Designer

The second part covers the Domino Designer program. One chapter provides a walk-through of the Integrated Development Environment features for developing each type of design element. Another chapter discusses how to organize projects in the Designer and manage templates.

Chapter 5 — The Designer IDE
by Brian Benz

In earlier versions of Lotus Notes, user and designer components were built into the same client software. With the release of Lotus Domino R5, and extended with Domino 6, Domino Designer has been a separately installable, separately executable product. With Domino Designer, developers now have separate end-user and developer environments, each organized for efficiency of the task-at-hand. This chapter presents the major elements of the Designer IDE to alert you to all its features and their functions.


  • Navigating the Designer IDE
  • Domino design elementsCoding and debugging features
  • Sharing resources
  • Developing Domino applications using Web
  • DAV-compliant tools
  • DXL utilities
  • Previewing your design

Chapter 6 — Managing and Deploying Application Projects
by Richard Schwartz

Most programmers are used to working with a development environment that organizes projects containing source files, object files, and executable files. Programmers who work with the Notes C and C++ APIs do work this way, but most Notes and Domino development doesn’t use those tools. So, for the most part, source files, executables, and separate data files or database systems are foreign concepts to Notes and Domino programmers. This chapter explains the concepts with which Notes and Domino work to organize projects and deploy applications.


  • Understanding projects, applications, and databases
  • Using templates
  • Working on multidatabase projects
  • Working on a development team
  • Deploying applications

Chapter 7 — Standard Templates
by Richard Schwartz

Notes and Domino provide powerful tools for the development of custom applications. Many Notes and Domino users, however, are totally unaware of this fact. They know only that their company uses Notes and Domino for e-mail, calendaring, and address books. Others know only that it provides e-mail and online discussion facilities. What they don’t know is that IBM engineers have built all the most popular features of Notes and Domino using the same programming tools that are available to every Notes and Domino programmer for custom applications.The features of Notes and Domino that end-users know best and that are responsible for much of the popularity of the products are built from ordinary Notes and Domino templates. Every Notes and Domino programmer can examine those templates to learn how those features work.Notes and Domino ship with more than 30 different template files. Many are employed in system administration tasks and are unfamiliar to most users, while others are extremely useful for learning how to develop your own applications.This chapter briefly describes the templates that are most familiar to end users: the Mail template, the Personal Address Book template, the Discussion template, and the Document Library templates.


  • Using a Mail template
  • Using the Personal Address Book template
  • Using the Discussion template
  • Using the Document Library templates

Part III — Application Architecture.

The third part covers the structural elements of a Notes and Domino application. Chapters cover views, database security, navigational design elements, advanced form design, database launch and other properties, and sharing code through subforms, shared fields, and code libraries.

Chapter 8 — Page and Form Basics
by Richard Schwartz

Pages and forms are design elements used to create formatted data displays in Notes and Domino. If you are familiar with HTML, it is important to understand that it was invented after Notes, so some Notes and Domino terminology does not match up precisely with what most Web programmers would expect. In HTML, a form is a portion of a page that can contain input elements. In Notes and Domino, a form is a design element used for displaying data from documents and entering new data into documents, and a page is a design element used only for displaying data. Pages are typically used for displaying online help, for menus used to navigate through the features of an application, or for lists of links. This chapter introduces you to the basics of creating pages and forms, and explains how to use them to build your Domino applications.


  • Creating pages
  • Creating forms
  • Formatting text on pages and forms
  • Data access through fields on forms

Chapter 9 — Views and Folders
by Rocky Oliver

Download the example files

Views and folders provide a robust way to display groups of documents ordered in a meaningful way. But views provide more functionality than just viewing documents. Views are often used as the starting point for workflow automation, for programmatically accessing documents, for providing calendar-based grouping of documents, and for much more. Views are one of the most powerful design elements in a Domino database, and this chapter introduces you to some powerful techniques for getting the most out of your views.This chapter will not teach you the basics of building a view — that’s what the Domino 6 Designer Help is for. What this chapter does do is build upon that help file and the basics it teaches, and helps you get the most out of your views and folders in both your Notes and Web-based applications.


  • Learning how views work
  • Optimizing your viewsMaking views more powerful than ever

Chapter 10 — Database Security
by Rocky Oliver

One of the cornerstones of Lotus Notes and Domino is security. Unlike other applications, where security is an obvious afterthought, Notes/Domino is built from the ground up with a rock-solid security infrastructure in place. This chapter helps you understand this security structure and what it means to your applications. You are introduced to server security, database security, and document security.


  • Security starts at the server
  • The database ACL
  • Document-level access
  • Field-level encryption(Non)security through obscurity
  • Plan your security from the beginning

Chapter 11 — Framesets and Outlines
by Brian Benz

Outlines and framesets augment the Menu and Action Bar navigational features that are built into Notes client, and add more options for control and display of an application UI, especially on the Web. This chapter focuses on the capabilities of using framesets and outlines in Notes client and Web applications, as well as tips, tricks, drawbacks, and alternatives for each feature.


  • About Navigators
  • Introduction to framesets and outlines
  • Outlines Framesets
  • Domino Web Application Navigation using outlines and framesets

Chapter 12 — Advanced Form Design
by Rocky Oliver

Download the example files

Chapter 8 introduced you to the basics of designing a form. This chapter shows you how to take your form design to the next level, helping you exploit forms in ways you may never have imagined. This chapter exposes you to various design elements that you can use with forms. Some practical uses are provided as examples, which are broken down so you can use these techniques in your applications.


  • Element integration overview
  • Tables Sections Hide-whens Layers Buttons and action hotspots
  • Form actions Image resources Embedded views
  • Advanced form design examples

Chapter 13 — Database Properties
by Richard Schwartz

Developing Notes and Domino applications is not just a matter of designing pages, forms, views, and other design elements. As discussed in Chapter 10, security settings are another important part of the application. In this chapter, you examine many other database-wide settings that help determine aspects of an application’s behavior. The database properties dialog provides a wealth of information about your database, and allows you to customize many of its behaviors.


  • Applying database settings
  • Accessing storage information
  • Exploring print settings
  • Exploring design settings
  • Exploring launch settings
  • Exploring full-text search settings
  • Exploring advanced settings

Chapter 14 — Sharing Code with Libraries
by Rocky Oliver

Download the example files

Script libraries are one of the most handy design elements in Lotus Notes and Domino. Script libraries enable you to reuse code in multiple design elements throughout your database application. Three types of script libraries exist: LotusScript libraries, JavaScript libraries, and Java libraries. This chapter doesn’t cover all the basics of using a LotusScript library — that discussion is covered in the Domino 6 Designer help. This chapter concentrates on more useful techniques for creating and using LotusScript libraries, and provides examples along the way.


  • Tips for creating a LotusScript library
  • Going deep instead of wide
  • Segmenting your libraries
  • Commenting your libraries
  • Chaining librariesExamples

Part IV — Automating Applications.

The fourth part covers programmable elements of an application. Individual chapters are devoted to field formulas, actions and events of various types, agents, Web programming, e-mail integration, security, and workflow. The actual programming shown in examples within this part is fairly simple, but it illustrates all the major components and built-in capabilities of the Notes and Domino environment.

Chapter 15 — Formulas in Forms and Views
by Rocky Oliver

Download the example files

The Formula language is extremely powerful, as discussed in Part V. This chapter concentrates on the various places you can use the Formula language in forms and views. You also learn helpful tips and techniques for using the Formula language in your forms and views to get the most out of your applications.


  • Using Formulas in forms
  • Formulas in form events
  • Formulas in fields
  • Miscellaneous uses
  • Formulas in views
  • Formulas in view events
  • Column formulas
  • Hide-when formulas

Chapter 16 — Actions, Buttons, and Action Hotspots
by Rocky Oliver

Download the example files

A user can execute a predefined set of code by clicking an action button (otherwise known as an action), a button, or an action hotspot. Actions are available in forms and views, while buttons and action hotspots are available in forms and pages. Each item is an agent that you call by clicking it instead of choosing it from a menu. What you can do in an agent, you can do in an action or button. You can use each of these items in various ways, many of which are described in this chapter. Actions and buttons can contain simple actions, LotusScript, formulas, and JavaScript. Additionally, in Notes/Domino 6 you can place client-specific code in each — one set of code for the Notes client and one set of code for Web browsers. Most examples in this chapter use the Formula language because it is the easiest to use; however, many examples in the book use other languages. The Bubba's Shrimp Ordering System example in Chapter 12 makes extensive use of LotusScript.


  • Action buttons
  • Using action buttons in forms
  • Using action buttons in views
  • Buttons and action hotspots

Chapter 17 — Form, View, and Database Events
by Rocky Oliver

Download the example files

An event occurs when an object, such as a form, does something. In object-oriented programming (OOP) languages such as LotusScript, there are places to put code that is executed when an event occurs, usually before (Query) or after (Post) the event takes place. Therefore, you can write code in these Query and Post events, and that code is executed before and/or after the event occurs, respectively. This chapter explains why events are important and what you can do with them. An entity known as an object model represents the contents of a database. An object model is a way to represent the data of a database as things, or objects, that you can access and work with. These objects include ways to access the data in the object (through properties) and ways to take action against the object (through methods). Objects that exist in the UI also perform actions — they are opened, closed, refreshed, saved, and so on. When an object does something, it’s an event. You sometimes have the opportunity to bind code to these events, either right before or right after the event occurs. Creating an application that performs based on when object events happen is known as event-driven programming. LotusScript, JavaScript, and Java are object-oriented languages that are used in event-driven programming. Even the Formula language is event-driven (though it really isn’t an object-oriented language), as you can use formulas in events as well as the other languages mentioned.


  • Understanding form events
  • QueryOpen
  • PostOpen
  • QueryModeChange,PostModeChange
  • QueryRecalc, PostRecalc
  • QuerySave, PostSave
  • QuerySend, PostSend
  • QueryClose
  • Understanding view events
  • New event:
  • InViewEditDatabase events
  • PostOpen
  • QueryDocumentDelete, PostDocumentDelete
  • QueryDocumentUndelete
  • QueryDragDrop, PostDragDrop
  • QueryDropToArchive, PostDropToArchive

Chapter 18 — Agents
by Rocky Oliver

Agents are small, mini-programs that you can create in Notes and Domino to perform tasks. An agent can be initiated by a user, scheduled, triggered when a certain event occurs, or initiated from a browser. Agents can run on the server or run locally, and can run as the person who called it or the person who last saved it. Agents are an extremely powerful component of Notes and Domino development.This chapter introduces you to various agent parameters, types, and uses. Tips and tricks are provided along the way, as well as cross-references to other examples in the book. It concentrates on agents in the Notes client and from a server. As always, this chapter is not meant to rehash the material in the Domino 6 Designer help; it simply offers some insight into the use of agents and provides some tips for their usage.


  • Understanding agents
  • Front-end versus back-end
  • Setting agent permissions
  • Understanding agent targets
  • Setting agent triggers
  • Location, location, location
  • Agents that execute from the Notes client
  • Agents that execute based on an event
  • Agents that execute on a schedule
  • Agents executed from a Web browser
  • Logging errors and troubleshooting
  • Agent testing
  • Agent logging
  • Remote debugging
  • Agent troubleshooting references

Chapter 19 —Web Applications
by Brian Benz

Download the example files

Because of Domino's advanced container model that naturally organizes and manages unstructured data, collaborative application capabilities, integrated development environments, and support for e-mail integration, Domino is a natural choice for a Web application server. This chapter introduces Domino’s advanced Web capabilities by demonstrating Domino features for collaborative Web applications and Web sites and illustrates these features by starting to develop the prototype Web site that is used throughout the rest of the book.


    • Introducing the Web site prototype
    • Using Web design elements
    • Understanding Web navigation
    • Understanding Web page display
    • Understanding Web data entry
    • Using shared fields

Chapter 20 —Mail-Enabled Applications
by Brian Benz

Download the example files

Aside from the integrated Domino Designer application development environment outlined in Chapter 5, and the ability to organize unstructured data into Web applications covered in Chapter 19, Domino has another important feature that makes it a world-class application platform: easy e-mail integration. In this chapter, we cover the advanced e-mail integration options for Domino and Web applications, including creating and managing mail-in applications and generating e-mail newsletters. Developers will learn how to add an opt-in e-mail list to a Domino Web site, how to create an application to manage subscriptions, changes, and removals from the e-mail list, and how to develop an application to organize and distribute e-mail newsletters.


  • Options for e-mail integration
  • E-mail options for forms
  • Simple actions for sending e-mail
  • E-mail options for @functions
  • E-mail options using LotusScript
  • E-mail options using Java Example:
  • An e-mail newsletter mailing application

Chapter 21 — Document Security
by Rocky Oliver

Download the example files for chapters 21 and 22.

Notes/Domino is one of the most secure applications available for storing, sharing, and working with sensitive information. Chapter 10 reviewed database security and mentioned document security. Because you store your information in documents, documents have the most security options available. This chapter helps you better understand the options available for securing your information.


  • Reviewing database security
  • Choosing document-level access
  • Understanding author and reader names fields
  • Encrypted fields
  • Document locking

Chapter 22 — Workflow Management
by Rocky Oliver

Download the example files for chapters 21 and 22.

Notes and Domino make a great container for information. Notes has many tools available out of the box that help you work with, manipulate, and manage your information. But you may want to extend the interaction with the user from just the things that a user initiates to an exchange between the user and the application, even to the point where the application initiates the interaction. A great deal of the power of Notes/Domino resides in its ability to initiate an interaction with a user — routing documents or informing users about things going on with their information in an application. In short, one of the strengths of Notes/Domino is its ability to create and manage automated workflow in an application.This chapter introduces you to two types of workflow in an application, and then provides an example application that you can play with and examine to gain ideas for your own applications.


  • Understanding workflow concepts
  • Understanding approval workflows
  • Using document locking
  • Integrating workflow: An example

Part V — Formula Language Techniques.

Part V covers the Formula language, which was the original programming language for Notes versions 1, 2, and 3.

Chapter 23 — Introduction to the Formula Language
by Rocky Oliver

Lotus Notes provides a rich set of programming tools in an integrated environment. The release of Notes/Domino 6 has added to that toolkit by enhancing existing tools or languages, such as LotusScript and Java, and new tools have also been added, such as integrated XML support. With the variety of choices available, it is easy to overlook the venerable granddaddy of Notes programming languages, the Formula language. But overlooking the Formula language as an integral part of your toolkit is a mistake. This chapter introduces you to the Formula language, explains the basics of its use, and shows you some advanced techniques for enhancing your Notes/Domino applications. The remaining chapters in Part V expand your knowledge of the Formula language


  • The Formula language defined
  • Why use the Formula language?
  • Where and when to use the Formula language

Chapter 24 — Working with @Functions
by Rocky Oliver

@Functions are the core components of the Formula language. In fact, they were the first components of the Formula language, and originally the only components. Beginning with a simplistic 93 core @Functions in Notes Version 1 — all of which are still usable today — the Formula language in Notes/Domino 6 now includes 256 documented @Functions. Now, we’re not going to attempt to cover all of them here (that’s what the Help file is for); however, you will be introduced to programming techniques for getting the most out of @Functions, and you will be introduced to some of the more useful @Functions. Subsequent chapters in this section dive into the details of using particular @Functions for specialized tasks.


  • Working with @Functions
  • Useful @Functions for Notes applications
  • Useful @Functions for Web applications

Chapter 25 — Introduction to @Commands
by Rocky Oliver

Chapter 24 took a fairly deep dive into @Functions. In this chapter, you explore the companions to @Functions in the Formula language, the @Commands. In reality, @Commands are just another type of @Function; however, they are different from other @Functions because virtually all of them are closely tied to things in the user interface (UI). @Commands enable you to take action against things in the UI, and these actions generally map to menus in Notes. This chapter serves as a primer on how to use @Commands in your applications. The chapter introduces techniques for working with @Commands, and then dives into some of the more useful @Commands that are available to you.


  • Working with @Commands
  • Useful @Commands for Notes applications
  • Useful @Commands for Web applications

Chapter 26 — Using the Formula Language to Retrieve Data
by Rocky Oliver

The earlier chapters of Part V introduced you to the Formula language. You learned some general guidelines for use and explored how the Formula language can help you in your development efforts. This chapter delves into some ways you can retrieve and work with data using the Formula language, concentrating on various uses of @DbColumn and @DbLookup. The chapter begins by introducing the basic usage of @DbColumn and @DbLookup for retrieving Notes data, and then explores how to use these two functions to retrieve data from external sources using ODBC.


  • Introducing @DbColumn and @DbLookup
  • Retrieving Domino data using @DbColumn and @DbLookup
  • Retrieving ODBC data using @DbColumn and @DbLookup

Chapter 27 — User Interaction Through the Formula Language
by Rocky Oliver

One of the most useful features of the Formula language is the ability it gives you to interact with users. You have a great deal of flexibility at your fingertips for informing users, gathering information from users, or interacting with users. The three main @Functions used to interact with users are @Prompt, @PickList, and @DialogBox. These functions have many optional parameters, and using them is an art form in and of itself.This chapter introduces you to some useful ways to work with @Prompt, @PickList and @DialogBox, and provides some concrete examples about how to get the most out of them. @Prompt allows you to provide information to a user, or ask the user to enter or choose information. @PickList allows you to use a view as a type of dialog box and enables the user to choose one or more documents. @DialogBox is the most flexible of all — it allows you to use a form as the basis for a dialog box, providing you virtually unlimited customization choices.


  • Working with @Prompt
  • Using @Prompt Programming with @Prompt
  • Programming with @PickList
  • Using @DialogBox

Chapter 28 — Advanced Formula Techniques
by Rocky Oliver

The chapters in Part V introduced you to the power and flexibility of the Formula language. This chapter takes your Formula finesse to a higher level, from the science of Formula language coding to the art of Formula language coding. The chapter starts by introducing you to the new looping features in Notes/Domino 6, and then shows you various ways to enhance your applications.


  • Looping in formulas
  • Working with listsAdvanced techniques for working with @DbColumn and @DbLookup

Parts VI-XI

Parts VI-XI

Part VI — LotusScript Language Techniques.

Part VI covers LotusScript, a scripting language similar to Visual Basic for Applications, which was added in Release 4. Part VI also includes information about working with other desktop applications via COM and OLE, as well as working with the C API from LotusScript.

Chapter 29 — Introduction to LotusScript
by Rocky Oliver

Download the example files.

Even though Lotus Notes was an innovative, flexible, and powerful collaboration platform prior to Release 4, it took a huge step forward with the release and the introduction of LotusScript. Originally introduced in Lotus Improv for Windows (an innovative but misunderstood spreadsheet product) in 1993, Lotus quickly decided to add a common scripting language to all of its products. LotusScript support was added to Lotus Notes Release 4 in January 1996. But what exactly is LotusScript? This chapter introduces you to the LotusScript language, and a couple of the concepts it is built on — object-oriented programming and event-driven programming. You are then introduced to other basic LotusScript concepts, such as syntax, classes, and objects, and the Domino Object Model.


  • Introduction to LotusScript
  • Introducing LotusScript syntax basics
  • Understanding data types in LotusScript
  • Understanding subroutines and functions in LotusScript
  • Using classes and objects in LotusScript
  • Using the LotusScript debugger

Chapter 30 — Working with the Domino Object Model in LotusScript
by Rocky Oliver

Download the example files.

You now have a working knowledge of how LotusScript works, and a basic understanding of classes and objects. This chapter takes that general knowledge and applies it to the LotusScript classes used to define the Domino Object Model.

The Domino Object Model (DOM) is an object model that represents the application programming interface (API). The API provides the interface for working with Domino databases. At its core, it is written in C. The other languages available in Domino — LotusScript, Java, C++, the Formula language, and even JavaScript — all provide higher-level access to the API itself and the object model it represents. Therefore, the features and functions available for working with Domino databases are relatively the same for all programming languages. Of course, some languages offer only a subset of functionality — for example, Java offers access to only the back-end portion of the object model (more on that later) — but the interfaces that do exist between the different languages are all used in relatively the same way, with a few syntactical differences.

The DOM is broken down into two major areas: @ UI, or front-end classes, and data, or back-end classes.


  • Understanding front-end versus back-end classes
  • Basic techniques for working with the Domino Object Model
  • Using script libraries
  • Domino Object Model LotusScript classes
  • Front-end classes
  • Back-end classes

Chapter 31 — Advanced LotusScript Techniques
by Rocky Oliver

Download the example files

Chapters 29 and 30 introduced you to LotusScript and to the Domino Object Model. You learned how to work with the language and the syntax and were taught some nice techniques and commonly used classes. This chapter takes that knowledge to another level. It exposes you to advanced techniques for getting the most out of LotusScript. Topics such as error trapping, working with COM/OLE, and techniques for working with lists and arrays are presented.


  • Error trapping in LotusScript
  • Working with lists and arrays
  • Using Java from LotusScript
  • Working with COM/OLE from LotusScript
  • Working with the C API from LotusScript
  • Creating LotusScript classes

Part VII — Java Techniques.

Java is an integral part of IBM's enterprise computing and e-business strategies. In this part, we cover details of working with Java in Domino Designer, show examples of Java Classes and methods in action, show examples of building an application and a servlet that accesses Domino data, provide examples of developing servlets and applications on third-party developer tools, provide techniques for building servlets that run on a Domino server, work with custom Domino JSP tags, and finish off the chapter with an example of a WebSphere servlet that accesses Domino data via custom Domino JSP tags.

Chapter 32 — Java and Domino Designer
by Brian Benz

Java has come a long way since a group called the “green team” was locked away in the Menlo Park, CA offices of Sun in 1991 to make an interactive TV system. The system was ahead of its time and didn’t sell well, but it spawned processor-independent technology to send and display interactive features on a screen. Interestingly for Domino developers, the interactive features and functionality were originally described as agents. The next objects to use Java were applets, which were small applications that could be delivered and displayed on a screen via the Internet. This technology took off in 1994 when Netscape announced a Java Virtual Machine (JVM) as a core component of its new Navigator Browser software. In 1997, Lotus added Java to Domino 4.6 and announced that Java would be a core component of the new Domino Designer in R5. At that time, Java had come full-circle, from interactive agents on a custom interactive TV system to interactive agents in Notes clients and on the Web. Today, Java is still used for applet delivery and functionality; however, it is more often used for server-side development and is rapidly becoming the back-end server language of choice when developing high-capacity enterprise Web applications. This chapter provides an overview of Java and the details and capabilities of Java in Domino, including building Domino agents and creating Java code libraries.


  • Introducing Java
  • Understanding Java functionality in Domino Designer
  • Using the Domino Designer Java UI
  • Developing an agent in Designer
  • Storing and referencing Java in a Domino code library

Chapter 33 — Java Classes and Methods
by Brian Benz

Download the example files

Domino Java classes and methods are an interface to the same Domino back-end classes that LotusScript uses. Developers will find many similarities between the LotusScript classes and syntax in Part VI (LotusScript) and the Java classes and methods in this part.In this chapter, we convert the LotusScript Newsletter mailing agent example to a single-threaded Java agent by starting with the Hello World Java agent from the last chapter and adding Domino Java classes and methods to correspond to the original agent’s LotusScript classes and methods. We then discuss the advantages of multithreaded Java and show what is required to convert the single-threaded Java agent to a multithreaded agent using the NotesThread class.


  • Introducing the Domino Java classes
  • Developing complex Domino agents in Java
  • Java agent development for LotusScript developers
  • Handling multiple classes in a Java agent
  • Developing multithreaded Java agents
  • Passing values from one Java agent thread and class to another

Chapter 34 — Accessing Domino from Java Applications
by Brian Benz

Download the example files

Java applications are stand-alone applications that have been written in Java instead of another programming language, such as C++. This chapter covers the steps necessary to integrate Domino data into a Java application by developing an interactive Java application UI that accesses Domino views, documents, and fields via the same Notes Objects Interface used for agent examples in Chapters 32 and 33.


  • Introducing Domino Java applications

  • Learning the prerequisites for developing Domino applications in Java
  • Converting a simple Domino Java agent to a Java application
  • An advanced Domino Java application example

Chapter 35 — Java Servlets for Domino
by Brian Benz

Download the example files (Diagnostic Servlet, Newletter Distribution and Java Servlet)

Domino has native capabilities for supporting Java servlets. In this chapter, we discuss that capability, how to code a servlet for use in the Domino environment, and issues surrounding Domino servlet deployment, performance, and security. Illustrating the examples will be the development and deployment of a simple Domino servlet.


  • Introduction to servlets
  • Introduction to Domino Java servlets
  • Prerequisites for developing Domino servlets
  • A simple servlet example: Domino diagnostics
  • Converting a Java agent to a servlet

Chapter 36 — Java Servlets Using Third-Party Developer Tools
by Brian Benz

Chapters 34 and 35 reviewed techniques for making Java applications and servlets work with Domino, but an important detail was glossed over — how are Domino Java servlets and applications developed? The Domino Designer UI is a great place to build Java agents, and it can even store and compile some simple applications and servlets. But most Java applications require classes and methods that the Domino Designer UI was never meant to handle. Complex application and servlet Java can usually be loaded into the UI, and the interface can even break up and list the classes in the Work pane to the left of the Programmer’s pane. Unfortunately, saving and compiling are not so predictable. This chapter outlines the steps for enabling Domino object support for the two most popular Java application development environments: WebSphere Studio Workbench, and SunOne Studio. Two options are discussed, partly because most large organizations with J2EE development initiatives have standardized on one of these platforms, and partly because of the different approaches taken in the user interface and features. Both platforms need some customization to enable the compiling and running of Domino applications, applets, and servlets, which we will cover in detail in this chapter. If readers already have one of these environments set up and running and configured for access to Domino objects, they can probably skip this chapter.


  • Developing Java applications and servlets
  • Developing Domino servlets with WebSphere Studio Workbench 2.0.1
  • Developing Domino servlets with SunONE Studio 4.0

Chapter 37 — Domino Custom JSP Tags
by Brian Benz

Download the example files

This chapter illustrates how to access and display Domino views, documents, and forms via servlets by using Domino's custom Java Server Pages (JSP) tags. You learn about servlet development using Domino JSP tags, deployment of JSP and Domino access capability on a remote server, and formatting of JSP content. You find out how to add JSP tag capabilities using the example diagnostic servlet from Chapter 35.

  • Outline:
  • Introducing Java Server Pages
  • Introducing JSP tags
  • Working with Domino custom JSP tags
  • Using Domino JSP tags

Chapter 38 — Domino and WebSphere
by Brian Benz

WebSphere application server is a J2EE servlet manager that provides scalability, security, and enterprise data access for servlet-based J2EE Web applications. The standard edition of WebSphere server has been bundled with Domino since early versions of R5, and Domino capabilities for accessing servlet functionality via CORBA are incorporated into Domino server. This chapter discusses the issues involved in deploying a servlet on WebSphere that accesses Domino data, and illustrates the issues and procedures by deploying and configuring J2EE Web applications and JSPs using Domino custom JSP tags on a WebSphere server.


  • Understanding the limitations of using WebSphere with Domino
  • Installing WebSphere
  • Configuring the Domino server for WebSphere
  • Setting up WebSphere and Domino SSO (single sign-on) capabilities
  • Deploying and running J2EE Web applications
  • Deploying and running JSPs

Part VIII — JavaScript Techniques.

JavaScript is a great tool for field validation and form data manipulation. Fields can be formatted, date fields can be verified, Numeric fields can be calculated before saving, and text lists and fields can be manipulated and populated based on user input. JavaScript is also very good for Web client image manipulation and navigation. JavaScript can be used to create rollovers and link highlighting, as well as more advanced DHTML techniques. In this part we'll cover JavaScript data entry validation, calculation, image manipulation and DHTML techniques.

Chapter 39 — JavaScript Basics
by Brian Benz

Download the example files

JavaScript is a platform-independent, event-driven, interpreted programming language that has been part of Domino since R5, and could be used with Domino 4.6 versions of Domino via pass-thru HTML. JavaScript should not to be confused with Java, which is very different in terms of functionality and language. JavaScript and Java can communicate with each other because the original intention was that a combination of Java applets and JavaScript would represent a complete client-side Web application development platform. However, for several technical and non-technical reasons, this never came to full fruition. Today, JavaScript is a common extension to HTML that can enhance the user experience by handling client-side events and application control in browser clients. JavaScript is useful for adding interactivity to Domino Web applications and Notes client applications. The Notes 6 client JavaScript feature set has added more complete access to JavaScript classes and methods than prior implementations and eliminated many of the bugs that hampered Notes client JavaScript development in R5. This chapter introduces JavaScript and describes basic techniques for JavaScript document object access and for detecting JavaScript client settings. The next chapter provides more information about the Notes DOM and JavaScript events in Domino.


  • Introducing JavaScript
  • Understanding JavaScript structure and syntax
  • Understanding the Domino Designer JavaScript UI
  • Storing and referencing JavaScript in a Domino JavaScript Library

Chapter 40 — Using JavaScript Events
by Brian Benz

Download the example files

In this chapter, you build on the basic JavaScript examples in the preceding chapter to develop advanced browser client functionality. Illustrations and examples in this chapter exploit JavaScript events, JavaScript actions, and JavaScript libraries to greatly extend the look and feel of the Web-based Mailing List Registration form.


  • Introducing Domino JavaScript events
  • Using Web data entry controls in JavaScript
  • Creating a Web-based Help system for Domino applications

Chapter 41 — DHTML
by Brian Benz

Download the example files

This chapter digs into the details of managing browser UI navigation and image manipulation to create a more visually pleasing Web client experience by adding DHTML capabilities to your existing Web-based newsletter registration application.


  • Introducing DHTML
  • Using CSS
  • Understanding layers and DIV tags
  • Using layers in Domino
  • Using DHTML in Domino
  • Using image rollovers
  • Creating DHTML data control functionality for Domino applications
  • Creating a DHTML help system for Domino applications

Chapter 42 — Combining Domino and Java Applets using JavaScript
by Brian Benz

Download the example files

JavaScript and Java applets can be connected to each other in Domino using an interface called LiveConnect. LiveConnect is supported in the most recent versions of Navigator, MS IE, and the Notes client, and manipulates Java applets using JavaScript through the applet API without the need for Java. However, the Java applet API must be available or published somewhere to have this work. Domino objects are available to Java applets using the Java AppletBase class. Domino has created four applets based on this class that can be embedded into Notes applications; the Outline, View, and Action Bar and Editor (Rich Text) applets. Other applets that extend the AppletBase class can also be accessed using LiveConnect, if the Applet APIs are published. This chapter provides some examples of manipulating Java applets from JavaScript using the Domino Designer UI, including isolating Java applet calls, properties, and methods, and using those calls to change properties of an applet embedded in an HTML page. It also covers techniques for embedding the JavaScript to Java calls into existing Domino UI elements.


  • Using Java applets
  • Using JavaScript and Java applets
  • Embedding applets in HTML pages
  • Working with Domino Java applets in Domino forms
  • Understanding Domino applets
  • Controlling Java applets in Domino forms

Part IX — Relational Database Integration.

Domino provides a large number of connection and integration options for incorporating relational data into Domino applications. This part covers tips and techniques for using @Db functions using ODBC, Domino Enterprise Connectivity Services, Domino Connection Resources, LotusScript and Java classes, connector options, and Lotus Enterprise Integrator.

Chapter 43 — Integrating Enterprise Data with Domino Applications
by Brian Benz

Download the example files

Domino data integration combines the collaborative, Web-enabled features of Notes and Domino with the vast amount of information that is contained in relational databases, legacy systems, transaction-based enterprise applications, and organizational data warehouses. This chapter covers tips and techniques for building data integration into Domino applications. After you review the options for data integration, you learn several techniques for including enterprise data in Domino applications by using an application that uses Domino Enterprise Connectivity Services (DECS), ODBC, LotusScript agents, JavaScript, @Functions, and Data Connection Resources (DCRs). You can apply the same techniques discussed for DECS and DCRs to all the data integration options in this chapter.


  • Learning Domino data integration options
  • Introducing Domino Enterprise Connectivity Services and Data Connection Resources
  • Understanding a Domino 6 DECS/DCR example
  • Setting up the Domino 6 Bible DECS examples

Chapter 44 — Developing Domino Applications for Data Integration
by Brian Benz

This chapter extends the data integration concepts that you learned in Chapter 43 by illustrating several practical examples of a working data integration solution. The example application uses Domino Enterprise Connectivity Services (DECS) to connect to an access database that contains over 1,000 popular quotations. The quotes table in the database contains four columns: A unique key for each quotation, a quotation source, the quotation, and the date that the quotation was added to the database. The application provides good examples of application, form, and other design element techniques for developing Domino solutions that integrate with enterprise data. The application in this chapter uses Domino Enterprise Connectivity Services (DECS) and Data Connection Resources (DCRs), but you can easily adapt it to use any Domino data integration option using the same techniques.


  • Triggering simple queries
  • Triggering multiple queries on a single query form
  • Switching forms to display single or multiple query results
  • Implementing Data Connection Resources (DCRs) in Domino 6

Chapter 45 — LEI Retrievals and Updates
by Rocky Oliver

Download the example files

One of the most exciting releases recently made by Lotus is the new version of the Lotus Enterprise Integrator, now known as LEI 6. LEI 6 provides many new and exciting features, as well as improvements in other areas. One great new feature is the concept of virtualization, which enables you to have a Domino database act as a pure front-end to relational data, with no documents in the database.

This chapter introduces you to LEI 6 and the powerful integration functionality it provides. You learn some of the basics of LEI, and then go into virtualization features. The chapter concludes with a fairly complex example provided by the LEI development team.


  • Understanding LEI basics
  • Configuring connections to external sources
  • Configuring LEI activities
  • Using integrated credentials

Part X — XML.

This part shows developers how XML fits into Domino application development strategies. Topics covered include how to use Domino servers to process XML data for enterprise integration and Web site solution, and how to create XML-based forms, pages, documents, and agents that allow for the importing and exporting of XML data from Domino databases. Examples show you how to create applications using the Lotus XML Toolkit classes for Java and provide techniques for transforming Web data via XSLT in Domino applications.

Chapter 46 — XML and Domino
by Brian Benz

Most Domino developers are aware of Domino’s power when building flexible applications by separating data from content. XML enhances this capability by adding functionality for sharing applications and data between different systems in a common text-based format. Domino and XML are great complements to one another, each providing several features that the other lacks. This chapter gives an introductory overview of Extensible Markup Language (XML), XML structure, parsing and transforming XML, and what XML can be used for in Domino applications. Chapters 47 through 54 delve into specific topics in more detail, and Chapters 55 through 58 provide details on the most exciting implementation of XML to date — Web services.


  • Introducing XML
  • Parsing XML
  • Transforming XML
  • Using XML data islands
  • Understanding XML and Domino

Chapter 47 — XML, DXL, and Domino Data
by Brian Benz

Download the example files

This chapter builds on the XML concepts introduced in Chapter 46 by reviewing examples in Domino, starting with the examples in the Notes and Domino 6 Programmer’s Bible XML Example database. The chapter also covers DXL for views and documents. DXL is the XML format that Lotus and IBM have created to represent Domino Data. You’re then introduced to the Domino DTD and the DXL schema, which enforce DXL data structure and syntax rules on XML data. Techniques for including the ReadViewEntries command in Domino Web applications are shown as an introduction to DXL. Once you understand the DXL, DTD, and schema concepts, you learn how to develop custom XML output form Domino forms, and how to apply a custom DTD to the custom XML output.


  • Using the Notes and Domino 6 Programmer’s Bible XML Example databaseXMLQuotes
  • Understanding DXL
  • Working with ReadViewEntries in Domino Web applications
  • Using DTDs and schemas
  • Using the Exporter, Transformer, and Viewer DXL utilities
  • Generating XML from Domino forms and fields
  • Applying a DTD to custom XML data

Chapter 48 — LotusScript and XML
by Brian Benz

Download the example files

This chapter focuses on techniques for creating and using LotusScript to generate flexible XML based on form and document data. Techniques include creating custom XML output, as well as working with the new NotesDXLExporter and NotesStream classes to generate DXL from Domino data.


  • Extending the XMLQuotes examples
  • Generating custom XML using LotusScript
  • Creating XML files using LotusScript
  • Generating DXL using LotusScript

Chapter 49 — Using Domino to Serve Relational XML
by Brian Benz

Download the example files

This chapter expands on the DECS-based relational database Access application example you saw in the data integration part of this book. As you may recall, the example in Chapter 44 uses Domino Enterprise Connectivity Services (DECS) to connect to an Access database that contains over 1,000 popular quotations. The quotes table in the database contains four columns: A unique key for each quotation, a quotation source, the quotation, and the date the quotation was added to the database. The application provides good examples of application, form, and other design element techniques for developing Domino solutions that integrate with enterprise data. In this chapter, you learn how to use the same Domino Web application to serve relational datasets or a representation of that data using XML. You also learn techniques for generating DXL from multi-record database queries.


  • Learning about the Notes and Domino 6 Bible DECS application
  • Retrieving XML documents
  • Generating XML results from relational database queries
  • Generating multivalue XML results from relational database queries

Chapter 50 — Developing Java Applications with XML and Domino
by Brian Benz

Download the example files

This chapter expands on the Chapter 34 Java application examples to illustrate how Java applications can access Domino objects and generate DXL and custom XML formats. The example highlighted in this chapter is a fully functional Java application that uses Java Swing classes and AWT events to generate a UI, Domino objects to access Domino data, and Domino and Lotus XML toolkit classes and methods to generate DXL and other types of XML.


  • Introducing the Java sample application — DominoBibleQuoteDXLApplication
  • Understanding system prerequisites for Java applications that access Domino
  • Introducing the DominoBibleQuoteDXLApplication source code
  • Creating the Java application UI
  • Generating custom XML output
  • Generating DXL with document.generateXML()
  • Generating DXL with the XML toolkit
  • Working with the Lotus XML toolkit

Chapter 51 — Generating XML with Domino Java Agents and Servlets
by Brian Benz

Download the example files

This chapter focuses on the tools and techniques required to generate DXL from document data using Java agents and servlets. You start with techniques for generating DXL to browser windows and file systems using Java agents. After that, You move on to techniques for creating servlets that return data to a browser window, and finish up with servlets that interact with your DXL Quote Generator Java Application from Chapter 50.


  • Using XML Java agents
  • Writing DXL to the file system with Java agents
  • Writing DXL to a browser window with Java agents
  • Using XML servlets
  • Example: A three-tier system combining Java applications
  • Servlets and Domino
  • Understanding the prerequisites for developing Domino XML servlets
  • Running the DXL application servlets from a Web browser
  • Running the DXL application servlets from a Java application
  • Under the hood of the DXL application servlets
  • Under the hood of the DXL Java Application — Servlet Edition

Chapter 52 — Getting XML into Domino
by Brian Benz

Download the example files

This chapter focuses on XML document parsing and manipulation using LotusScript and Java. You start with an introduction to XML document parsing, including DOM and SAX. You then review LotusScript and Java agent examples, which include parsing an XML document using DOM and parsing a DXL document using SAX.


  • Parsing XML documents
  • Understanding XML parsers
  • Using the Document Object Model (DOM)
  • Using the Simple API for XML (SAX)
  • Examples: Using LotusScript and Java agents to parse XML and DXL documents

Chapter 53 — Transforming XML with XSLT
by Brian Benz

Download the example files

In the last chapter, you discovered how to parse and assimilate XML and DXL data into Domino documents. This chapter covers tips and techniques for transforming XML documents into other XML formats and HTML using Extensible Stylesheet Language Transformation (XSLT). Examples include writing LotusScript and Java agents that perform XSL transformations, tips for writing XSL stylesheets for Domino-generated data, how to integrate XSL transformations for added display flexibility, and using the DXL Transformer for transforming Domino design elements.


  • Introducing XSL (Extensible Stylesheet Language)
  • Using the DXL transformer utility
  • Using the LotusScript NotesXSLTransformer class
  • Transforming DXL with Java
  • Learning DXL transformation techniques

Chapter 54 — XML Data Islands
by Brian Benz

This chapter brings together many of the previous XML, XSL, JavaScript, and DHTML examples to show developers how to use the MSXML parser and Domino design elements to create JavaScript-based XML parsing and XSL transformation. We use MSXML parsing and transformation features to create a Web page that gathers DXL from a View via the ?ReadViewEntries command, transforms the data, parses the data into a table, then adds buttons to the top of the page to facilitate client-side sorting of the data.


  • Introduction to XML data islands
  • The DXLDataIslandExample page
  • Transforming a DXL view into an XML data island
  • Parsing data island data into a table
  • Sorting data islands using JavaScript and XSL

Part XI — Web Services.

This part introduces developers to the concepts of Web services, and then goes under the hood of Web services to show you how they actually work. Examples show you how to call Web services from Domino clients via HTTP and RPC, as well as enabling Domino agents to handle Web Service requests.

Chapter 55 — Web Services Introduction
by Brian Benz

Web Services are service-oriented, component-based, self-describing applications that are based on an architecture of emerging standards. This chapter introduces Web Services and how they relate to Domino applications, starting with the basic concepts of Web Services architecture; Simple Object Access Protocol (SOAP), Web Services Description Language (WSDL), and Universal Description, Discovery, and Integration (UDDI).


  • Understanding Web Services
  • Learning about Web Services building blocks
  • Understanding Web Services architecture
  • Looking at the Web Services models
  • Serving Web Services from Domino
  • Consuming Web Services with a Notes client

Chapter 56 — SOAP, WSDL, and UDDI
by Brian Benz

Chapter 55 introduced you to the concepts behind Web Services, the architecture of Web Services prototypes, and common Web Services models. This chapter continues the introduction by digging deeper into the main building blocks of Web Services — SOAP, WSDL, and UDDI — and illustrating how the components work together in a Web Services environment.


  • Simple Object Access Protocol (SOAP)
  • Web Service Description Language (WSDL)
  • Universal Description, Discovery, and Integration (UDDI)

Chapter 57 — Serving Web Services from Domino
by Brian Benz

Download the example files

This chapter focuses on creating Java classes that accept SOAP requests and return SOAP data in a Domino server environment. The chapter also covers tools for generating WSDL for Domino Web Services and deploying Web Services agents.


  • Walking through an example: A three-tier Web Services system combining Java applications
  • Web Services and Domino
  • Learning the prerequisites for developing Domino Web Services
  • Deploying the Web Services class
  • WSDL and WSDD files
  • Running the DXL application
  • Web Services from a Java application
  • Under the hood of the DXL application Web Services
  • Under the hood of the DXL Java application — Web Services Edition

Chapter 58 — Consuming Web Services in Notes Client Applications
by Brian Benz

This chapter illustrates the great potential of the Notes client to become a full-featured Web Services client. You’re introduced to SOAPConnect, which enables Web Services access via SOAP from LotusScript. You also work through examples of a Notes client accessing Web Services from a Java agent using AXIS.


  • Understanding the options for consuming Web Services from Notes clients
  • Learning about SOAPConnect
  • Working with an example: Accessing the temperature and stock quote Web Services from Notes via SOAPConnect
  • Working with an example: Accessing the temperature and stock quote Web Services from Notes via Java agents using AXIS