Application Development

Chapter 4 . Defining Application Architecture

With Panther, you can start with a simple, client/server, two-tier architecture application and when your application requirements increase, convert your application to three-tier architecture. Or, begin with an distributed application structure—create both the client and server components at the same time.

Components of a Panther Application

A typical three-tier Panther application, consisting of the following Prolifics tools and application components, is illustrated in Figure 4-1.

Figure 4-1 Components of an enhanced, three-tier client/server Prolifics application.

A database—JDB is Prolifics's built-in prototyping database which you can use to get started. Interfaces to other database engines are available; one of those interfaces is included in each Panther distribution.
A client executable—Prolifics provides both basic development and production executables for your client platforms.
Distributed application environment—The middleware and middleware adapters control three-tier processes and communication between client and application server components.

JetNet is Prolifics's middleware product; middleware adapters are also available for BEA Tuxedo and WebSphere Application Server. On Windows, you can deploy COM components in your Panther application using COM, DCOM, and MTS.
Server executables to support three-tier architecture—Prolifics provides the server executables you need for your choice of middleware.
Client library—Contains the application components that make up the user interface portion of your application. It can store screens, reports, service components, menus, and JPL modules that you create using the editor as well as any other elements, such as bitmaps, that the interface uses.
Server library—Contains the service components of a distributed application and their related JPL modules.
Configuration files—Reside on client machines and, in a three-tier application on server machines, and are used by Prolifics to interpret your environment.

A three-tier JetNet/BEA Tuxedo application also has:

Common library—Contains application-wide objects, such as the JIF, which is the binary file you update to define your application's services, plus any code or objects shared by clients and servers.

Some of these components also exist in simpler, two-tier applications: the database, client executables, client library, and configuration files.

Figure 4-2 Components of a two-tier client/server Prolifics application.

Building Two-Tier Applications

A two-tier application is distributed between client machine and the database server. The client machine controls the presentation logic and all or most of the application logic. The client can access data in the database through SQL interactions (coded or application-generated) or by making calls to the database's stored procedures.

To build a two-tier application:

Create an application directory on the client machine.
Set up the client. Modify prol5w32.ini or the Prolifics resource file and the environment settings as needed to recognize the installation and locate files needed by Panther and its Prolifics tools.
(JetNet only) If you are providing shared access to remote libraries and repositories, set up a file access server (refer to JetNet Guide/BEA Tuxedo Guide for details on configuring a server), and create an application directory on the server machine.
Invoke the editor (prodev/prodev32.exe), and create a repository (default name is data.dic).
From within the editor, connect to the database, and import database definitions into the repository.
Build the application screens using the screen wizard or editor.
Add programming logic to the screens.
Add additional application components, such as tool bars, menus, and reports.
Integrate application components; make the screens work with other screens or reports using push buttons, control strings, and function keys.
Test and debug the screens within the authoring environment.
Performance tune.
Package and deploy the application.

Building Distributed Applications

Distributed applications separate the business logic of the application from the user interface. The application logic is built into service components that reside on the application or component server. The client workstations provide the presentation interface, some application logic, and can make requests to the application servers to perform commonly used logic and access a database. Using service requests, there is no need for a continuous connection between the client and the database server.

Building a JetNet/BEA Tuxedo Application

The following steps summarize the process for JetNet/BEA Tuxedo applications:

To build a three-tier JetNet/BEA Tuxedo application:

Create an application directory on the Panther application server.
Create or copy the necessary libraries, such as server.lib, client.lib and common.lib.
Set up your application server or servers (refer to JetNet/BEA Tuxedo Guide).
Set up the client. Modify prol5w32.ini or the Prolifics resource file and the environment settings as needed to recognize the installation and locate files needed by Panther and its Prolifics tools.
Invoke the editor (prodev/prodev32.exe), and create a repository that resides on the server machine (default name is data.dic).
From within the editor, connect to the database, and import database definitions into the repository.
Build client screens, reports, and/or service components using the editor or the wizards. Save objects to their appropriate libraries (on the server machine for shared access and in local libraries for nonshared access).
Update the JIF with service definitions.
Add client and server processing; add logic for service components and for client screens. Implement C, Java, or JPL code as needed; for C functions, rebuild executables to incorporate functions.
Add additional application components, such as tool bars, menus, and reports.
Integrate application components; for example, make client screens work with other screens or reports by implementing push buttons, control strings, and function keys.
Test and debug both the client and server portions of the application.
Performance tune your application to improve event processing.
Package and deploy the finished application.

Figure 4-3 Components of a Prolifics JetNet/BEA Tuxedo development environment includes access to local and remote libraries as well as direct and remote access to the database.

Building a Component-based Application

The following steps summarize the process for component-based applications:

To build a component-based application:

Set up the client. Modify prol5w32.ini and the environment settings as needed to recognize the installation and locate files needed by Panther and its Prolifics tools.
Invoke the editor (prodev32.exe), and create a repository (default name is data.dic).
From within the editor, connect to the database, and import database definitions into the repository.
Build client screens, reports, and/or service components using the editor or the wizards.
Add client and server processing. Add business logic to service components; add user interface functionality to client screens. Implement C, Java, or JPL code as needed; for C functions, rebuild client executables to incorporate functions.
Save objects to their appropriate libraries (to client.lib for client screens and to server.lib for service components). Saving service components will generate the DLLs and type library files needed for COM components or the Java files needed for EJBs.
Add additional application components, such as tool bars, menus, and reports.
Integrate application components; for example, make client screens work with other screens or reports by implementing push buttons, control strings, and function keys.
Create an application directory on the application server machine (or the machine acting as the COM component server).
Create or copy the necessary application libraries, such as server.lib, and the component's files to the server machine. For COM components, you need to copy the DLLS and type libraries. For EJBs, you need to copy the jar file containing the Java class files, interfaces, and deployment descriptor.
Based on your deployment needs, install the components. For COM components, you need to register the components on client machines.
Test and debug both the client and server portions of the application.
Performance tune your application to improve event processing.
Package and deploy the finished application.