Table of Contents
Preface
Chapter 1: Introduction to Oracle SOA Suite
Chapter 2: Writing Your First Service
Chapter 3: Service Enabling Existing Systems
Chapter 4: Loosely Coupling Services
Chapter 5: Using BPEL to Build Composite Services and Business Processes
Chapter 6: Adding in Human Workflow
Chapter 7: Using Business Rules to Define Decision Points
Chapter 8: Building Real-time Dashboards
Chapter 9: oBay Introduction
Chapter 10: Designing the Service Contract
Chapter 11: Building Business Services
Chapter 12: Building Validation into Services
Chapter 13: Error Handling
Chapter 14: Message Interaction Patterns
Chapter 15: Workflow Patterns
Chapter 16: Using Business Rules to Implement Services
Chapter 17: The Importance of Bindings
Chapter 18: Packaging and Deployment
Chapter 19: Testing Composite Applications
Chapter 20: Defining Security and Management Policies
Index
- Chapter 1: Introduction to Oracle SOA Suite
- Service-oriented architecture in short
- Service
- Orientation
- Architecture
- Why SOA is different
- Terminology
- Inter-operability
- Extension and evolution
- Reuse in place
- SOA Suite components
- Services and adapters
- ESB—service abstraction layer
- Service orchestration—BPEL Process Manager
- Rules
- Security and monitoring—OWSM
- Active monitoring–BAM
- Business to business—B2B
- Complex Event Processing—CEP
- SOA Suite architecture
- Top level
- Component view
- Implementation view
- A recursive example
- JDeveloper
- Other components
- Service repository and registry
- BPA Suite
- BPM Suite
- Portals and WebCenter
- Enterprise manager SOA management pack
- Summary
- Service-oriented architecture in short
- Chapter 2: Writing Your First Service
- Installing SOA Suite
- Writing our first BPEL process
- Creating an application
- Creating a BPEL project
- Assigning values to variables
- Deploying the process
- Testing the BPEL process
- Writing our first proxy service
- Writing the Echo proxy service
- Creating a change session
- Creating a project
- Creating 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
- Chapter 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
- 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
- Generate an adapter
- Modify the port type
- Modify the binding
- Add 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
- Writing to a database
- Summary
- Types of systems
- Chapter 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
- 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
- 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
- Summary
- Coupling
- Chapter 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
- Core BPEL process
- A simple composite service
- Creating our Stock Quote service
- Import 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
- Creating our Stock Quote service
- Summary
- Basic structure of a BPEL process
- Chapter 6: Adding in Human Workflow
- Workflow overview
- Leave approval workflow
- Creating our workflow process
- Defining the workflow task
- Specifying task parameters
- Creating the user interface to process the task
- Running the workflow process
- Creating our 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
- Dynamic task assignment
- 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
- Reassigning reportee tasks
- Summary
- Chapter 7: Using Business Rules to Define Decision Points
- Business Rule concepts
- Leave approval rule
- Using the Rule Author
- Creating a Rule Repository
- Creating a dictionary
- Defining facts
- Creating XML Facts
- Using aliases
- Hiding facts and properties
- Saving the rule dictionary
- Creating a rule set
- Adding a rule to our rule set
- Defining the test for the pattern
- Creating a Decision Service
- Creating a Rule Engine Connection
- Using a file based repository
- Using a WebDAV repository
- Creating a Decision Service
- Adding a Decide activity
- Assigning facts
- Creating a Rule Engine Connection
- Using functions
- Importing Java classes as facts
- Creating a function
- Invoking a function from within a rule
- Summary
- Business Rule concepts
- Chapter 8: Building Real-time Dashboards
- How BAM differs from traditional business intelligence
- Oracle BAM scenarios
- BAM architecture
- Logical view
- Physical view
- Capture
- Store
- Process
- Deliver
- BAM platform anomaly
- User interface
- Monitoring process state
- Defining data objects
- A digression on populating data object fields
- Instrumenting BPEL
- Testing the events
- Creating a simple dashboard
- Defining data objects
- Monitoring process status
- Monitoring KPIs
- Summary
- Chapter 9: oBay Introduction
- oBay requirements
- User registration
- User login
- Selling items
- List a new item
- Cancel listing
- Completing the sale
- View account
- Buying items
- Search for items
- Bidding on items
- User registration
- Defining our blueprint for SOA
- Architecture goals
- Typical SOA architecture
- Application services layer
- Virtual services layer
- Business services layer
- Business process
- User Interface layer
- One additional layer
- Where the SOA Suite fits
- oBay requirements
- 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
- oBay Application services
- Downloading and installing oBay application
- Summary
- Chapter 10: Designing the Service Contract
- Using XML Schema to define business objects
- Modelling data in XML
- Data decomposition
- Data hierarchy
- Data semantics
- Use attributes for metadata
- Schema guidelines
- Element naming
- Namespace considerations
- Partitioning the canonical model
- Single namespace
- Multiple namespaces
- Chameleon namespaces
- Modelling data in XML
- Using WSDL to define business services
- Use document (literal) wrapped
- Building your abstract WSDL document
- WSDL namespace
- Defining the 'wrapper' elements
- Defining the 'message' elements
- Defining the 'portType' element
- Using XML Schema and the WSDL within BPEL PM
- Sharing XML Schemas across BPEL processes
- Deploying schemas to the BPEL server
- Importing schemas
- Updating the schema URL
- Importing the WSDL document into BPEL PM
- Adding the PartnerLink definition to the abstract WSDL
- Sharing XML Schemas in the service bus
- Importing the WSDL document into the service bus
- Sharing XML Schemas across BPEL processes
- Strategies for managing change
- Major and minor versions
- Service implementation versioning
- Schema versioning
- Change schema location
- Update schema version attribute
- Resist changing the schema namespace
- WSDL versioning
- Incorporating changes to the canonical model
- Changes to the physical contract
- Updating the service endpoint
- Managing the service lifecycle
- Major and minor versions
- Summary
- Using XML Schema to define business objects
- Chapter 11: Building Business Services
- Build versus reuse
- Adapters and web service wrappers
- Adapters
- Service wrappers
- Adapters and web service wrappers
- Reusing existing functionality directly
- Exposing a PL/SQL stored procedure as a service
- Launching the PL/SQL web service wizard
- Choosing the level of Java Enterprise Edition support
- Selecting a database connection and defining service bindings
- Determine message style
- Select stored procedures and functions to expose
- Exposing a PL/SQL stored procedure as a service
- Modifying existing functionality using service bus
- Converting an existing service to canonical form
- Create a new service interface
- Adding the non-canonical service
- More complex conversions
- Exposing a Java class as a service
- Wrapping the Java code
- Launching the Web Service wizard
- Select deployment platform
- Select service name
- Select message format
- Provide custom serializers
- Mapping
- Select methods
- Converting an existing service to canonical form
- Creating services from scratch
- Creating a Java service from a WSDL
- Starting the wizard
- Choosing the WSDL
- Choosing the mapping options
- The generated Java
- Creating a Java service from a WSDL
- Summary
- Build versus reuse
- Chapter 12: Building Validation into Services
- Using XML Schema validation
- Strongly typed services
- Loosely typed services
- Combined approach
- Using schema validation within BPEL PM
- Validation of inbound documents
- Validation of outbound documents
- Validation between BPEL processes
- Setting validateXML for a BPEL domain
- Setting validateXML for a PartnerLink
- Using schema validation within the service bus
- Validation of inbound documents
- Validation of outbound documents
- Using Schematron for validation
- Overview of Schematron
- Assertions
- Rules
- Patterns
- Namespaces
- Schema
- Intermediate validation
- Cross field validation
- Date validation
- Element present
- Using Schematron within BPEL PM
- Creating a Partner Link for the Validation Service
- Creating a Schematron file
- Invoking the validate operation
- Sharing a Schematron between processes
- Using Schematron with the service bus
- Overview of Schematron
- 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
- Using XML Schema validation
- Chapter 13: 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
- Catching faults
- Using the fault management framework
- Defining a fault policy
- Defining fault policy conditions
- Defining fault policy actions
- Binding fault policies
- Binding fault polices at the process level
- Binding fault policies at the domain level
- Binding resolution
- Human intervention in BPEL Console
- Change the input variable contents and retry
- Set the output variable and continue
- Defining a fault policy
- Handling faults within the service bus
- Handling faults in synchronous proxy services
- Raising an error
- Defining an error handler
- Getting the qualified fault name
- Handling unexpected faults
- Returning a SOAP Fault
- Adding a Service Error Handler
- Handling permanent faults
- Handling transient faults
- Handling faults in one-way proxy services
- Handling faults in synchronous proxy services
- Summary
- Business faults
- Chapter 14: Message Interaction Patterns
- Message routing
- WS-Addressing
- Request message with WS-Addressing
- Response message with WS-Addressing
- Additional message exchanges
- WS-Addressing
- Using BPEL correlation sets
- Using correlation sets for multiple process interactions
- Defining a correlation set property
- Defining correlation set
- Using correlation sets
- Defining property aliases
- Using correlation sets for multiple process interactions
- 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
- Message routing
- Scheduling services
- Defining the schedule file
- Using FlowN
- Accessing branch specific data in FlowN
- Dynamic Partner Links
- Define common interface
- Define Job Partner Link
- Create endpoint reference
- Update Endpoint
- Re-cycling the scheduling file
- Summary
- Message routing
- Chapter 15: Workflow Patterns
- Managing multiple participants in a workflow
- Using multiple assignment and routing policies
- Determining the outcome by a group vote
- Using multiple Human Tasks
- Linking individual Human Tasks
- Using multiple assignment and routing policies
- Using the workflow API
- Defining the order fulfillment Human Task
- Specifying task parameters
- Specifying the routing policy
- Notification settings
- Querying task instances
- Defining a Partner Link for the Task Query Service
- User authentication
- Querying tasks
- Flex fields
- Populating Flex Fields
- Accessing Flex fields
- Getting task details
- Updating a task instance
- Defining a PartnerLink for the Task Service
- Using the updateTask operation
- Defining the order fulfillment Human Task
- Summary
- Managing multiple participants in a workflow
- Chapter 16: Using Business Rules to Implement Services
- How the rule engine works
- Asserting facts
- Executing the ruleset
- Rule activation
- Rule firing
- Retrieve result
- Session management
- Debugging a ruleset
- Using DM.println to add additional logging
- Using business rules to implement an auction
- Defining our XML Facts
- Defining the decision service
- Using a global variable to reference the result set
- 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
- Using Calendar functionality
- 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
- Complete ruleset
- Evaluating facts in date order
- Performance considerations
- Managing state within the BPEL process
- How the rule engine works
- Summary
- Chapter 17: The Importance of Bindings
- The web services stack
- Logical view of web services stack
- Physical view of web services stack
- Understanding Web Service Description Language (WSDL)
- How to read WSDL
- <definitions>
- <types>
- <message>
- <portType>
- <binding>
- <service>
- How to read WSDL
- The case for different bindings
- Connectivity
- Transactionality
- Performance
- JCA bindings
- Java bindings
- Creating a Java binding
- Service bus bindings
- Summary
- The web services stack
- Chapter 18: 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 BPEL Process Manager
- Deploying a BPEL process using the BPEL Console
- Deploying a BPEL process using 'ant'
- Enabling web service endpoint and WSDL location alteration
- Enabling adapter configuration
- XML Schema locations
- XSL imports
- BPEL deployment framework
- Oracle Web Services Manager (OWSM)
- Oracle rules
- Business activity monitoring
- Commands
- Selecting items
- Using iCommand
- Deployment architectures
- SOA Suite deployment architectures
- Using an external web server or load balancer
- Web services manager
- Console and monitor
- Oracle Service Bus
- Business activity monitoring
- Local hostnames
- SOA Suite deployment architectures
- Summary
- The need for packaging
- Chapter 19: Testing Composite Applications
- SOA Suite testing model
- One-off testing
- Testing BPEL processes
- Testing the service bus
- Automated testing
- The BPEL test framework
- BPEL test suites
- Data validation
- Deploying the test suite
- Running the test suites
- Partner link handling in test cases
- Simulation of process to process interactions
- Baseline scripts
- The BPEL test framework
- Regression testing
- System testing
- Composite testing
- Component testing
- Unit testing
- Performance testing
- User interface testing
- Summary
- Chapter 20: 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
- Web Services Manager model
- Policies
- Agents and gateways
- Distinctive benefits of gateways and agents
- Service bus model
- Security outside the SOA Suite
- Creating gateways and agents
- Creating a gateway
- Registering gateway services
- Creating an agent
- Enabling agent services
- Creating a gateway
- Defining policies
- Creating a new policy template to perform basic authentication
- Creating the template
- Extracting Credentials
- Authenticating a user
- Authorizing a user
- Saving the pipeline template
- Creating a new policy
- Creating an agent policy
- Creating a gateway policy
- Applying a policy through Service Bus Console
- Service accounts
- Using a service account
- Managing service bus user accounts
- Service bus roles
- Using a role to protect a proxy service
- Final thoughts on security
- Creating a new policy template to perform basic authentication
- Monitoring services
- Monitoring overall service statistics in OWSM
- Defining a Service Level Agreement in OWSM
- Other monitoring and measuring features in OWSM
- Monitoring in service bus
- Creating an Alert Destination
- Enabling service monitoring
- Creating an alert rule
- Monitoring the service
- What makes a good SLA
- Summary
- Security and management challenges in the SOA environment
