| Stereotype |
Description |
EIP_Aggregator
|
Use a stateful filter, an Aggregator, to collect and store individual messages until a complete set of related messages has been received. Then, the Aggregator publishes a single message distilled from the individual messages.
|
EIP_Association
|
|
EIP_Association_Message
|
|
EIP_ClaimCheck
|
Store message data in a persistent store and pass a Claim Check to subsequent components. These components can use the Claim Check to retrieve the stored information.
|
EIP_CompetingConsumers
|
Create multiple Competing Consumers on a single channel so that the consumers can process multiple messages concurrently.
|
EIP_Component
|
|
EIP_ComposedMessageProcessor
|
Use a Composed Message Processor to process a composite message. The Composed Message Processor splits the message up, routes the sub-messages to the appropriate destinations and re-aggregates the responses back into a single message.
|
EIP_ContentBasedRouter
|
Use a Content-Based Router to route each message to the correct recipient based on message content.
|
EIP_ContentEnricher
|
Use a specialized transformer, a Content Enricher, to access an external data source in order to augment a message with missing information.
|
EIP_ContentFilter
|
Use a Content Filter to remove unimportant data items from a message leaving only important items.
|
EIP_ControlBus
|
Use a Control Bus to manage an enterprise integration system. The Control Bus uses the same messaging mechanism used by the application data, but uses separate channels to transmit data that is relevant to the management of components involved in the message flow
|
EIP_DatatypeChannel
|
Use a separate Datatype Channel for each data type, so that all data on a particular channel is of the same type.
|
EIP_DeadLetterChannel
|
When a messaging system determines that it cannot or should not deliver a message, it may elect to move the message to a Dead Letter Channel.
|
EIP_Detour
|
Construct a Detour with a context-based router controlled via the Control Bus. In one state the router routes incoming messages through additional steps while in the other it routes messages directly to the destination channel.
|
EIP_DurableSubscriber
|
Use a Durable Subscriber to make the messaging system save messages published while the subscriber is disconnected.
|
EIP_DynamicRouter
|
Use a Dynamic Router, a Router that can self-configure based on special configuration messages from participating destinations.
|
EIP_EnvelopeWrapper
|
Use a Envelope Wrapper to wrap application data inside an envelope that is compliant with the messaging infrastructure. Unwrap the message when it arrives at the destination.
|
EIP_EventDrivenConsumer
|
The application should use an Event-Driven Consumer, one that is automatically handed messages as they’re delivered on the channel.
|
EIP_Fail
|
|
EIP_GuaranteedDelivery
|
Use a Guaranteed Delivery to make messages persistent so that they are not lost even if the messaging system crashes.
|
EIP_ChannelAdapter
|
Use a Channel Adapter that can access the application's API or data and publish messages on a channel based on this data, and that likewise can receive messages and invoke functionality inside the application
|
EIP_ChannelPurger
|
Use a Channel Purger to remove unwanted messages from a channel.
|
EIP_InvalidMessageChannel
|
The receiver should move the improper message to an Invalid Message Channel, a special channel for messages that could not be processed by their receivers.
|
EIP_Key
|
|
EIP_MessageBus
|
Structure the connecting middleware between these applications as a Message Bus that enables them to work together using messaging.
|
EIP_MessageDispatcher
|
Create a Message Dispatcher on a channel that will consume messages from a channel and distribute them to performers.
|
EIP_MessageEndpoint
|
Connect an application to a messaging channel using a Message Endpoint, a client of the messaging system that the application can then use to send or receive messages.
|
EIP_MessageFilter
|
Use a special kind of Message Router, a Message Filter, to eliminate undesired messages from a channel based on a set of criteria.
|
EIP_MessageHeader
|
Package the information into a Message, a data record that the messaging system can transmit through a message channel. message has two parts: a header and a body. The header holds information about the data being transmitted, its origin, and its destination. The body holds the actual data.
|
EIP_MessageChannel
|
Connect the applications using a Message Channel, where one application writes information to the channel and the other one reads that information from the channel.
|
EIP_MessagePayload
|
Package the information into a Message, a data record that the messaging system can transmit through a message channel. message has two parts: a header and a body. The header holds information about the data being transmitted, its origin, and its destination. The body holds the actual data.
|
EIP_MessagePayloadCommand
|
Use a Command Message to reliably invoke a procedure in another application.
|
EIP_MessagePayloadCorrelationIdentifier
|
Each reply message should contain a Correlation Identifier, a unique identifier that indicates which request message this reply is for.
|
EIP_MessagePayloadDocument
|
Use a Document Message to reliably transfer a data structure between applications.
|
EIP_MessagePayloadEnvelope
|
Use a Envelope Wrapper to wrap application data inside an envelope that is compliant with the messaging infrastructure. Unwrap the message when it arrives at the destination.
|
EIP_MessagePayloadEvent
|
Use an Event Message for reliable, asynchronous event notification between applications.
|
EIP_MessagePayloadExpiration
|
Set the Message Expiration to specify a time limit how long the message is viable.
|
EIP_MessagePayloadExpired
|
Set the Message Expiration to specify a time limit how long the message is viable.
|
EIP_MessagePayloadFormatIndicator
|
Design a data format that includes a Format Indicator, so that the message specifies what format it is using.
|
EIP_MessagePayloadReturnAddress
|
The request message should contain a Return Address that indicates where to send the reply message.
|
EIP_MessageRouter
|
Insert a special filter, a Message Router, which consumes a Message from one Message Channel and republishes it to a different Message Channel channel depending on a set of conditions.
|
EIP_MessageSequence
|
Whenever a large set of data may need to be broken into message-size chunks, send the data as a Message Sequence and mark each message with sequence identification fields.
|
EIP_MessageStore
|
Use a Message Store to capture information about each message in a central location.
|
EIP_MessageTranslator
|
Use a special filter, a Message Translator, between other filters or applications to translate one data format into another.
|
EIP_MessagingBridge
|
Use a Messaging Bridge, a connection between messaging systems, to replicate messages between systems.
|
EIP_MessagingGateway
|
Use a Messaging Gateway, a class than wraps messaging-specific method calls and exposes domain-specific methods to the application.
|
EIP_Normalizer
|
Use a Normalizer to route each message type through a custom Message Translator so that the resulting messages match a common format.
|
EIP_PollingConsumer
|
The aplication should use a Polling Consumer, one that explicitly makes a call when it wants to receive a message
|
EIP_ProcessManager
|
Use a central processing unit, a Process Manager, to maintain the state of the sequence and determine the next processing step based on intermediate results.
|
EIP_PublishSubscribeChannel
|
Send the event on a Publish-Subscribe Channel, which delivers a copy of a particular event to each receiver.
|
EIP_RecipientList
|
Define a channel for each recipient. Then use a Recipient List to inspect an incoming message, determine the list of desired recipients, and forward the message to all channels associated with the recipients in the list.
|
EIP_RequestReply
|
Send a pair of Request-Reply messages, each on its own channel.
|
EIP_Resequencer
|
Use a stateful filter, a Resequencer, to collect and re-order messages so that they can be published to the output channel in a specified order.
|
EIP_RoutingSlip
|
Attach a Routing Slip to each message, specifying the sequence of processing steps. Wrap each component with a special message router that reads the Routing Slip and routes the message to the next component in the list.
|
EIP_SelectiveConsumer
|
Make the consumer a Selective Consumer, one that filteres the messages delivered by its channel so that it only receives the ones that match its criteria.
|
EIP_ServiceActivator
|
Design a Service Activator that connects the messages on the channel to the service being accessed.
|
EIP_SmartProxy
|
Use a Smart Proxy to store the Return Address supplied by the original requestor and replace it with the address of the Smart Proxy. When the service sends the reply message route it to the original Return Address.
|
EIP_Splitter
|
Use a Splitter to break out the composite message into a series of individual messages, each containing data related to one item.
|
EIP_TestMessage
|
Therefore, use Test Message to assure the health of message processing components.
|
EIP_TransactionalClient
|
Use a Transactional Client—make the client’s session with the messaging system transactional so that the client can specify transaction boundaries.
|
EIP_WireTap
|
Insert a simple Recipient List into the channel that publishes each incoming message to the main channel and a secondary channel.
|