Stereotype catalogue

Stereotypes are an inbuilt mechanism for logically extending or altering the meaning, display and syntax of a model element. Different model elements have different standard stereotypes associated with them.

Technology name
MDG Technology for EIP from BOBOVO. Inspired by the book Enterprise Integration Patterns by Gregor Hohpe and Bobby Woolf.

Stereotype catalogue

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.