Oracle SOA Suite 11g R1 Developer's Guide电子书

Oracle SOA Suite 11g R1 Developer's Guide

Table of Contents

Oracle SOA Suite 11g R1 Developer's Guide

Credits

Foreword

About the Authors

Acknowledgement

Acknowledgement

About the Reviewers

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Errata

Piracy

Questions

I. Getting Started

1. Introduction to Oracle SOA Suite

Service-oriented architecture in short

Service

Orientation

Architecture

Why SOA is different

Terminology

Interoperability

Extension and evolution

Reuse in place

Service Component Architecture (SCA)

Component

Service

Reference

Wire

Composite.xml

Properties

SOA Suite components

Services and adapters

ESB – service abstraction layer

Oracle Service Bus and Oracle Mediator

Service orchestration – the BPEL process manager

Rules

Security and monitoring

Active monitoring – BAM

Business to Business – B2B

Complex Event Processing – CEP

Event delivery network

SOA Suite architecture

Top level

Component view

Implementation view

A recursive example

JDeveloper

Other components

Service repository and registry

BPA Suite

The BPM Suite

Portals and WebCenter

Enterprise manager SOA management pack

Summary

2. Writing your First Composite

Installing SOA Suite

Writing your first BPEL process

Creating an application

Creating an SOA project

SOA project composite templates

Creating a BPEL process

Assigning values to variables

Deploying the process

Testing the BPEL process

Adding a Mediator

Using the Service Bus

Writing our first proxy service

Writing the Echo proxy service

Creating a Change Session

Creating a project

Creating the project folders

Creating service WSDL

Importing a WSDL

Creating our business service

Creating our proxy service

Creating message flow

Activating the Echo proxy service

Testing our proxy service

Summary

3. Service-enabling Existing Systems

Types of systems

Web service interfaces

Technology interfaces

Application interfaces

Java Connector Architecture

Creating services from files

A payroll use case

Reading a payroll file

Starting the wizard

Naming the service

Identifying the operation

Defining the file location

Selecting specific files

Detecting that the file is available

Message format

Defining a native format schema

Using a sample file

Record structure

Choosing a root element

Message delimiters

Record type names

Field properties

Verifying the result

Finishing the wizards

Throttling the file and FTP adapter

Creating a dummy message type

Adding an output message to the read operation

Using the modified interface

Writing a payroll file

Selecting the FTP connection

Choosing the operation

Selecting the file destination

Completing the FTP file writer service

Moving, copying, and deleting files

Generating an adapter

Modifying the port type

Modifying the binding

Configuring file locations through additional header properties

Adapter headers

Testing the file adapters

Creating services from databases

Writing to a database

Selecting the database schema

Identifying the operation type

Identifying tables to be operated on

Identifying the relationship between tables

Under the covers

Summary

4. Loosely-coupling Services

Coupling

Number of input data items

Number of output data items

Dependencies on other services

Dependencies of other services on this service

Use of shared global data

Temporal dependencies

Reducing coupling in stateful services

Service abstraction tools in SOA Suite

Do you have a choice?

When to use the Mediator

When to use Oracle Service Bus

Oracle Service Bus design tools

Oracle Workshop for WebLogic

Oracle Service Bus Console

Service Bus overview

Service Bus message flow

Virtualizing service endpoints

Moving service location

Using Adapters in Service Bus

Selecting a service to call

Virtualizing service interfaces

Physical versus logical interfaces

Mapping service interfaces

Applying canonical form in the Service Bus

An important optimization

Using the Mediator for virtualization

Summary

5. Using BPEL to Build Composite Services and Business Processes

Basic structure of a BPEL process

Core BPEL process

Variables

Partner links

Messaging activities

Synchronous messaging

Asynchronous messaging

One way messaging

A simple composite service

Creating our StockQuote service

Importing StockService schema

Calling the external web services

Calling the web service

Assigning values to variables

Testing the process

Calling the exchange rate web service

Assigning constant values to variables

Using the expression builder

Asynchronous service

Using the wait activity

Improving the stock trade service

Creating the while loop

Checking the price

Using the switch activity

Summary

6. Adding in Human Workflow

Workflow overview

Leave approval workflow

Defining the human task

Specifying task parameters

Specifying task assignment and routing policy

Invoking our human task from BPEL

Creating the user interface to process the task

Running the workflow process

Processing tasks with the worklist application

Improving the workflow

Dynamic task assignment

Assigning tasks to multiple users or groups

Cancelling or modifying a task

Withdrawing a task

Modifying a task

Difference between task owner and initiator

Requesting additional information about a task

Managing the assignment of tasks

Reassigning reportee tasks

Reassigning your own task

Delegating tasks

Escalating tasks

Using rules to automatically manage tasks

Setting up a sample rule

Summary

7. Using Business Rules to Define Decision Points

Business rule concepts

XML facts

Decision services

Leave approval business rule

Creating a decision service

Implementing our business rules

Adding a rule to our ruleset

Creating the IF clause

Creating the Then clause

Calling a business rule from BPEL

Assigning facts

Using functions

Creating a function

Testing a function

Testing decision service functions

Invoking a function from within a rule

Using decision tables

Defining a bucket set

Creating a decision table

Conflict resolution

Summary

8. Using Business Events

How EDN differs from traditional messaging

A sample use case

Event Delivery Network essentials

Events

Event publishers

Publishing an event using the Mediator component

Publishing an event using BPEL

Publishing an event using Java

Creating the event

Creating the event connection

Publishing the event

Event subscribers

Consuming an event using Mediator

Consuming an event using BPEL

EDN publishing patterns with SOA Suite

Publishing an event on receipt of a message

Publishing an event on a synchronous message response

Publishing an event on a synchronous message request and reply

Publishing an event on an asynchronous response

Publishing an event on an asynchronous message request and reply

Publishing an event on an event

Monitoring event processing in Enterprise Manager

Summary

9. Building Real-time Dashboards

How BAM differs from traditional business intelligence

Oracle BAM scenarios

BAM architecture

Logical view

Physical view

Acquire

Store

Process

Deliver

Steps in using BAM

User interface

Monitoring process state

Defining reports and data required

Defining data objects

A digression on populating data object fields

Instrumenting BPEL and SCA

Invoking the BAM adapter as a regular service

Creating a BAM adapter

Invoking the BAM adapter

Invoking the BAM adapter through BPEL sensors

Testing the events

Creating a simple dashboard

Monitoring process status

Monitoring KPIs

Summary

II. Putting it All Together

10. oBay Introduction

oBay requirements

User registration

User login

Selling items

List a new item

Completing the sale

View account

Buying items

Search for items

Bidding on items

Defining our blueprint for SOA

Architecture goals

Typical SOA Architecture

Application services layer

Virtual services layer

Business services layer

Functional type

Service consumer

Business process

User interface layer

One additional layer

Where the SOA Suite fits

Composite application

Composite granularity

Composite reusability

Composite lifecycle

Composite security and management policies

Basic composite design pattern

Where to implement virtual services

Mediator as a proxy for a composite

Mediator as a proxy for an external reference

Using a composite as a virtual service

Service invocation between composite applications

Centralized approach

Peer-to-peer topology

Hybrid approach

oBay high-level architecture

oBay application services

Workflow services

External web services

oBay developed services

oBay internal virtual services

oBay business services

oBay business processes

oBay user interface

Summary

11. Designing the Service Contract

Using XML Schema to define business objects

Modeling data in XML

Data decomposition

Data hierarchy

Data semantics

Using attributes for metadata

Schema guidelines

Element naming

Name length

Compound names

Naming standards

Namespace considerations

Always specify a target namespace

Default namespace

Qualified or unqualified element names

Qualified or unqualified attributes

Namespace naming conventions

Global versus local

Elements versus types

Partitioning the canonical model

Single namespace

Multiple namespaces

Separate common objects into their own namespaces

Using WSDL to define business services

Use Document (literal) wrapped

Building your abstract WSDL document

WSDL namespace

Defining the 'wrapper' elements

Defining a schema for our wrapper elements

Importing our wrapper elements

Defining the 'message' elements

Defining the 'PortType' Element

Using XML Schema and the WSDL within SOA Suite

Sharing XML Schemas across composites

Defining an MDS connection

Importing schemas from MDS

Manually importing schemas

Deploying schemas to the SOA infrastructure

Creating a JAR file within JDeveloper

Creating an SOA Bundle for a JAR file

Importing the WSDL document into a composite

Sharing XML Schemas in the Service Bus

Importing the WSDL document into the Service Bus

Strategies for managing change

Major and minor versions

Service implementation versioning

Schema versioning

Changing schema location

Updating schema version attribute

Resisting changing the schema namespace

WSDL versioning

Incorporating changes to the canonical model

Changes to the physical contract

Updating the service endpoint

Including version identifiers in the WSDL definition

Managing the service lifecycle

Summary

12. Building Entity Services Using Service Data Objects (SDOs)

Service Data Objects

Oracle 11g R1 support for SDO

Oracle SOA Suite 11g SDO support

Implementing a Service Data Object

Overview of ADF Business Components

Creating our ListingSDO application

Creating our Listing Business Components

Defining Entity objects

Defining updatable View objects

Defining the application module

Testing the listing ADF-BC in JDeveloper

Generating the primary key using an Oracle Sequence

Creating the ADF extension class for EntityImpl

Updating default ADF base classes

Configuring Listing entity to use Oracle Sequence

Creating the ListingSDO service interface

Enabling master detail updates

Deploying the Service Data Object

Creating a service deployment profile

Setting Web Context Root

Registering SDO with SOA infrastructure

Registering the ListingSDO as an RMI service

Configuring global JDBC data source

Determining the SDO registry key

Using the ListingSDO in an SOA composite

Creating an ADF-BC Service Reference

Invoking the SDO from BPEL

Creating an entity variable

Creating a Listing entity

Binding to the Listing entity

Inserting a detail SDO into a master SDO

Updating a detail SDO

Deleting a detail SDO

Deleting a Service Data Object

Exposing the SDO as a business service

Summary

13. Building Validation into Services

Validation within a composite

Using XML Schema validation

Strongly-typed services

Loosely-typed services

Combined approach

Schema validation within the Mediator

Using schema validation within BPEL PM

Validation of BPEL variables

Validation of inbound and outbound documents

Setting validateXML for a partner link

Using schema validation within the Service Bus

Validation of inbound documents

Validation of outbound documents

Using Schematron for validation

Overview of Schematron

Assertions

Rules

Using a relative context

Patterns

Namespaces

Schema

Intermediate validation

Cross field validation

Using XPath predicates in rules

Using XPath 2.0 functions

Date validation

Element present

Using Schematron within the Mediator

Using the Metadata Service to hold Schematron files

Returning Schematron errors

Using Schematron with the Service Bus

Putting validation in the underlying service

Using Business Rules for validation

Coding in validation

Returning validation failures in synchronous services

Defining faults

Custom fault codes

Validation failures in asynchronous services

Layered validation considerations

Dangers of over validation

Dangers of under validation

Negative coupling of validation

Summary

14. Error Handling

Business faults

Defining faults in synchronous services

Defining faults in asynchronous services

Handling business faults in BPEL

Catching faults

Adding a catch branch

Throwing faults

Compensation

Defining compensation

Triggering a Compensation handler

Adding a Compensate activity

Returning faults

Asynchronous Considerations

Handling business faults in Mediators

Synchronous Mediators

System faults

Asynchronous Mediators

Using timeouts

Using the fault management framework

Using the fault management framework in BPEL

Using the fault management framework in Mediator

Defining a fault policies file

Defining a fault policy

Defining fault policy conditions

Specifying the <faultName>

Specifying the <condition>

Defining fault policy actions

Retry action

Human intervention action

Abort action

Rethrow action

Replay scope action

Java action

Binding fault policies

Defining bindings on the composite

Defining bindings on a component

Defining bindings on an external reference

Binding resolution

Using MDS to hold fault policy files

Human intervention in Fusion Middleware Control Console

Handling faults within the Service Bus

Handling faults in synchronous proxy services

Raising an error

Defining an error handler

Adding a route error handler

Checking the type of SOAP Faults

Getting the qualified fault name

Creating a SOAP Fault

Handling unexpected faults

Returning a SOAP Fault

Adding a service error handler

Handling permanent faults

Generating alerts

Enabling alerts

Handling transient faults

Retrying a non-responsive business service

Handling faults in one-way proxy services

Summary

15. Advanced SOA Suite Architecture

Relationship of infrastructure to service engines

Composite execution and suspension

BPEL dehydration events

Threading and message delivery in SOA Suite

One-way message delivery

Immediate execution of one-way messages in BPEL

Activation agent threads

Dispatcher threads

Transactions

BPEL transactions

BPEL component properties

BPEL partner link properties

BPEL activities

Transactions and thread wrinkles in BPEL

Reply handling

Oracle Service Bus (OSB) transactions

Transactional binding

Non-transactional binding

Non-transactional proxy

Transactional proxy

Comparison to EJB

Clustering

Load balancing

JMS considerations

Testing considerations

Adapter considerations

Metadata repository considerations

Database connections

Summary

16. Message Interaction Patterns

Messaging within a composite

Processing of messages within the Mediator

Processing of messages within BPEL PM

Message addressing

Multi-protocol support

Message correlation

WS-Addressing

Request message with WS-Addressing

Response message with WS-Addressing

Using BPEL correlation sets

Using correlation sets for multiple process interactions

Defining a correlation set property

Defining correlation set

Using correlation sets

Initializing the correlation set

Defining property aliases

Message aggregation

Message routing

Correlating the callback

Specifying the reply to address

Creating a proxy process

Using the pick activity

Defining the correlation sets

Completing the aggregation

Scheduling services

Defining the schedule file

Using FlowN

Accessing branch-specific data in FlowN

Dynamic partner links

Defining a common interface

Defining a job partner link

Creating an endpoint reference

Updating the endpoint

Recycling the scheduling file

Summary

17. Workflow Patterns

Managing multiple participants in a workflow

Using multiple assignment and routing policies

Determining the outcome by a group vote

Voting on the outcome

Sharing attachments and comments

Assigning participants

Skipping the second step

Using multiple human tasks

Linking individual human tasks

Using the workflow API

Defining the order fulfillment human task

Specifying task parameters

Specifying the routing policy

Notification settings

Querying task instances

Defining an external reference for the Task Query Service

User authentication

Creating the credential element

Querying tasks

Specifying the display column list

Flex fields

Populating flex fields

Accessing flex fields

Specifying the query predicate

Using flex fields in the query predicate

Ordering the data

Getting task details

Updating a task instance

Using the updateTask operation

Updating the task payload

Updating the task flex fields

Updating the task outcome

Summary

18. Using Business Rules to Implement Services

How the rule engine works

Asserting facts

Executing the ruleset

Rule activation

Rule firing

Retrieving result

Session management

Debugging a ruleset

Debugging a decision service with a test function

Debugging a decision service within a composite

Using the print function to add additional logging

Using business rules to implement auction

Defining our XML facts

Defining the business rule

Configuring the decision function

Deselect Check Rule Flow

Asserting the XML tree

Using a global variable to reference the resultset

Defining a global variable

Defining a rule to initialize a global variable

Writing our auction rules

Evaluating facts in date order

Checking for non-existent fact

Updating the bid status

Using inference

Processing the next valid bid

Using functions to manipulate XML facts

Asserting a winning bid

Retracting a losing bid

Rules to process a new winning bid

Validating the next bid

Rule to process a losing bid

Capping the winning bid amount

Complete ruleset

Performance considerations

Managing state within the BPEL process

Using functions to control the assertion of facts

Summary

III. Other Considerations

19. Packaging and Deployment

The need for packaging

Problems with moving between environments

Types of interface

Web interfaces

Command-line interfaces

SOA Suite packaging

Oracle Service Bus

Oracle SOA composites

Deploying a SCA composite via the EM Console

Deploying a SCA composite using Ant

Compile parameters (ant-sca-compile.xml)

Package parameters (ant-sca-package.xml)

Deploy parameters (ant-sca-deploy.xml)

Test parameters (ant-sca-test.xml)

Revisions and milestones

The default revision

Enabling web service endpoint and WSDL location alteration

Enabling adapter configuration

XML schema locations

XSL imports

Composite configuration plan framework

Creating a configuration plan template

Creating a configuration plan

Attaching a configuration plan to an SCA archive

Web services security

Oracle rules

Business activity monitoring

Commands

Selecting items

Using iCommand

Summary

20. Testing Composite Applications

SOA Suite testing model

One-off testing

Testing composites

Testing the Service Bus

Automated testing

The composite test framework

Composite test suites

Injecting data into the test case

Data validation

Emulating components and references

Deploying and running test suites

Regression testing

System testing

Composite testing

Component testing

Unit testing

Performance testing

User interface testing

Summary

21. Defining Security and Management Policies

Security and management challenges in the SOA environment

Evolution of security and management

Added complications of SOA environment

Security Impacts of SOA

Management and monitoring impacts of SOA

Securing services

Security outside the SOA Suite

Network security

Preventing message interception

Restricting access to services

Declarative security versus explicit security

Security as a facet

Security as a service

Security model

Policy enforcement points

Policies

Agents and gateways

Distinctive benefits of gateways and agents

Benefits of gateways

Drawbacks of gateways

Benefits of agents

Drawbacks of agents

The gateway dilemma

Service Bus model

Defining policies

Creating a new policy to perform authentication and authorization

Creating the authorization policy

Oracle-recommended naming conventions for polices

Creating the policy

Applying a policy

Applying a policy through the Service Bus Console

Importing a policy

Applying OWSM policies in Service Bus

Final thoughts on security

Monitoring services

Monitoring service health in SOA Suite

System up-down status

System throughput view

Monitoring SOA Composite performance

Monitoring in the Service Bus

Creating an alert destination

Enabling service monitoring

Creating an alert rule

Monitoring the service

What makes a good SLA

Summary

Index