JMS学习

今天的Demo演示了点对点模型中消息发送者与消息消费者在传递消息时的两种方式,一种是不管消息队列中有没有消息,消费者一直在取;一种是监听消息队列,当有消息时才取.

 

首先开启服务,我这里用的是Activemq,运行相应的bat文件即可.在浏览器访问http://localhost:8161/,看到欢迎界面代表成功.

 

第一种:消费者直接取

 

[java]  view plain copy print ?

1. package com.tgb.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.ActiveMQConnectionFactory;  
12.   
13. /** 
14.  * 消息生产者 
15.  * @author ghy 
16.  * 
17.  */  
18. public class QueueSender {  
19.       
20.     private static final String USERNAME=ActiveMQConnectionFactory.DEFAULT_USER;//默认的连接用户名  
21.     private static final String PASSWORD=ActiveMQConnectionFactory.DEFAULT_PASSWORD;//默认的连接密码  
22.     private static final String BROKEURL=ActiveMQConnectionFactory.DEFAULT_BROKER_URL;//默认的连接地址  
23.     private static final int SENDNUM=10;//发送的消息数量  
24.       
25.     public static void main(String[] args){  
26.         ConnectionFactory connectionFactory;//连接工厂  
27.         Connection connection=null; //连接  
28.         Session session;  //会话,接受或者发送消息的线程  
29.         Destination destination;  //消息的目的地  
30.         MessageProducer messageProducer; //消息发送者  
31.           
32.         //实例化连接工厂  
33.         connectionFactory=new ActiveMQConnectionFactory(QueueSender.USERNAME,QueueSender.PASSWORD,QueueSender.BROKEURL);  
34.           
35.         try {  
36.             connection=connectionFactory.createConnection();//创建连接  
37.             connection.start();//启动连接  
38.             session=connection.createSession(true, Session.AUTO_ACKNOWLEDGE);//创建连接  
39.             destination=session.createQueue("FirstQueue1");//创建消息队列  
40.             messageProducer=session.createProducer(destination);//创建消息生产者  
41.             sendMessage(session,messageProducer);  
42.             session.commit();  
43.         } catch (Exception e) {  
44.             e.printStackTrace();  
45.         }finally{  
46.             if(connection!=null){  
47.                 try {  
48.                     connection.close();  
49.                 } catch (JMSException e) {  
50.                     e.printStackTrace();  
51.                 }  
52.             }  
53.         }                 
54.     }  
55.     public static void sendMessage(Session session,MessageProducer messageProducer){  
56.         for (int i=0;i<QueueSender.SENDNUM;i++){  
57.             TextMessage message;  
58.             try {  
59.                 message = session.createTextMessage("ActiveMQ 发送的消息" + i);            
60.                 System.out.println("发送消息:" + "ActiveMQ 发送的消息" + i);           
61.                 messageProducer.send(message);  
62.             } catch (JMSException e) {  
63.                 e.printStackTrace();  
64.             }  
65.         }  
66.     }  
67. }  

QueueSender发送消息后的运行结果:

   

通过控制台可以看到消息队列中的消息数目及入队(生产)和出列(消费)情况.

[java]  view plain copy print ?

1. package com.tgb.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.Session;  
9. import javax.jms.TextMessage;  
10.   
11. import org.apache.activemq.ActiveMQConnection;  
12. import org.apache.activemq.ActiveMQConnectionFactory;  
13.   
14. /** 
15.  * 消息消费者 
16.  * @author ghy 
17.  * 
18.  */  
19. public class QueueReceiver {  
20.       
21.     private static final String USERNAME=ActiveMQConnection.DEFAULT_USER;//默认连接的用户名  
22.     private static final String PASSWORD=ActiveMQConnection.DEFAULT_PASSWORD;//默认连接密码  
23.     private static final String BROKEURL=ActiveMQConnection.DEFAULT_BROKER_URL;//默认链接地址  
24.       
25.     public static void main(String[] args){  
26.         ConnectionFactory connectionFactory;//连接工厂  
27.         Connection connection=null;//连接  
28.         Session session;//会话  
29.         Destination destination;//目的地  
30.         MessageConsumer messageConsumer;//消息消费者  
31.           
32.         connectionFactory=new ActiveMQConnectionFactory(QueueReceiver.USERNAME,QueueReceiver.PASSWORD,QueueReceiver.BROKEURL);  
33.         try {  
34.             connection=connectionFactory.createConnection();//创建连接  
35.             connection.start();//启动连接  
36.             session=connection.createSession(false, Session.AUTO_ACKNOWLEDGE);//创建session  
37.             destination=session.createQueue("FirstQueue1");//创建连接的消息队列  
38.             messageConsumer=session.createConsumer(destination);//创建消息消费者  
39.             while(true){                  
40.                 TextMessage textMessage=(TextMessage) messageConsumer.receive();//接收消息  
41.                 if(textMessage!=null){  
42.                     System.out.println("收到的消息:" + textMessage.getText());  
43.                 }else{  
44.                     break;  
45.                 }  
46.             }                     
47.               
48.         } catch (JMSException e) {  
49.             e.printStackTrace();  
50.         }  
51.           
52.           
53.     }  
54. }  

QueueReceiver接收消息后的运行结果:

     

可以看到已经生产的10条消息已经被现在的这个消费者消费了.

第二种:使用监听的方式

 

再次运行QueueSender,发送10条消息,运行结果和控制台显示同上.

 

 

[java]  view plain copy print ?

1. package com.tgb.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.Session;  
9. import javax.jms.TextMessage;  
10.   
11. import org.apache.activemq.ActiveMQConnection;  
12. import org.apache.activemq.ActiveMQConnectionFactory;  
13.   
14. /** 
15.  * 消息消费者 
16.  * @author ghy 
17.  * 
18.  */  
19. public class QueueReceiver2 {  
20.       
21.     private static final String USERNAME=ActiveMQConnection.DEFAULT_USER;//默认连接的用户名  
22.     private static final String PASSWORD=ActiveMQConnection.DEFAULT_PASSWORD;//默认连接密码  
23.     private static final String BROKEURL=ActiveMQConnection.DEFAULT_BROKER_URL;//默认链接地址  
24.       
25.     public static void main(String[] args){  
26.         ConnectionFactory connectionFactory;//连接工厂  
27.         Connection connection=null;//连接  
28.         Session session;//会话  
29.         Destination destination;//目的地  
30.         MessageConsumer messageConsumer;//消息消费者  
31.           
32.         connectionFactory=new ActiveMQConnectionFactory(QueueReceiver2.USERNAME,QueueReceiver2.PASSWORD,QueueReceiver2.BROKEURL);  
33.         try {  
34.             connection=connectionFactory.createConnection();//创建连接  
35.             connection.start();//启动连接  
36.             session=connection.createSession(false, Session.AUTO_ACKNOWLEDGE);//创建session  
37.             destination=session.createQueue("FirstQueue1");//创建连接的消息队列  
38.             messageConsumer=session.createConsumer(destination);//创建消息消费者  
39.             messageConsumer.setMessageListener(new Listener());//注册监听器            
40.               
41.         } catch (JMSException e) {  
42.             e.printStackTrace();  
43.         }  
44.           
45.           
46.     }  
47. }  

监听器:

[java]  view plain copy print ?

1. package com.tgb.activemq;  
2.   
3. import javax.jms.JMSException;  
4. import javax.jms.Message;  
5. import javax.jms.MessageListener;  
6. import javax.jms.TextMessage;  
7.   
8.   
9. /** 
10.  * 监听器 
11.  * @author ghy 
12.  * 
13.  */  
14. public class Listener implements MessageListener {  
15.   
16.       
17.     public void onMessage(Message message) {  
18.           
19.         try {  
20.             System.out.println("收到的消息:" + ((TextMessage)message).getText());  
21.         } catch (JMSException e) {  
22.             e.printStackTrace();  
23.         }     
24.     }  
25. }  

QueueReceiver2接收消息后的运行结果:

可以看到刚刚生产的10条消息已经被消费者QueueReceiver2消费了.

======================================================================================

接下来我对2个接收者同时接收消息做了测试,纯属测试结果如下.

再次发送10条消息:

         

       QueueReceiver接收了5条:

     

      QueueReceiver2接收了5条:

     

 我们不要被这个均分的现象迷惑了,在这种情况下,多个消息消费者同时接收消息时,什么时候接收到,接收到多少条是不确定的.但是在实际应用中,消息生产者要发送消息给哪个消息消费者是确定的,就像我们要给人写信,收信人是确定的,而不是写完就寄出去了,信被送到哪算哪.