JMS订阅模式消息_durable consumer is in use for client-CSDN博客

发布/订阅模型,消息会发送到一个名为主题(Topic)的虚拟通道中,消息生产者成为发布者(Publisher),消息的消费者成为订阅者(Subscriber);与点对点模型的最大不同,就是发布到主题的消息,能够被多个订阅者接收,类似于广播.发布/订阅模型的消息传输机制是一个基于推送(push)的方式,消息将有JMS Provider主动的向消息消费者广播,消费者客户端无需请求或者轮询,只需要保持Connection的活跃性即可.

不过在发布/订阅消息传送模型的内部,有多种不同类型的订阅者(比如,受托管订阅者,耐久订阅者,临时订阅者,动态订阅者);临时订阅者(TemporarySubscriber)为只有它主动侦听主题时才能收到消息,JMS Provider不会为临时订阅者持久存储"离线时"的任何消息的副本;持久订阅者将接收到发布的每条消息的一个副本,即使发布消息时,订阅者处于"离线"状态.

    Java代码   
    
  
 ###contextFactory  
 java.naming.factory.initial = org.apache.activemq.jndi.ActiveMQInitialContextFactory  
 ###brokerUrl,any protocol  
 java.naming.provider.url = tcp://localhost:61616  
 ##username  
 ##java.naming.security.principal=  
 ##password  
 ##java.naming.security.credentials=  
 ##connectionFactory,for building sessions  
 connectionFactoryNames = QueueCF,TopicCF  
 ##topic.<topicName> = <physicalName-of-topic>  
 ##your application should use <topicName>,such as:  
 ## context.lookup("topic1");  
 ##It can be more than once  
 topic.topic1 = jms.topic1  
 ##queue.<topicName> = <physicalName-of-queue>  
 queue.queue1 = jms.queue1  

    Java代码   
    
  
 //Topic发布者  
 package com.test.jms.simple.topic;  
   
 import javax.jms.DeliveryMode;  
 import javax.jms.Message;  
 import javax.jms.MessageConsumer;  
 import javax.jms.Session;  
 import javax.jms.Topic;  
 import javax.jms.TopicConnection;  
 import javax.jms.TopicConnectionFactory;  
 import javax.jms.TopicPublisher;  
 import javax.jms.TopicSession;  
 import javax.jms.TopicSubscriber;  
 import javax.naming.Context;  
 import javax.naming.InitialContext;  
   
 public class SimplePublisher {  
   
     private TopicPublisher producer;  
     private TopicSession session;  
     private TopicConnection connection;  
     private boolean isOpen = true;  
       
     public SimplePublisher() throws Exception{  
         Context context = new InitialContext();  
         TopicConnectionFactory connectionFactory = (TopicConnectionFactory)context.lookup("TopicCF");  
         connection = connectionFactory.createTopicConnection();  
         connection.setClientID("OK111");  
         session = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);  
         Topic topic = (Topic)context.lookup("topic1");  
         producer = session.createPublisher(topic);//non durable  
         producer.setDeliveryMode(DeliveryMode.PERSISTENT);  
         connection.start();  
           
     }  
       
       
     public boolean send(String text) {  
         if(!isOpen){  
             throw new RuntimeException("session has been closed!");  
         }  
         try{  
             Message message = session.createTextMessage(text);  
             producer.send(message);  
             return true;  
         }catch(Exception e){  
             return false;  
         }  
     }  
       
     public synchronized void close(){  
         try{  
             if(isOpen){  
                 isOpen = false;  
             }  
             session.close();  
             connection.close();  
         }catch (Exception e) {  
             //  
         }  
     }  
       
 }  

    Java代码   
    
  
 //Topic订阅者  
 package com.test.jms.simple.topic;  
   
 import javax.jms.Session;  
 import javax.jms.Topic;  
 import javax.jms.TopicConnection;  
 import javax.jms.TopicConnectionFactory;  
 import javax.jms.TopicSession;  
 import javax.jms.TopicSubscriber;  
 import javax.naming.Context;  
 import javax.naming.InitialContext;  
   
 import com.test.jms.object.TopicMessageListener;  
   
 public class SimpleSubscriber {  
   
     private TopicConnection connection;  
     private TopicSession session;  
     private TopicSubscriber consumer;  
       
     private boolean isStarted;  
       
     public SimpleSubscriber(String clientId) throws Exception{  
         Context context = new InitialContext();  
         TopicConnectionFactory connectionFactory = (TopicConnectionFactory)context.lookup("TopicCF");  
         connection = connectionFactory.createTopicConnection();  
         connection.setClientID(clientId);  
         session = connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);  
         Topic topic = (Topic)context.lookup("topic1");  
         consumer = session.createDurableSubscriber(topic, "Test-subscriber");  
         consumer.setMessageListener(new TopicMessageListener());  
     }  
       
       
     public synchronized boolean start(){  
         if(isStarted){  
             return true;  
         }  
         try{  
             connection.start();  
             isStarted = true;  
             return true;  
         }catch(Exception e){  
             return false;  
         }  
     }  
       
     public synchronized void close(){  
         isStarted = false;  
         try{  
             session.close();  
             connection.close();  
         }catch(Exception e){  
             //  
         }  
     }  
 }  

    Java代码   
    
  
 //测试类  
 package com.test.jms.simple.topic;  
   
   
   
   
 public class SimpleTestMain {  
   
     /** 
      * @param args 
      */  
     public static void main(String[] args) throws Exception{  
         SimpleSubscriber consumer = new SimpleSubscriber("TestClientId");  
         consumer.start();  
           
         SimplePublisher productor = new SimplePublisher();  
         for(int i=0; i<10; i++){  
             productor.send("message content:" + i);  
         }  
         productor.close();  
         //consumer.close();  
     }  
       
   
 }  

在session.createSubscriber(Topic topic)方法中,将会创建一个"非耐久性"主题,即只有subscriber侦听时才会收到消息,当subscriber离线时,它将错过消息.session.createDurableSubscriber(Topic topic,String name)用来创建一个耐久性订阅者,这种订阅者不会错过离线时的消息,JMS Provider将会为它保留所有的消息副本(必须符合相应的消息选择器).其中参数"name"用来表示此订阅者的名字,name的值可以任意,也不允许重复.

其中耐久性订阅者,必须对connection设定ClientId且此ID全局不能重复,否则将会抛出:javax.jms.JMSException: You cannot create a durable subscriber without specifying a unique clientID on a Connection.

一个session中只能创建一个耐久性订阅者,否则将抛出异常:javax.jms.JMSException: Durable consumer is in use for client;不过一个connection下可以有多个耐久性订阅者.

如果一个connection下有多个耐久订阅者时,此时订阅者的name不能重复,否则抛出: javax.jms.JMSException: Durable consumer is in use for client: TestClientId and subscriptionName: ..

session.unsubscribe(String name)方法为取消订阅,取消当前connection下指定name的订阅者.此后JMS Provider将不会为其保存消息副本.如果你确定一个耐久订阅者不会再次激活时,你需要"取消订阅",否则JMS Provider将会一直为它保存消息副本,而且极有可能带来存储上的风险,如果磁盘或者内存消耗完毕,将会导致JMS Provider故障.

Topic中消息副本的存储模式(数据库描述):

    Java代码   
    
  
 ++++++++++++Consumers table+++++++  
 ++id      |       Name                      |       destinationId         |     created  
 1                  clientID1::name1                  testTopoc               122222222  
 2                  clientID1::name2                  testTopoc               122323232  
 //其中Name + destinationId为唯一索引.  
   
   
 ++++++++++++Messages_handles+++++++  
 ++id      |    messagId    |     destinationId    |    consumerId  |   delivered  
   
 1                 10010                 testTopic                      1                0  
 2                 10010                 testTopic                      2                0  
 //消息的实体将会保存在其他表中,通过messageId与其关联.  
 //此表中messageId + destinationId + consumerId为唯一索引.  

通过这个存储模式,我们能够理解出JMS Provider是如何创建消息副本的:每创建一个耐久订阅者都将会在Consumer表中新增一条记录,当"取消订阅"之后,相应的consumer记录也会被删除;当一个Topic中新的消息生成时,将会检索consumer表中此destinationId下的所有consumer,然后为每个conusmer生成消息副本--在Message_handles表中插入一条数据;如果某个consumer消费了一条消息,将会在message_handles表中删除消息副本记录.（某些JMS 实现，可能是记录每个订阅者已经消费的最后一个消息的ID，而不是消息的副本）

其中createDurableSubscriber(Topic topic,String name,String selector,boolean noLocal)方法中还有一个重要的参数--noLocal,此参数主要用来控制此订阅者是否接受本地消息,所谓本地消息就是当前Connection下其他publisher发送的消息(对于JMS Provider而言,就是ClientID标识),如果noLocal = true,那么意味着将只能收到其他Client发布的消息.