Enterprise Integration Patterns

Short description: 2003 book by Gregor Hohpe and Bobby Woolf

Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions

Author| Gregor Hohpe and Bobby Woolf
Language| English
Series| Martin Fowler Signature Series
Subject| Enterprise integration pattern
Genre| Non-fiction, Software development
Published| 10 October 2003
ISBN| 978-0321200686

Enterprise Integration Patterns is a book by Gregor Hohpe and Bobby Woolf which describes 65 patterns for the use of enterprise application integration and message-oriented middleware in the form of a pattern language.

## Contents

* 1 The integration (messaging) pattern language
* 1.1 Integration styles and types
* 1.2 Messaging
* 1.3 Message Channel
* 1.4 Message Construction
* 1.5 Message Router
* 1.6 Message Transformation
* 1.7 Message Endpoint
* 1.8 System Management
* 2 Implementation
* 3 See also
* 4 References
* 5 External links

## The integration (messaging) pattern language

The pattern language presented in the book consists of 65 patterns structured into 9 categories, which largely follow the flow of a message from one system to the next through channels, routing, and transformations. The book includes an icon-based pattern language, sometimes nicknamed "GregorGrams" after one of the authors. Excerpts from the book (short pattern descriptions) are available on the supporting website (see External links).

### Integration styles and types

The book distinguishes four top-level alternatives for integration:

1. File Transfer
2. Shared Database
3. Remote Procedure Invocation
4. Messaging

The following integration types are introduced:

* Information Portal
* Data Replication
* Shared Business Function
* Service Oriented Architecture
* Distributed Business Process
* Business-to-Business Integration
* Tightly Coupled Interaction vs. Loosely Coupled Interaction

### Messaging

* Message Channel
* Message
* Pipes and Filters
* Message Router
* Message Translator
* Message Endpoint

### Message Channel

* Point-to-Point Channel
* Publish-Subscribe Channel
* Datatype Channel
* Invalid Message Channel
* Dead Letter Channel
* Guaranteed Delivery
* Channel Adapter
* Messaging Bridge
* Message Bus

### Message Construction

* Command Message
* Document Message
* Event Message
* Request-Reply
* Return Address
* Correlation Identifier
* Message Sequence
* Message Expiration
* Format Indicator

### Message Router

* Content-Based Router
* Message Filter
* Dynamic Router
* Recipient List
* Splitter
* Aggregator
* Resequencer
* Composed Message Processor
* Scatter-Gather
* Routing Slip
* Process Manager
* Message Broker

### Message Transformation

* Envelope Wrapper
* Content Enricher
* Content Filter
* Claim Check
* Normalizer
* Canonical Data Model

### Message Endpoint

* Messaging Gateway
* Messaging Mapper
* Transactional Client
* Polling Consumer
* Event-Driven Consumer
* Competing Consumers
* Message Dispatcher
* Selective Consumer
* Durable Subscriber
* Idempotent Receiver
* Service Activator

### System Management

* Control Bus
* Detour
* Wire Tap
* Message History
* Message Store
* Smart Proxy
* Test Message
* Channel Purger

The pattern language continues to be relevant as of today, for instance in cloud application development and integration, and in the internet of things. In 2015, the two book authors reunited—for the first time since the publication of the book—for a retrospective and interview in IEEE Software.[1]

## Implementation

Enterprise Integration Patterns are implemented in many open source integration solutions. Notable implementations include Spring Integration, Apache Camel, Red Hat Fuse, Mule ESB and Guaraná DSL.

## See also

* Enterprise messaging system
* Loose coupling
* Software design pattern

## References

1. ↑ Zimmermann, Olaf; Pautasso, Cesare; Hohpe, Gregor; Woolf, Bobby (2016). "A Decade of Enterprise Integration Patterns: A Conversation with the Authors". IEEE Software 33 (1): 13–19. doi:10.1109/MS.2016.11.

## External links

* No URL found. Please specify a URL here or add one to Wikidata.
* "Table Of Contents". http://www.enterpriseintegrationpatterns.com/toc.html.
* "The Add-in for Enterprise Architect extended the capability of this tool to create EIP models.". http://www.bobovo.eu/.

* v
* t
* e

Software design patterns

Creational|

* Abstract factory
* Builder
* Dependency injection
* Factory method
* Lazy initialization
* Multiton
* Object pool
* Prototype
* RAII
* Singleton

Structural|

* Adapter
* Bridge
* Composite
* Decorator
* Delegation
* Facade
* Flyweight
* Front controller
* Marker interface
* Module
* Proxy
* Twin

Behavioral|

* Blackboard
* Chain of responsibility
* Command
* Interpreter
* Iterator
* Mediator
* Memento
* Null object
* Observer
* Servant
* Specification
* State
* Strategy
* Template method
* Visitor

Functional|

* Closure
* Currying
* Function composition
* Functor
* Monad
* Generator

Concurrency|

* Active object
* Actor
* Balking
* Barrier
* Binding properties
* Coroutine
* Compute kernel
* Double-checked locking
* Event-based asynchronous
* Fiber
* Futex
* Futures and promises
* Guarded suspension
* Immutable object
* Join
* Lock
* Messaging
* Monitor
* Nuclear
* Proactor
* Reactor
* Read write lock
* Scheduler
* Thread pool
* Thread-local storage

Architectural|

* ADR
* Active record
* Broker
* Client–server
* CBD
* DAO
* DTO
* DDD
* ECB
* ECS
* EDA
* Front controller
* Identity map
* Interceptor
* Implicit invocation
* Inversion of control
* Model 2
* MOM
* Microservices
* MVA
* MVC
* MVP
* MVVM
* Monolithic
* Multitier
* Naked objects
* ORB
* P2P
* Publish–subscribe
* PAC
* REST
* SOA
* Service locator
* SN
* SBA
* Specification

Cloud
Distributed|

* Ambassador
* Anti-Corruption Layer
* Bulkhead
* Cache-Aside
* Circuit Breaker
* CQRS
* Compensating Transaction
* Competing Consumers
* Compute Resource Consolidation
* Event Sourcing
* External Configuration Store
* Federated Identity
* Gatekeeper
* Index Table
* Leader Election
* MapReduce
* Materialized View
* Pipes
* Filters
* Priority Queue
* Publisher-Subscriber
* Queue-Based Load Leveling
* Retry
* Scheduler Agent Supervisor
* Sharding
* Sidecar
* Strangler
* Throttling
* Valet Key

Other|

* Business delegate
* Composite entity
* Intercepting filter
* Lazy loading
* Mangler
* Mock object
* Type tunnel
* Method chaining

Books|

* Design Patterns
* Enterprise Integration Patterns

People|

* Christopher Alexander
* Erich Gamma
* Ralph Johnson
* John Vlissides
* Grady Booch
* Kent Beck
* Ward Cunningham
* Martin Fowler
* Robert Martin
* Jim Coplien
* Douglas Schmidt
* Linda Rising

Communities|

* The Hillside Group
* The Portland Pattern Repository

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Enterprise Integration Patterns. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Enterprise_Integration_Patterns&oldid=263914"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template