Composite applications are applications that consist of two or more components that may have been independently developed, working together to perform tasks that none of the member applications could perform by itself. Each component publishes and consumes messages from other components, and performs actions based upon user interaction or information received from other components. Support for composite applications is one of the central points for Notes/Domino 8. Composite applications in Notes 8 can wire together multiple components from Notes applications, Lotus Component Designer applications, and Eclipse into a single application context for the end user.
Composite applications, whether they are based on Notes/Domino 8, Web Sphere Portal, or Lotus Expeditor, are the frontend or user interface to an enterprise's SOA strategy. They, in effect, consume the services that are offered by the composite architectures put in place to support SOA.
An example of a composite application would be a simple customer relationship management application. This application needs to display a list of accounts, opportunities, and contacts to end users.
The accounts component should display accounts owned by the end user. When the end user selects an account in the account component, the opportunities for that account should be displayed in the opportunities component, and all of the contacts for the first opportunity should be displayed in the contacts component.
In the application described, the components are "communicating" with each other by publishing and consuming properties via a property broker. When the user clicks on an account, the account component publishes the accountkey property to the property broker. The opportunities component has been written to "listen" for the accountkey property to be published, and when it is, it performs a lookup into a data store, pulling back all the specific opportunities for the published account key. Once it has displayed all of the opportunities for the account, it selects the first opportunity for display and then publishes the opportunitykey property to the property broker. The contacts component then performs a lookup to display all of the contacts for the opportunity.
When the user selects a different opportunity, the opportunity component again publishes an opportunitykey property and the contacts component receives this new opportunitykey property and displays the correct contacts for the selected opportunity
Using component applications, developers can respond quickly to requests from the line of business for functionality changes. For example, in the case of the customer relationship management application described, the line of business may decide to purchase a telephony component to dial the phone and log all phone calls made. The developers of the application would need to simply modify the contact component to publish the phone number of a contact with a name that the new telephony component listens for and the call could be made on behalf of the user.
In addition to being used within the customer relationship management application, the components developed could be put together with other components to form entirely different applications. Each component already understands what data it needs to publish and consume to perform its actions, and contains the code to perform those specific actions on backend systems. The reuse of the components will save the developers and the organization time whenever they are reused.
Composite applications also require a new programming model for Notes/Domino 8. This model mirrors the model within WebSphere Portal 6, in that multiple components are aggregated into a single UI with the property broker acting as the "glue" that allows the various components to interact and share data, even if the components are from different systems. This programming model is something new in Notes 8 and required some changes to Domino Designer 8.
As a side note, the new programming model of composite applications will most probably bring its own set of problems. For example, what happens in a composite application when one of the components fails? In this "composite crash" situation, what does the composite application need to do in order to recover?
Additionally, from an infrastructure point of view, composite applications will only be as available as their weakest component. What good would a reservations system, implemented with many components, be if one of the components were not hosted by a highly available infrastructure, while the others were? We see these sorts of issues being dealt with currently by customers venturing into the composite world via SOAs.
There are two main categories of change for development related to composite applications in Notes/Domino 8 application design and programming. We will look at both of them in the following sections.
In order to allow your Notes or Domino application to participate within a composite application, you must first decide which design elements need to be accessible to other components. To make these components available to other components within your composite application, they are specified within a Web Services Description Language (WSDL) file. The composite application property broker then uses this WSDL file as a map into your application and its published properties and actions.
To allow this mapping to occur, the Composite Application Editor is used. Without making changes to legacy Notes/Domino application functionality, the Composite Application Editor can be used to surface the elements of the application such as forms, views, documents, and other Notes elements to the composite application.
Another element of composite application design is deciding where the application components will reside. Composite applications can be hosted within a local NSF file on a Notes client, on a Domino 8 application server, in the WebSphere Portal, or in Lotus Expeditor. The Notes/Domino application components are created with the Composite Application Editor, while WebSphere Portal composite applications can be created with the Composite Application Editor or the Portal Application Template Editor.
As mentioned earlier, the addition of composite applications to the development strategy for Notes/Domino 8 required some changes and additions to the existing programming model.
Within a composite application, the components must be able to interact even if they were defined with different tools and technologies. Some components may even be stored within different database technologies. One component may be NSF-based while another may be stored within a relational database store. The components need a standardized way to define the properties and actions that they support, so that an application developer can wire them together into a composite application. The standard way to define these properties and actions is via a WSDL file.
Let's take a quick look at properties, actions, and wires
Component properties are the data items that a given component produces. They are either input properties (consumed by the component) or output (produced by the component) properties. Each property is assigned a data type, which is based on the WC3 primitive data types. These include String, Boolean, decimal, time, and date. The primitive data types can also be utilized to build new data types. For example, within Notes 8, some new data types for components will be available that map to common data available within the mail, calendar, and contacts applications. Some of these new data types are listed in the following table:
Data type name
Extends data type
List of people to receive an e-mail
"mailto:firstname.lastname@example.org?subject=Our Dogs are Smartemail@example.com,firstname.lastname@example.orgemail@example.com"
E-mail address following RFC 822
"My Gerbil <firstname.lastname@example.org>"
"Little Man <email@example.com>"
Actions are the logic that is used to consume a property. For example, a component may implement an action that sends an e-mail when it receives a mailTo type property from another component. The code within the component that sends the e-mail based on the information consumed from the property is the action for the component. Components can obviously contain multiple actions depending on the business logic required for the component.
It is easy to confuse a web services action with a Notes action. The web services action is a name in a WSDL file that represents functionality that will consume a property. Notes actions can be coupled with a web services action so that the Notes action gets called to consume a property. The LotusScript in the Notes action can then implement code to act on the property.
The following screenshot shows a Notes action in the Notes 8 mail template that is coupled with a web services action, NewMemoUsingMailtoURL. You can see that in the code, the LotusScript is using a property broker to gain access to the property:
Wires are the construct by which components interact within a composite application. A wire is simply a programmatic definition of which components talk to each other. The components must share common properties and then produce and consume them via actions. More simply put, wires connect properties to actions.
For example, an application developer could wire together a contact list component with an e-mail component. When the user selects a contact from the contact list, the contact list component would produce and publish a mailTo type property, which could then be consumed by the e-mail component. The e-mail component would consume the published mailTo property and compose an e-mail using the data contained within the property.
The following screenshot shows the components available within the Notes 8 mail template that are available for use in other component applications as well, shown from the Component Palette within the new Composite Application Editor:
Lotus Component Designer
Lotus Component Designer is the new version of Workplace Designer, with support for WebSphere Portal 6. It is a development environment built on top of Eclipse, which allows for the creation of document-based applications using visual design methods with no need to know the intricacies of J2EE.
Forms are the building blocks for applications built with Lotus Component Design. Applications can have more than one form associated with them. Each form then contains one or more controls. Controls include views, images, text boxes, combo boxes, radio buttons, and tables.
The forms and controls within a Lotus Component Designer application are used to manipulate an XML-based document model, which is stored in a relational database. This allows for the separation of the look and feel of the application from its data.
Here are a number of new features of Lotus Component Designer.
Lotus Component Designer allows you to migrate components created with previous releases into release 8. The migration tool is a part of the component import process and can detect older versions of components. When an older version is detected, its pages are converted to the new XSP format.
Help and enhanced welcome page
As shown in the following screenshot, the new Lotus Component Designer welcome page offers a rich set of options including an overview, tutorials, samples, web resources, and context-sensitive help:
Lotus Component Designer is an accessible software development tool with which you can create accessible components. It is compliant with IBM Corporate Instruction 162 (CI 162) which meets the U.S. government's federal accessibility guidelines for information technology. It requires that the hardware, software, services, web pages, and internal applications are accessible to persons with disabilities.
Composite application support
With Lotus Component Designer, you can now create applications that can work within the IBM WebSphere Portal composite application model. These components can interact with components created with Notes/Domino 8 as well.
Controls and pages
There are many new features and additions to controls and pages. A few favorites are as follows:
- Preview images directly from the Choose Image dialog box without having to add it to the page first
- Create custom controls, which combine two or more controls into a single control
- Add UI controls that are not listed in the standard UI Controls palette, such as supported AJAX controls
- Web page preview without having to leave Lotus Component Designer
Some of the new features and enhancements for data connectivity are as follows:
- Local connections are supported in components. Connections are the sets of information used to connect to a data source such as a database.
- The schema editor has been improved so as to provide an easy graphical way to create and edit XML schemas.
- Components can now store data in external data sources such as Domino databases and XML files on a target server.
- A new query editor is available to provide a more granular and flexible way to populate view queries.
Some of the new features and enhancements for deployment are as follows:
- There is a new XSP file format for registry and page loading which has been made public. For more information, visit the Lotus Component Designer developerWorks website at the following URL: http://www-01.ibm.com/software/lotus/
- A new XSP tag library is available, offering a library of UI controls, data sources, simple actions and other controls. This library is located in the \doc\ controls directory.
Some of the new features and enhancements for deployment are as follows:
- One can deploy components to servers without having knowledge of J2EE applications and without the administrator credentials
- Components can be deployed to a cluster for production deployment by exporting the components Web Archive (WAR) and Data Definition Language (DDL) files and providing them to your administrators
- Basic authentication is now supported for WebSphere Portal 6.x
New Web 2.0 features
Some of the new Web 2.0 features that are available in Notes/Domino 8.5, such as RSS and ATOM are discussed in the following sections.
RSS and ATOM
RSS and ATOM are feed formats used to publish web content that is updated on a regular basis. News organizations, governments, private companies, and even individuals via their daily blogs publish RSS and ATOM feeds. All you need to read these feeds is an RSS or ATOM reader such as Notes 8 and access to the Internet.
Feeds within Lotus Notes 8.5 are included as a sidebar plugin along with the Sametime Contacts, Activities, and Day-At-A-Glance, on the right-side of the screen:
With Notes/Domino 8, you can also generate RSS feeds from Domino databases including the new blog template and Domino Web Access. The Domino RSS Syndication template is used to create the feeds from any Domino view. The agents and script libraries from this template can also be used within other applications.
The first step is to create a database to manage your feeds. Create the new application and base it on the RSS Feed Generator template:
Once the database has been created, you will want to set up the global options that apply to all the RSS feeds that are generated. To do this, click on Set Global Options
Using the Set Global options dialog, you can control the following:
- Protocol used when accessing feeds: This can be set either to http:// or https://
- RSS <guid> element prefix: This can be set either to notes:// or http://
- Default database page redirect time: This is entered in seconds
- Available Feeds Header (use HTML): This displays all available feeds
- Default Database Page (use HTML): This is the default HTML for the feed database
Once the defaults are set, you can define a feed and direct it to a specific mail file, based on a user or on a specific database
When a feed is defined, you are able to get a list of all available feeds from the Domino server by directing your browser to the feed database that you created earlier. From this web page, you will be able to add the feed into your favorite
Starting with Notes 8, you can create your own web log, or blog, using the new Domino Web Log template (dominoblog.ntf). Once created, you can use either Lotus Notes or a web browser to add content and manage your blog. The resultant web page shows the first entry of the author's blog. The template allows a creation of blog entries from the Notes client or from the website itself:
The following screenshot shows what the new blog template looks like when accessed from a client:
Lotus Expeditor is the base platform for Lotus rich clients such as Notes 8 Standard and Sametime 7.5. It is also a product that companies can leverage to build their own rich client solutions. Built on top of Eclipse (an open source IDE), Lotus Expeditor adds the ability to create composite applications, a local data store for credentials and application data, role-based provisioning, enhanced security, and offline abilities.
One of the problems with rich clients in the past, was the cost of deployment and support. Rich clients are large installations that needed to be upgraded and supported. In fact, it is the cost of deployment and support that helped to drive the web-based applications that we see in wide use today. Everyone with a rich client knew what version of it they were running, but there is no reason to know what version of eBay, Google Mail, or your corporate WebSphere Portal you may be using because they are server managed and will have been updated all the time with new features, functions, and content.
In fact, as the rush towards web-based applications required more and more functionality to be supported by the browser, the "light browser" itself became very large and started to require deployment and support planning. In some instances, the browser footprint on a client became larger than some rich client applications.
Lotus Expeditor can be thought of as a platform that has all the benefits of rich clients but also has the benefits of those web-based applications because it can be centrally managed. It can also be described as a "local portal" because it can be used to create composite applications that contain Notes/Domino 8 components, JSR-168 compliant portlets, SWING, and AWT applications without the need for a network connection.
Lotus Expeditor does this by implementing client-side containers for the components that communicate via a local property-broker implementation. This can have another benefit—speed of execution. As the code is executing within the Lotus Expeditor platform, the composite application may not be affected by network and backend systems latency, or at least may be affected only to the extent that it utilizes those systems.
In addition to responsiveness, applications built with Lotus Expeditor can also be more reliable and portable due to their local execution and data stores. This results in a rich client that has the benefits of a browser but with a user experience that can be better than a browser due to speed, reliability, centralized management, and the ability to work online or offline. When working offline, the applications store transactions in the local data store. Once connected to the company network, Lotus Expeditor can then synchronize the transactions to the host application and may even download updates for the application itself.
Some of the applications that can be built with Lotus Expeditor include customer service and support applications, such as bank teller and reservations clerk, as well as sales force automation applications, such as mobile CRM or insurance claims management.
In this article, we reviewed some of the major new features and enhancements that affect Notes/Domino 8 application development. We covered Composite Applications, Lotus Component Designer, Web 2.0, and Lotus Expeditor.
- Integrating IBM Cognos TM1 with IBM Cognos 8 BI [Article]
- Introducing Sametime 8.5.2 [Article]
- IBM WebSphere Application Server: Administration Tools [Article]
- IBM Lotus Domino: Exploring View Options for the Web [Article]