Best Practices for WLI Application Life Cycle

Introduction

Features of WLI

Understanding Requirements

Designing WLI Applications

Modeling Business Processes and Services

Defining Business Processes

Identifying Process Objectives and Goals

Identifying Key Performance Indicators for the Process

Identifying Process Actors or Participants

Identifying Public and Private Processes

Identifying Initiator and Participant Processes

Keeping Processes Modular

Enabling end-to-end, Cross-functional Processes

Separating Production and Monitoring Processes

Designing and Developing Services

Service Classification

Identify Services

Define Service Contract

Define Input and Output Service Messages

Define Pre and Post Conditions for Services

Decide the Service Calling Paradigm

Decide the Service Granularity

Define Quality of Service Requirements

Design Service With a Service Proxy

Design Reusable Services

Design Loosely Coupled Services

Composing and Developing WLI Applications

Naming Standard for WLI Application Artifacts and Variables

Modular JPD Design

Modular XML Document

Parallel Node

JPD Exceptions

Event Handlers for Process Events

JPD Transactions and Compensation Management

Transaction Boundaries

Transactions for Synchronous and Asynchronous Processes

Transactions and Controls

Transactional and XA Compliant

Transactional and not XA Compliant Controls

Non-transactional Controls

JPD State Management

JPD Versioning

Singleton JPD

Race Condition With Dynamic Subscription

Dead Letter Channel Subscription

High Quality of Service JPD

SLA Threshold for JPDs

Monitor JPDs

Security Policy for JPDs

Interoperable JPDs

Communication Between JPDs

Using Controls

Using Dynamic Properties and Annotation for Controls

Buffering Service Control Methods During Asynchronous Calls

Using Control Factory to Manage Multiple Instances of a Control

Data Transformation

Canonical Data Model

Runtime Selection of a Transformation

Developing a Task Plan

Task Plan for Exception Management

Integrating Custom Logic With a Task Plan

Deploying and Maintaining WLI Applications

Deploying WLI Application During Runtime

Deploying WLI Application in a Cluster

Configuring Trading Partner Integration Resources

Changing Cluster Configurations and Deployment Requests

Load Balancing in a WLI Cluster

HTTP Functions in a Cluster

JMS Functions in a Cluster

Synchronous Clients and Asynchronous Business Processes

RDBMS Event Generators

Application Integration Functions in a Cluster

Synchronous Services

Asynchronous Services

WLI Performance Tips and Application Recovery

Performance Tips

Design-Time Performance Tips

Processes, Controls, and Callback Methods

Best Performance From Parallel Nodes in Business Processes

Pending Messages in JMS Queues

Removing Pending JMS Timer Messages

Increasing the Transaction Timeout Period

Run-Time Tuning Tips

Using Flags to Start WebLogic Server and Maximize Performance

Tuning WebLogic Integration Applications

Configuring max-beans-in-free-pool for the JMS Event Generator

Versioning for a Stateful Business Process

Setting Process Tracking Levels to Optimize Performance

Running the Archiver When Process Tracking Levels are set to None

Disabling Information Web Services Messages

Using the Document Store With the WebLogic Integration Application

Choosing the Best Persistence Model for JMS

Monitoring Parameters for WebLogic Integration Application Running Under Load

Reducing the Number of Transactions Timing out

Causes for Memory Leaks in Application

WLI Application Recovery

Configuring WebLogic Integration Application for Recovery

Starting the Recovery Process

Core Implementation Patterns for WLI Applications

Core Implementation Patterns for a JPD

Pattern 1: Basic Synchronous Stateless two-way Service

Pattern 2: Basic Asynchronous Stateless two-way Service

Pattern 3: Basic Asynchronous Stateless one-way Service

Pattern 4: Basic Asynchronous Stateful two-way Service

Pattern 5: Basic Asynchronous Stateful one-way Service

Pattern 6: Composite Synchronous Stateless two-way Service

Pattern 7: Composite Synchronous Stateful two-way Service

Pattern 8: Composite Asynchronous Stateless two-way Service

Pattern 9: Composite Asynchronous Stateless one-way Service

Pattern 10: Composite Asynchronous Stateful two-way Service

Pattern 11: Composite Asynchronous Stateful one-way Service

Other Patterns

SyncAsync Pattern

De-Synchronizer Pattern

De-Synchronizer Service

Coarse-Grained Process Front-end for a Fine-Grained Process

Loosely Coupled Process With a Common Message Interface

Dynamic Property Driven Processes

IDE Recommendations

Differences between WLI 8.x IDE and WLI 10.2 IDE

Project Structure

Eclipse-based Projects

File Extensions

No Wizard for Some Controls

Using Enterprise JavaBeans (EJB) Controls

DTF Design View not Available

XQuery

Iterative Development

Standards

Upgrading Sample Application System Schemas

Mapper Test View

Performance Setting for a Complex Application

Guidelines

Guidelines While Creating WLI Application

Guidelines During Application Development Stage

Guidelines While Building an Application

Recommended Reading

Appendix: Analyzing Use Cases and Requirements