eClient 101 Customization and Integration

124 eClient 101 Customization and Integration

6.1 Programming interface overview

The application programming interfaces (APIs) are a set of classes that access

and manipulate either local or remote data according to the architecture

described in 1.3, “Information Integrator for Content Version 8” on page 6.

The APIs support:

򐂰 A common object model for data access

򐂰 Multiple searches and updates across a heterogeneous combination of

content servers

򐂰 A flexible mechanism for using a combination of search engines such as the

Content Manager text search feature

򐂰 Workflow capability

򐂰 Text analysis capability (Information Mining Service)

򐂰 Document viewing capability

򐂰 Administration functions

򐂰 Client/server implementation for Java applications

You can choose from the following interfaces:

򐂰 C++ classes

򐂰 Java classes

򐂰 JavaBeans

򐂰 Controller servlet and JSP tag library

Because we focus on the APIs that can directly be used in J2EE applications

such as eClient, the C++ API is not discussed in detail; however, the C++ classes

are aligned with the Java classes and can therefore be used in a similar way.

The Java APIs can reside on both the EIP server and the client (both provide the

same interface). The client API communicates with the server to access data

through the network via Java RMI (Remote Method Invocation). Communication

between the client and the server is performed by classes; it is not necessary to

add additional programs.

Java classes consist of the following packages:

򐂰 server

򐂰 client

򐂰 cs

򐂰 common

Chapter 6. Creating applications with EIP 125

The client and server classes provide the same APIs, but have different

implementations.

The server package is com.ibm.mm.sdk.server. The classes in the server

package communicate directly with the federated or back-end content server.

The client package is com.ibm.mm.sdk.client. The classes in the client package

communicate with the classes in the server package via RMI.

The common classes are shared by both the client and server.

Sometimes, an application does not know where the content resides. For

example, an application can have content residing on the client at one time and

on the server at another time. The cs package connects the client and server

dynamically depending on .ini file settings.

The client application must import the client package, the dynamic application

must import the cs package, and the server application must import the server

package.

Although the same API is provided for the client and server, the client package

has an additional exception item because it communicates with the server

package.

The EIP JavaBeans can be divided into:

򐂰 Non-visual Java beans

You can use the non-visual beans to build Java and Web client applications

that require a customized user interface. The non-visual beans support the

standard bean programming model by providing default constructors,

properties, events and a serializable interface. You can use the non-visual

beans in builder tools that support introspection.

򐂰 Visual Java beans

The visual beans are customizable, Swing-based, graphical user interface

components. Use the visual beans to build Java applications for Windows.

You can place them within windows and dialogs of Java-based applications.

Because the visual beans are built using the non-visual beans (as a data

model), you must use them in conjunction with the non-visual beans when

building an application.

The sample applications discussed in the following sections show how to create

applications with the Java APIs and the JavaBeans.

An example of visual and non-visual JavaBeans is the viewer toolkit, which

allows you to integrate document viewing capabilities in your application. It

consists of a generic document viewer, a document viewer bean and a document