Enterprise Messaging Foundations

Enterprise Messaging Foundations
Jeremy Deane
http://jeremydeane.net

Agenda
v Environment Setup
v Asynchronous Hello World!
v Messaging Foundations
v Exercises
v Messaging Networks
v Advanced Messaging
v Extensible Messaging
v Exercises

Environment Setup
§ JDK 1.8+ Pre-Requisite ($JAVA_HOME in path)
§ Maven 3.3.3+ Pre-Requisite ($MAVEN_HOME in path)
§ Download and unzip ActiveMQ – Version 5.14.0+
§ Download hawtio – Version:1.4.56+
§ rename hawtio-app.jar
§ Download (Clone) Code From Github
§ https://github.com/jtdeane/magic-supplies
§ https://github.com/jtdeane/message-client
§ https://github.com/jtdeane/docker-message-client
§ https://github.com/jtdeane/camel-standalone-router
§ Windows Install ActiveMQ as Service:
./$ACTIVEMQ_HOME/win65/InstallService.bat
Docker Commands: ../docker-message-client/Enterprise Messaging Fundamentals Commands
Non-Docker Commands: ../message-client/Enterprise Messaging Fundamentals Commands

Docker – Portainer Setup
1. Create Volume
2. Start Portainer (no –v arg /var..sock for windows)
3. View Portainer (change admin password first time)
docker volume create portainer_data
docker run -d -p 9898:9000 -v /var/run/docker.sock:/var/run/docker.sock
-v portainer_data:/data portainer/portainer
http://localhost:9898/#/auth

Asynchronous Hello World!
1. Start ActiveMQ
2. Build Magic Supplies Project
3. Optional import into IDE
4. Execute Message Producer – Run as JUnit Test
5. View ActiveMQ Console
6. Execute Message Consumer – Run as JUnit Test
cd $ACTIVEMQ_HOME/bin
./activemq start OR ./activemq.bat
cd magic-supplies
mvn clean install
Open http://localhost:8161/admin/ {admin/admin}
Open http://localhost:8161/admin/queues.jsp
mvn test -Dtest=JMSProducerFunctionalTest
mvn test -Dtest=JMSConsumerFunctionalTest

ActiveMQ Web Console Alternative: hawtio
1. Start hawtio
2. Open in Web Browser
3. Select ConnectàLocal
4. Connect to ActiveMQ
5. Click new Agent URL to launch browsing
6. Select ActiveMQ
java -jar hawtio-app.jar --port 8090
http://localhost:8090/hawtio

ActiveMQ Message Broker
<execution environment>
Spring-Boot Application
REST
Controller
Message
Listener
TopicQueue
Magic Supplies Application
§ Spring Boot Web Application
§ Spring Boot 1.4.0
§ JMS Listeners - ActiveMQ

Magic Supplies Web Services
1. Start ActiveMQ *
2. Start Web Application
3. Open Browser
4. View Health Check Response
* Web Application requires ActiveMQ started
mvn spring-boot:run -Drun.arguments="-Xmx256m,-Xms128m”
OR
cd magic-supplies/target
java -jar magic-supplies-1.0.0.jar
http://localhost:8080/info
{"build":{"description":"Magic Supplies Web Application","name":"Magic Supplies Web
Appication","version":"1.0.0","artifact":"magic-supplies"}}

Magic Supplies Web Services - Docker
1. Update Docker Compose
2. Build & Start Docker Compose
3. View Health Check Response
4. Displayed
Also starts ActiveMQ (http://localhost:8161/admin/) & Hawtio (http://localhost:8090/hawtio)
#replace magic supplies build
build: .
#with magic supplies image
image: jtdeane/magic-supplies:latest
docker-compose up
http://localhost:8080/info
{"build":{"description":"Magic Supplies Web Application","name":"Magic Supplies Web
Appication","version":"1.0.0","artifact":"magic-supplies"}}

Hawtio connect to ActiveMQ - Docker
1. Open in Browser
2. Connect Remote to ActiveMQ (admin/admin)
3. View Queues

P2P Hidden Costs
Bottom Line SOA
by Marc Rix
Web services
A web service does NOT truly decouple the
consumer and provider
P2P Integrations
The cost of maintaining P2P integrations increases
exponentially as the number of the connections
increases
# of connections
$
gain
value
cost
loss

Enterprise Integration Patterns*
* A.K.A. Message Exchange Patterns (MEP)
Publish Subscribe Domain (Topics)
Point-to-Point Domain (Queues)

Enterprise Integration Patterns
Channel Message
FIlter
SquareTriangle ChannelSquare SquareSquare
Guaranteed Message Delivery
Filter Messages
Asynchronous Request Reply

Message Oriented Architecture (MOA)
MessageSender Receiver
Broker
TopicQueue
creates
processe
s
Delivers
Connects/to Connects/to
Hosted//by

Java Message Service (JMS)*
* Alternative – Advanced Message Queuing Protocol (AMQP)
Message
JMS & Custom Properties
Payload
Properties (a.k.a. Headers)
§ JMS* (e.g. JMSType, JMSCorrelationID,
JMSDeliveryMode, JMSExpiration)
§ Custom (e.g. MimeType, Token)
Payload (a.k.a. Body)
§ Text
§ Object
§ Map
§ Bytes
§ Stream

Java Message Service (JMS)
Producer
Publisher
Message Broker
<JMS Providert>
Topic
Queue
Subscriber
Consumer
<Listener>
Subscriber
Message Store
JMS
Selector
Channel
Channel

Apache ActiveMQ
Integration Options
Java Message Service (JMS)
Advanced Message Queuing Protocol (AMQP)
Deployment Flexibility
Stand-alone
Embedded
Advanced Topologies
Master-Slave High Availability (HA)
Federated Network
Support
Active Open Source Community
Commercial 24X7 Options
Languages - Transport
• Java-Scala – TCP/NIO
• Ruby, Perl, Python – Stomp
• C# (NMS) –TCP/NIO

Exercise: JMS Sender
1. Start ActiveMQ
2. Build Client
3. Execute JAR
4. View Message from ActiveMQ or hawtio (test.alchemy)
java -jar message-client-1.0.0.jar
mvn clean install
cd target
Spring Application
ActiveMQ Standalone Broker
Alchemy
Queue
Message
Sender
Channel
message-client/src/main/java/cogito/online/application/MessageClient:sendAlchemyAlert(..)

Exercise: JMS Sender - Docker
1. Start Docker Message Client
2. Execute client
http://localhost:9999/message/test
Stop existing Docker-Compose Magic Supplies
Spring Application
ActiveMQ Standalone Broker
Alchemy
Queue
Message
Sender
Channel
docker-message-client/src/main/java/ws/cogito/test/Application:sendAlchemyAlert(..)
#replace Docker Message Client build
build: .
#with Docker Message Client image
image: jtdeane/docker-message-client:latest
docker-compose up

Demo: JMS Listeners
magic-supplies/src/main/java/cogito/online/application/MagicSuppliesConfiguration
magic-supplies/src/main/java/cogito/online/messaging/SingleOrderProcessingMessageListener
magic-supplies/src/main/java/cogito/online/messaging/OrderProcessingMessageListener
Srping-Boot Application
Message
Listener
Configuration
Producer
<Message Client>
Message Broker
<JMS Providert>
Queue
Message Store
Channel

Exercise: JMS Listener
1. Start ActiveMQ
2. Start Web Application
3. Execute JAR
4. View Activity via ActiveMQ or hawtio
5. View Magic-Supplies Console Log
java -jar message-client-1.0.0.jar magic.order
java -jar message-client-1.0.0.jar magic.orders

Exercise: JMS Listener - Docker
1. Start Docker Message Client Supplies
2. Execute client
4. View Magic-Supplies Console Log
http://localhost:9999/message/magic.order
http://localhost:9999/message/magic.orders
Stop existing Docker-Compose Magic Supplies (if up)
build: .
docker-compose up

Demo: JMS Subscribers
magic-supplies/src/main/java/cogito/online/application/MagicSuppliesConfiguration
magic-supplies/src/main/java/cogito/online/messaging/AlertProcessingTopicListener.java
Message
Subscriber
Configuration
Producer
<Message Client>
Message Broker
<JMS Providert>
Topic
Channel

Exercise: JMS Subscribers
1. Start ActiveMQ
2. Start Magic Supplies
3. Execute JAR
4. View Activity via ActiveMQ (or hawtio)
5. View Magic-Supplies Console Logs
java -jar message-client-1.0.0.jar magic.alerts
Open http://localhost:8161/admin/topics.jsp

Exercise: JMS Listener - Subscribers
1. Start Magic Supplies
2. Execute client
3. View Message from ActiveMQ or Hawtio
4. View Magic-Supplies Console Logs
http://localhost:9999/message/magic.alerts
Stop existing Docker-Compose Magic Supplies (if up)
build: .
docker-compose up

ActiveMQ Broker Topologies
ActiveMQ in Action by Bruce Snyder,
Dejan Bosanac, and Rob Davies
§ Embedded Broker (VM Transport)
§ Standalone Broker (a.k.a. Client-Server)
§ Load Balanced Brokers
§ Networked Brokers (a.k.a. Store and Forward)
failover:(tcp://BrokerA:61616,tcp://BrokerC:61616)?
randomize=true

ActiveMQ High Availability and Disaster Recovery
ActiveMQ in Action by Bruce Snyder,
Dejan Bosanac, and Rob Davies
§ Master Slave – File System
§ KahaDB
§ SAN-NFS4
§ Master Slave – JDBC
§ RDBMS (e.g. PostgreSQL)
§ Master Slave – Replicated
§LevelDB & Zookeeper
§ Failover Protocol (use domain aliases)
failover:(tcp://PrimaryBroker:61616,tcp://SecondaryBroker:61616)?randomize=false

ActiveMQ High Availability Example
failover:(tcp://PrimaryBroker:61616,tcp://SecondaryBroker:61616)?randomize=false
Linux VM
Queue
<Execution Environment>
ActiveMQ (Master)
Topic
Linux VM
Queue
ActiveMQ (Slave)
Topic
<NFS Mount>
Kaha DB

ActiveMQ Simple High Availability Demo
1. Create the following directory structure
2. Unpack ActiveMQ twice renaming to master and slave
3. Update Master ../conf/activemq.xml: Name, Management,
Persistence, and Network Configurations
../cluster
../cluster/data
../cluster/master
../cluster/slave

<broker xmlns="http://activemq.apache.org/schema/core" brokerName="master"
dataDirectory="${activemq.data}”>

<managementContext>
<managementContext createConnector="true" connectorPort="1099"/>
</managementContext>

<persistenceAdapter>
<kahaDB directory="<<your location>>"/cluster/data"/>
</persistenceAdapter>

<networkConnectors>
<networkConnector uri="static:(tcp://localhost:61617)"/>
</networkConnectors>

ActiveMQ High Availability Demo
4. Update Slave ../conf/activemq.xml: Name, Management,
Persistence, Network, Transport Configurations
5. Update Slave ../conf/jetty.xml: jettyPort

<broker xmlns="http://activemq.apache.org/schema/core" brokerName="slave"
dataDirectory="${activemq.data}">

<networkConnectors>
<networkConnector uri="static:(tcp://localhost:61616)"/>
</networkConnectors>
<!– update – also remove other transports à
<transportConnector name="openwire"
uri="tcp://0.0.0.0:61617?maximumConnections=1000&wireFormat.maxFrameSiz
e=104857600"/>
<property name="port" value="8162"/>

ActiveMQ High Availability Demo
6. Start the Master and then the Slave Broker
7. Open Master Web Console – Queues Page
8. Create a Queue and Send a Message
9. Stop the Master Broker
10. Open Slave Web Console – Queues Page
11. View the Queue and persisted Message
cd ../cluster/<<master || slave>>/bin
cd ../cluster/<<master || slave>>/bin
./activemq stop OR Ctrl+C

ActiveMQ Federated Topology Example
Linux VM
Queue
ActiveMQ (Master)
Topic
Linux VM
Queue
ActiveMQ (Slave)
Topic
<NFS Mount>
Kaha DB
Linux VM
Queue
ActiveMQ (Master)
Topic
Linux VM
Queue
ActiveMQ (Slave)
Topic
<NFS Mount>
Kaha DB
Linux VM
Queue
ActiveMQ (Master)
Topic
Linux VM
Queue
ActiveMQ (Slave)
Topic
<NFS Mount>
Kaha DB
Web Network Segment
Service Network Segment
Data Network Segment

ActiveMQ Error Handling
§ Dead Letter Queue (DLQ)
§ Review (Web Console)
§ Redeliver (Plug-in)
§ Remediate (Policy)
§ Monitor DLQ Depth
§ Alerts (Splunk Example)
§ Failed Message Transactions
§ Rollback
§ DLQ
§ Throw or Log Exception

ActiveMQ Security
§ Authentication and Authorization
§ Web Console
§ JMX Connector (Bind to specific Port #)
§ Queues and Topics
§ Auditing
§ Monitor Logs
§ Periodically Audit Access
§ Confidentiality
§ Transport (SSL)
§ Messages (Encryption)
§ KahaDB Files (Encryption)
§ Log Files (Encryption)

Apache Camel – Enterprise Integration Library
Camel In Action by Claus Ibsen and Jonathan Anstey
§ Domain Specific Languages (DSL) – Java, Scala, Spring DSL
§ Route Builders – create Endpoints (i.e. from & to) using
Components (e.g. protocol) and Processors (e.g. Mediation,
Enrichment
§ Route Engine – Loads and executes Routes

Apache Camel Message
JMS
JMS & Custom Properties
Payload
Camel (IN)
Camel Headers
Body
Camel (OUT)
Camel Headers
Body
HTTP Request
HTTP Headers
Body

Apache Camel Route Processing
/*
* Splitter - xpath expression
*/
from("activemq:emagic.orders").
split(splitXPath).
parallelProcessing().
to("activemq:emagic.order");
Camel Route Engine
Camel Route
<JMS Component>
Endpoint (From)
<EIP Processor>
Some Processing
<DB Component>
Endpoint (To)
Camel
Message
Conﬁgurations
/*
* Content Based Routing - Inpatient-Outpatient Events
* http://camel.apache.org/jsonpath.html
*/
from("activemq:event.ingestion").
process(new TrackingIdProcessor()).
choice().
when().jsonpath("$[?(@.class==inpatient)]").
to("activemq:event.inpatient").
otherwise().
to("activemq:event.outpatient").
end().
to("activemq:event.audit");

Spring-Boot & Apache Camel
Java Runtime Environment (JRE)
Spring IOC Container
Camel Route Engine
Camel Route
<JMS Component>
Endpoint (From)
<EIP Processor>
Some Processing
<DB Component>
Endpoint (To)
Camel
Message
Conﬁgurations
/** Spring Boot – Camel Route Application */
@Configuration
@ImportResource("classpath:camel-route-spring.xml")
public class MagicRouterApplication {
public static void main(String[] args) {
SpringApplication.run(MagicRouterApplication.class, args);
}
}

Spring Boot Application
<Executable JAR>
Message Broker
<JMS Provider>
Queue
<magic.order>
Content Router
Queue
<priority.orders>
Queue
<emagic.orders>
Camel Routes
Queue
<emagic.order>
Splitter
Producer
<Message Client>
Message
Subscriber
Configuration
Message
Listener
Producer
<Console>
Exercise: Content Based Routing

Exercise : Content Based Routing
1. Build project and import into IDE (e.g. Eclipse, IntelliJ)
2. View MagicRouteBuilder.java & MagicRouterApplication.java
3. View camel-route-spring.xml
4. Execute Spring Boot Application
5. Execute Message Client
cd camel-standalone-router
mvn clean install
mvn eclipse:eclipse
mvn spring-boot:run OR
java –jar ./target/camel-standalone-router-1.0.0.jar
java -jar message-client-1.0.0.jar emagic.orders

Exercise : Content Based Routing
6. Open ActiveMQ Web Console and view priority.order queue
7. View Magic Supplies log for orders processed (magic.order)
8. View Camel Standalone – JConsole
9. Connect to Camel – hawtio
jconsole {pid}

Exercise: Content Based Routing - Docker
1. Build Camel Standalone Router Docker Compose
2. Start Camel Standalone Router Docker
3. Execute Test
4. View Messages from ActiveMQ or Hawtio (priority.order)
docker compose up
mvn clean install
docker-compose build
http://localhost:9999/message/emagic.orders
Stop existing Docker-Compose Message Client

Hawtio connect to Camel- Docker
1. Open in Browser
2. Connect Remote to Camel
endpoints.jolokia.sensitive=falseapplication.properties
<dependency>
<groupId>org.jolokia</groupId>
<artifactId>jolokia-core</artifactId>
<version>1.3.7</version>
</dependency>
pom.xml

Camel Unit Testing
@Override
protected CamelContext createCamelContext() throws Exception {
CamelContext context = super.createCamelContext();
//setup routes to Mock Endpoints
context.addRoutes(new RouteBuilder() {
public void configure() {
//test xpath split
from ("direct:split").
split(new XPathBuilder (MagicRouteBuilder.splitXpath)).
to("mock:order");
});
return context;
}
@Test
public void testSplitLogic() throws Exception {
//Set expectations
MockEndpoint order = getMockEndpoint("mock:order");
order.expectedMessageCount(3);
//read in a small batch
String xml = IOUtils.toString(this.getClass().
getResourceAsStream("batch.xml"), "UTF-8");
//execute the test
template.sendBody("direct:split", xml);
//should be three orders in the batch
order.assertIsSatisfied();
}
MagicRouteBuilderTest.java

Camel Functional Testing
1. Download and install Apache JMeter
2. Copy $ACTIVEMQ_HOME/activemq-all-5.13.1.jar to $JMETER_HOME/lib
3. Start JMeter - ./jmeter.sh or jmeter.bat
4. Open camel-magic-router/src/test/jmeter/Mock Camel Publisher.jmx
5. Run test
Other possible frameworks
• RobotFramework
• SOAPUI

Message Broker
<JMS Provider>
Producer
<JMeter>
Queue
<emagic.dead>
Queue
<emagic.orders>
Camel Routes
Splitter Dead Letter
Channel
Demo: Dead Letter Channel
errorHandler(deadLetterChannel("activemq:emagic.dead").maximumRedeliveries(1).redeliveryDelay(1000));
java -jar message-client-1.0.0.jar emagic.bad
http://localhost:9999/message/emagic.bad

ActiveMQ Master Broker
ActiveMQ Slave A Broker
ActiveMQ Slave B Broker
Spring Boot Application 1
<Executable JAR>
Camel Routes
<Executable JAR>
<Executable JAR>
Camel Routes Camel Routes
Spring-Boot & Camel – ActiveMQ Integration
Primary Benefits:
§ Resiliency – Camel Route failure does not take down Broker
§ Extensibility – Swap out Message Broker or EIP Framework
§ Continuous Development – No Broker or Web Server downtime

Competing Consumers
ActiveMQ Broker
Spring Boot App 1
<Executable JAR>
Camel Routes
Spring Boot App 2
<Executable JAR>
Camel Routes
Spring Boot App 3
<Executable JAR>
Camel Routes
Queue
<emagic.order>
Golden Path – Processed once in order
Bad Producer
Redis
Key-Value
Store
Idempotent Competing Consumers

Spring-Boot & Camel – Deployment Options
Linux VM
Camel
Route
Spring-Boot Camel
Camel
Route
Properties Log
Linux VM
Camel
Route
Spring-Boot Camel
Camel
Route
Properties Log
Port: 2100
Camel
Route
Spring-Boot Camel
Camel
Route
Properties Log
Port: 2101
§ Single Application per VM
§ Multiple Applications per VM
§ IaaS Container (e.g. Docker)
§ PaaS Container (e.g. Cloud Foundry)

Exercise: Enrichment and Transformation
1. Update: Replace Simple Choice Route with Mediation Route
2. Stop Spring Boot, Build Project, and Start Spring Boot
XmlJsonDataFormat xmlJsonFormat = new XmlJsonDataFormat();
xmlJsonFormat.setForceTopLevelObject(true);
from("activemq:emagic.order").
choice().
when().simple("${in.body} contains 'Houdini'").
process(new Processor() {
public void process(Exchange exchange) {
exchange.getIn().setHeader("VIP", "true");
}
}).
to("activemq:priority.order").
otherwise().
marshal(xmlJsonFormat).
transform(body().regexReplaceAll("@", "")).
to("activemq:magic.order");
mvn clean install

Exercise: Enrichment and Transformation
4. Open ActiveMQ Web Console and view priority.order queue
5. View Magic Supplies log for orders processed

Exercise: Enrichment and Transformation - Docker
1. Update: Replace Simple Choice Route with Mediation Route
XmlJsonDataFormat xmlJsonFormat = new XmlJsonDataFormat();
xmlJsonFormat.setForceTopLevelObject(true);
choice().
when().simple("${in.body} contains 'Houdini'")
process(new Processor() {
public void process(Exchange exchange) {
exchange.getIn().setHeader("VIP", "true");
}
})
to("activemq:priority.order").
otherwise().
marshal(xmlJsonFormat).
transform(body().regexReplaceAll("@", "")).

Exercise: Enrichment and Transformation - Docker
3. Execute Test
4. View Message from ActiveMQ or hawtio (priority.order)
5. View Magic Supplies log for orders processed
docker compose up
mvn clean install

Exercise: Wire-Tap
1. Replace Routing w/: Wire-Tap to Splitter and Evaluation Route
3. Execute Message Client & View Results
wireTap("direct:ministry").
from("direct:ministry").
choice().
when().simple("${in.body} contains 'Elder'").
log("ILLEGAL MAGIC ALERT").
to("activemq:topic:magic.alerts").
otherwise().
log("...off into the ether");
mvn clean install
Open http://localhost:8161/admin/topics.jsp Wire Ttap

Exercise: Wire-Tap - Docker
1. Replace Routing w/: Wire-Tap to Splitter and Evaluation Route
Wire Ttap
wireTap("direct:ministry").
from("direct:ministry").
choice().
when().simple("${in.body} contains 'Elder'").
log("ILLEGAL MAGIC ALERT").
to("activemq:topic:magic.alerts").
otherwise().
log("...off into the ether");

Exercise: Wire-Tap- Docker
3. Execute Test
4. View Messages from ActiveMQ or hawtio
docker compose up
mvn clean install
Wire Ttap

Bonus Exercise: Idempotent Consumer (In-Memory)
?
Idempotent Consumer
1. View IdempotentConsumerRouteBuilder in Camel-Standalone-
Router
2. Start Camel-Standalone Router
4. Open ActiveMQ Web Console (or view via hawtio)
• Only two of three sent messages should be present.
java -jar message-client-1.0.0.jar unique.orders

Bonus Exercise: Idempotent Consumer (In-Memory)
1. View IdempotentConsumerRouteBuilder in Camel-Standalone-Router
3. Execute Test
4. View Messages from ActiveMQ or Hawtio
docker compose up
http://localhost:9999/message/unique.orders
?
Idempotent Consumer
docker logs -f {magic-supplies-container id}

Bonus Exercise: Idempotent Consumer (Redis)
?
Idempotent Consumer
1. Download Install Redis
• Mac: brew install redis
• Linux: yum install redis
• Windows: https://github.com/rgl/redis/downloads
2. Update camel-route-spring.xml – Uncomment

<bean id="redisConnectionFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<property name="hostName" value="localhost"/>
<property name="port" value="6379"/>
</bean>
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="redisConnectionFactory"/>
</bean>

Bonus Exercise*: Idempotent Consumer (Redis)
1. Update IdempotentConsumerRouteBuilder – Comment:
2. Update IdempotentConsumerRouteBuilder - Uncomment
from("activemq:unique.order").
idempotentConsumer(header("uniqueId"),
MemoryIdempotentRepository.memoryIdempotentRepository(200)).
..
@AutowiredRedisTemplate<String, String> redisTemplate;
..
from("activemq:unique.order").
idempotentConsumer(header("uniqueId"),
RedisIdempotentRepository.redisIdempotentRepository(redisTemplate, "camel-repo")).
mvn clean install
*LOCAL ONLY – But for Spring-Redis-Docker See: https://github.com/jtdeane/magic-batch

Bonus Exercise *: Idempotent Consumer (Redis)
?
Idempotent Consumer
2. Open ActiveMQ Web Console (or view via hawtio)
java -jar message-client-1.0.0.jar unique.orders
*LOCAL ONLY – But for Spring-Redis-Docker See: https://github.com/jtdeane/magic-batch

Questions & FeedbackQuestions & Feedback
My Contact
information:
Jeremy Deane
jeremy.deane@gmail.com
http://jeremydeane.net
https://github.com/jtdeane/magic-supplies
https://github.com/jtdeane/message-client
https://github.com/jtdeane/docker-message-client
https://github.com/jtdeane/camel-standalone-router

Enterprise Messaging Foundations

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Enterprise Messaging Foundations

Similar to Enterprise Messaging Foundations (20)

Recently uploaded

Recently uploaded (20)

Enterprise Messaging Foundations