Best Practices for WLI Application Lifecycle

     Previous  Next    Contents    View as PDF - New Window  Get Adobe Reader - New Window
Content starts here


Features of WLI

Understanding Requirements

Architecture and Design of the WLI Application

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

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

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

Loosely Coupled Process With a Common Message Interface

Dynamic Property Driven Processes

Understanding Requirements

  Back to Top       Previous  Next