全文用到的生产者代码:

  1. package cn.qlq.activemq;
  2.  
  3. import javax.jms.Connection;
  4. import javax.jms.ConnectionFactory;
  5. import javax.jms.JMSException;
  6. import javax.jms.MessageProducer;
  7. import javax.jms.Queue;
  8. import javax.jms.Session;
  9. import javax.jms.TextMessage;
  10.  
  11. import org.apache.activemq.ActiveMQConnectionFactory;
  12.  
  13. /**
  14.  * 生产消息
  15.  *
  16.  * @author QiaoLiQiang
  17.  * @time 2018年9月18日下午11:04:41
  18.  */
  19. public class MsgProducer {
  20.  
  21.     // 默认端口61616
  22.     private static final String url = "tcp://localhost:61616/";
  23.     private static final String queueName = "myQueue";
  24.     private static Session session = null;
  25.  
  26.     public static void main(String[] args) throws JMSException {
  27.         // 1创建ConnectionFactory
  28.         ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url);
  29.         // 2.由connectionFactory创建connection
  30.         Connection connection = connectionFactory.createConnection();
  31.         // 3.启动connection
  32.         connection.start();
  33.         // 4.创建Session===第一个参数是是否事务管理，第二个参数是应答模式
  34.         session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
  35.         // 5.创建Destination(Queue继承Queue)
  36.         Queue destination = session.createQueue(queueName);
  37.         // 6.创建生产者producer
  38.         MessageProducer producer = session.createProducer(destination);
  39.         for (int i = 0; i < 10; i++) {
  40.             // 7.创建Message，有好多类型，这里用最简单的TextMessage
  41.             TextMessage tms = session.createTextMessage("textMessage:" + i);
  42.  
  43.             // 设置附加属性
  44.             tms.setStringProperty("str", "stringProperties" + i);
  45.  
  46.             // 8.生产者发送消息
  47.             producer.send(tms);
  48.         }
  49.  
  50.         // 9.提交事务
  51.         session.commit();
  52.  
  53.         // 10.关闭connection
  54.         session.close();
  55.         connection.close();
  56.     }
  57.  
  58. }

1.消息接收确认

　　JMS 消息只有在被确认之后，才认为已经被成功地消费了。消息的成功消费通常包含三个阶段：客户接收消息、客户处理消息和消息被确认。

(1)　在事务性会话中，事务被提交的时候，确认自动发生。也就是事务性回话需要进行session.commit()。如下消费者代码:

  1. package cn.qlq.activemq;
  2.  
  3. import java.util.Enumeration;
  4.  
  5. import javax.jms.Connection;
  6. import javax.jms.ConnectionFactory;
  7. import javax.jms.JMSException;
  8. import javax.jms.Message;
  9. import javax.jms.MessageConsumer;
  10. import javax.jms.MessageListener;
  11. import javax.jms.Queue;
  12. import javax.jms.Session;
  13. import javax.jms.TextMessage;
  14.  
  15. import org.apache.activemq.ActiveMQConnectionFactory;
  16.  
  17. /**
  18.  * 消费消息
  19.  *
  20.  * @author QiaoLiQiang
  21.  * @time 2018年9月18日下午11:26:41
  22.  */
  23. public class MsgConsumer {
  24.  
  25.     // 默认端口61616
  26.     private static final String url = "tcp://localhost:61616/";
  27.     private static final String queueName = "myQueue";
  28.  
  29.     public static void main(String[] args) throws JMSException {
  30.         // 1创建ConnectionFactory
  31.         ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url);
  32.         // 2.由connectionFactory创建connection
  33.         Connection connection = connectionFactory.createConnection();
  34.         Enumeration jmsxPropertyNames = connection.getMetaData().getJMSXPropertyNames();
  35.         while (jmsxPropertyNames.hasMoreElements()) {
  36.             String nextElement = (String) jmsxPropertyNames.nextElement();
  37.             System.out.println("JMSX name ===" + nextElement);
  38.         }
  39.         // 3.启动connection
  40.         connection.start();
  41.         // 4.创建Session===第一个参数是是否事务管理，第二个参数是应答模式
  42.         Session session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
  43.         // 5.创建Destination(Queue继承Queue)
  44.         Queue destination = session.createQueue(queueName);
  45.         // 6.创建消费者consumer
  46.         MessageConsumer consumer = session.createConsumer(destination);
  47.  
  48.         int i = 0;
  49.         while (i < 10) {
  50.             TextMessage textMessage = (TextMessage) consumer.receive();
  51.             System.out.println("接收消息:" + textMessage.getText() + ";属性" + textMessage.getStringProperty("str"));
  52.             i++;
  53.  
  54.         }
  55.  
  56.         // 提交事务，进行确认收到消息
  57.         session.commit();
  58.  
  59.         session.close();
  60.         connection.close();
  61.     }
  62. }

补充:如果在事务性会话中应答模式是Session.SESSION_TRANSACTED，也需要手动提交事务:

  1.         // 4.创建Session===第一个参数是是否事务管理，第二个参数是应答模式
  2.         Session session = connection.createSession(true, Session.SESSION_TRANSACTED);
  3. 　　　　　　...
  4.         // 提交事务，进行确认收到消息
  5.         session.commit();

(2)在非事务性会话中，消息何时被确认取决于创建会话的应答模式(acknowledgement mode)。该参数有以下三个值可选:

  • Session.AUTO_ACKNOWLEDGE

　　当客户成功的从receive方法返回的时候，或者从 MessageListener.onMessage方法成功返回的时候，会话自动确认客户收到的消息。(接收端线程不会结束，原因是listener新起了一个线程一直监听，如果再次运行接收端新开一个consumer是接收不到消息的，消息已经被第一个消费了)

  1. package cn.qlq.activemq;
  2.  
  3. import java.util.Enumeration;
  4.  
  5. import javax.jms.Connection;
  6. import javax.jms.ConnectionFactory;
  7. import javax.jms.JMSException;
  8. import javax.jms.Message;
  9. import javax.jms.MessageConsumer;
  10. import javax.jms.MessageListener;
  11. import javax.jms.Queue;
  12. import javax.jms.Session;
  13. import javax.jms.TextMessage;
  14.  
  15. import org.apache.activemq.ActiveMQConnectionFactory;
  16.  
  17. /**
  18.  * 消费消息
  19.  *
  20.  * @author QiaoLiQiang
  21.  * @time 2018年9月18日下午11:26:41
  22.  */
  23. public class MsgConsumer {
  24.  
  25.     // 默认端口61616
  26.     private static final String url = "tcp://localhost:61616/";
  27.     private static final String queueName = "myQueue";
  28.  
  29.     public static void main(String[] args) throws JMSException {
  30.         // 1创建ConnectionFactory
  31.         ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url);
  32.         // 2.由connectionFactory创建connection
  33.         Connection connection = connectionFactory.createConnection();
  34.         Enumeration jmsxPropertyNames = connection.getMetaData().getJMSXPropertyNames();
  35.         while (jmsxPropertyNames.hasMoreElements()) {
  36.             String nextElement = (String) jmsxPropertyNames.nextElement();
  37.             System.out.println("JMSX name ===" + nextElement);
  38.         }
  39.         // 3.启动connection
  40.         connection.start();
  41.         // 4.创建Session===第一个参数是是否事务管理，第二个参数是应答模式
  42.         Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
  43.         // 5.创建Destination(Queue继承Queue)
  44.         Queue destination = session.createQueue(queueName);
  45.         // 6.创建消费者consumer
  46.         MessageConsumer consumer = session.createConsumer(destination);
  47.  
  48.         int i = 0;
  49.         while (i < 10) {
  50.             TextMessage textMessage = (TextMessage) consumer.receive();
  51.             System.out.println("接收消息:" + textMessage.getText() + ";属性" + textMessage.getStringProperty("str"));
  52.             i++;
  53.  
  54.         }
  55.         session.close();
  56.         connection.close();
  57.     }
  58. }
  • Session.CLIENT_ACKNOWLEDGE  客户端应答

　　客户通过调用消息的acknowledge方法确认消息。需要注意的是，在这种模式中，确认是在会话层上进行，确认一个被消费的消息将自动确认所有已被会话消费的消息。例如，如果一个消息消费者消费了10 个消息，然后确认第5 个消息，那么所有10 个消息都被确认。如果接受了五个消息然后进行了确认，又接受了五个消息，只会对前面五个进行确认，后面接受的消息不会影响。

  1. package cn.qlq.activemq;
  2.  
  3. import java.util.Enumeration;
  4.  
  5. import javax.jms.Connection;
  6. import javax.jms.ConnectionFactory;
  7. import javax.jms.JMSException;
  8. import javax.jms.Message;
  9. import javax.jms.MessageConsumer;
  10. import javax.jms.MessageListener;
  11. import javax.jms.Queue;
  12. import javax.jms.Session;
  13. import javax.jms.TextMessage;
  14.  
  15. import org.apache.activemq.ActiveMQConnectionFactory;
  16.  
  17. /**
  18.  * 消费消息
  19.  *
  20.  * @author QiaoLiQiang
  21.  * @time 2018年9月18日下午11:26:41
  22.  */
  23. public class MsgConsumer {
  24.  
  25.     // 默认端口61616
  26.     private static final String url = "tcp://localhost:61616/";
  27.     private static final String queueName = "myQueue";
  28.  
  29.     public static void main(String[] args) throws JMSException {
  30.         // 1创建ConnectionFactory
  31.         ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url);
  32.         // 2.由connectionFactory创建connection
  33.         Connection connection = connectionFactory.createConnection();
  34.         Enumeration jmsxPropertyNames = connection.getMetaData().getJMSXPropertyNames();
  35.         while (jmsxPropertyNames.hasMoreElements()) {
  36.             String nextElement = (String) jmsxPropertyNames.nextElement();
  37.             System.out.println("JMSX name ===" + nextElement);
  38.         }
  39.         // 3.启动connection
  40.         connection.start();
  41.         // 4.创建Session===第一个参数是是否事务管理，第二个参数是应答模式
  42.         Session session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
  43.         // 5.创建Destination(Queue继承Queue)
  44.         Queue destination = session.createQueue(queueName);
  45.         // 6.创建消费者consumer
  46.         MessageConsumer consumer = session.createConsumer(destination);
  47.  
  48.         int i = 0;
  49.         while (i < 10) {
  50.             TextMessage textMessage = (TextMessage) consumer.receive();
  51.             System.out.println("接收消息:" + textMessage.getText() + ";属性" + textMessage.getStringProperty("str"));
  52.             i++;
  53.  
  54.             if (i == 10) {// 确保消费完所有的消息再进行确认
  55.                 textMessage.acknowledge();
  56.             }
  57.         }
  58.  
  59.         session.close();
  60.         connection.close();
  61.     }
  62. }
  • Session.DUPS_OK_ACKNOWLEDGE (了解就好)

该选择只是会话迟钝的确认消息的提交。如果JMS provider失败，那么可能会导致一些重复的消息。如果是重复的消息，那么JMS provider 必须把消息头的JMSRedelivered字段设置为true

2.第二种机制

1.消息持久性

JMS 支持以下两种消息提交模式：
　　PERSISTENT：只是JMS provider持久保存消息，以保证消息不会因为JMS provider的失败而丢失
　　NON_PERSISTENT：不要求JMS provider持久保存消息

// producer.setDeliveryMode(DeliveryMode.PERSISTENT);将消息传递特性置为持久化
producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);// 非持久化

2.消息优先级　　

　　可以使用消息优先级来指示JMS provider首先提交紧急的消息。优先级分10个级别，从0（最低）到9（最高）。如果不指定优先级，默认级别是4。需要注意的是，JMS provider并不一定保证按照优先级的顺序提交消息

3.消息过期

可以设置消息在一定时间后过期，默认是永不过期

  1. producer.setTimeToLive(Long aliveTime);

　　注意timeToLive属性只会在DisableMessageTimestamp=false(禁用消息时间戳)的情况下才有意义

4.消息的临时目的地

　　可以通过会话上的createTemporaryQueue 方法和createTemporaryTopic 方法来创建临时目的地。它们的存在时间只限于创建它们的连接所保持的时间。只有创建该临时目的地的连接上的消息消费者才能够从临时目的地中提取消息。

生产者:

  1. package cn.qlq.activemq;
  2.  
  3. import javax.jms.Connection;
  4. import javax.jms.ConnectionFactory;
  5. import javax.jms.JMSException;
  6. import javax.jms.MessageProducer;
  7. import javax.jms.Queue;
  8. import javax.jms.Session;
  9. import javax.jms.TemporaryQueue;
  10. import javax.jms.TemporaryTopic;
  11. import javax.jms.TextMessage;
  12.  
  13. import org.apache.activemq.ActiveMQConnectionFactory;
  14.  
  15. /**
  16.  * 生产消息
  17.  *
  18.  * @author QiaoLiQiang
  19.  * @time 2018年9月18日下午11:04:41
  20.  */
  21. public class MsgProducer {
  22.  
  23.     // 默认端口61616
  24.     private static final String url = "tcp://localhost:61616/";
  25.     private static final String queueName = "myQueue";
  26.     private static Session session = null;
  27.  
  28.     public static void main(String[] args) throws JMSException {
  29.         // 1创建ConnectionFactory
  30.         ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url);
  31.         // 2.由connectionFactory创建connection
  32.         Connection connection = connectionFactory.createConnection();
  33.         // 3.启动connection
  34.         connection.start();
  35.         // 4.创建Session===第一个参数是是否事务管理，第二个参数是应答模式
  36.         session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
  37.         // 5.创建Destination(Queue继承Queue)
  38.         Queue destination = session.createQueue(queueName);
  39.  
  40.         TemporaryQueue temporaryQueue = session.createTemporaryQueue();
  41.  
  42.         // 6.创建生产者producer
  43.         MessageProducer producer = session.createProducer(destination);
  44.         for (int i = 0; i < 1; i++) {
  45.             // 7.创建Message，有好多类型，这里用最简单的TextMessage
  46.             TextMessage tms = session.createTextMessage("textMessage:" + i);
  47.  
  48.             // 设置附加属性
  49.             tms.setStringProperty("str", "stringProperties" + i);
  50.  
  51.             tms.setJMSReplyTo(temporaryQueue);
  52.  
  53.             // 8.生产者发送消息
  54.             producer.send(tms);
  55.         }
  56.  
  57.         // 9.提交事务
  58.         session.commit();
  59.  
  60.         // 10.关闭connection
  61.         session.close();
  62.         connection.close();
  63.     }
  64.  
  65. }

执行一次查看消息后台:

消费者:

  1. package cn.qlq.activemq;
  2.  
  3. import java.util.Enumeration;
  4.  
  5. import javax.jms.Connection;
  6. import javax.jms.ConnectionFactory;
  7. import javax.jms.Destination;
  8. import javax.jms.JMSException;
  9. import javax.jms.MessageConsumer;
  10. import javax.jms.Queue;
  11. import javax.jms.Session;
  12. import javax.jms.TextMessage;
  13.  
  14. import org.apache.activemq.ActiveMQConnectionFactory;
  15.  
  16. /**
  17.  * 消费消息
  18.  *
  19.  * @author QiaoLiQiang
  20.  * @time 2018年9月18日下午11:26:41
  21.  */
  22. public class MsgConsumer {
  23.  
  24.     // 默认端口61616
  25.     private static final String url = "tcp://localhost:61616/";
  26.     private static final String queueName = "myQueue";
  27.  
  28.     public static void main(String[] args) throws JMSException {
  29.         // 1创建ConnectionFactory
  30.         ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url);
  31.         // 2.由connectionFactory创建connection
  32.         Connection connection = connectionFactory.createConnection();
  33.         Enumeration jmsxPropertyNames = connection.getMetaData().getJMSXPropertyNames();
  34.         while (jmsxPropertyNames.hasMoreElements()) {
  35.             String nextElement = (String) jmsxPropertyNames.nextElement();
  36.             System.out.println("JMSX name ===" + nextElement);
  37.         }
  38.         // 3.启动connection
  39.         connection.start();
  40.         // 4.创建Session===第一个参数是是否事务管理，第二个参数是应答模式
  41.         Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
  42.         // 5.创建Destination(Queue继承Queue)
  43.         Queue destination = session.createQueue(queueName);
  44.         // 6.创建消费者consumer
  45.         MessageConsumer consumer = session.createConsumer(destination);
  46.  
  47.         int i = 0;
  48.         while (i < 1) {
  49.             TextMessage textMessage = (TextMessage) consumer.receive();
  50.             System.out.println("接收消息:" + textMessage.getText() + ";属性" + textMessage.getStringProperty("str"));
  51.             i++;
  52.  
  53.             Destination jmsReplyTo = textMessage.getJMSReplyTo();
  54.             System.out.println(jmsReplyTo);
  55.         }
  56.  
  57.         session.close();
  58.         connection.close();
  59.     }
  60. }

结果:

JMSX name ===JMSXUserID
JMSX name ===JMSXGroupID
JMSX name ===JMSXGroupSeq
JMSX name ===JMSXDeliveryCount
JMSX name ===JMSXProducerTXID
接收消息:textMessage:0;属性stringProperties0
temp-queue://ID:MicroWin10-1535-49479-1551765172839-1:1:1

3.机制3  ====持久订阅

　　首先消息生产者必须使用PERSISTENT提交消息。客户可以通过会话上的createDurableSubscriber方法来创建一个持久订阅，该方法的第一个参数必须是一个topic。第二个参数是订阅的名称。JMS provider会存储发布到持久订阅对应的topic上的消息。如果最初创建持久订阅的客户或者任何其它客户，使用相同的连接工厂和连接的客户ID，相同的主题和相同的订阅名，再次调用会话上的createDurableSubscriber方法，那么该持久订阅就会被激活。JMS provider会向客户发送客户处于非激活状态时所发布的消息。持久订阅在某个时刻只能有一个激活的订阅者。持久订阅在创建之后会一直保留，直到应用程序调用会话上的unsubscribe方法。

4.  机制4

1.本地事务

　　在一个JMS客户端，可以使用本地事务来组合消息的发送和接收。

　　JMS Session接口提供了commit和rollback方法。事务提交意味着生产的所有消息被发送，消费的所有消息被确认；事务回滚意味着生产的所有消息被销毁，消费的所有消息被恢复并重新提交，除非它们已经过期。

　　事务性的会话总是牵涉到事务处理中，commit或rollback方法一旦被调用，一个事务就结束了，而另一个事务被开始。关闭事务性会话将回滚其中的事务。

　　需要注意的是，如果使用请求/回复机制，即发送一个消息，同时希望在同一个事务中等待接收该消息的回复，那么程序将被挂起，因为直到事务提交，发送操作才会真正执行。需要注意的还有一个，消息的生产和消费不能包含在同一个事务中。

2.JMS的PTP模型(队列模式)

　　JMS PTP(Point-to-Point)模型定义了客户端如何向队列发送消息，从队列接收消息，以及浏览队列中的消息。

　　PTP模型是基于队列的，生产者发消息到队列，消费者从队列接收消息，队列的存在使得消息的异步传输成为可能。和邮件系统中的邮箱一样，队列可以包含各种消息，JMS Provider 提供工具管理队列的创建、删除。

　　PTP的一些特点：

1：如果在Session 关闭时，有一些消息已经被收到，但还没有被签收(acknowledged)，那么，当消费者下次连接到相同的队列时，这些消息还会被再次接收
2：如果用户在receive 方法中设定了消息选择条件，那么不符合条件的消息会留在队列中，不会被接收到
3：队列可以长久地保存消息直到消费者收到消息。消费者不需要因为担心消息会丢失而时刻和队列保持激活的连接状态，充分体现了异步传输模式的优势

3.JMS的Pub/Sub模型(重要)

　　JMS Pub/Sub 模型定义了如何向一个内容节点发布和订阅消息，这些节点被称作topic

　　主题可以被认为是消息的传输中介，发布者(publisher)发布消息到主题，订阅者(subscribe) 从主题订阅消息。主题使得消息订阅者和消息发布者保持互相独立，不需要接触即可保证消息的传送。

    Pub/Sub的一些特点：

1：消息订阅分为非持久订阅和持久订阅
　　　非持久订阅只有当客户端处于激活状态，也就是和JMS Provider保持连接状态才能收到发送到某个主题的消息，而当客户端处于离线状态，这个时间段发到主题的消息将会丢失，永远不会收到。
　　　持久订阅时，客户端向JMS 注册一个识别自己身份的ID，当这个客户端处于离线时，JMS Provider会为这个ID 保存所有发送到主题的消息，当客户再次连接到JMS Provider时，会根据自己的ID 得到所有当自己处于离线时发送到主题的消息。(必须先启动消费者注册一下ID)
2：如果用户在receive 方法中设定了消息选择条件，那么不符合条件的消息不会被接收
3：非持久订阅状态下，不能恢复或重新派送一个未签收的消息。只有持久订阅才能恢复或重新派送一个未签收的消息。
4：当所有的消息必须被接收，则用持久订阅。当丢失消息能够被容忍，则用非持久订阅

  • 非持久订阅的生产者和消费者
  1. public class MsgProducer {
  2.  
  3.     // 默认端口61616
  4.     private static final String url = "tcp://localhost:61616/";
  5.     private static final String topicName = "myTopic";
  6.  
  7.     public static void main(String[] args) throws JMSException {
  8.         // 1创建ConnectionFactory
  9.         ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url);
  10.         // 2.由connectionFactory创建connection
  11.         Connection connection = connectionFactory.createConnection();
  12.         // 3.启动connection
  13.         connection.start();
  14.         // 4.创建Session===第一个参数是是否事务管理，第二个参数是应答模式
  15.         Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
  16.         // 5.创建Destination(Queue继承Queue,Topic也继承Destination==这三个都是接口)
  17.         Destination destination = session.createTopic(topicName);
  18.         // 6.创建生产者producer
  19.         MessageProducer producer = session.createProducer(destination);
  20.         for (int i = 0; i < 100; i++) {
  21.             // 7.创建Message，有好多类型，这里用最简单的TextMessage
  22.             TextMessage tms = session.createTextMessage("textMessage:" + i);
  23.             // 8.生产者发送消息
  24.             producer.send(tms);
  25.  
  26.             System.out.println("send:" + tms.getText());
  27.         }
  28.         // 9.关闭connection
  29.         connection.close();
  30.     }
  31.  
  32. }
  1. public class MsgConsumer {
  2.  
  3.     // 默认端口61616
  4.     private static final String url = "tcp://localhost:61616/";
  5.     private static final String topicName = "myTopic";
  6.  
  7.     public static void main(String[] args) throws JMSException {
  8.         // 1创建ConnectionFactory
  9.         ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url);
  10.         // 2.由connectionFactory创建connection
  11.         Connection connection = connectionFactory.createConnection();
  12.         // 3.启动connection
  13.         connection.start();
  14.         // 4.创建Session===第一个参数是是否事务管理，第二个参数是应答模式
  15.         Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
  16.         // 5.创建Destination(Queue继承Queue,Topic也继承Destination==这三个都是接口)
  17.         Destination destination = session.createTopic(topicName);
  18.         // 6.创建消费者consumer
  19.         MessageConsumer consumer = session.createConsumer(destination);
  20.         // 7.给消费者绑定监听器(消息的监听是一个异步的过程，不可以关闭连接，绑定监听器线程是一直开启的，处于阻塞状态，所以可以在程序退出关闭)
  21.         consumer.setMessageListener(new MessageListener() {
  22.             @Override
  23.             public void onMessage(Message message) {
  24.                 // 7.1由于消费者接受的是TextMessage，所以强转一下
  25.                 TextMessage tms = (TextMessage) message;
  26.                 try {
  27.                     System.out.println("接收消息:" + tms.getText());
  28.                 } catch (JMSException e) {
  29.                     e.printStackTrace();
  30.                 }
  31.             }
  32.         });
  33.     }
  34.  
  35. }
  • 持久订阅的生产者和消费者

　　　　生产者将发布模式改为持久模式，默认是持久模式。必须在开启connection之前设置。

  1. public class MsgProducer {
  2.  
  3.     // 默认端口61616
  4.     private static final String url = "tcp://localhost:61616/";
  5.     private static final String topicName = "myTopic";
  6.  
  7.     public static void main(String[] args) throws JMSException {
  8.         // 1创建ConnectionFactory
  9.         ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url);
  10.         // 2.由connectionFactory创建connection
  11.         Connection connection = connectionFactory.createConnection();
  12.  
  13.         // 3.创建Session===第一个参数是是否事务管理，第二个参数是应答模式
  14.         Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
  15.         // 4.创建Destination(Queue继承Queue,Topic也继承Destination==这三个都是接口)
  16.         Destination destination = session.createTopic(topicName);
  17.         // 5.创建生产者producer
  18.         MessageProducer producer = session.createProducer(destination);
  19.         // 6设置为持久模式(这个必须在下面开启connection之前)
  20.         producer.setDeliveryMode(DeliveryMode.PERSISTENT);
  21.         // 7.启动connection
  22.         connection.start();
  23.  
  24.         for (int i = 0; i < 10; i++) {
  25.             // 8.创建Message，有好多类型，这里用最简单的TextMessage
  26.             TextMessage tms = session.createTextMessage("textMessage:" + i);
  27.             // 9.生产者发送消息
  28.             producer.send(tms);
  29.  
  30.             System.out.println("send:" + tms.getText());
  31.         }
  32.         // 9.关闭connection
  33.         connection.close();
  34.     }
  35. }

需要注意的是:　

　　1：要用持久化订阅，发送消息者要用 DeliveryMode.PERSISTENT 模式，在连接之前设定
　　2：一定要设置完成后，再start 这个 connection

  1. public class MsgConsumer {
  2.  
  3.     // 默认端口61616
  4.     private static final String url = "tcp://localhost:61616/";
  5.     private static final String topicName = "myTopic";
  6.  
  7.     public static void main(String[] args) throws JMSException {
  8.         // 1创建ConnectionFactory
  9.         ConnectionFactory connectionFactory = new ActiveMQConnectionFactory(url);
  10.         // 2.由connectionFactory创建connection
  11.         Connection connection = connectionFactory.createConnection();
  12.         // 设置链接的ID
  13.         connection.setClientID("cc1");
  14.         // 3.创建Session===第一个参数是是否事务管理，第二个参数是应答模式
  15.         Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
  16.         // 4.创建Destination(Queue继承Queue,Topic也继承Destination==这三个都是接口)
  17.         Topic destination = session.createTopic(topicName);
  18.         // 创建TopicSubscriber来订阅;需要在连接上设置消费者id，用来识别消费者;设置好了过后再start 这个 connection
  19.         TopicSubscriber ts = session.createDurableSubscriber(destination, "C11");
  20.         // 5.启动connection
  21.         connection.start();
  22.         // 6.接受消息(用上面的TopicSubscriber接收消息)
  23.         Message message = ts.receive();
  24.         while (message != null) {
  25.             TextMessage txtMsg = (TextMessage) message;
  26.             session.commit();
  27.             System.out.println("收到消 息：" + txtMsg.getText());
  28.             message = ts.receive(1000L);
  29.         }
  30.         session.close();
  31.         connection.close();
  32.     }
  33. }

需要注意的是:

1：需要在连接上设置消费者id，用来识别消费者。也就是 connection.setClientID("cc1");
2：需要创建TopicSubscriber来订阅，也就是 session.createDurableSubscriber(destination, "C11");
3：要设置好了过后再start 这个 connection
4：一定要先运行一次，等于向消息服务中间件注册这个消费者，然后再运行客户端发送信息，这个时候，无论消费者是否在线，都会接收到，不在线的话，下次连接的时候，会把没有收过的消息都接收下来。
5: 接受消息是使用TopicSubscriber来接收消息

对于持久订阅我们查看activemq订阅的后台:

补充:关于持久化消息和费持久化消息

有两种方式指定传送模式:

　　1.使用setDeliveryMode方法，这样所有的消息都采用此传送模式;如producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT)

　　2.使用producer.send方法为每条消息设置传送模式

持久化消息

　　持久化消息是 ActiveMQ 的默认传送模式，此模式保证这些消息只被传送一次和成功使用一次。对于这些消息，可靠性是优先考虑的因素。可靠性的另一个重要方面是确保持久性消息传送至目标后，消息服务在向消费者传送它们之前不会丢失这些消息。

　　这意味着在持久性消息传送至目标时，消息服务将其放入持久性数据存储。如果消息服务由于某种原因导致失败，它可以恢复此消息并将此消息传送至相应的消费者。虽然这样增加了消息传送的开销，但却增加了可靠性。

非持久化消息

　　保证这些消息最多被传送一次。对于这些消息，可靠性并非主要的考虑因素。此模式并不要求持久性的数据存储，也不保证消息服务由于某种原因导致失败后消息不会丢失。

ActiveMQ中JMS的可靠性机制的更多相关文章

  1. JMS 基本可靠性机制 和 事务机制

    4.3.1 基本可靠性机制4.3.1.1 控制消息的签收(Acknowledgment) 客户端成功接收一条消息的标志是这条消息被签收.成功接收一条消息一般包括如 下三个阶段:1．客户端接收消息:2． ...

  2. ActiveMQ的JMS消息可靠机制

    JMS消息可靠机制 ActiveMQ消息签收机制: 客戶端成功接收一条消息的标志是一条消息被签收,成功应答. 消息的签收情形分两种: 1.带事务的session 如果session带有事务,并且事务成 ...

  3. ActiveMQ学习笔记（3）----JMS的可靠性机制

    1. 消息接收确认 JMS消息只有在被确认之后,才认为已经被成功的消费了,消息成功消费通常包含三个阶段:客户接收消息,客户处理消息和消息被确认. 在事务性会话中,当一个事务被提交的时候,确认自动发生. ...

  4. 分布式-信息方式-JMS可靠性机制

                        JMS的可靠性机制1.消息接收确认        JMS消息只有在被确认之后,才认为已经被成功地消费了.消息的成功消费通常包含三个阶段:客户接收消息.客户处理消 ...

  5. Springboot+ActiveMQ(ActiveMQ消息持久化,保证JMS的可靠性,消费者幂等性)

    ActiveMQ 持久化设置: 在redis中提供了两种持久化机制:RDB和AOF 两种持久化方式,避免redis宕机以后,能数据恢复,所以持久化的功能 对高可用程序来说 很重要. 同样在Active ...

  6. 转载：ActiveMQ的可靠性机制

    1.JMS消息确认机制 JMS消息只有在被确认之后,才认为已经被成功地消费了.消息的成功消费通常包含三个阶段:客户接收消息.客户处理消息和消息被确认.在事务性会话中,当一个事务被提交的时候,确认自动发 ...

  7. ActiveMQ消息的可靠性机制(转)

    文章转自:http://www.linuxidc.com/Linux/2013-02/79664.htm 1.JMS消息确认机制 JMS消息只有在被确认之后,才认为已经被成功地消费了.消息的成功消费通 ...

  8. ActiveMQ中的安全机制 [转]

    本文简单介绍ActiveMQ通过JAAS实现的安全机制.JAAS(Java Authentication and Authorization Service)也就是java认证/授权服务.这是两种不同 ...

  9. ActiveMq 之JMS 看这一篇就够了

    什么是JMS MQ 全称:Java MessageService 中文:Java 消息服务. JMS 是 Java 的一套 API 标准,最初的目的是为了使应用程序能够访问现有的 MOM 系 统(MO ...

随机推荐

  1. java中一维数组的定义和遍历

    public class ArrayDemo1{ public static void main(String[] args){ //1 定义数组 并同时赋值 int[] arr = new int[ ...

  2. C++: 带参数回调函数和不带参数的回调函数；

    在C++中,回调函数的应用比较广泛且重要. 通过传递函数指针到其他地方,能够实现远程回调的作用,能够实现远程调用而不需要事件触发信号或者其他机制来实现,方便而快捷: 首先,回调函数有两种形式:  静态 ...

  3. python3.x 和pip3的安装

    python3.x 和pip3的安装 本人在学习python3的时候,视频中使用的是python3,在讲解到有些第三方库的时候,无法使用到pip3 install来安装所需的库.由于系统是centos ...

  4. CodeForces5E 环转链,dp思想

    http://codeforces.com/problemset/problem/5/E 众所周知,在很久以前,在今天的 Berland 地区,居住着 Bindian 部落.他们的首都被 n 座山所环 ...

  5. Centos 7最小化InfluxDB部署

    配置源 [influxdb] name = InfluxDB Repository - RHEL \$releasever baseurl = https://repos.influxdata.com ...

  6. 网络编程基础【day09】：socketserver使用（九）

    本节内容 1.概述 2.socketserver类型 3.创建socketserver步骤 4.简单的代码实现 一.概述 我们之前的用户都是不支持多并发的,所以我们现在需要一个支持多用户,实现一个并发 ...

  7. ACM-ICPC 2018 焦作赛区网络预赛 A Magic Mirror（签到）

    https://nanti.jisuanke.com/t/31710 题意 若输入的是Jessie或jessie,输出Good guy!,否则输出Dare you say that again? 分析 ...

  8. python 精华梳理(已理解并手写)--全是干货--已结

    基础部分 map,reduce,filter,sort,推导式,匿名函数lambda , 协程,异步io,上下文管理 自定义字符串转数字方法一不使用reduce import re def str2i ...

  9. SQL-数据库刷题

    因是个人总结,只列出对自己有用的或较难的: 下面这道题,第一次拿到,我尝试用 开窗函数 ROW_NUMBER()OVER() 编号,但是发现不能够处理好连续的问题, 上网查找了别人的解法记录下来,其实 ...

  10. request 和 response 对象

    Request 对象 request 对象表示 HTTP 请求,包含了请求查询字符串,参数,内容,HTTP 头部等属性 常见属性 /* req.app:当callback为外部文件时,用req.app ...