ActiveMQ 开发 点对点消息实现 1

ActiveMQ 开发包下载及运行环境搭建

主页：http://activemq.apache.org/
目前最新版本：5.11.1
开发包及源码下载地址：http://activemq.apache.org/activemq-5111-release.html

ActiveMQ 服务启动地址：http://127.0.0.1:8161/admin/ 用户名/密码admin/admin

ActiveMQ下载完毕后，点击以下文件(64位和32位分别点击对应文件夹下的该文件):

ActiveMQ 服务器启动完毕后，打开http://127.0.0.1:8161/admin/ 用户名/密码admin/admin,将会见到如下界面:

ActiveMq 点对点消息实现

第一种方式：直接Receive 方式

1.Session.AUTO_ACKNOWLEDGE。当客户成功的从receive 方法返回的时候，或者从MessageListener.onMessage
方法成功返回的时候，会话自动确认客户收到的消息。
2.Session.CLIENT_ACKNOWLEDGE。客户通过消息的acknowledge 方法确认消息。需要注意的是，在这种模
式中，确认是在会话层上进行：确认一个被消费的消息将自动确认所有已被会话消费的消息。例如，如果一
个消息消费者消费了10 个消息，然后确认第5 个消息，那么所有10 个消息都被确认。
3.Session.DUPS_ACKNOWLEDGE。该选择只是会话迟钝第确认消息的提交。如果JMS provider 失败，那么可
能会导致一些重复的消息。如果是重复的消息，那么JMS provider 必须把消息头的JMSRedelivered 字段设置
为true。

首先我们创建Java工程，导入activemq-all-5.11.1.jar，如下

然后我们建立一个生产者类，负责发送消息,并创建一个名为MyQueue1的队列

[java]  view plain  copy

1. package cn.com.evan.Jms.activemq;  
2.   
3. import javax.jms.Connection;  
4. import javax.jms.ConnectionFactory;  
5. import javax.jms.Destination;  
6. import javax.jms.JMSException;  
7. import javax.jms.MessageProducer;  
8. import javax.jms.Session;  
9. import javax.jms.TextMessage;  
10.   
11. import org.apache.activemq.ActiveMQConnection;  
12. import org.apache.activemq.ActiveMQConnectionFactory;  
13.   
14. public class JmsProducer {  
15.   
16.     private static String USERNAME = ActiveMQConnection.DEFAULT_USER;  
17.     private static String PASSWORD = ActiveMQConnection.DEFAULT_PASSWORD;  
18.     private static String BROKERURL = ActiveMQConnection.DEFAULT_BROKER_URL;  
19.     private static Integer SENDNUM = 10;  
20.   
21.     public static void main(String[] args) {  
22.         ConnectionFactory connectionFactory;  
23.         Connection connection = null;  
24.         Session session;  
25.         Destination destination;  
26.         MessageProducer messageProducer;  
27.   
28.         connectionFactory = new ActiveMQConnectionFactory(USERNAME, PASSWORD,  
29.                 BROKERURL);  
30.         try {  
31.             connection = connectionFactory.createConnection();  
32.             connection.start();  
33.             session = connection.createSession(Boolean.TRUE,  
34.                     Session.AUTO_ACKNOWLEDGE);  
35.             destination = session.createQueue("MyQueue1");// Create message queue  
36.             messageProducer = session.createProducer(destination);// Create producer  
37.             sendMessage(session,messageProducer);  
38.             session.commit();  
39.         } catch (Exception e) {  
40.             // TODO Auto-generated catch block  
41.             e.printStackTrace();  
42.         }finally{  
43.             if(connection!=null){  
44.                 try {  
45.                     connection.close();  
46.                 } catch (JMSException e) {  
47.                     // TODO Auto-generated catch block  
48.                     e.printStackTrace();  
49.                 }  
50.             }  
51.         }  
52.   
53.     }  
54.       
55.     public static void sendMessage(Session session, MessageProducer messageProducer) throws JMSException{  
56.         for(int i=0;i<JmsProducer.SENDNUM;i++){  
57.             TextMessage message = session.createTextMessage("ActiveMQ"+i);  
58.             messageProducer.send(message);  
59.             System.out.println("发送消息:"+message.getText());  
60.         }  
61.     }  
62.   
63. }  

运行程序，可以看到控制台已经发送了10条信息

我们打开activeMq控制台http://127.0.0.1:8161/admin/，查看消息发送的情况，可以看到MyQueue1里已经存放着10条消息，但还没有被消费

接着我们创建一个消费者，负责从消息队列MyQueue1里接受消息，这里我们用一个死循环去不断监听消息

[java]  view plain  copy

1. package cn.com.evan.Jms.activemq;  
2.   
3. import javax.jms.Connection;  
4. import javax.jms.ConnectionFactory;  
5. import javax.jms.Destination;  
6. import javax.jms.JMSException;  
7. import javax.jms.MessageConsumer;  
8. import javax.jms.MessageProducer;  
9. import javax.jms.Session;  
10. import javax.jms.TextMessage;  
11.   
12. import org.apache.activemq.ActiveMQConnection;  
13. import org.apache.activemq.ActiveMQConnectionFactory;  
14.   
15. public class JmsComsumer {  
16.     private static String USERNAME = ActiveMQConnection.DEFAULT_USER;  
17.     private static String PASSWORD = ActiveMQConnection.DEFAULT_PASSWORD;  
18.     private static String BROKERURL = ActiveMQConnection.DEFAULT_BROKER_URL;  
19.     private static Integer SENDNUM = 10;  
20.   
21.     public static void main(String[] args) {  
22.         ConnectionFactory connectionFactory;  
23.         Connection connection = null;  
24.         Session session;  
25.         Destination destination;  
26.         MessageConsumer messageConsumer;  
27.   
28.         connectionFactory = new ActiveMQConnectionFactory(USERNAME, PASSWORD,  
29.                 BROKERURL);  
30.         try {  
31.             connection = connectionFactory.createConnection();  
32.             connection.start();  
33.             session = connection.createSession(Boolean.FALSE,  
34.                     Session.AUTO_ACKNOWLEDGE);  
35.             destination = session.createQueue("MyQueue1");// Create message  
36.                                                             // queue  
37.             messageConsumer = session.createConsumer(destination);// Create  
38.                                                                     // producer  
39.   
40.             while (true) {  
41.                 TextMessage message = (TextMessage) messageConsumer  
42.                         .receive(100000);  
43.                 if (message != null) {  
44.                     System.out.println("接收信息：" + message.getText());  
45.   
46.                 } else  
47.                     break;  
48.             }  
49.         } catch (Exception e) {  
50.             // TODO Auto-generated catch block  
51.             e.printStackTrace();  
52.         }  
53.   
54.     }  
55.   
56. }  

运行程序可以看到消费者已经接受到10条消息

我们再查看activeMq控制台，可以看到消息已经被消费了10条

第二种方式：使用监听器去监听消息

首先我们创建一个监听器，实现MessageListener 借口

[java]  view plain  copy

1. package cn.com.evan.Jms.activemq;  
2.   
3. import javax.jms.JMSException;  
4. import javax.jms.Message;  
5. import javax.jms.MessageListener;  
6. import javax.jms.TextMessage;  
7.   
8. public class MyMessageListener implements MessageListener{  
9.   
10.     @Override  
11.     public void onMessage(Message msg) {  
12.           
13.         try {  
14.             System.out.println("接受消息:"+((TextMessage)msg).getText());  
15.         } catch (JMSException e) {  
16.             // TODO Auto-generated catch block  
17.             e.printStackTrace();  
18.         }  
19.           
20.     }  
21.       
22.       
23.   
24. }  

我们把上面的JmsConsumer 修改下，加入我们自定义的监听器 

[java]  view plain  copy

1. package cn.com.evan.Jms.activemq;  
2.   
3. import javax.jms.Connection;  
4. import javax.jms.ConnectionFactory;  
5. import javax.jms.Destination;  
6. import javax.jms.JMSException;  
7. import javax.jms.MessageConsumer;  
8. import javax.jms.MessageProducer;  
9. import javax.jms.Session;  
10. import javax.jms.TextMessage;  
11.   
12. import org.apache.activemq.ActiveMQConnection;  
13. import org.apache.activemq.ActiveMQConnectionFactory;  
14.   
15. public class JmsComsumer {  
16.     private static String USERNAME = ActiveMQConnection.DEFAULT_USER;  
17.     private static String PASSWORD = ActiveMQConnection.DEFAULT_PASSWORD;  
18.     private static String BROKERURL = ActiveMQConnection.DEFAULT_BROKER_URL;  
19.     private static Integer SENDNUM = 10;  
20.   
21.     public static void main(String[] args) {  
22.         ConnectionFactory connectionFactory;  
23.         Connection connection = null;  
24.         Session session;  
25.         Destination destination;  
26.         MessageConsumer messageConsumer;  
27.   
28.         connectionFactory = new ActiveMQConnectionFactory(USERNAME, PASSWORD,  
29.                 BROKERURL);  
30.         try {  
31.             connection = connectionFactory.createConnection();  
32.             connection.start();  
33.             session = connection.createSession(Boolean.FALSE,  
34.                     Session.AUTO_ACKNOWLEDGE);  
35.             destination = session.createQueue("MyQueue1");// Create message  
36.                                                             // queue  
37.             messageConsumer = session.createConsumer(destination);// Create  
38.                                                                     // producer  
39.   
40.             messageConsumer.setMessageListener(new MyMessageListener());// set listener which we created before  
41.         } catch (Exception e) {  
42.             // TODO Auto-generated catch block  
43.             e.printStackTrace();  
44.         }  
45.   
46.     }  
47.   
48. }  

我们先运行JmsConsumer，让它监听MyQueue1队列里的消息，再运行JmsProducer

此时，我们在控制台可以看到消费者也接受到10条信息

打开activeMq控制台，可以看到消费者跟上面一样同样也消费了10条消息 

以上两种消息处理方式介绍完毕，下一章会介绍一个发布者对多个消费者的发布订阅模式实例