Performance Tuning for Content Manager

58 Performance Tuning for Content Manager

J2EE packaging

One of the most significant changes introduced by the J2EE specification is how

application components are packaged for deployment. During a process called

assembly, J2EE components are packaged into modules. Modules are then

packaged into applications. Applications can be deployed on the application

server. Each module and application contains a J2EE deployment descriptor.

The deployment descriptor is an XML file providing instructions for deploying the

application.

2.2.2 Three-tier architecture

WebSphere Application Server provides the application logic layer in a three-tier

architecture, enabling client components to interact with data resources and

legacy applications. Collectively, three-tier architectures (see Figure 2-5 on

page 36) are programming models that enable the distribution of application

functionality across three independent systems, typically:

 Client components running on local workstations (tier 1)

 Processes running on remote servers (tier 2)

 A discrete collection of databases, Resource Managers, and mainframe

applications (tier 3)

Figure 2-9 Typical WebSphere three-tier architecture

Tier 1

presentation

Tier 2

Application logic

Tier 3

data / resource

clients

application

servers

mainframe

resource

manager

resources

(databases)

Tier 1

presentation

Tier 2

Application logic

Tier 3

data / resource

clients

application

servers

mainframe

resource

manager

resources

(databases)

Chapter 2. Content Manager base products 59

Tier 1 (presentation)

Responsibility for presentation and user interaction resides with the first-tier

components. These client components enable the user to interact with the

second-tier processes in a secure and intuitive manner. WebSphere Application

Server supports several client types.

Clients do not access the third-tier services directly. For example, a client

component provides a form on which a customer orders products. The client

component submits this order to the second-tier processes, which check the

product databases and perform tasks needed for billing and shipping.

Tier 2 (application logic layer)

The second-tier processes are commonly referred to as the application logic

layer. These processes manage the business logic of the application, and are

permitted access to the third-tier services. The application logic layer is where

the bulk of the processing work occurs. Multiple client components are able to

access the second-tier processes simultaneously, so this application logic layer

must manage its own transactions.

Continuing with the previous example, if several customers attempt to place an

order for the same item, of which only one remains, the application logic layer

must determine who has the right to that item, update the database to reflect the

purchase, and inform the other customers that the item is no longer available.

Without an application logic layer, client components access the product

database directly. The database is required to manage its own connections,

typically locking out a record that is being accessed. A lock can occur simply

when an item is placed into a shopping cart, preventing other customers from

even considering it for purchase. Separating the second and third tiers reduces

the load on the third-tier services, can improve overall network performance, and

enables more eloquent connection management.

Tier 3 (data/resource)

The third-tier services are protected from direct access by the client components

by residing within a secure network. Interaction must occur through the

second-tier processes.

Communication among tiers

All three tiers must be able to communicate with each other. Open, standard

protocols, and exposed APIs simplify this communication. Client components

can be written in any programming language, such as Java or C++, and can run

on any operating system, as long as they can speak with the application logic

layer. Likewise, the databases in the third tier can be of any design, as long as

the application layer can query and manipulate them. The key to this architecture

is the application logic layer.