IntroductionCourse Outline
Topics
 

In SOA, ESB patterns are used to integrate applications and businesses. The goal of this course is to explain the most common ESB patterns as well as show how to implement them in the IBM WebSphere ESB 6.2 platform. Below is a list of most key topics discussed:

  • Gathering and analyzing requirements in SOA
  • Service identification techniques
  • How to model a message flow
  • Service invocation and composition
  • Content based message routing
  • Audit logging
  • Message filtering
  • Data translation details
  • Communication protocol mapping
  • Messaging and asynchronous communication
  • Service security patterns
  • Error handling
  • Transaction management
 
Audience
 

Architects and senior developers who would like to learn about the concepts behind a SOA based application integration architecture. After taking this course, students will learn how to gather requirements and analyze them. They will learn how to identify services and model message flows.

If you are a developer and want to learn about WebSphere ESB programming, WA1797 WebSphere Enterprise Service Bus (ESB) 6.2 Programming is recommended.
 
Prerequisites
 

Good knowledge of Web Services (SOAP and WSDL) is required. Basic understanding of general software architecture concepts like security, messaging and transaction management is definitely recommended.

Knowledge of Java programming is optional and not required.
 
Duration
 

4 days
Download Sample Labs Lab Setup Guide

Outline for Architecting SOA Using Enterprise Service Bus (ESB) IBM Edition Training

Chapter 1 - Enterprise Service Bus (ESB) Pattern
 
  • SOA and the ESB Pattern
  • Loose Coupling
  • Service Invocation and Composition
  • Message Flow and Business Process
  • Data Integration
  • ESB in Action
  • The ESB Patterns
  • Service Virtualization Patterns
  • Service Enablement Patterns
  • Message Based Integration Patterns
  • Summary
 

Chapter 2 - Introduction to WebSphere Integration Developer (WID) v6.2
 
  • WebSphere Integration Developer (WID) v6.2
  • SCA Basics
  • Wiring Example
  • Items Developed in WID
  • The Project Structure
  • Working With Shared Components
  • Using the IDE
  • The Test Server
  • The Build Process
  • Exporting Applications
  • Module Versioning
  • Summary
 

Chapter 3 - Introduction to Mediation Flow
 
  • What is Mediation Flow?
  • Source and Target Operations
  • Message Flow Logic
  • Mediation Primitives
  • Anatomy of a Message
  • Developing a Mediation Flow
  • Routing Primitives
  • Transformation Primitives
  • Other Primitives
  • Subflow
  • Summary
 

Chapter 4 - Service Component Architecture (SCA)
 
  • Need For a New Programming Model
  • SCA Vendor Support
  • SCA Basics
  • SCA Components
  • A Service Component
  • References and Wires
  • Wiring Example
  • Service Assembly Model
  • Example Assembly
  • Imports
  • Export
  • Example Import and Export
  • Summary
 

Chapter 5 - SOA Case Study
 
  • The Story of Air Handling International (AHI)
  • The Parts Ordering Process
  • Why the Process is Not Working Well
  • Opportunities and Challenges
  • Solving the Problem the Old Way
  • Solving the Problem the ESB Way
  • Inside the ESB
  • Summary
 

Chapter 6 - Business Objects
 
  • What is a Business Object?
  • Creating a New Business Object
  • Editing a Business Object
  • Setting Field Multiplicity
  • Refactoring Business Objects
  • Private Business Object
  • Data Type Inheritance
  • SimpleType Inheritance
  • Abstract Business Object
  • Schema Wildcards
  • Specify Schema Restrictions
  • Business Object Validation
  • Best Practices
  • Accessing Business Objects Using SDO API
  • Using the SDO API
  • Summary
 

Chapter 7 - Service Interface Design
 
  • What is a Service Interface?
  • Uses of an Interface
  • The Structure of an Interface
  • Creating an Interface
  • The Interface Editor
  • SMO Body Type
  • Refactoring Interfaces
  • Summary
 

Chapter 8 - Binding and Protocol Translation
 
  • The Import Component
  • The Export Component
  • Introduction to Binding
  • Supported Binding Types
  • Implementing Protocol Translation Pattern
  • The Web Service Binding
  • Creating a Web Service Import
  • Creating a Web Service Export
  • Creating a New web Service
  • Summary
 

Chapter 9 - Data Mapping
 
  • Introduction to Mapping
  • Choosing a Type of Mapping
  • Embedded or Standalone Mapping
  • Using Data Maps from a Mediation Flow
  • Create Embedded Map for Mediation Flow
  • Root of a Map
  • Mapping Editor
  • Mapping Header and Context
  • Header Setter Primitives
  • Types of Data Transformations for XML Maps
  • Types of Array Data Transformations for XML Maps
  • Types of Data Transformations for Business Object Maps
  • Automatic Mapping
  • Using Map from Business Process
  • Creating a Standalone Map
  • Adding Objects to the Standalone Map
  • Substitution Groups
  • Mapping Schema Wildcards
  • Set Message Type Mediation Primitive
  • Message Element Setter Primitive
  • Need for Reverse Maps
  • Summary
 

Chapter 10 - Introduction to Service Oriented Analysis & Design (SOAD)
 
  • Introduction to SOAD
  • Applying OOAD Principles
  • Encapsulation
  • Encapsulation in SOAD
  • Inheritance
  • Inheritance in SOAD
  • Polymorphism
  • Polymorphism in SOAD
  • Why OOAD Is Not Enough
  • Granularity
  • The Need for Loose Coupling
  • The SOAD Methodology
  • The SOAD Methodology Steps
  • Stage 1: Requirements Gathering & Process or Message Flow Modeling
  • Stage 1: Requirements Gathering & Process Modeling
  • Stage 2: Service Identification
  • Stage 3: Service Implementation
  • Stage 4: Process Implementation
  • SOAD Stages and SOA Lifecycle
  • Summary
 

Chapter 11 - Requirements Gathering and Message Flow Modeling
 
  • Where are We in Stages of SOAD?
  • Where are We in Service Lifecycle?
  • Overview of this Phase
  • Requirements Gathering Using Use Case
  • Anatomy of a Business Use Case
  • Example Use Case: Parts Ordering by AHI Inc.
  • Modeling the Message Flow
  • Anatomy of a Message Flow Model
  • Scope of Use Case and Message Flow
  • What is BPMN?
  • Basic Structure of a Message Flow
  • Start and End Events
  • Message Exchange
  • Conditional Flow Paths
  • Parallel Execution
  • Looping
  • Modeling the Actors
  • Summary
 

Chapter 12 - Service Identification and Specification
 
  • Stages of SOAD
  • Where are We in Service Lifecycle?
  • The Service Identification Stage
  • The Service Model
  • Service Model Example #1
  • Service Model Example #2
  • Service Model Example #3
  • Identify Service Operations from Business Process Model
  • Identify Service Operations from Message Flow Model
  • Group Operations as Services
  • Reuse Services and Applications
  • Define Logical Data Model
  • Specify Service Interface
  • Specify Business Process or Message Flow Interface
  • Business Process Case Study
  • Message Flow Case Study
  • Service Contract Template
  • Service Design Best Practices
  • Summary
 

Chapter 13 - Service Invocation and Composition
 
  • Service Invocation and Composition
  • Service Invoke Mediation Primitive
  • Service Invoke Mediation Primitive
  • Using a Service Invoke Primitive
  • Augmentation/Enrichment Pattern
  • Augmentation/Enrichment Pattern - Example
  • Augmentation/Enrichment Pattern – Example
  • Retry the Same Service Pattern
  • Retry the Same Service Pattern – Example
  • Retry an Alternate Service Pattern
  • Retry an Alternate Service Pattern – Example
  • Sequencing Pattern
  • Sequencing Pattern – Example
  • Callout Node vs. Service Invoke Primitive
  • Dynamic Service Invocation
  • Dynamic Import Name
  • Dynamic Endpoint URL
  • Summary
 

Chapter 14 - Content-Based Routing
 
  • Routing in Mediation
  • Reasons to Perform Content-Based Routing
  • Routing Pattern
  • Refactoring to Implement Routing
  • Routing Primitives
  • Message Filter Primitive
  • Type Filter Primitive
  • Type Filter Output Format
  • Routing to Other Primitives
  • Summary
 

Chapter 15 - Looping, Splitting and Aggregation
 
  • Introduction
  • Implement Looping
  • Access Iteration Element
  • Implementing Splitting and Aggregation
  • Setting up the Fan Out
  • Setting up the Fan In Primitive
  • Ending Fan In Wait Early
  • Aggregating Service Responses
  • Saving Response in Shared Context
  • Mapping Body to Shared Context and Vice Versa
  • Doing Things in Parallel
  • Summary
 

Chapter 16 - Messaging Bindings
 
  • Messaging Binding Choices
  • Publishing a JMS Message
  • Consuming a JMS Message
  • JMS Import Binding Configuration
  • Message Correlation in Import
  • JMS Export Binding Configuration
  • Message Correlation on Export
  • Working with Native MQ Binding
  • MQ Import Configuration
  • MQ Export Configuration
  • Messaging in WebSphere Environments
  • Default Messaging
  • Service Integration Bus
  • Service Integration Bus
  • WebSphere MQ
  • Which To Use?
  • Default Messaging JMS Configuration
  • Relationship Between Default Messaging Components
  • WebSphere MQ JMS Configuration
  • Relationship Between MQ Messaging Components
  • Summary
 

Chapter 17 - Transaction and Error Handling
 
  • Transaction Basics
  • Transaction in Mediation Flow
  • Transaction Context Propagation
  • Controlling Context Propagation
  • Basics of Error Handling
  • Error Handling in a Service
  • Designing Faults
  • Catching Errors in a Message Flow
  • Returning a Fault from a Message Flow
  • Raising an Exception
  • Stopping a Flow Path
  • Summary
 

Chapter 18 - Adapters
 
  • What is an Adapter?
  • Adapter and SOA
  • Adapter Example
  • The Adapter Pattern
  • Adapter Support from WID
  • Adapter Based Services
  • Advantages of Adapter Based Services
  • Generating Adapter Based Services
  • Outbound Processing
  • Inbound Processing
  • Enterprise Discovery
  • Case Study
  • Flat File Adapter
  • Inbound File Adapter
  • Configuring the Inbound Service
  • Outbound File Adapter
  • Configuring Outbound Service
  • Adapter Administration
  • Summary
 

Chapter 19 - WESB Programming Best Practices
 
  • Use the Right Module and Runtime
  • Design the Module Structure
  • Beaware of Data Types and Service Interface Changes
  • Select Binding Type Carefully
  • Document Artifacts
  • Use Java Code Sparingly
  • Automate Unit Test
  • Use Message Context Correctly
  • Use One-Way Operations Carefully
  • Perform Extensive Logging
  • Summary