You are previewing Open Source SOA.
O'Reilly logo
Open Source SOA

Book Description

Software Oriented Architecture, or SOA, has become embraced by many organizations as a means of improving reusability of software assets; providing better alignment between business and IT; and, increasing agility for responding to demands in the marketplace. This is accomplished by breaking individual units of functionality into services that can then be exposed through open protocols and standards.

Until recently, many of the software technologies used for developing SOA-based solutions were limited to expensive, commercial offerings. However, that has now changed, and a compelling open source SOA platform can be implemented exclusively with open source products. This book identifies a suite of open source products that can be used for a building SOA environment, and describes how they can be integrated by practitioners. It includes a hands-on introduction to the products selected; a multitude of source code examples; and implementation through real-life case studies.

"A survival guide in the complex landscape of open source SOA."

—Alberto Lagna, whitebox.it

"An invaluable guide ... excellent examples."

—Rick Wagner, Acxiom Corp.

"The in-depth comparisons of various open source SOA products are worth the price of the book."

—Peter Johnson, Unnisys

"... applicable to any SOA project, regardless of the platform."

—Irena Kennedy, Microsoft

"Practical SOA solution that integrates key open source technologies."

—Doug Warren, Java Web Services

Table of Contents

  1. Copyright
  2. Preface
  3. Acknowledgments
  4. About This Book
    1. Roadmap
    2. Code conventions and downloads
    3. Author Online
    4. About the cover illustration
  5. 1. History and principles
    1. 1. SOA essentials
      1. 1.1. Brief history of distributed computing
        1. 1.1.1. Problems related to RPC-based solutions
        2. 1.1.2. Understanding SOAP's messaging styles
        3. 1.1.3. Advent of SOA
      2. 1.2. The promise of web services for delivering SOA
      3. 1.3. Understanding the core characteristics of SOA
        1. 1.3.1. Service interface/contract
        2. 1.3.2. Service transparency
        3. 1.3.3. Service loose coupling and statelessness
        4. 1.3.4. Service composition
        5. 1.3.5. Service registry and publication
      4. 1.4. Technologies of a SOA platform
        1. 1.4.1. Business process management
        2. 1.4.2. Enterprise decision management
        3. 1.4.3. Enterprise service bus
        4. 1.4.4. Event stream processor
        5. 1.4.5. Java Message Service
        6. 1.4.6. Registry
        7. 1.4.7. Service components and compositions
        8. 1.4.8. Web service mediation
      5. 1.5. Introducing a SOA maturity model
      6. 1.6. Summary
    2. 2. Defining the Open SOA Platform
      1. 2.1. Evaluating open source products
      2. 2.2. Choosing a BPM solution
        1. 2.2.1. BPM product evaluation criteria
        2. 2.2.2. Open source BPM products
        3. 2.2.3. Selecting a BPM solution
        4. 2.2.4. Introducing JBoss jBPM
      3. 2.3. Choosing an enterprise decision management solution
        1. 2.3.1. EDM product evaluation criteria
        2. 2.3.2. Open source EDM products
        3. 2.3.3. Selecting an EDM
        4. 2.3.4. Introducing JBoss Rules (Drools)
      4. 2.4. Choosing an ESB
        1. 2.4.1. ESB product evaluation criteria
        2. 2.4.2. Open source ESB products
        3. 2.4.3. Selecting an ESB
        4. 2.4.4. Introducing Synapse as a lightweight ESB
      5. 2.5. Choosing an ESP solution
        1. 2.5.1. What is event stream processing?
        2. 2.5.2. Introducing Esper
      6. 2.6. Choosing a registry
        1. 2.6.1. Registry evaluation criteria
        2. 2.6.2. Open source registry products
        3. 2.6.3. Selecting a registry
        4. 2.6.4. Introducing WSO2 Registry
      7. 2.7. Choosing a service components and composites framework
        1. 2.7.1. Examining the Service Component Architecture
        2. 2.7.2. Introducing Apache Tuscany
      8. 2.8. Choosing a web services mediation solution
      9. 2.9. Summary
  6. 2. Assembling components and services
    1. 3. Creating services using Apache Tuscany
      1. 3.1. What are service components and compositions?
      2. 3.2. The SCA assembly model
        1. 3.2.1. Introducing the composite file
        2. 3.2.2. Configuring components
        3. 3.2.3. Defining services
        4. 3.2.4. Working with properties
        5. 3.2.5. Implementation options
        6. 3.2.6. Using references for dependency injection
        7. 3.2.7. Defining available bindings
      3. 3.3. Summary
    2. 4. Advanced SCA
      1. 4.1. Configuration using component types
      2. 4.2. SCA interaction models
        1. 4.2.1. Using conversations
        2. 4.2.2. Understanding callbacks
      3. 4.3. Scripting language support
        1. 4.3.1. Creating a Ruby component
        2. 4.3.2. Creating a Java interface using the Ruby method signature
        3. 4.3.3. Modifying the service implementation class
        4. 4.3.4. Modifying the composition assembly
      4. 4.4. Advanced Tuscany/SCA
        1. 4.4.1. Production deployment
        2. 4.4.2. Introducing Service Data Objects (SDOs)
        3. 4.4.3. Advanced SDO features
      5. 4.5. Summary
  7. 3. Business process management
    1. 5. Introducing jBPM
      1. 5.1. BPM: the "secret sauce" of SOA
      2. 5.2. History and overview of JBoss jBPM
        1. 5.2.1. Development lifecycle of a jBPM process
        2. 5.2.2. Graph-oriented programming and jBPM
      3. 5.3. Understanding nodes
        1. 5.3.1. Node nodetype
        2. 5.3.2. Task-node nodetype
        3. 5.3.3. State nodetype
        4. 5.3.4. Mail-node nodetype
        5. 5.3.5. Decision nodetype
        6. 5.3.6. Fork and join nodetypes
      4. 5.4. Using transitions
      5. 5.5. Extending using actions
        1. 5.5.1. Action class property instantiation
        2. 5.5.2. Using action expressions
      6. 5.6. Using events for capturing lifecycle changes in a process
      7. 5.7. Managing context using variables
      8. 5.8. Summary
    2. 6. jBPM tasks
      1. 6.1. What are tasks?
        1. 6.1.1. Task management using the jBPM Console
        2. 6.1.2. task element configuration
      2. 6.2. Task user management
        1. 6.2.1. Actors and assignments
        2. 6.2.2. Understanding swimlanes
      3. 6.3. Using timers
        1. 6.3.1. Task controllers
      4. 6.4. Developing with the task API
        1. 6.4.1. Identifying processes within a jBPM instance
        2. 6.4.2. Identifying running process instances for a given process
        3. 6.4.3. Finding open tasks within a process instance
        4. 6.4.4. Finding all tasks assigned to a user
        5. 6.4.5. Finding all pooled tasks for an actor
        6. 6.4.6. Completing a task
      5. 6.5. Summary
    3. 7. Advanced jBPM capabilities
      1. 7.1. Important enterprise features of jBPM
        1. 7.1.1. Superstates for grouping
        2. 7.1.2. Using subprocesses to manage complexity
        3. 7.1.3. Managing exceptions
        4. 7.1.4. Scripting with BeanShell
        5. 7.1.5. Audit logging
        6. 7.1.6. Understanding asynchronous continuations
      2. 7.2. Integration with SCA/SDO
        1. 7.2.1. Using SCA client components for service integration
        2. 7.2.2. Service enabling jBPM
        3. 7.2.3. Developing the ListProcesses service operation
        4. 7.2.4. Developing the CreateProcessInstance service operation
      3. 7.3. Summary
  8. 4. Event stream processing, integration, and mediation
    1. 8. Complex events using Esper
      1. 8.1. Business events in the enterprise
      2. 8.2. Understanding events
        1. 8.2.1. BAM and ESP—what's the difference?
        2. 8.2.2. Event-Driven Architecture and SOA
      3. 8.3. What is Esper?
      4. 8.4. Getting started with Esper
        1. 8.4.1. What are event objects?
        2. 8.4.2. Defining and registering query statements
        3. 8.4.3. Specifying listeners or subscribers
        4. 8.4.4. Configuration options
      5. 8.5. EPL basics
        1. 8.5.1. Querying events
        2. 8.5.2. Using variables
        3. 8.5.3. Understanding views
        4. 8.5.4. Creating new event streams with named windows
      6. 8.6. Advanced Esper
        1. 8.6.1. Extending with functions
        2. 8.6.2. Applying event patterns
        3. 8.6.3. Using JDBC for remote connectivity
      7. 8.7. Service enabling Esper
        1. 8.7.1. Creating a framework and components
        2. 8.7.2. Esper service and session manager
        3. 8.7.3. SCA composite file
        4. 8.7.4. Testing with soapUI
      8. 8.8. Summary
    2. 9. Enterprise integration and ESBs
      1. 9.1. The relationship between ESB and SOA
      2. 9.2. Historical foundations of ESB
        1. 9.2.1. Core ESB capabilities
        2. 9.2.2. Appropriate uses of an ESB
        3. 9.2.3. Inappropriate uses of an ESB
      3. 9.3. Introducing Apache Synapse
        1. 9.3.1. Protocol adapters
        2. 9.3.2. Message-oriented middleware
        3. 9.3.3. XML-based messaging
        4. 9.3.4. Intelligent routing and distribution
        5. 9.3.5. Message transformation
        6. 9.3.6. Tasks/timers
        7. 9.3.7. Quality of service/web mediation
        8. 9.3.8. Monitoring and administration
        9. 9.3.9. Extendable API
      4. 9.4. Basic Apache Synapse message and service mediation
        1. 9.4.1. Simple message mediation example
        2. 9.4.2. Simple service mediation example
      5. 9.5. Summary
    3. 10. ESB implementation with Apache Synapse
      1. 10.1. Learning Synapse through a case study
        1. 10.1.1. Phase 1: typical web service mediation using error handling, routing, and transport switching
        2. 10.1.2. Phase 2: protocol/transport bridging and event propagation
        3. 10.1.3. Phase 3: using tasks, scripting, and database integration
        4. 10.1.4. Phase 4: quality of service mediation
      2. 10.2. Phase 1: simple web service mediation
        1. 10.2.1. Sales order initiation
        2. 10.2.2. Configuring the service mediation proxy and using validation mediation
        3. 10.2.3. Configuring XSLT mediation
        4. 10.2.4. Transport switching from HTTP to JMS
        5. 10.2.5. Transport switching from JMS to HTTP
      3. 10.3. Phase 2: VFS, CSV, email, and message wiretap
        1. 10.3.1. Using the VFS transport
        2. 10.3.2. Working with CSV files
        3. 10.3.3. Exception handling and SMTP transport
        4. 10.3.4. Using the wiretap message pattern
      4. 10.4. Phase 3: tasks, DB mediator, and iterator
        1. 10.4.1. Configuring Synapse tasks
        2. 10.4.2. Using the iterator mediator to split messages
        3. 10.4.3. Using the DB mediator
      5. 10.5. Phase 4: QoS using Synapse
        1. 10.5.1. Implementing WS-Security
        2. 10.5.2. Using Synapse throttling mediator
      6. 10.6. Summary
  9. 5. Enterprise decision management
    1. 11. Business rules using JBoss Drools
      1. 11.1. Understanding business rules
        1. 11.1.1. Benefits and drivers of the business rule approach
        2. 11.1.2. Relationship to SOA
        3. 11.1.3. Characteristics of a rules engine
        4. 11.1.4. Business rules management systems
      2. 11.2. Introducing Drools
        1. 11.2.1. Hello World, Drools!
        2. 11.2.2. Running Hello World, Drools!
      3. 11.3. Drools Rule Language (DRL) overview
      4. 11.4. Drools header elements
        1. 11.4.1. package
        2. 11.4.2. import
        3. 11.4.3. expander
        4. 11.4.4. global
        5. 11.4.5. function
      5. 11.5. Defining rules in Drools
        1. 11.5.1. Modifying rule behavior with attributes
        2. 11.5.2. Conditional part of rule statement (when part)
        3. 11.5.3. Consequence part of rule statement (then part)
      6. 11.6. Querying facts in Drools
      7. 11.7. Drools RuleFlow for rule orchestration
      8. 11.8. Alternatives to using Drools Rule Language
        1. 11.8.1. Using DSLs for business user authoring
        2. 11.8.2. Defining rules using decision tables
      9. 11.9. Summary
    2. 12. Implementing Drools
      1. 12.1. Case study overview
        1. 12.1.1. Defining the DRL rules
        2. 12.1.2. Running as an embedded engine
        3. 12.1.3. User-friendly rules using a DSL
      2. 12.2. Rules management using Drools Guvnor
        1. 12.2.1. Guvnor functionality overview
        2. 12.2.2. Rule authoring using Guvnor
      3. 12.3. Developing decision services
        1. 12.3.1. What are decision services?
        2. 12.3.2. Designing the decision service
        3. 12.3.3. Implementing the decision service using Tuscany and Drools
        4. 12.3.4. Testing
      4. 12.4. Summary
  10. A. Resources