Enterprise Service Bus

Enterprise Service Bus

Chapter 1. Introduction to the Enterprise Service Bus
Section 1.1. SOA in an Event-Driven Enterprise
Section 1.2. A New Approach to Pervasive Integration
Section 1.3. SOA for Web Services, Available Today
Section 1.4. Conventional Integration Approaches
Section 1.5. Requirements Driven by IT Needs
Section 1.6. Industry Traction
Section 1.7. Characteristics of an ESB
Section 1.8. Adoption of ESB by Industry
Section 1.9. Summary

Chapter 2. The State of Integration
Section 2.1. Business Drivers Motivating Integration
Section 2.2. The Current State of Enterprise Integration
Section 2.3. Leveraging Best Practices from EAI and SOA
Section 2.4. Refactoring to an ESB
Section 2.5. Summary

Chapter 3. Necessity Is the Mother of Invention
Section 3.1. The Evolution of the ESB
Section 3.2. The ESB in Global Manufacturing
Section 3.3. Finding the Edge of the Extended Enterprise
Section 3.4. Standards-Based Integration
Section 3.5. Case Study: Manufacturing
Section 3.6. Summary

Chapter 4. XML: The Foundation for Business Data Integration
Section 4.1. The Language of Integration
Section 4.2. Applications Bend, but Don't Break
Section 4.3. Content-Based Routing and Transformation
Section 4.4. A Generic Data Exchange Architecture
Section 4.5. Summary

Chapter 5. Message Oriented Middleware (MOM)
Section 5.1. Tightly Coupled Versus Loosely Coupled Interfaces
Section 5.2. MOM Concepts
Section 5.3. Asynchronous Reliability
Section 5.4. Reliable Messaging Models
Section 5.5. Transacted Messages
Section 5.6. The Request/Reply Messaging Pattern
Section 5.7. Messaging Standards
Section 5.8. Summary

Chapter 6. Service Containers and Abstract Endpoints
Section 6.1. SOA Through Abstract Endpoints
Section 6.2. Messaging and Connectivity at the Core
Section 6.3. Diverse Connection Choices
Section 6.4. Diagramming Notations
Section 6.5. Independently Deployable Integration Services
Section 6.6. The ESB Service Container
Section 6.7. Service Containers, Application Servers, and Integration Brokers
Section 6.8. Summary

Chapter 7. ESB Service Invocations, Routing, and SOA
Section 7.1. Find, Bind, and Invoke
Section 7.2. ESB Service Invocation
Section 7.3. Itinerary-Based Routing: Highly Distributed SOA
Section 7.4. Content-Based Routing (CBR)
Section 7.5. Service Reusability
Section 7.6. Specialized Services of the ESB
Section 7.7. Summary

Chapter 8. Protocols, Messaging, Custom Adapters, and Services
Section 8.1. The ESB MOM Core
Section 8.2. A Generic Message Invocation Framework
Section 8.3. Case Study: Partner Integration
Section 8.4. Summary

Chapter 9. Batch Transfer Latency
Section 9.1. Drawbacks of ETL
Section 9.2. The Typical Solution: Overbloat the Inventory
Section 9.3. Case Study: Migrating Toward Real-Time Integration
Section 9.4. Summary

Chapter 10. Java Components in an ESB
Section 10.1. Java Business Integration (JBI)
Section 10.2. The J2EE Connector Architecture (JCA)
Section 10.3. Java Management eXtensions (JMX)
Section 10.4. Summary

Chapter 11. ESB Integration Patterns and Recurring Design Solutions
Section 11.1. The VETO Pattern
Section 11.2. The Two-Step XRef Pattern
Section 11.3. Portal Server Integration Patterns
Section 11.4. The Forward Cache Integration Pattern
Section 11.5. Federated Query Patterns
Section 11.6. Summary

Chapter 12. ESB and the Evolution of Web Services
Section 12.1. Composability Among Specifications
Section 12.2. Summary of WS-* Specifications
Section 12.3. Adopting the WS-* Specifications in an ESB
Section 12.4. Conclusion

Appendix A. Appendix: List of ESB Vendors

Overview of the Chapters

Chapter 1 gives an overview of the ESB, including the many characteristics that define it. It also explains the evidence of industry adoption and market attraction of this new concept in service-oriented integration.

Chapter 2 provides a summary of the drivers, both business and technical, that have contributed to the need for a new approach to integration. It also examines some surprising statistics showing that, in general, the enterprise is far from connected, and it explores the shortfalls of Enterprise Application Integration (EAI) approaches to date. It explains the characteristics of an "accidental architecture" which helps you to identify your own architecture issues. Lastly, it explains how the ESB concept draws from best practices of previous integration approaches, and shows that you can refactor toward an ESB and away from an accidental architecture in incremental steps.

Chapter 3 examines some key concepts of the ESB, including the many requirements, technology drivers, and forces in the IT climate that led to the creation of the ESB concept. This is explained in the context of the recent history of the evolution of the ESB, illustrating the point that an ESB is not merely an academic exercise; it is born out of necessity, based on real requirements and difficult integration problems that couldn't be solved by any preexisting integration technology. The discussion concludes with a high-level study of an ESB deployment, in which a manufacturer exposes inventory management and supply chain optimization functionality to its remote distributors as shared services through an ESB. This study, along with many others, will be revisited in more technical detail in later chapters.

Chapter 4 explores the use of XML as a means for providing the mediation between diverse data structures and formats as data is passed between applications. It also examines how ESB-enabled data transformation and content-based routing services can support an XML data exchange architecture that insulates individual applications from changes in data structures, as integrated business processes improve over time.

Chapter 5 explains Message Oriented Middleware and its role in an enterprise integration strategy. A MOM is a key part of the ESB architecture, as it provides the underpinnings to the network of virtual channels that an ESB uses to route messages throughout an extended enterprise and beyond. This chapter explains how the definition of a MOM has evolved to support the highly diverse and distributed topologies and open standards that an ESB integration requires. (In other words, it's not your Mom's MOM.) The chapter goes on to explain the key differences between the low-level coding of using a MOM versus the higher-level configuration aspects of using an ESB.

Chapter 6 explains the details of what makes an ESB an ESB. The ESB provides an architecture that brings together all the concepts described in previous chapters into an infrastructure that can span an extended enterprise and beyond. This chapter describes the ESB service container—a key enabler of the highly distributed, event-driven SOA—and its concept of endpoint abstraction.

Chapter 7 covers the service invocation model—i.e., the underlying framework that provides the SOA in an ESB. We will discuss multiple forms of process routing, including the concept of itinerary-based routing and the role it plays in enabling a highly distributed SOA across independently deployed services.

We will also discuss some fundamental ESB services such as content-based routing and XSLT transformation, and explore how service types can be defined and then reused for different purposes through elements of configuration. Finally, we will see how additional capabilities can be layered on top of an ESB through an advanced service, such as an XML persistence service and an orchestration service.

Chapter 8 examines how the ESB can extend its MOM core to create the flexibility in protocols necessary to connect to applications in an adaptable and non-intrusive way. This includes an explanation of how XML and SOAP messaging can be integral parts of an ESB strategy, yet also be flexible enough to carry other data formats such as EDI X12 messages. This chapter also shows the details of a partner integration using an ESB, and examines the use of third-party adapters and custom integration services for integrating with SAP.

Chapter 9 explores the most common form of integration being done today: bulk data transfer and batch updating using Extract, Transform, and Load (ETL) techniques. We will discuss the business impact of the latency and reliability issues associated with this integration method, and examine the prescriptive steps for migrating toward real-time integration using an ESB in the context of a case study using pattern sketches.

Chapter 10 examines the various Java components in an ESB. The ESB is a platform-neutral concept, and could be implemented without any Java involved. However, a good ESB should take advantage of Java components due to the large adoption of Java-based technology across IT departments. A fairly extensive list of specifications that are utilized within an ESB comes out of the Java Community Process (JCP) on a regular basis; this could be the subject of a whole other book. Some Java specifications are particularly worth calling attention to because they have a special impact on the operation of an ESB. Chapter 10 will discuss the following specifications and their impact on making an ESB a more effective integration environment:

• Java Business Integration (JBI): A specification describing the way integration components, such as ESB services, can be plugged together in a vendor-neutral and portable fashion.
• J2EE Connector Architecture (JCA): A specification that defines how to use a standard set of interface contracts for creating adapters to connect into, and interact with, enterprise applications.
• Java Management eXtensions (JMX): A specification for remote management defining the means by which an application can interface with a management infrastructure and management consoles.

Chapter 11 examines some common uses of an ESB in integration scenarios. The ESB concept already has a number of common uses that solve some very common and challenging integration problems. These include the Validate, Enrich, Transform, Operate (VETO) pattern and its derivatives, a "two-step XRef" pattern, and several variations of backend integration patterns that are driven by enterprise portal requirements, such as a federated query/response pattern and forward caching using an ESB caching service.

Chapter 12 provides an overview of the evolving web services specifications (including the WS-* family of specifications), and explains how web services and ESBs will move forward together.

Appendix A contains the list of vendors who are currently offering or are promising to offer an ESB product in the future. I will try my best to keep this up to date with subsequent printings of the book.