249 lines
9.1 KiB
HTML
249 lines
9.1 KiB
HTML
<!--
|
|
Licensed to the Apache Software Foundation (ASF) under one
|
|
or more contributor license agreements. See the NOTICE file
|
|
distributed with this work for additional information
|
|
regarding copyright ownership. The ASF licenses this file
|
|
to you under the Apache License, Version 2.0 (the
|
|
"License"); you may not use this file except in compliance
|
|
with the License. You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing,
|
|
software distributed under the License is distributed on an
|
|
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
KIND, either express or implied. See the License for the
|
|
specific language governing permissions and limitations
|
|
under the License.
|
|
-->
|
|
|
|
<html>
|
|
<head>
|
|
<title>ActiveMQ JMS Load Balanced Static Clustered Queue Example</title>
|
|
<link rel="stylesheet" type="text/css" href="../common/common.css" />
|
|
<link rel="stylesheet" type="text/css" href="../common/prettify.css" />
|
|
<script type="text/javascript" src="../common/prettify.js"></script>
|
|
</head>
|
|
<body onload="prettyPrint()">
|
|
<h1>JMS Load Balanced Static Clustered One Way Queue Example</h1>
|
|
|
|
<p>This example demonstrates a JMS queue deployed on three different nodes. The three nodes are configured to form a one way cluster
|
|
from a <em>static</em> list of nodes. </p>
|
|
<p>A one way cluster is different from a symmetrical cluster in that each node is only connected to one another node in
|
|
a chain type fashion, so server 0 -> server 1 -> server 2</p>
|
|
<p>We then create a consumer on the queue on each node, and we create a producer on only one of the nodes.</p>
|
|
<p>We then send some messages via the producer, and we verify that <b>all</b> consumers receive the sent messages
|
|
in a round-robin fashion.</p>
|
|
<p>In other words, ActiveMQ <b>load balances</b> the sent messages across all consumers on the cluster</p>
|
|
<p>This example uses JNDI to lookup the JMS Queue and ConnectionFactory objects. If you prefer not to use
|
|
JNDI, these could be instantiated directly.</p>
|
|
<p>Here's the relevant snippet from the server configuration, which tells the server to form a one way cluster between the three nodes
|
|
and to load balance the messages between the nodes. Note that we have set <em>allow-direct-connections-only</em> to true,
|
|
this means that this server will only ever connect the address's specified in the list of connectors. ALso notice
|
|
that <em>max-hops</em> is 2, this is because server 0 is not directly connected to server 2, 2 hops in fact, so we
|
|
allow any updates from servers up to 2 hops away</p>
|
|
<pre class="prettyprint">
|
|
<code>
|
|
<cluster-connection name="my-cluster">
|
|
<address>jms</address>
|
|
<connector-ref>netty-connector</connector-ref>
|
|
<retry-interval>500</retry-interval>
|
|
<use-duplicate-detection>true</use-duplicate-detection>
|
|
<forward-when-no-consumers>true</forward-when-no-consumers>
|
|
<max-hops>2</max-hops>
|
|
<static-connectors allow-direct-connections-only="true">
|
|
<connector-ref>server1-connector</connector-ref>
|
|
</static-connectors>
|
|
</cluster-connection>
|
|
</code>
|
|
</pre>
|
|
<p>For more information on ActiveMQ load balancing, and clustering in general, please see the clustering
|
|
section of the user manual.</p>
|
|
<h2>Example step-by-step</h2>
|
|
<p><i>To run the example, simply type <code>mvn verify</code> from this directory</i></p>
|
|
|
|
<ol>
|
|
<li> Get an initial context for looking up JNDI from server 0.</li>
|
|
<pre class="prettyprint">
|
|
<code>
|
|
ic0 = getContext(0);
|
|
</code>
|
|
</pre>
|
|
|
|
<li>Look-up the JMS Queue object from JNDI</li>
|
|
<pre class="prettyprint">
|
|
<code>
|
|
Queue queue = (Queue)ic0.lookup("/queue/exampleQueue");
|
|
</code>
|
|
</pre>
|
|
|
|
<li>Look-up a JMS Connection Factory object from JNDI on server 0</li>
|
|
<pre class="prettyprint">
|
|
<code>
|
|
ConnectionFactory cf0 = (ConnectionFactory)ic0.lookup("/ConnectionFactory");
|
|
</code>
|
|
</pre>
|
|
|
|
|
|
<li>grab an initial connection and wait, in reality you wouldn't do it this way but since we want to ensure an
|
|
equal load balance we do this and then create 4 connections round robined</li>
|
|
<pre class="prettyprint">
|
|
<code>
|
|
initialConnection = cf0.createConnection();
|
|
</code>
|
|
</pre>
|
|
|
|
<li>We create a JMS Connection connection0 which is a connection to server 0</li>
|
|
<pre class="prettyprint">
|
|
<code>
|
|
connection0 = cf0.createConnection()
|
|
</code>
|
|
</pre>
|
|
|
|
<li>We create a JMS Connection connection0 which is a connection to server 1</li>
|
|
<pre class="prettyprint">
|
|
<code>
|
|
connection1 = cf0.createConnection()
|
|
</code>
|
|
</pre>
|
|
|
|
<li>We create a JMS Connection connection0 which is a connection to server 2</li>
|
|
<pre class="prettyprint">
|
|
<code>
|
|
connection2 = cf0.createConnection()
|
|
</code>
|
|
</pre>
|
|
|
|
<li>We create a JMS Session on server 0</li>
|
|
<pre class="prettyprint">
|
|
<code>
|
|
Session session0 = connection0.createSession(false, Session.AUTO_ACKNOWLEDGE);
|
|
</code>
|
|
</pre>
|
|
|
|
<li>We create a JMS Session on server 1</li>
|
|
<pre class="prettyprint">
|
|
<code>
|
|
Session session1 = connection1.createSession(false, Session.AUTO_ACKNOWLEDGE);
|
|
</code>
|
|
</pre>
|
|
|
|
<li>We create a JMS Session on server 1</li>
|
|
<pre class="prettyprint">
|
|
<code>
|
|
Session session2 = connection2.createSession(false, Session.AUTO_ACKNOWLEDGE);
|
|
</code>
|
|
</pre>
|
|
<li>We start the connections to ensure delivery occurs on them</li>
|
|
<pre class="prettyprint">
|
|
<code>
|
|
connection0.start();
|
|
|
|
connection1.start();
|
|
|
|
connection2.start();
|
|
</code>
|
|
</pre>
|
|
|
|
|
|
<li>We create JMS MessageConsumer objects on server 0 and server 1</li>
|
|
<pre class="prettyprint">
|
|
<code>
|
|
MessageConsumer consumer0 = session0.createConsumer(queue);
|
|
|
|
MessageConsumer consumer2 = session2.createConsumer(queue);
|
|
|
|
MessageConsumer consumer3 = session3.createConsumer(queue);
|
|
</code>
|
|
</pre>
|
|
|
|
|
|
<li>We create a JMS MessageProducer object on server 0.</li>
|
|
<pre class="prettyprint">
|
|
<code>
|
|
Session sendSession = getServerConnection(0, connection0, connection1, connection2).createSession(false, Session.AUTO_ACKNOWLEDGE);
|
|
|
|
MessageProducer producer = sendSession.createProducer(queue);
|
|
</code>
|
|
</pre>
|
|
|
|
<li>We send some messages to server 0.</li>
|
|
<pre class="prettyprint">
|
|
<code>
|
|
final int numMessages = 18;
|
|
|
|
for (int i = 0; i < numMessages; i++)
|
|
{
|
|
TextMessage message = session0.createTextMessage("This is text message " + i);
|
|
|
|
producer.send(message);
|
|
|
|
System.out.println("Sent message: " + message.getText());
|
|
}
|
|
</code>
|
|
</pre>
|
|
|
|
<li>We now consume those messages on *both* server 0 and server 1.
|
|
We note the messages have been distributed between servers in a round robin fashion.
|
|
ActiveMQ has <b>load balanced</b> the messages between the available consumers on the different nodes.
|
|
ActiveMQ can be configured to always load balance messages to all nodes, or to only balance messages
|
|
to nodes which have consumers with no or matching selectors. See the user manual for more details.</li>
|
|
JMS Queues implement point-to-point message where each message is only ever consumed by a
|
|
maximum of one consumer.
|
|
<pre class="prettyprint">
|
|
<code>
|
|
for (int i = 0; i < numMessages; i += 2)
|
|
{
|
|
TextMessage message0 = (TextMessage)consumer0.receive(5000);
|
|
|
|
System.out.println("Got message: " + message0.getText() + " from node 0");
|
|
|
|
TextMessage message1 = (TextMessage)consumer1.receive(5000);
|
|
|
|
System.out.println("Got message: " + message1.getText() + " from node 1");
|
|
|
|
TextMessage message2 = (TextMessage)consumer2.receive(5000);
|
|
|
|
System.out.println("Got message: " + message2.getText() + " from node " + con2Node);
|
|
}
|
|
</code>
|
|
</pre>
|
|
|
|
<li>And finally (no pun intended), <b>always</b> remember to close your JMS resources after use, in a <code>finally</code> block. Closing a JMS connection will automatically close all of its sessions, consumers, producer and browser objects</li>
|
|
|
|
<pre class="prettyprint">
|
|
<code>
|
|
finally
|
|
{
|
|
if (initialConnection != null)
|
|
{
|
|
initialConnection.close();
|
|
}
|
|
|
|
if (connection0 != null)
|
|
{
|
|
connection0.close();
|
|
}
|
|
|
|
if (connection1 != null)
|
|
{
|
|
connection1.close();
|
|
}
|
|
|
|
if (connection2 != null)
|
|
{
|
|
connection2.close();
|
|
}
|
|
|
|
if (ic0 != null)
|
|
{
|
|
ic0.close();
|
|
}
|
|
}
|
|
</code>
|
|
</pre>
|
|
|
|
</ol>
|
|
</body>
|
|
</html>
|