ActiveMQ入门实例 - ActiveMQ教程

1.下载ActiveMQ

去官方网站下载：http://activemq.apache.org/

2.运行ActiveMQ

解压缩apache-activemq-5.5.1-bin.zip，然后双击apache-activemq-5.5.1\bin\activemq.bat运行ActiveMQ程序。

启动ActiveMQ以后，登陆：http://localhost:8161/admin/，创建一个Queue，命名为FirstQueue。

3.创建Eclipse项目并运行

创建project：ActiveMQ-5.5，并导入apache-activemq-5.5.1\lib目录下需要用到的jar文件，项目结构如下图所示：

3.1.Sender.java

package com.xuwei.activemq;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;

public class Sender {
    private static final int SEND_NUMBER = 5;

    public static void main(String[] args) {
        // ConnectionFactory ：连接工厂，JMS 用它创建连接
        ConnectionFactory connectionFactory;
        // Connection ：JMS 客户端到JMS Provider 的连接
        Connection connection = null;
        // Session： 一个发送或接收消息的线程
        Session session;
        // Destination ：消息的目的地;消息发送给谁.
        Destination destination;
        // MessageProducer：消息发送者
        MessageProducer producer;
        // TextMessage message;
        // 构造ConnectionFactory实例对象，此处采用ActiveMq的实现jar
        connectionFactory = new ActiveMQConnectionFactory(
                ActiveMQConnection.DEFAULT_USER,
                ActiveMQConnection.DEFAULT_PASSWORD,
                "tcp://localhost:61616");
        try {
            // 构造从工厂得到连接对象
            connection = connectionFactory.createConnection();
            // 启动
            connection.start();
            // 获取操作连接
            session = connection.createSession(Boolean.TRUE,
                    Session.AUTO_ACKNOWLEDGE);
            // 获取session注意参数值xingbo.xu-queue是一个服务器的queue，须在在ActiveMq的console配置
            destination = session.createQueue("FirstQueue");
            // 得到消息生成者【发送者】
            producer = session.createProducer(destination);
            // 设置不持久化，此处学习，实际根据项目决定
            producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
            // 构造消息，此处写死，项目就是参数，或者方法获取
            sendMessage(session, producer);
            session.commit();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != connection)
                    connection.close();
            } catch (Throwable ignore) {
            }
        }
    }

    public static void sendMessage(Session session, MessageProducer producer)
            throws Exception {
        for (int i = 1; i <= SEND_NUMBER; i++) {
            TextMessage message = session
                    .createTextMessage("ActiveMq 发送的消息" + i);
            // 发送消息到目的地方
            System.out.println("发送消息：" + "ActiveMq 发送的消息" + i);
            producer.send(message);
        }
    }
}

3.2.Receiver.java

package com.xuwei.activemq;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.MessageConsumer;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;

public class Receiver {
    public static void main(String[] args) {
        // ConnectionFactory ：连接工厂，JMS 用它创建连接
        ConnectionFactory connectionFactory;
        // Connection ：JMS 客户端到JMS Provider 的连接
        Connection connection = null;
        // Session： 一个发送或接收消息的线程
        Session session;
        // Destination ：消息的目的地;消息发送给谁.
        Destination destination;
        // 消费者，消息接收者
        MessageConsumer consumer;
        connectionFactory = new ActiveMQConnectionFactory(
                ActiveMQConnection.DEFAULT_USER,
                ActiveMQConnection.DEFAULT_PASSWORD,
                "tcp://localhost:61616");
        try {
            // 构造从工厂得到连接对象
            connection = connectionFactory.createConnection();
            // 启动
            connection.start();
            // 获取操作连接
            session = connection.createSession(Boolean.FALSE,
                    Session.AUTO_ACKNOWLEDGE);
            // 获取session注意参数值xingbo.xu-queue是一个服务器的queue，须在在ActiveMq的console配置
            destination = session.createQueue("FirstQueue");
            consumer = session.createConsumer(destination);
            while (true) {
                //设置接收者接收消息的时间，为了便于测试，这里谁定为100s
                TextMessage message = (TextMessage) consumer.receive(100000);
                if (null != message) {
                    System.out.println("收到消息" + message.getText());
                } else {
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != connection)
                    connection.close();
            } catch (Throwable ignore) {
            }
        }
    }
}

4.注意事项

1. 最后接收者跟发送者在不同的机器上测试
2. 项目所引用的jar最后在ActiveMQ下的lib中找，这样不会出现版本冲突。

5.测试过程

因为是在单机上测试，所以需要开启两个eclipse，每一个eclipse都有自身的workspace。我们在eclipse1中运行Receiver，在eclipse2中运行Sender。

刚开始eclipse1中运行Receiver以后console介面没有任何信息，在eclipse2中运行Sender以后，eclipse2中的console显示如下信息：

发送消息：ActiveMq 发送的消息1
发送消息：ActiveMq 发送的消息2
发送消息：ActiveMq 发送的消息3
发送消息：ActiveMq 发送的消息4
发送消息：ActiveMq 发送的消息5

而回到eclipse1中发现console界面出现如下信息：

收到消息ActiveMq 发送的消息1
收到消息ActiveMq 发送的消息2
收到消息ActiveMq 发送的消息3
收到消息ActiveMq 发送的消息4
收到消息ActiveMq 发送的消息5

 PS:2012-2-27

今天发现测试并不需要开启两个eclipse，在一个eclipse下页可以启动多个程序，并且有多个console，在上面的Receiver.java中，设置一个较大的时间，比如receive(500000)，如下代码所示：

TextMessage message = (TextMessage) consumer.receive(500000);

这个时候运行Receiver.java的话，会使得这个Receiver.java一直运行500秒，在eclipse中可以发现：

点击那个红色方块可以手动停止运行程序。

运行玩receiver以后我们在运行sender，在运行完sender以后，我们要切换到receiver的console，如下图所示：

-------------  ActiveMQ教程  --------------

Queue与Topic的比较

1、JMS Queue执行load balancer语义：

一条消息仅能被一个consumer收到。如果在message发送的时候没有可用的consumer，那么它将被保存一直到能处理该message的consumer可用。如果一个consumer收到一条message后却不响应它，那么这条消息将被转到另一个consumer那儿。一个Queue可以有很多consumer，并且在多个可用的consumer中负载均衡。

2、Topic实现publish和subscribe语义：

一条消息被publish时，它将发到所有感兴趣的订阅者，所以零到多个subscriber将接收到消息的一个拷贝。但是在消息代理接收到消息时，只有激活订阅的subscriber能够获得消息的一个拷贝。

3、分别对应两种消息模式：

Point-to-Point (点对点),Publisher/Subscriber Model (发布/订阅者)

其中在Publicher/Subscriber模式下又有Nondurable subscription（非持久订阅）和durable subscription (持久化订阅)2种消息处理方式。

ProducerTool.java用于发送消息：

[java]  view plain copy

1. import javax.jms.Connection;     
2. import javax.jms.DeliveryMode;     
3. import javax.jms.Destination;     
4. import javax.jms.JMSException;     
5. import javax.jms.MessageProducer;     
6. import javax.jms.Session;     
7. import javax.jms.TextMessage;     
8.     
9. import org.apache.activemq.ActiveMQConnection;     
10. import org.apache.activemq.ActiveMQConnectionFactory;     
11.     
12. public class ProducerTool {     
13.     
14.     private String user = ActiveMQConnection.DEFAULT_USER;     
15.     
16.     private String password = ActiveMQConnection.DEFAULT_PASSWORD;     
17.     
18.     private String url = ActiveMQConnection.DEFAULT_BROKER_URL;     
19.     
20.     private String subject = "TOOL.DEFAULT";     
21.     
22.     private Destination destination = null;     
23.     
24.     private Connection connection = null;     
25.     
26.     private Session session = null;     
27.     
28.     private MessageProducer producer = null;     
29.     
30.     // 初始化     
31.     private void initialize() throws JMSException, Exception {     
32.         ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(     
33.                 user, password, url);     
34.         connection = connectionFactory.createConnection();     
35.         session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);     
36.         destination = session.createQueue(subject);     
37.         producer = session.createProducer(destination);     
38.         producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);     
39.     }     
40.     
41.     // 发送消息     
42.     public void produceMessage(String message) throws JMSException, Exception {     
43.         initialize();     
44.         TextMessage msg = session.createTextMessage(message);     
45.         connection.start();     
46.         System.out.println("Producer:->Sending message: " + message);     
47.         producer.send(msg);     
48.         System.out.println("Producer:->Message sent complete!");     
49.     }     
50.     
51.     // 关闭连接     
52.     public void close() throws JMSException {     
53.         System.out.println("Producer:->Closing connection");     
54.         if (producer != null)     
55.             producer.close();     
56.         if (session != null)     
57.             session.close();     
58.         if (connection != null)     
59.             connection.close();     
60.     }     
61. }      

ConsumerTool.java用于接受消息，我用的是基于消息监听的机制，需要实现MessageListener接口，这个接口有个onMessage方法，当接受到消息的时候会自动调用这个函数对消息进行处理。

[java]  view plain copy

1. import javax.jms.Connection;     
2. import javax.jms.Destination;     
3. import javax.jms.JMSException;     
4. import javax.jms.MessageConsumer;     
5. import javax.jms.Session;     
6. import javax.jms.MessageListener;     
7. import javax.jms.Message;     
8. import javax.jms.TextMessage;     
9.     
10. import org.apache.activemq.ActiveMQConnection;     
11. import org.apache.activemq.ActiveMQConnectionFactory;     
12.     
13. public class ConsumerTool implements MessageListener {     
14.     
15.     private String user = ActiveMQConnection.DEFAULT_USER;     
16.     
17.     private String password = ActiveMQConnection.DEFAULT_PASSWORD;     
18.     
19.     private String url = ActiveMQConnection.DEFAULT_BROKER_URL;     
20.     
21.     private String subject = "TOOL.DEFAULT";     
22.     
23.     private Destination destination = null;     
24.     
25.     private Connection connection = null;     
26.     
27.     private Session session = null;     
28.     
29.     private MessageConsumer consumer = null;     
30.     
31.     // 初始化     
32.     private void initialize() throws JMSException, Exception {  
33.      //连接工厂是用户创建连接的对象，这里使用的是ActiveMQ的ActiveMQConnectionFactory根据url，username和password创建连接工厂。  
34.         ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(     
35.                 user, password, url);   
36.         //连接工厂创建一个jms connection  
37.         connection = connectionFactory.createConnection();     
38.         //是生产和消费的一个单线程上下文。会话用于创建消息的生产者，消费者和消息。会话提供了一个事务性的上下文。  
39.         session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);  //不支持事务   
40.         //目的地是客户用来指定他生产消息的目标还有他消费消息的来源的对象，两种消息传递方式：点对点和发布/订阅  
41.         destination = session.createQueue(subject);   
42.         //会话创建消息的生产者将消息发送到目的地  
43.         consumer = session.createConsumer(destination);     
44.              
45.     }     
46.     
47.     // 消费消息     
48.     public void consumeMessage() throws JMSException, Exception {     
49.         initialize();     
50.         connection.start();     
51.              
52.         System.out.println("Consumer:->Begin listening...");     
53.         // 开始监听     
54.         consumer.setMessageListener(this);     
55.         // Message message = consumer.receive();     
56.     }     
57.     
58.     // 关闭连接     
59.     public void close() throws JMSException {     
60.         System.out.println("Consumer:->Closing connection");     
61.         if (consumer != null)     
62.             consumer.close();     
63.         if (session != null)     
64.             session.close();     
65.         if (connection != null)     
66.             connection.close();     
67.     }     
68.     
69.     // 消息处理函数     
70.     public void onMessage(Message message) {     
71.         try {     
72.             if (message instanceof TextMessage) {     
73.                 TextMessage txtMsg = (TextMessage) message;     
74.                 String msg = txtMsg.getText();     
75.                 System.out.println("Consumer:->Received: " + msg);     
76.             } else {     
77.                 System.out.println("Consumer:->Received: " + message);     
78.             }     
79.         } catch (JMSException e) {     
80.             // TODO Auto-generated catch block     
81.             e.printStackTrace();     
82.         }     
83.     }     
84. }   

 

如果想主动的去接受消息，而不用消息监听的话，把consumer.setMessageListener(this)改为Message message = consumer.receive()，手动去调用MessageConsumer的receive方法即可。

下面是测试类Test.java：

[java]  view plain copy

1. import javax.jms.JMSException;     
2. mport org.apache.activemq.ActiveMQConnection;  
3.     
4. public class Test {     
5.     
6.     /**   
7.      * @param args   
8.      */    
9.     public static void main(String[] args) throws JMSException, Exception {     
10.        
11.      // TODO Auto-generated method stub     
12.         ConsumerTool consumer = new ConsumerTool();     
13.         ProducerTool producer = new ProducerTool();    
14.         System.out.println(ActiveMQConnection.DEFAULT_BROKER_URL+"------------");  
15.         // 开始监听     
16.         consumer.consumeMessage();     
17.              
18.         // 延时500毫秒之后发送消息     
19.         Thread.sleep(500);     
20.         producer.produceMessage("Hello, world!");     
21.         producer.close();     
22.              
23.         // 延时500毫秒之后停止接受消息     
24.         Thread.sleep(500);     
25.         consumer.close();     
26.     }     
27. }