Contents


Preface

Using the Documentation
About This Guide
What You Should Already Know
How This Guide Is Organized
Documentation Conventions
Related Information

Programming with Servlets and JSPs
Programming with EJBs
Programming with JDBC

Chapter 1 Designing iAS Applications

Identifying Application Requirements

Defining the Requirements
Matching Requirements to the Application Model

Assembling the Development Team

The Architect
Team Roles for the Presentation Layer

Java Servlet Developers
JSP Developers
HTML Designers
Graphic Artists
Client-Side JavaScript Developers

Team Roles for the Business Logic Layer

Session Bean Developers
Entity Bean Developers

Team Roles for the Data and Legacy Access Layer

Designing the User Interface
Guidelines for Effective Development

Easing Development
Maintaining or Reusing Code
Improving Performance
Planning for Scalability

Chapter 2 Controlling Applications with Servlets

Introducing Servlets

Servlets in iAS Applications
How Servlets Work

Types of Servlets
How the Servlet Engine Allocates Resources
Run-Time Servlet Modifications

How Servlets Are Configured
Important Servlet Files and Locations
Deploying Servlets

Designing Servlets

Choose a Component: Servlet or JSP
Choose Servlet Type: HttpServlet or GenericServlet
Create Standard or Non-Standard Servlets
Planning for Code Re-Use
How Many Servlets for Each Interaction?

One servlet handles one request
One servlet handles multiple requests
Several servlets handle one request

Creating Servlets

Writing the Servlet's Class File

Creating the Class Declaration
Overriding Methods
Handling Sessions and Security
Accessing Business Logic Components
Handling Threading Issues
Delivering Results to the Client

Creating the Servlet's Deployment Descriptor

Deployment Descriptor Elements

Accessing Optional iAS Features

Invoking Servlets

Calling a Servlet With a URL

Invoking Specific Application Servlets
Invoking Generic Application Servlets

Calling a Servlet Programmatically

Chapter 3 Presenting Application Pages with JavaServer Pages

Introducing JavaServer Pages
How JSPs Work
Designing JSPs

Choose a Component: Servlet or JSP
Designing for Ease of Maintenance: How Many JSPs?
Designing for Portability: Generic JSPs

Creating JSPs

General Syntax

JSP Tags
Escape Characters
Comments

Java Directives

<%@ page%>
<%@ include%>
<%@ taglib... %>

Java Scripting Elements

Java Declarations <%! ... %>
Java Expressions <%= ... %>
Java Scriptlets <%...%>

Java Actions

<jsp:useBean>
<jsp:setProperty>
<jsp:getProperty>
<jsp:include>
<jsp:forward>
<jsp:plugin>

Implicit Objects

Programming Advanced JSPs

Including Other Resources
Using Java Beans
Accessing Business Objects

Deploying JSPs

Unregistered JSPs
Registered JSPs

Invoking JSPs

Calling a JSP With a URL

Invoking JSPs in a Specific Application
Invoking JSPs in the Generic Application

Invoking a JSP From a Servlet

JSP 1.1 Tag Summary
Value-added Features

PagePath
Custom Tag Extensions
Database Query TagLib

LDAP Tag Library
Conditional Tag Library
Switch tag
Case tag
Value tag
dynamicValue tag
Attribute Tag Library

Load-balancing for JSPs
JSP Page Caching

Chapter 4 Introducing Enterprise JavaBeans

What Enterprise JavaBeans Do
What Is an Enterprise JavaBean?

Understanding Client Contracts
Understanding Component Contracts
Understanding Jar File Contracts

Session Beans and Entity Beans

Understanding Session Beans
Understanding Entity Beans

The Role of EJBs in iAS Applications
Designing an Object-Oriented Application

Planning Guidelines
Using Session Beans
Using Entity Beans
Planning for Failover Recovery
Working with Databases
Deploying EJBs

Chapter 5 Using Session EJBs to Manage Business Rules

Introducing Session EJBs
Session Bean Components

Creating the Remote Interface

Declaring vs. Implementing the Remote Interface

Creating the Class Definition

Session Timeout
Passivation and Activation

Creating the Home Interface

Additional Session Bean Guidelines

Creating Stateless or Stateful Beans
Accessing iAS Functionality
Serializing Handles and References
Managing Transactions
Committing a Transaction
Accessing Databases
Session Bean Failover

How to Configure a Stateful Bean with Failover
How the Failover Process Works
How often is the State Saved
How the State is Saved
How the Failover Process Works
Failover Guidelines

Chapter 6 Building Business Entity EJBs

Introducing Business Entity EJBs

How an Entity Bean Is Accessed

Entity Bean Components

Creating the Class Definition

Using ejbActivate and ejbPassivate
Using ejbLoad and ejbStore
Using setEntityContext and unsetEntityContext
Using ejbCreate Methods
Using Finder Methods
Declaring vs. Implementing the Remote Interface

Creating the Home Interface

Defining Create Methods
Defining Find Methods

Creating the Remote Interface

Additional Entity Bean Guidelines

Accessing iAS Functionality
Serializing Handles and References
Managing Transactions
Committing a Transaction

Commit Options B and C

Handling Concurrent Access
Accessing Databases
Container Managed Persistence

How Container Managed Persistence Works
Pluggable Container Managed Persistence
How to Use Persistence Managers in iAS
iAS Persistence Manager Reference Implementation

Chapter 7 Handling Transactions with EJBs

Understanding the Transaction Model
Specifying Transaction Attributes in an EJB
Using Bean Managed Transactions

Chapter 8 Using JDBC for Database Access

Introducing JDBC

Supported Functionality
Understanding Database Limitations
Understanding iAS Limitations
Supported Databases

Using JDBC in Server Applications

Using JDBC in EJBs

Managing Transactions with JDBC or javax.transaction.UserTransaction
Specifying Transaction Isolation Level

Using JDBC in Servlets

Handling Connections

Local Connections

Registering a Local Datasource

Global Connections

Using Resouce Managers
Registering a Global Datasource
Creating a Global Connection

Container Managed Local Connections

Registering a Container Managed Local Datasource

Working with JDBC Features

Working With Connections
Pooling Connections
Working with ResultSet

Concurrency Support
Updatable Result Set Support

Working with ResultSetMetaData
Working with PreparedStatement
Working with CallableStatement
Handling Batch Updates
Creating Distributed Transactions
Working with Rowsets

Using iASRowSet
Using CachedRowSet
Creating a RowSet

Using JNDI

Chapter 9 Rich Client

Overview of Rich Client

What is a Rich Client

Rich Client Architecture and Use Cases

Architecture
Use Cases

Value-added Features

Load Balancing
Failover
Security

Developing for a Rich Client

Server Side
Client Side

Application Client Container

Sample code

Sample client code
Sample Principal Class

Chapter 10 Packaging for Deployment

Overview of Packaging and Deployment
Introducing XML DTDs

Application Deployment Descriptor
Component Deployment Descriptors
Creating Deployment Descriptors
Deployment Descriptors
Document Type Definition (DTD)
The iAS Registry
GUIDs

Application XML DTD

J2EE Application DTD
iAS Application DTD
Sample Application XML DD File

Web Application XML DTD

Web Application Overview
Web Application XML DTD

Element for specifying an iAS Web Application
Elements for Specifying Servlet Information
Examples for Setting Cache Criteria
Elements for Specifying Session Information
Elements for Specifying EJB Reference Information
Elements for Specifying Resource Reference Information
Elements for Specifying nls Settings
Elements for Specifying Role Mapping

EJB XML DTD

EJB Jar File Contents
Specifying Parameter Passing Rules
EJB iAS XML DTD

Rich Client XML DTD

iAS Rich Client XML DTD

Elements for Specifying EJB Reference Information
Elements for Specifying Resource Reference Information

Resource XML DTD

Datasource XML DTD
Rich Client Datasource XML DTD

Chapter 11 Creating and Managing User Sessions

Introducing Sessions

Sessions and Cookies
Sessions and Security

How to Use Sessions

Creating or Accessing a Session
Examining Session Properties
Binding Data to a Session
Invalidating a Session
Controlling the Type of Session
Sharing Sessions with AppLogics

Chapter 12 Writing Secure Applications

iAS Security Goals
iAS Specific Security Features
iAS Security Model
Overview of Security Responsibilities

Application Developer
Application Assembler
Application Deployer

Common Security Terminology

Authentication
Authorization
Role Mapping

Container Security
Programmatic Security
Declarative Security

Application Level Security
Servlet Level Security
EJB Level Security

User Authentication by Servlets

HTTP Basic Authentication
SSL Mutual Authentication
Form Based Login

User Authorization by Servlets

Defining Roles
Referencing Security Roles
Defining Method Permissions
Sample web application DD

User Authorization by EJBs

Defining roles
Defining method permissions
Security role references:
Realm

User Authentication for Single Sign-on

How to Configure for Single Sign-on
Single Sign-on Example

User Authentication for Rich Client
Guide to Security Information

User Information
Security Roles

Chapter 13 Taking Advantage of iAS Features

Accessing the Servlet Engine

Accessing the Servlet's AppLogic
Accessing the Server Context

Caching Servlet Results
Using Application Events

The Application Events API

The IAppEventMgr Interface
The IAppEventObj Interface

Creating a New Application Event

Sending and Receiving Email from iAS

Accessing the Controlling AppLogic
Receiving Email
Sending Email

iAS Application Builder Features

Validating Form Field Data

Validation Methods
Validation Rules
Error Handlers
Example Validation Rules

Creating Named Form Action Handlers
Example Validation and Form Action Handler

Appendix A Using the Java Message Service

About the JMS API

JMS Messaging Styles

Enabling JMS and Integrating Providers

Enabling JMS Connection Pooling
Enabling the IBM MQ Provider
Enabling the Sun JMQ Provider

Using JMS in Applications

JNDI and Application Component Deployment
Connection Factory Proxy
Connection Pooling
User Identity Mapping
About Default Username
About Explicit User ID Map
ConnectionFactoryProxies and Application Created Threads
JMS Features Not Supported

JMS Administration

JMS Object Administration Tools
JNDI Properties for JMS Administration Tools
JMS Object Administration for IBM MQ
Connection Factory Proxy Administration
Creating a Proxy:
Deleting a Proxy
Listing Proxy Parameters
User ID Map Administration
Connection Pooling Configuration

Sample Applications
Future of JMS in iAS

Default JMS Provider
Message Driven Enterprise Java Beans
Using JMS in distributed transactions

Appendix B Dynamic Reloading

How Dynamic Reloading Works
Summary of Related Registry Entries

Appendix C Sample Deployment Files

Application DD XML Files

Sample Application DD XML File
Sample iAS Application DD XML File

Web Application DD XML Files

Sample Web Application DD XML File
Sample iAS Web-app DD XML File

EJB-jar DD XML Files

Sample EJB-jar DD XML File
Sample iAS EJB-jar DD XML File

Rich Client DD XML Files
Resource DD XML Files

Glossary

Index