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
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.
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.
Use a Channel Purger to remove unwanted messages from a channel.
Use a Command Message to reliably invoke a procedure in another application.
Create multiple Competing Consumers on a single channel so that the consumers can process multiple messages concurrently.
Use a Content-Based Router to route each message to the correct recipient based on message content.
Use a Content Filter to remove unimportant data items from a message leaving only important items.
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 mess
Each reply message should contain a Correlation Identifier, a unique identifier that indicates which request message this reply is for.
Use a specialized transformer, a Content Enricher, to access an external data source in order to augment a message with missing information.
Use a separate Datatype Channel for each data type, so that all data on a particular channel is of the same type.
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.
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.
Use 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.
Use a Document Message to reliably transfer a data structure between applications.
Use a Durable Subscriber to make the messaging system save messages published while the subscriber is disconnected.
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.
The application should use an Event-Driven Consumer, one that is automatically handed messages as they
re delivered on the channel.
Use an Event Message for reliable, asynchronous event notification between applications.
Use a special kind of Message Router, a Message Filter, to eliminate undesired messages from a channel based on a set of criteria.
Use Guaranteed Delivery to make messages persistent so that they are not lost even if the messaging system crashes.
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.
Structure the connecting middleware between these applications as a Message Bus that enables them to work together using messaging.
Create a Message Dispatcher on a channel that will consume messages from a channel and distribute them to performers.
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.
Package the information into a Message, a data record that the messaging system can transmit through a message channel.
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.
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.
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.
Use a Message Store to capture information about each message in a central location.
Use a special filter, a Message Translator, between other filters or applications to translate one data format into another.
Design a Service Activator that connects the messages on the channel to the service being accessed.
Use a Messaging Bridge, a connection between messaging systems, to replicate messages between systems
Use a Messaging Gateway, a class than wraps messaging-specific method calls and exposes domain-specific methods to the application.
Use a Normalizer to route each message type through a custom Message Translator so that the resulting messages match a common format.
The aplication should use a Polling Consumer, one that explicitly makes a call when it wants to receive a message.
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.
Send the event on a Publish-Subscribe Channel, which delivers a copy of a particular event to each receiver.
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.
Send a pair of Request-Reply messages, each on its own channel.
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.
The request message should contain a Return Address that indicates where to send the reply message.
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.
Use a Splitter to break out the composite message into a series of individual messages, each containing data related to one item.
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.
Use Test Message to assure the health of message processing components
Use a Transactional Client
make the client
s session with the messaging system transactional so that the client can specify transaction boundaries.
Insert a simple Recipient List into the channel that publishes each incoming message to the main channel and a secondary channel.
Blank Box for additional templates
Service template
itional templates
Arial Unicode MS
Symbol
Wingdings
Arial
SimSun
PMingLiU
MS PGothic
Dotum
Sylfaen
Estrangelo Edessa
Vrinda
Shruti
Mangal
Tunga
Sendnya
Raavi
Dhenu
Latha
Gautami
Cordia New
MS Farsi
Gulim
Times New Roman
Arial Narrow
Guide
TheDoc
Page-1
Gesture Format
Aggregator
Basic
Visio 00
Aggregator.18
Rectangle.32
Adapter
Composed Message Processor
Durable Subscriber
Pipes & Filters.10
Channel
Pipes & Filters.28
Channel Purger
Pipes & Filters.27
Command Message
Connector
Visio 90
Square.4
Circle
Competing Consumers
Pipes & Filters.37
Content Based Router
Message Router
Pipes & Filters.6
Rectangle.2
Content Filter
Content Filter.21
Control Bus
Pipes & Filters.61
Correlation ID
Message
Pipes & Filters.105
Database
Content Enricher
Data Enricher.22
Datatype Channel
Dead Letter Channel
Detour
Message Dispatcher
Pipes & Filters.103
Document Message
Publish-Subscribe Channel
Pipes & Filters.153
Envelope Wrapper
Message Branch
Rectangle.104
Triangle
Event-Driven Consumer
Pipes & Filters.172
Event Message
Message Filter
Message Endpoint
Rectangle.30
Guaranteed Delivery
Invalid Message Channel
Pipes & Filters.179
Message Bus
Pipes & Filters.189
Rectangle.15
Dynamic connector.4
Square.5
Service Activator
ProcessNumber
Selective Consumer
Recipient List
Channel Adapter
Message Sequence
Pipes & Filters.233
Message Store
Pipes & Filters.271
Message Translator
Messaging Bridge
Pipes & Filters.288
Messaging Gateway
Normalizer
Polling Consumer
Process Manager
Flow Normal
Pipes & Filters.338
Rectangle.56
Decision
Cost
Duration
Resources
Request Reply
Pipes & Filters
Row_1
Pipes & Filters.358
Resequencer
Square.9
Return Address
Pipes & Filters.377
Routing Slip
Routing Table
Rectangle.397
Splitter
Rectangle.5
Claim Check
Square.14
Service
Test Message
Transactional Client
Wire Tap
Pipes & Filters.442
Blank
Circle.15
Owner
Function
StartDate
EndDate
Status
SetDefaultSize
ResizeWithText
visVersion
DefaultWidth
DefaultHeight
ResizeTxtHeight