JMS 消息持久订阅者测试

一、 测试内容：

1.         消息持久订阅者在运行过程中死机之后再次重启，是否可以收到之前属于自己应该消费的消息但是由于死机尚未消费的消息。

2.         位于 A 机器上的名为 Durable_Subscriber 的消息持久订阅者由于某种原因导致永久性死机，此时启动 B 机器上的名为 Durable_Subscriber 的消息持久订阅者，测试是否此订阅者是否可以继续接管原来A 上的订阅者的所有工作。

 

二、 测试程序：

1.         针对测试内容 1 ：

1.1            测试程序

view plain

1. public class MyTopicPublisher {  
2.     static final String CLIENT_ID = "lichaopeng";  
3.     static final String CONN_FACTORY = "my_conn_factory";  
4.     static final String TOPIC_NAME = "my_topic";  
5.     static final String SUBSCRIBER_NAME = "Durable_Subscriber";  
6.     public static void main(String[] args) throws NamingException,  
7.             JMSException, InterruptedException {  
8.         InitialContext cntx = new InitialContext();  
9.         TopicConnectionFactory connFactory = (TopicConnectionFactory) cntx  
10.                 .lookup(CONN_FACTORY);  
11.         Topic topic = (Topic) cntx.lookup(TOPIC_NAME);  
12.         TopicConnection conn = connFactory.createTopicConnection();  
13.         TopicSession session = conn.createTopicSession(false,  
14.                 TopicSession.CLIENT_ACKNOWLEDGE);  
15.         TopicPublisher publisher = session.createPublisher(topic);  
16.         conn.start();  
17.         int count = 0;  
18.         while (++count <= 10) {  
19.             String text = "TextMessage" + count;  
20.             TextMessage msg = session.createTextMessage(text);  
21.             publisher.publish(msg);  
22.             System.out.println("publisher message:" + text);  
23.             Thread.sleep(5 * 1000);  
24.         }  
25.     }  
26. }  

 

view plain

1. public class MyTopicSubsciber implements MessageListener {  
2.     public MyTopicSubsciber() throws NamingException, JMSException {  
3.         InitialContext cntx = new InitialContext();  
4.         TopicConnectionFactory connFactory = (TopicConnectionFactory) cntx  
5.                 .lookup(MyTopicPublisher.CONN_FACTORY);  
6.         Topic topic = (Topic) cntx.lookup(MyTopicPublisher.TOPIC_NAME);  
7.         TopicConnection conn = connFactory.createTopicConnection();  
8.         conn.setClientID(MyTopicPublisher.CLIENT_ID);  
9.         TopicSession session = conn.createTopicSession(false,  
10.                 TopicSession.CLIENT_ACKNOWLEDGE);  
11.         TopicSubscriber subscriber = session.createDurableSubscriber(topic,  
12.                 MyTopicPublisher.SUBSCRIBER_NAME);  
13.         subscriber.setMessageListener(this);  
14.         conn.start();  
15.     }  
16.     public void onMessage(Message arg0) {  
17.         TextMessage msg = (TextMessage) arg0;  
18.         try {  
19.             System.out.println(msg.getText());  
20.             arg0.acknowledge();  
21.             Thread.sleep(8 * 1000);  
22.         } catch (Exception e) {  
23.             e.printStackTrace();  
24.         }  
25.     }  
26.     public static void main(String[] args) throws NamingException, JMSException {  
27.         new MyTopicSubsciber();  
28.     }  
29. }  

 

1.2           测试过程：

首先启动 MyTopicSubsciber ，然后启动 MyTopicPublisher 。

在 MyTopicPublisher 发送了 4 条消息之后，此时 MyTopicSubsciber 刚刚消费了 2 条消息。

此时关闭 MyTopicSubsciber ，而 MyTopicPublisher 继续运行。

然后重启 MyTopicSubsciber ， MyTopicSubsciber 接收到了所有之前未消费的消息。

 

1.3           测试结论：消息持久订阅者在运行过程中死机之后再次重启，可以收到之前属于自己应该消费的消息但是由于死机尚未消费的消息

 

2.         针对测试内容 2 ：

2.1            测试程序：同上

2.2            测试过程：

首先启动 A 上的 MyTopicSubsciber ，然后启动 A 上的 MyTopicPublisher 。

在 MyTopicPublisher 发送了 4 条消息之后，此时 A 上的 MyTopicSubsciber 刚刚消费了 2 条消息。

此时 A 上 MyTopicSubsciber ，而 MyTopicPublisher 继续运行。

启动 B 上的 MyTopicSubsciber ， B 上的 MyTopicSubsciber 接收到了所有之前未消费的消息。

2.3          测试结论：位于 A 机器上的名为 Durable_Subscriber 的消息持久订阅者由于某种原因导致永久性死机，此时启动 B 机器上的名为 Durable_Subscriber 的消息持久订阅者，此订阅者可以继续接管原来 A 上的订阅者的所有工作。

 

三、 备注：

1.         为了更精细的控制整个流程，建议使用 CLIENT_ACKNOWLEDGE 的方式有客户端自己决定应答的时机。

2.         取消订阅的方式：

view plain

1. public class Unsubscriber {  
2.     public Unsubscriber() throws NamingException, JMSException {  
3.         InitialContext cntx = new InitialContext();  
4.         TopicConnectionFactory connFactory = (TopicConnectionFactory) cntx  
5.                 .lookup(MyTopicPublisher.CONN_FACTORY);  
6.         TopicConnection conn = connFactory.createTopicConnection();  
7.         conn.setClientID(MyTopicPublisher.CLIENT_ID);  
8.         TopicSession session = conn.createTopicSession(false,  
9.                 TopicSession.CLIENT_ACKNOWLEDGE);  
10.         conn.start();  
11.         session.unsubscribe(MyTopicPublisher.SUBSCRIBER_NAME);  
12.         conn.close();  
13.     }  
14.     public static void main(String[] args) throws NamingException, JMSException {  
15.         new Unsubscriber();  
16.     }  
17. }  

3.         JNDI 配置：

view plain

1. ## do not modify the following please  
2. java.naming.factory.initial=org.apache.activemq.jndi.ActiveMQInitialContextFactory  
3. java.naming.factory.url.pkgs=org.jboss.naming;org.jnp.interfaces  
4. java.naming.security.principal=system  
5. java.naming.provider.url=tcp://192.168.1.69:61616  
6. jnp.disableDiscovery=true  
7. java.naming.security.credentials=manager  
8. connectionFactoryNames=my_conn_factory  
9. topic.my_topic=my_topic