ActiveMQ入门示例

ActiveMQ入门示例

 

ActiveMQ有两种模式，点对点和发布/订阅模式，点对点中消息只能被一个消费者消费，而发布订阅中，消息可以被一群消费者消费，很好理解。下面的例子是点对点的

 

   安装ActiveMQ很简单就不说了，客户端使用API只需添加以下依赖：

Xml代码 

1. <dependency>  
2.     <groupId>org.apache.activemq</groupId>  
3.     <artifactId>activemq-all</artifactId>  
4.     <version>5.9.1</version>  
5. </dependency>  
6. <dependency>  
7.     <groupId>log4j</groupId>  
8.     <artifactId>log4j</artifactId>  
9.     <version>1.2.17</version>  
10. </dependency>  

 

 

代码：

Sender.java:

Java代码 

1. package cc.lixiaohui.test.jms.activemq.p2p;  
2.   
3. import java.util.UUID;  
4. import java.util.concurrent.ExecutorService;  
5. import java.util.concurrent.Executors;  
6.   
7. import javax.jms.Connection;  
8. import javax.jms.ConnectionFactory;  
9. import javax.jms.Destination;  
10. import javax.jms.JMSException;  
11. import javax.jms.MessageProducer;  
12. import javax.jms.Session;  
13. import javax.jms.TextMessage;  
14.   
15. import org.apache.activemq.ActiveMQConnectionFactory;  
16. import org.apache.log4j.Logger;  
17.   
18. import cc.lixiaohui.test.jms.activemq.Constants;  
19.   
20. public class Sender {  
21.     //发送间隔  
22.     private long interval = 1 * 1000;  
23.       
24.     private ConnectionFactory factory;  
25.   
26.     private Connection conn;  
27.       
28.     private Destination dest;  
29.       
30.     private Session session;  
31.   
32.     private MessageProducer producer;  
33.     // 单线程池负责发送  
34.     private ExecutorService worker = Executors.newSingleThreadExecutor();  
35.   
36.     private volatile boolean stop = false;  
37.       
38.     private static final Logger logger = Logger.getLogger(Sender.class);  
39.       
40.     public Sender(String brokenURL, String user, String passwd,  
41.             String queueName) throws JMSException {  
42.         factory = new ActiveMQConnectionFactory(user, passwd, brokenURL);  
43.         conn = factory.createConnection();  
44.         conn.start();  
45.         session = conn.createSession(true, Session.AUTO_ACKNOWLEDGE);  
46.         dest = session.createQueue(queueName);  
47.         producer = session.createProducer(dest);  
48.     }  
49.       
50.     public void setInterval(long l) {  
51.         interval = l;  
52.     }  
53.   
54.     public void start() {  
55.         worker.submit(new SendTask());  
56.     }  
57.   
58.     public synchronized void stop() {  
59.         stop = true;  
60.         worker.shutdown();  
61.     }  
62.   
63.     private TextMessage randomMsg() {  
64.         String uuid = UUID.randomUUID().toString();  
65.         TextMessage msg = null;  
66.         try {  
67.             msg = session.createTextMessage(uuid);//把uuid作为消息  
68.             msg.setJMSCorrelationID(uuid);  
69.         } catch (JMSException e) {  
70.             e.printStackTrace();  
71.         }  
72.       
73.         return msg;  
74.     }  
75.   
76.     private class SendTask implements Runnable {  
77.   
78.         public void run() {  
79.             logger.info("Send task begin...");  
80.             while (!stop) {  
81.                 try {  
82.                     // 发送  
83.                     TextMessage msg = randomMsg();  
84.                     producer.send(msg);  
85.                     session.commit(); // commit后消息才会发送到服务端  
86.                     logger.info("Send text message : " + msg.getText());  
87.                     // 间隔  
88.                     Thread.sleep(interval);  
89.                 } catch (Exception e) {  
90.                     e.printStackTrace();  
91.                     break;  
92.                 }  
93.             }  
94.               
95.             logger.info("Send task finished...");  
96.         }  
97.     }  
98.       
99.     public static void main(String[] args) throws JMSException {  
100.         Sender sender = new Sender(Constants.URL, Constants.USER, Constants.PASSWD, Constants.DEFAULT_QUEUE);  
101.         sender.start();  
102.     }  
103. }  

 

 

Reciever.java:

Java代码 

1. package cc.lixiaohui.test.jms.activemq.p2p;  
2.   
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.Executors;  
5.   
6. import javax.jms.Connection;  
7. import javax.jms.ConnectionFactory;  
8. import javax.jms.Destination;  
9. import javax.jms.JMSException;  
10. import javax.jms.Message;  
11. import javax.jms.MessageConsumer;  
12. import javax.jms.MessageListener;  
13. import javax.jms.Session;  
14. import javax.jms.TextMessage;  
15.   
16. import org.apache.activemq.ActiveMQConnectionFactory;  
17. import org.apache.log4j.Logger;  
18.   
19. import cc.lixiaohui.test.jms.activemq.Constants;  
20.   
21. public class Reciever {  
22.     public static final int RECIEVE_MODE_SYNC = 0;  
23.     public static final int RECIEVE_MODE_ASYNC = 1;  
24.   
25.     private ConnectionFactory factory;  
26.   
27.     private Connection conn;  
28.   
29.     private Destination dest;  
30.   
31.     private Session session;  
32.   
33.     private MessageConsumer consumer;  
34.   
35.     private ExecutorService worker = Executors.newSingleThreadExecutor();  
36.   
37.     private volatile boolean stop = false;  
38.   
39.     private long interval = 3 * 1000;  
40.   
41.     private static final Logger logger = Logger.getLogger(Reciever.class);  
42.   
43.     // 同步/异步接收模式，默认同步  
44.     private int mode = RECIEVE_MODE_SYNC;  
45.   
46.     public Reciever(String brokenURL, String user, String passwd,  
47.             String queueName) throws JMSException {  
48.         factory = new ActiveMQConnectionFactory(user, passwd, brokenURL);  
49.         conn = factory.createConnection();  
50.         conn.start();  
51.         session = conn.createSession(true, Session.AUTO_ACKNOWLEDGE);  
52.         dest = session.createQueue(queueName);  
53.         consumer = session.createConsumer(dest);  
54.     }  
55.   
56.     public void setInterval(long l) {  
57.         interval = l;  
58.     }  
59.   
60.     public void setMode(int mode) {  
61.         this.mode = mode;  
62.     }  
63.   
64.     public void start() throws JMSException {  
65.           
66.         if (mode == RECIEVE_MODE_ASYNC) {// 异步  
67.             logger.info("Recieved task begin in async mode...");  
68.             // 由activemq组件回调  
69.             consumer.setMessageListener(new MessageListener() {  
70.   
71.                 public void onMessage(Message message) {  
72.                     handleRecievedMessage(message);  
73.                     try {  
74.                         session.commit();  
75.                     } catch (JMSException e) {  
76.                         e.printStackTrace();  
77.                         stop = true;  
78.                     }  
79.                 }  
80.   
81.             });  
82.         } else if (mode == RECIEVE_MODE_SYNC) {// 同步, 由于另起线程, 这里也不阻塞  
83.             worker.submit(new RecieveTask());  
84.         }  
85.     }  
86.   
87.     private void handleRecievedMessage(Message recievedMsg) {  
88.         if (recievedMsg instanceof TextMessage) {  
89.             TextMessage msg = (TextMessage) recievedMsg;  
90.             try {  
91.                 logger.info("Recieved message : " + msg.getText());  
92.             } catch (JMSException e) {  
93.                 e.printStackTrace();  
94.             }  
95.         }  
96.     }  
97.   
98.     public void stop() {  
99.         stop = true;  
100.     }  
101.   
102.     private class RecieveTask implements Runnable {  
103.   
104.         public void run() {  
105.             logger.info("Recieved task begin in sync mode...");  
106.             while (!stop) {  
107.                 try {  
108.                     Message msg = consumer.receive();  
109.                     handleRecievedMessage(msg);  
110.                     session.commit();  
111.                     Thread.sleep(interval);  
112.                 } catch (Exception e) {  
113.                     e.printStackTrace();  
114.                     break;  
115.                 }  
116.             }  
117.             logger.info("Recieve task finished...");  
118.         }  
119.   
120.     }  
121.   
122.     public static void main(String[] args) throws JMSException {  
123.         Reciever reciever = new Reciever(Constants.URL, Constants.USER,  
124.                 Constants.PASSWD, Constants.DEFAULT_QUEUE);  
125.         reciever.setMode(RECIEVE_MODE_ASYNC);  
126.         reciever.start();  
127.     }  
128.   
129. }  

 

 

测试结果：

1.Reciever在ASYNC模式，注意看日志时间，可以看到Sender一旦了消息，Reciever就会接受到消息(忽略网络)

 

 

2.Reciever在ASYNC模式下，Sender每秒发一个消息，而接收者每3秒接收一个消息：可以看到Reciever接受的时间是和Sender发送的时间是无联系的。