Service Oriented Java Business Integration


Service Oriented Java Business Integration
eBook: $29.99
Formats: PDF, PacktLib, ePub and Mobi formats
$17.99
save 40%!
Print + free eBook + free PacktLib access to the book: $79.98    Print cover: $49.99
$49.99
save 37%!
Free Shipping!
UK, US, Europe and selected countries in Asia.
Also available on:
Overview
Table of Contents
Author
Support
Sample Chapters
  • Vendor-independent integration of components and services through JBI explained with real-world examples
  • Hands-on guidance to ESB-based Integration of loosely coupled, pluggable services
  • Enterprise Integration Patterns (EIP) in action, in code
  • ESB integration solutions using Apache open-source tools

Book Details

Language : English
Paperback : 436 pages [ 235mm x 191mm ]
Release Date : March 2008
ISBN : 1847194400
ISBN 13 : 9781847194404
Author(s) : Binildas A. Christudas
Topics and Technologies : All Books, Enterprise Products and Platforms, Enterprise, Java, SOA


Table of Contents

Preface
Chapter 1: Why Enterprise Service Bus
Chapter 2: Java Business Integration
Chapter 3: JBI Container—ServiceMix
Chapter 4: Binding—The Conventional Way
Chapter 5: Some XFire Binding Tools
Chapter 6: JBI Packaging and Deployment
Chapter 7: Developing JBI Components
Chapter 8: Binding EJB in a JBI Container
Chapter 9: POJO Binding Using JSR181
Chapter 10: Bind Web Services in ESB—Web Services Gateway
Chapter 11: Access Web Services Using the JMS Channel
Chapter 12: Java XML Binding using XStream
Chapter 13: JBI Proxy
Chapter 14: Web Service Versioning
Chapter 15: Enterprise Integration Patterns in ESB
Chapter 16: Sample Service Aggregation
Chapter 17: Transactions, Security, Clustering, and JMX
Index
  • Chapter 1: Why Enterprise Service Bus
    • Boundary-Less Organization
      • Multiple Systems
      • No Canonical Data Format
      • Autonomous, but Federated
      • Intranet versus Internet
      • Trading Partners
    • Integration
      • Enterprise Application Integration
    • Integration Architectures
      • Point-to-Point Solution
      • Hub-and-Spoke Solution
      • Enterprise Message Bus Integration
      • Enterprise Service Bus Integration
    • Enterprise Service Bus versus Message Bus
      • Similarities and Differences
      • Maturity and Industry Adoption
    • Making the Business Case for ESB
      • How many Channels
      • Volatile Interfaces
      • New Systems Introducing Data Redundancy
      • Service Reuse
      • System Management and Monitoring
    • Enterprise Service Bus
      • Service in ESB
      • Abstraction beyond Interface
      • Service Aggregation
      • Service Enablement
      • Service Consolidation
      • Service Sharing
      • Linked Services
      • Virtualization of Services
      • Services Fabric
    • Summary
  • Chapter 2: Java Business Integration
    • SOA—the Motto
      • Why We Need SOA
      • What is SOA?
      • SOA and Web Services
      • Service Oriented Integration (SOI)
    • JBI in J2EE—How they Relate
      • Servlets, Portlets, EJB, JCA, and so on
      • JBI and JCA—Competing or Complementing
      • JBI—a New Standard
    • JBI in Detail
      • JSR 208
      • JBI Nomenclature
    • Provider—Consumer Contract
      • Detached Message Exchange
      • Provider—Consumer Role
      • Message Exchange
      • Service Invocation
    • Message Exchange Patterns (MEP)
      • In-Only MEP
      • Robust In-Only MEP
      • In-Out MEP
      • In-Optional-Out MEP
    • ESB—Will it Solve all Our Pain Points
    • Summary
  • Chapter 3: JBI Container—ServiceMix
    • ServiceMix—Under the Hood
      • Salient Features
    • ServiceMix Architecture
      • Architecture Diagram
      • Normalized Message Router Flows
    • Other ESBs
      • Mule
      • Celtix
      • Iona Artix
      • PEtALS
      • ChainBuilder
    • Installing ServiceMix
      • Hardware Requirements
      • OS Requirements
      • Run-time Environment
      • Installing ServiceMix in Windows
      • Installing ServiceMix in Unix
      • Configuring ServiceMix
      • Starting ServiceMix
      • Stopping ServiceMix
      • Resolving classpath Issues
    • ServiceMix Components—a Synopsis
      • Standard JBI Components
      • Lightweight JBI Components
    • Your First JBI Sample—Binding an External HTTP Service
      • Servlet-based HTTP Service
      • Configure the HTTP Service in ServiceMix
      • Run ServiceMix Basic JBI Container
      • Run a Client against ServiceMix
      • What Just Happened in ServiceMix
      • Spring XML Configuration for ServiceMix
    • Summary
  • Chapter 4: Binding—The Conventional Way
    • Binding—What it Means
      • Binding
      • Endpoints
    • Apache SOAP Binding
      • A Word about Apache SOAP
      • Apache SOAP Format and Transports
      • RPC and Message Oriented
      • Binding Services
    • Sample Bind a Stateless EJB Service to Apache SOAP
      • Sample Scenario
      • Code Listing
      • Running the Sample
        • Deploying the EJB
        • Bind EJB to SOAP
        • Run the Client
      • What Just Happened
      • How the Sample Relates to ServiceMix
    • Summary
  • Chapter 5: Some XFire Binding Tools
    • Binding in XFire
      • XFire Transports
      • JSR181 and XFire
    • Web Service Using XFireConfigurableServlet
      • Sample Scenario
      • Code Listing
      • Running the Sample
    • Web Service using XFire Spring XFireExporter
      • Sample Scenario
      • Code Listing
      • Running the Sample
    • Web Service Using XFire Spring Jsr181 Handler
      • Sample Scenario
      • Code Listing
      • Running the Sample
    • XFire Export and Bind EJB
      • Sample Scenario
      • Code Listing
      • Running the Sample
    • XFire for Lightweight Integration
    • Summary
  • Chapter 6: JBI Packaging and Deployment
    • Packaging in ServiceMix
      • Installation Packaging
      • Service Assembly Packaging
      • Service Unit Packaging
    • Deployment in ServiceMix
      • Standard and JBI compliant
      • Lightweight
    • Packaging and Deployment Sample
      • Phase One—Component Development
      • Phase Two—Component Packaging
    • Running the Packaging and Deployment Sample
    • Summary
  • Chapter 7: Developing JBI Components
    • Need for Custom JBI Components
    • ServiceMix Component Helper Classes
      • MessageExchangeListener
      • TransformComponentSupport
    • Create, Deploy, and Run JBI Component
      • Code HttpInterceptor Component
      • Configure HttpInterceptor Component
      • Package HttpInterceptor Component
      • Deploy HttpInterceptor Component
      • Build and Run the Sample
    • Summary
  • Chapter 8: Binding EJB in a JBI Container
    • Component versus Services
      • Coexisting EJB Components with Services
      • Indiscrimination at Consumer Perspective
    • Binding EJB Sample
      • Step One—Define and Deploy the EJB Service
      • Step Two—Bind EJB to ServiceMix
      • Step Three—Deploy and Invoke EJB Binding in ServiceMix
      • Step Four—Access WSDL and Generate Axis-based Stubs to Access EJB Outside Firewall
    • Reconciling EJB Resources
    • Summary
  • Chapter 9: POJO Binding Using JSR181
    • POJO
      • What are POJOs
      • Comparing POJO with other Components
    • ServiceMix servicemix-jsr181
      • JSR 181
      • servicemix-jsr181
      • servicemix-jsr181 Deployment
      • servicemix-jsr181 Endpoint
    • POJO Binding Sample
      • Sample Use Case
      • POJO Code Listing
      • XBean-based POJO Binding
      • Deployment Configuration
      • Deploying and Running the Sample
      • Access WSDL and Generate Axis-based Stubs to Access POJO Remotely
    • Accessing JBI Bus Sample
      • Sample Use Case for Accessing JBI Bus
      • Sample Code Listing
      • Build, Deploy, and Run the Sample
    • Summary
  • Chapter 10: Bind Web Services in ESB—Web Services Gateway
    • Web Services
      • Binding Web Services
      • Why Another Indirection?
    • HTTP
    • ServiceMix's servicemix-http
      • servicemix-http in Detail
      • Consumer and Provider Roles
      • servicemix-http XBean Configuration
      • servicemix-http Lightweight Configuration
    • Web Service Binding Sample
      • Sample Use Case
      • Deploy the Web Service
      • XBean-based servicemix-http Binding
      • Deploying and Running the Sample
      • Access WSDL and Generate Axis Stubs to Access the Web Service Remotely
    • Summary
  • Chapter 11: Access Web Services Using the JMS Channel
    • JMS
    • Web Service and JMS
      • Specifications for Web Service Reliable Messaging
      • SOAP over HTTP versus SOAP over JMS
    • JMS in ServiceMix
      • Servicemix-jms
      • Consumer and Provider Roles
      • servicemix-jms XBean Configuration
      • servicemix-jms Lightweight Configuration
    • Protocol Bridge
    • Web Service in the JMS Channel Binding Sample
      • ServiceMix Component Architecture for the JMS Web Service
      • Deploy the Web Service
      • XBean-based servicemix-jms Binding
      • XBean-based servicemix-eip Pipeline Bridge
      • XBean-based servicemix-http Provider Destination
      • Deploying the Sample and Starting ServiceMix
      • Test Web Service Using JMS Channel
    • Summary
  • Chapter 12: Java XML Binding using XStream
    • Java XML Binding
      • JAXB
      • XStream
      • ServiceMix and XStream
    • XStream in a Normalized Message Router Sample
      • Sample Use Case
      • Code HTTPClient
      • Unmarshalling to Transfer Objects
      • HttpInterceptor Component
      • XStreamInspector Component
      • Configure Interceptor and Inspector Components
      • Package Interceptor and Inspector Components
      • Deploy Interceptor and Inspector Components
      • Build and Run the Sample
    • Summary
  • Chapter 13: JBI Proxy
    • Proxy—A Primer
      • Proxy Design Pattern
      • JDK Proxy Class
      • Sample JDK Proxy Class
    • ServiceMix JBI Proxy
    • JBI Proxy Sample Implementing Compatible Interface
      • Proxy Code Listing
      • XBean-based JBI Proxy Binding
      • Deployment Configuration
      • Deploying and Running the Sample
    • JBI Proxy Sample implementing In-Compatible interface
      • Proxy Code Listing
      • XBean-based JBI Proxy Binding
      • Deployment Configuration
      • Deploying and Running the Sample
    • Invoke External Web Service from the ServiceMix Sample
      • Web Service Code Listing
      • Axis Generated Client Stubs
      • XBean-based JBI Proxy Binding
      • Deployment Configuration
      • Deploying and Running the Sample
      • Proxy and WSDL Generation
    • Summary
  • Chapter 14: Web Service Versioning
    • Service Versioning—A Means to SOA
      • Services are Autonomous
      • Change is the Only Constant Thing
      • All Purpose Interfaces
      • SOA Versioning—Don't Touch the Anti-Pattern
      • Types can Inherit—Why not My Schemas
      • If Not Versions, Then What
    • Strategy to Version Web Service
      • Which Level to Version
      • Version Control in a Schema
      • targetNamespace for WSDL
      • Version Parameter
    • Web Service Versioning Approaches
      • Covenant
      • Multiple Endpoint Addresses
    • Web Service Versioning Sample using ESB
      • Sample Use Case
      • Configure Components in ESB
      • Deploy and Run the Sample
    • Web Service Versioning Operational Perspective
    • Summary
  • Chapter 15: Enterprise Integration Patterns in ESB
    • Enterprise Integration Patterns
      • What are EAI Patterns?
      • EAI Patterns Book and Site
    • ServiceMix EAI Patterns
      • Why ServiceMix for EAI Patterns?
      • ServiceMix EAI Patterns Configuration
    • EAI Patterns—Code and Run Samples in ESB
      • Content-based Router
        • Notation
        • Explanation
        • Illustrative Design
        • Sample Use Case
        • Sample Code and Configuration
        • Deploy and Run the Sample
      • Content Enricher
        • Notation
        • Explanation
        • Illustrative Design
        • Sample Use Case
        • Sample code and configuration
        • Deploy and Run the Sample
      • XPath Splitter
        • Notation
        • Explanation
        • Illustrative Design
        • Sample Use Case
        • Sample Code and Configuration
        • Deploy and Run the Sample
      • Static Recipient List
        • Notation
        • Explanation
        • Illustrative Design
        • Sample Use Case
        • Sample Code and Configuration
        • Deploy and Run the Sample
      • Wiretap
        • Notation
        • Explanation
        • Illustrative Design
        • Sample Use Case
        • Sample Code and Configuration
        • Deploy and Run the Sample
      • Message Filter
        • Notation
        • Explanation
        • Illustrative Design
        • Sample Use Case
        • Sample Code and Configuration
        • Deploy and Run the Sample
      • Split Aggregator
        • Notation
        • Explanation
        • Illustrative Design
        • Sample Use Case
        • Sample Code and Configuration
        • Deploy and Run the Sample
      • Pipeline
        • Notation
        • Explanation
        • Illustrative Design
        • Sample Use Case
        • Sample Code and Configuration
        • Deploy and Run the Sample
      • Static Routing Slip
        • Notation
        • Explanation
        • Illustrative Design
        • Sample Use Case
        • Sample Code and Configuration
        • Deploy and Run the Sample
    • Summary
  • Chapter 16: Sample Service Aggregation
    • Provision Service Order—Business Integration Sample
      • Solution Architecture
      • JBI-based ESB Component Architecture
      • Understanding the Message Exchange
      • Deploying and Running the Sample
    • Summary
  • Chapter 17: Transactions, Security, Clustering, and JMX
    • Cross Cutting Concerns—Support Inside ServiceMix
      • Transactions
      • Security
      • Clustering
      • JMX
    • Sample Demonstrating Transaction
      • Sample Use Case
      • Configure Transaction in ServiceMix
      • Deploy and Run the Sample
    • Sample demonstrating Security
      • Sample Use Case
      • Configure Basic Authorization in servicemix-http
      • Deploy and Run the Sample
    • Sample Demonstrating Clustering
      • Sample Use Case
      • Configure ServiceMix Cluster
      • Deploy and run the sample
    • Sample demonstrating JMX
      • Enable JMX in ServiceMix Application
      • Initialize JMX Console—MC4J
      • Retrieve WSDL through JMX
    • Summary

Binildas A. Christudas

Binildas C. A. provides Technical Architecture consultancy for IT solutions. He has over 13 years of IT experience, mostly in Microsoft and Sun technologies. Distributed Computing and Service Oriented Integration are his main stream skills, with extensive hands-on experience in Java and C#.NET programming. Binil holds a BTech. degree in Mechanical Engineering from College of Engineering, Trivandrum (www.cet.ac.in) and an MBA in Systems Management, from Institute of Management, Kerala (www.imk.ac.in). A well-known and a highly sought-after thought leader, Binil has designed and built many highly scalable middle-tier and integration solutions for several top-notch clients including Fortune 500 companies. He has been previously employed by multiple IT consulting firms including IBS Software Services (www.ibsplc.com) and Tata Consultancy Services (www.tcs.com) and currently works for Infosys Technologies (www.infosys.com) as a Principal Architect where he heads the J2EE Architects group servicing Communications Service Provider clients.

Binil is a Sun Certified Programmer (SCJP), Developer (SCJD), Business Component Developer (SCBCD) and Enterprise Architect (SCEA), Microsoft Certified Professional (MCP) and Open Group (TOGAF8) Certified Enterprise Architecture Practitioner. He is also a Licensed Zapthink Architect (LZA) in SOA. Besides Technical Architecture Binil also practices Enterprise Architecture.

When not in software, Binil spends time with wife Sowmya & daughter Ann in ‘God's Own Country’, Kerala (www. en.wikipedia.org/wiki/Kerala). Binil does long distance running and is a national medalist in Power Lifting. You may contact Binil at biniljava@yahoo.co.in or binil_christudas@infosys.com.

Sorry, we don't have any reviews for this title yet.

Code Downloads

Download the code and support files for this book.


Submit Errata

Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.

Sample chapters

You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.

Frequently bought together

Service Oriented Java Business Integration +    Getting Started with PhantomJS =
50% Off
the second eBook
Price for both: ₨382.80

Buy both these recommended eBooks together and get 50% off the cheapest eBook.

What you will learn from this book

  • Assembling services and porting them across containers using JBI
  • Exposing EJB as a WSDL-compliant service across firewalls
  • Binding remote services to ESB to be consumed internally
  • Exposing local components in ESB like POJO as externally accessible WSDL-compliant services
  • Providing a web service gateway for external consumers
  • Accessing web services over a reliable transport channel like JMS
  • Implementing web service versioning using ESB
  • Implementing service aggregation at ESB
  • Transactions, Security, Clustering, and JMX in ESB

Chapter 1 begins with a quick tour on Enterprise Integration and the associated issues so that you can better understand the problem that we are trying to solve, rather than following a solution for an unknown problem. We also introduce Enterprise Service Bus (ESB) architecture and compare and contrast that with other integration architectures.

Chapter 2 introduces Java Business Integration (JBI), inspects the need for another standard for Business Integration, and looks into the details of what this standard is all about.

Chapter 3 introduces ServiceMix, which is an open-source ESB platform in the Java programming language, built from the ground up with JBI APIs and principles. It also runs through a few other ESB products.

Chapter 4 looks at how we have been binding services locally or remotely even before the ESB became popular. The chapter demonstrates how tunneling using conventional J2EE tools will help to expose even technology-specific API services. An example of such a service is an EJB service to be exposed through firewalls over HTTP, so that the service becomes technology agonistic.

Chapter 5 introduces XFire, which is a new generation Java SOAP framework to easily expose web services. Here we demonstrate the integration capabilities of XFire.
 
Chapter 6 teaches you JBI packaging and deployment. After going through this chapter you will be able to build, package, and deploy integration artifacts as standard JBI packages into the JBI container.

Chapter 7 teaches you how to create your own components and deploy them onto the JBI container. This chapter visits the core API from the ServiceMix as well as from the JBI specification, which will function as useful helper classes using which you can develop integration components quickly.

Chapter 8 shows you how to bind Enterprise Java Beans components to the ESB. EJB is the Distributed Component paradigm in the Java-J2EE world and the industry has a lot invested in this technology. Coexisting services with those components will help you to reuse those existing investments so that we can continue building new systems based on higher levels of SOA maturity.

Chapter 9 shows POJO Binding to the ESB using JSR181. POJO components can be easily exposed as WSDL-compliant services to the JBI bus.

Chapter 10 illustrates how to bind web services to the ServiceMix ESB, thus creating a web services gateway at the ESB layer.

Chapter 11 looks at how Java Message Service (JMS), which is a platform-dependent messaging technology, can increase the QoS features of web services by making web services accessible through the JMS channel.

Chapter 12 introduces Java XML binding and XStream, which is a simple open-source library to serialize Java objects to XML and back again. We show the XStream integration with ESB demonstrating streaming of data across the bus.

Chapter 13 visits the JDK Proxy classes and then explains the JBI Proxy in detail with examples. We show a practical use of the JBI Proxy—Proxying the external web services in the JBI bus.

Chapter 14 explains versioning in the SOA context and explains various strategies and approaches to versioning services. It also explains and demonstrates a versioning example leveraging the targetNamespace attribute. Versioning services, especially versioning of web services, is a topic of heated discussion in many forums and sites.

Chapter 15 explains that the EAI patterns are nuggets of advice made out of aggregating basic Message Exchange Pattern elements to solve frequently recurring integration problems. We can look at EAI patterns as design patterns for solving integration problems. This chapter demonstrates many of the common EAI patterns.

Chapter 16 looks into a sample use case. One of the useful applications of ESB is to provide a "Services Workbench" in which we can use various integration patterns available to aggregate services to carry out business processes.

Chapter 17 visits a few selected QoS features such as Transactions, Security, Clustering, and Management, which can impact the programming and deployment aspects using ESB.

In Detail

The goal of Java Business Integration (JBI) is to allow components and services to be integrated in a vendor-independent way, allowing users and vendors to plug and play.

Java Business Integration (JBI) is a specification aiming to define a Service Provider Interface for integration containers so that integration components written for these containers are portable across containers and also integrate with other components or services using standard protocols and formats. JBI is based on JSR 208, which is an extension of Java 2 Enterprise Edition (J2EE).

This book first discusses the various integration approaches available and introduces the Enterprise Service Bus (ESB), a new architectural pattern that facilitates integrating services. ESB provides mediation services including routing and transformation. Java Business Integration (JBI) provides a collaboration framework that provides standard interfaces for integration components and protocols to plug into, thus allowing the assembly of Service-Oriented Integration (SOI) frameworks following the ESB pattern. Once JBI and ESB are introduced, we look at how we have been doing service integration without either of these using traditional J2EE. The book then slowly introduces ESB and, with the help of code, showcases how easily things can be done using JBI.

Get hands-on guidance to ESB based Integration using lightweight, open-source Java Business Integration tools.

Approach

The book covers all concepts with examples that can be built, deployed, and run by readers using the Apache Ant tool in Apache ServiceMix, which is an open-source Enterprise Service Bus that combines the functionality of a Service Oriented Architecture (SOA) and an Event Driven Architecture (EDA).
 
The aim of this book is to prepare an architect or developer for building integration solutions using ESB. To that end, this book takes a practical approach, emphasizing how to get things done in ServiceMix with code. When needed, it delves into the theoretical aspects of ESB, and such discussions are supplemented with working samples. The book, thus, distils some of the knowledge that has emerged over the last decade in the realm of Java Integration. 

Who this book is for

This book is aimed at Java developers and integration architects who want to become proficient with the Java Business Integration (JBI) standard. Readers should have some experience with Java and have developed and deployed applications in the past, but need no previous knowledge of JBI. The book can also be useful to anyone who is struggling to understand ESB and how it differs from other architectures and to understand its position in SOA.
This book primarily targets IT professionals in the field of SOA and Integration solutions—in other words, intermediate to advanced users. You are likely to find the book useful if you fall into any of the following categories:

  • A programmer, designer, or architect in Java who wants to learn and code in JBI or ESB.
  • A programmer, designer, or architect who doesn't normally code in Java can still benefit from this book, since we 'assemble integration components' using XML with little to no Java code.
  • An IT Manager or an Officer who knows well about SOA or SOI but want to see something in code (you can adorn your flashy presentations with some live code too).

 

Code Download and Errata
Packt Anytime, Anywhere
Register Books
Print Upgrades
eBook Downloads
Video Support
Contact Us
Awards Voting Nominations Previous Winners
Judges Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software
Resources
Open Source CMS Hall Of Fame CMS Most Promising Open Source Project Open Source E-Commerce Applications Open Source JavaScript Library Open Source Graphics Software