[MQ]消息队列基本知识

MQ

Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法，消息中间件

RPC: 异步调用，及时获得调用结果，具有强一致性结果，关心业务调用处理结果
消息队列：两次异步RPC调用，将调用内容在队列中进行转储，并选择合适的时机进行投递（错峰流控）

系统间直接调用

• 系统之间接口耦合比较严重
  - 微服务架构之前，一个功能会被拆为多个函数（子模块），写程序时一般链式调用，增加模块时代码的改动量太大
• 面对大流量并发容易被冲垮
  - 每个接口模块的吞吐能力是有限的，需要流量缓冲池来保证后端系统按照自身吞吐能力进行消费达到削峰
• 等待同步存在性能问题
  - 强弱依赖梳理能够将非关键调用链路的操作异步化以提高整体系统的吞吐能力

作用

解耦

异步提升效率

流量削峰

缺点

下载安装

• ACMQ基于Java，所以需要现在linux上安装好Java环境

• 官网Linux下载ActiveMQ

    	 http://activemq.apache.org/
  

• 按照步骤

    	http://blog.csdn.net/gebitan505/article/details/55096222
  

• 启动
  ./ activemq start

查看程序启动是否成功

ACMQ默认端口为61616

• 查看进程
  ps -ef|grep activemq
• 查看端口是否被占用
  netstat -apn| grep 61616
• 查看端口是否被占用
  lsof -i:61616

启动时指定日志输出文件

activemq日志默认的位置是在：%activemq安装目录%/data/activemq.log

	service activemq start  >  /usr/local/raohao/activemq.log

ActiveMQ控制台

• 访问activemq管理页面地址：http://IP地址:8161/(注意81616是后台端口号，8161是前台端口号)
• 账户admin 密码admin
• 先ping通主机和linux（一定要先关闭防火墙）
  

适用场景

• 最主要是用以实现实现高性能、高可用、可伸缩和最终一致性架构
• 异步控制消息的消费处理
• 控制消息的消费顺序
• 可以和spring/springboot整合简化代码
• 配置集群容错的mq集群

队列

pom.xml导入依赖

		
  
  
    org.apache.activemq
    activemq-all
    5.15.9
  
  
  
    org.apache.xbean
    xbean-spring
    3.16
  

队列消息生产者

	package com.at.activemq.queue;
	
	import org.apache.activemq.ActiveMQConnectionFactory;
	import javax.jms.*;
	
	public class JmsProduce {
	    //  linux 上部署的activemq 的 IP 地址 + activemq 的端口号
	    public static final String ACTIVEMQ_URL = "tcp://118.24.20.3:61626";
	    // 目的地的名称
	    public static final String QUEUE_NAME = "jdbc01";
	
	
	    public static void main(String[] args) throws  Exception{
	     // 1 按照给定的url创建连接工厂，这个构造器采用默认的用户名密码。该类的其他构造方法可以指定用户名和密码。
    ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
    // 2 通过连接工厂，获得连接 connection 并启动访问。
    Connection connection = activeMQConnectionFactory.createConnection();
    connection.start();
    // 3 创建会话session 。第一参数是是否开启事务， 第二参数是消息签收的方式
    Session session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
    // 4 创建目的地（两种 ：队列/主题）。Destination是Queue和Topic的父类
    //注意此处导包时要选择Queue（javax.jms）
    Queue queue = session.createQueue(QUEUE_NAME);
    // 5 创建消息的生产者
    MessageProducer messageProducer = session.createProducer(queue);
    // 6 通过messageProducer 生产 3 条 消息发送到消息队列中
    for (int i = 1; i < 4 ; i++) {
        // 7  创建消息
        TextMessage textMessage = session.createTextMessage("msg--" + i);
        // 8  通过messageProducer发送给mq
        messageProducer.send(textMessage);
    }
    // 9 关闭资源
    messageProducer.close();
    session.close();
    connection.close();
    System.out.println("  **** 消息发送到MQ完成 ****");
}

}

在ActiveMQ控制台显示如下：

	- Number Of Pending Messages：
	 等待消费的消息，这个是未出队列的数量，公式=总接收数-总出队列数。
	- Number Of Consumers：
	消费者数量，消费者端的消费者数量。
	- Messages Enqueued：
	进队消息数，进队列的总消息量，包括出队列的。这个数只增不减。
	- Messages Dequeued：
	出队消息数，可以理解为是消费者消费掉的数量。

当有一个消息进入这个队列时，等待消费的消息是1，进入队列的消息是1。
当消息消费后，等待消费的消息是0，进入队列的消息是1，出队列的消息是1。
当再来一条消息时，等待消费的消息是1，进入队列的消息就是2

队列消息消费者

		package  com.at.activemq.queue;

import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

// 消息的消费者
public class JmsConsumer {

	    public static final String ACTIVEMQ_URL = "tcp://118.24.20.3:61626";
	    public static final String QUEUE_NAME = "jdbc01";
	
	    public static void main(String[] args) throws Exception{
	       ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
        javax.jms.Connection connection = activeMQConnectionFactory.createConnection();
        connection.start();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Queue queue = session.createQueue(QUEUE_NAME);
        // 5 创建消息的消费者
        MessageConsumer messageConsumer = session.createConsumer(queue);
        while(true){
            // reveive() 一直等待接收消息，在能够接收到消息之前将一直阻塞。 是同步阻塞方式 。和socket的accept方法类似的
// reveive(Long time) : 等待n毫秒之后还没有收到消息，就是结束阻塞
            // 因为消息发送者是 TextMessage，所以消息接受者也要是TextMessage,一定要保证一致
            TextMessage message = (TextMessage)messageConsumer.receive(); 
            if (null != message){
                System.out.println("****消费者的消息："+message.getText());
            }else {
                break;
            }
        }
        messageConsumer.close();
        session.close();
        connection.close();
    }
}

异步监听式消费者

	package  com.at.activemq.queue;
	
	import org.apache.activemq.ActiveMQConnectionFactory;
	import javax.jms.*;
	
	// 消息的消费者  也就是回答消息的系统
	public class JmsConsumer {
	
	    public static final String ACTIVEMQ_URL = "tcp://118.24.20.3:61626";
	
	    public static final String QUEUE_NAME = "jdbc01";
	
	    public static void main(String[] args) throws Exception{
	        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
	        javax.jms.Connection connection = activeMQConnectionFactory.createConnection();
	        connection.start();
	        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
	        Queue queue = session.createQueue(QUEUE_NAME);
	        MessageConsumer messageConsumer = session.createConsumer(queue);
	
	        /* 通过监听的方式来消费消息，是异步非阻塞的方式消费消息。
	           通过messageConsumer 的setMessageListener 注册一个监听器，当有消息发送来时，系统自动调用MessageListener 的 onMessage 方法处理消息
	         */
	         //注意MessageListener是一个接口，此处new接口实现一个匿名内部类
	         messageConsumer.setMessageListener(new MessageListener() {
	       
	            public void onMessage(Message message)  {
			//  instanceof 判断是否A对象是否是B类的子类，要确保消息种类
	                    if (null != message  && message instanceof TextMessage){
	                        TextMessage textMessage = (TextMessage)message;
	                        try {
	                            System.out.println("****消费者的消息："+textMessage.getText());
	                        }catch (JMSException e) {
	                            e.printStackTrace();
	                        }
	                }
	            }
	        });
			         // 让主线程不要结束。因为一旦主线程结束了，其他的线程（如此处的监听消息的线程）也都会被迫结束。
	        // 实际开发中，我们的程序会一直运行，这句代码都会省略
	        //System.in.read();保证控制台不灭，输入一个字符返回其ASCII，用它来做一个阻塞
	        System.in.read();
	        messageConsumer.close();
	        session.close();
	        connection.close();
	    }
	}

队列消息（Queue）总结

(1) 两种消费方式

• 同步阻塞方式(receive)
  订阅者或接收者抵用MessageConsumer的receive()方法来接收消息，receive方法在能接收到消息之前（或超时之前）将一直阻塞。

• 异步非阻塞方式（监听器onMessage()）
  订阅者或接收者通过MessageConsumer的setMessageListener(MessageListener listener)注册一个消息监听器，当消息到达之后，系统会自动调用监听器MessageListener的onMessage(Message message)方法。

（2） 队列的特点

（3）消息消费情况

主题

topic

• 在发布订阅消息传递域中，目的地被称为主题（topic）
• 发布/订阅消息传递域的特点如下：
  - （1）生产者将消息发布到topic中，每个消息可以有多个消费者，属于1：N的关系；
  - （2）生产者和消费者之间有时间上的相关性。订阅某一个主题的消费者只能消费自它订阅之后发布的消息。
  - （3）生产者生产时，topic不保存消息它是无状态的不落地，假如无人订阅就去生产，那就是一条废消息，所以，一般先启动消费者再启动生产者
  - 注意一定要先启动订阅再启动生产，否则发送的消息时是废的消息

生产者案例

				package  com.at.activemq.topic;
		
		import org.apache.activemq.ActiveMQConnectionFactory;
		import javax.jms.*;
		
			public class JmsProduce_topic {
		
		    public static final String ACTIVEMQ_URL = "tcp://192.168.17.3:61616";
		    public static final String TOPIC_NAME = "topic01";
		
		    public static void main(String[] args) throws  Exception{
		             ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
		        Connection connection = activeMQConnectionFactory.createConnection();
		        connection.start();
		        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
		
		        Topic topic = session.createTopic(TOPIC_NAME);
		
		        MessageProducer messageProducer = session.createProducer(topic);
		        for (int i = 1; i < 4 ; i++) {
					         TextMessage textMessage = session.createTextMessage("topic_name--" + i);
		            messageProducer.send(textMessage);
		            MapMessage mapMessage = session.createMapMessage();
		        }
		        messageProducer.close();
		        session.close();
		        connection.close();
		        System.out.println("  **** TOPIC_NAME消息发送到MQ完成 ****");
		    }
		}

消费者案例

	package  com.at.activemq.topic;
	
	import org.apache.activemq.ActiveMQConnectionFactory;
	import javax.jms.*;
	
	public class JmsConsummer_topic {
	    public static final String ACTIVEMQ_URL = "tcp://192.168.17.3:61616";
	    public static final String TOPIC_NAME = "topic01";
	
	    public static void main(String[] args) throws Exception{
	        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
	        Connection connection = activeMQConnectionFactory.createConnection();
	        connection.start();
	        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
	
	        // 4 创建目的地 （两种 ： 队列/主题   这里用主题）
	        Topic topic = session.createTopic(TOPIC_NAME);
	
	        MessageConsumer messageConsumer = session.createConsumer(topic);
	// MessageListener接口只有一个方法，可以使用lambda表达式
	        messageConsumer.setMessageListener( (message) -> {
	            if (null != message  && message instanceof TextMessage){
	                     TextMessage textMessage = (TextMessage)message;
			                    try {
			                      System.out.println("****消费者text的消息："+textMessage.getText());
			                            }catch (JMSException e) {
	                    }
	                }
	        });
	
	        System.in.read();
	        messageConsumer.close();
	        session.close();
	        connection.close();
	    }
	}
	存在多个消费者，每个消费者都能收到，自从自己启动后所有生产的消息

ActiveMQ控制台

tpoic和queue

JMS编码总体规范

Java消息服务（JMS）

• Java消息服务指的是两个应用程序之间进行异步通信的API，它为标准协议和消息服务提供了一组通用接口，包括创建、发送、读取消息等，用于支持Java应用程序开发
• 在JavaEE中，当两个应用程序使用JMS进行通信时，它们之间不是直接相连的，而是通过一个共同的消息收发服务组件关联起来以达到解耦/异步削峰的效果

JMS四大元素

• JMS provider：实现JMS接口和规范的消息中间件也就是MQ服务器
• JMS producer： 消息生产者
• JMS consumer：消息消费者
• JMS message

JMS message

消息头

JMS的消息头属性,消息的生产者可以set这些属性，消息的消费者可以get这些属性。
这些属性在send方法里面也可以设置

• JMSDestination：消息目的地

• JMSDeliveryMode：消息持久化模式（持久或非持久）

• JMSExpiration：消息过期时间()

• JMSPriority：消息的优先级

• JMSMessageID：消息的唯一标识符。后面我们会介绍如何解决幂等性

    			package  com.at.activemq.topic;
    			
    			import org.apache.activemq.ActiveMQConnectionFactory;
    			import javax.jms.*;
    			
    			public class JmsProduce_topic {
    			
    			    public static final String ACTIVEMQ_URL = "tcp://118.24.20.3:61626";
    			    public static final String TOPIC_NAME = "topic01";
    			
    			    public static void main(String[] args) throws  Exception{
    			        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
    			        Connection connection = activeMQConnectionFactory.createConnection();
    			        connection.start();
    			        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    			        Topic topic = session.createTopic(TOPIC_NAME);
    			        MessageProducer messageProducer = session.createProducer(topic);
    			
    			        for (int i = 1; i < 4 ; i++) {
    			            TextMessage textMessage = session.createTextMessage("topic_name--" + i);
    			            // 这里可以指定每个消息的目的地
    			            textMessage.setJMSDestination(topic);
    			            /*
    			            持久模式和非持久模式。
    			            一条持久性的消息：应该被传送“一次仅仅一次”，这就意味着如果JMS提供者出现故障，该消息并不会丢失，它会在服务器恢复之后再次传递。
    			            一条非持久的消息：最多会传递一次，这意味着服务器出现故障，该消息将会永远丢失。
    			             */
    			            textMessage.setJMSDeliveryMode(0);
    			            /*
    			            可以设置消息在一定时间后过期，默认是永不过期。
    			            消息过期时间，等于Destination的send方法中的timeToLive值加上发送时刻的GMT时间值。
    			            如果timeToLive值等于0，则JMSExpiration被设为0，表示该消息永不过期。
    			            如果发送后，在消息过期时间之后还没有被发送到目的地，则该消息被清除。
    			             */
    			            textMessage.setJMSExpiration(1000);
    			            /*  消息优先级，从0-9十个级别，0-4是普通消息5-9是加急消息。
    			            JMS不要求MQ严格按照这十个优先级发送消息但必须保证加急消息要先于普通消息到达。默认是4级。
    			             */
    			            textMessage.setJMSPriority(10);
    			            // 唯一标识每个消息的标识。MQ会给我们默认生成一个，我们也可以自己指定。
    			            textMessage.setJMSMessageID("ABCD");
    			            // 上面有些属性在send方法里也能设置
    			            messageProducer.send(textMessage);
    			        }
    			        messageProducer.close();
    			        session.close();
    			        connection.close();
    			        System.out.println("  **** TOPIC_NAME消息发送到MQ完成 ****");
    			    }
    			}
  

消息体

五种消息体格式

演示

• 生产者

    package  com.at.activemq.topic;
    
    import org.apache.activemq.ActiveMQConnectionFactory;
    import javax.jms.*;
    
    public class JmsProduce_topic {
    
        public static final String ACTIVEMQ_URL = "tcp://118.24.20.3:61626";
        public static final String TOPIC_NAME = "topic01";
    
        public static void main(String[] args) throws  Exception{
            ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
             javax.jms.Connection connection = activeMQConnectionFactory.createConnection();
             connection.start();
            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            Topic topic = session.createTopic(TOPIC_NAME);
            MessageProducer messageProducer = session.createProducer(topic);
    
            for (int i = 1; i < 4 ; i++) {
    // 发送TextMessage消息体
                TextMessage textMessage = session.createTextMessage("topic_name--" + i);
                messageProducer.send(textMessage);
                // 发送MapMessage  消息体。set方法: 添加，get方式：获取
                MapMessage  mapMessage = session.createMapMessage();
                mapMessage.setString("name", "张三"+i);
                mapMessage.setInt("age", 18+i);
                messageProducer.send(mapMessage);
            }
            messageProducer.close();
            session.close();
            connection.close();
            System.out.println("  **** TOPIC_NAME消息发送到MQ完成 ****");
        }
    }
  

• 消费者

    			package  com.at.activemq.topic;
    			
    			import org.apache.activemq.ActiveMQConnectionFactory;
    			import javax.jms.*;
    			
    			public class JmsConsummer_topic {
    			    public static final String ACTIVEMQ_URL = "tcp://118.24.20.3:61626";
    			    public static final String TOPIC_NAME = "topic01";
    			
    			    public static void main(String[] args) throws Exception{
    			        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
    			        javax.jms.Connection connection = activeMQConnectionFactory.createConnection();
    			        connection.start();
    			        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    			        Topic topic = session.createTopic(TOPIC_NAME);
    			        MessageConsumer messageConsumer = session.createConsumer(topic);
    			
    			        messageConsumer.setMessageListener( (message) -> {
    			 // 判断消息是哪种类型之后，再强转。
    			            if (null != message  && message instanceof TextMessage){
    			                   TextMessage textMessage = (TextMessage)message;
    			                    try {
    			                      System.out.println("****消费者text的消息："+textMessage.getText());
    			                    }catch (JMSException e) {
    			                    }
    			                }
    			            if (null != message  && message instanceof MapMessage){
    			                MapMessage mapMessage = (MapMessage)message;
    			                try {
    			                    System.out.println("****消费者的map消息："+mapMessage.getString("name"));
    			                    System.out.println("****消费者的map消息："+mapMessage.getInt("age"));
    			                }catch (JMSException e) {
    			                }
    			            }
    			
    			        });
    			        System.in.read();
    			        messageConsumer.close();
    			        session.close();
    			        connection.close();
    			    }
    			}
  

消息属性

• 如果需要除消息头字段之外的值，那么可以使用消息属性
• 他是识别/去重/重点标注等操作
• 以属性名和属性值对的形式制定
• 可以将属性视为消息头得扩展，属性指定一些消息头没有包括的附加信息，比如可以在属性里指定消息选择器
• 消息的属性就像可以分配给一条消息的附加消息头一样。它们允许开发者添加有关消息的不透明附加信息
• 还用于暴露消息选择器在消息过滤时使用的数据

-生产者

		package  com.at.activemq.topic;
		
		import org.apache.activemq.ActiveMQConnectionFactory;
		import javax.jms.*;
		
		public class JmsProduce_topic {
		
		    public static final String ACTIVEMQ_URL = "tcp://118.24.20.3:61626";
		    public static final String TOPIC_NAME = "topic01";
		
		    public static void main(String[] args) throws  Exception{
		        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
		        Connection connection = activeMQConnectionFactory.createConnection();
		        connection.start();
		        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
		        Topic topic = session.createTopic(TOPIC_NAME);
		        MessageProducer messageProducer = session.createProducer(topic);
		
		        for (int i = 1; i < 4 ; i++) {
		            TextMessage textMessage = session.createTextMessage("topic_name--" + i);
		            // 调用Message的set*Property()方法，就能设置消息属性。根据value的数据类型的不同，有相应的API。
		            textMessage.setStringProperty("From","[email protected]");
		            textMessage.setByteProperty("Spec", (byte) 1);
		            textMessage.setBooleanProperty("Invalide",true);
		            messageProducer.send(textMessage);
		        }
		        messageProducer.close();
		        session.close();
		        connection.close();
		        System.out.println("  **** TOPIC_NAME消息发送到MQ完成 ****");
		    }
		}

• 消费者

    		package  com.at.activemq.topic;
    		
    		import org.apache.activemq.ActiveMQConnectionFactory;
    		import javax.jms.*;
    		
    		public class JmsConsummer_topic {
    		    public static final String ACTIVEMQ_URL = "tcp://118.24.20.3:61626";
    		    public static final String TOPIC_NAME = "topic01";
    		
    		    public static void main(String[] args) throws Exception{
    		        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
    		        javax.jms.Connection connection = activeMQConnectionFactory.createConnection();
    		        connection.start();
    		        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    		        Topic topic = session.createTopic(TOPIC_NAME);
    		        MessageConsumer messageConsumer = session.createConsumer(topic);
    		
    		        messageConsumer.setMessageListener( (message) -> {
    		            if (null != message  && message instanceof TextMessage){
    		                    TextMessage textMessage = (TextMessage)message;
    		                    try {
    		                      System.out.println("消息体："+textMessage.getText());
    		                      System.out.println("消息属性："+textMessage.getStringProperty("From"));
    		                      System.out.println("消息属性："+textMessage.getByteProperty("Spec"));
    		                      System.out.println("消息属性："+textMessage.getBooleanProperty("Invalide"));
    		                    }catch (JMSException e) {
    		                    }
    		                }
    		        });
    		        System.in.read();
    		        messageConsumer.close();
    		        session.close();
    		        connection.close();
    		    }
    		}
  

消息的持久化

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

我的理解：在消息生产者将消息成功发送给MQ消息中间件之后。无论是出现任何问题，如：MQ服务器宕机、消费者掉线等。都保证（topic要之前注册过，queue不用）消息消费者，能够成功消费消息。如果消息生产者发送消息就失败了，那么消费者也不会消费到该消息

queue消息非持久和持久

• queue非持久，当服务器宕机，消息不存在（消息丢失了）。即便是非持久，消费者在不在线的话，消息也不会丢失，等待消费者在线，还是能够收到消息的。
• queue持久化，当服务器宕机，消息依然存在。queue消息默认是持久化。

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

topic消息持久化

topic默认就是非持久化，因为生产者生产消息时，消费者也要在线，这样消费者才能消费到消息。
topic消息持久化，只要消费者向MQ服务器注册过，所有生产者发布成功的消息，该消费者都能收到，不管是MQ服务器宕机还是消费者不在线

• 生产者

    		package  com.at.activemq.topic;
    		
    		import org.apache.activemq.ActiveMQConnectionFactory;
    		import javax.jms.*;
    		
    		// 持久化topic 的消息生产者
    		public class JmsProduce_persistence {
    		
    		    public static final String ACTIVEMQ_URL = "tcp://192.168.17.3:61616";
    		    public static final String TOPIC_NAME = "topic01";
    		
    		    public static void main(String[] args) throws  Exception{
    		        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
    		        javax.jms.Connection connection = activeMQConnectionFactory.createConnection();
    		        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    		        Topic topic = session.createTopic(TOPIC_NAME);
    		        MessageProducer messageProducer = session.createProducer(topic);
    		
    		        // 设置持久化topic 
    		        messageProducer.setDeliveryMode(DeliveryMode.PERSISTENT);
    		        // 设置持久化topic之后再，启动连接
    		        connection.start();
    		        for (int i = 1; i < 4 ; i++) {
    		            TextMessage textMessage = session.createTextMessage("topic_name--" + i);
    		            messageProducer.send(textMessage);
    		            MapMessage mapMessage = session.createMapMessage();
    		        }
    		        messageProducer.close();
    		        session.close();
    		        connection.close();
    		        System.out.println("  **** TOPIC_NAME消息发送到MQ完成 ****");
    		    }
    		}
  

• 消费者

    						package  com.at.activemq.topic;
    		
    		import org.apache.activemq.ActiveMQConnectionFactory;
    		import javax.jms.*;
    		
    		// 持久化topic 的消息消费者
    		public class JmsConsummer_persistence {
    		    public static final String ACTIVEMQ_URL = "tcp://192.168.17.3:61616";
    		    public static final String TOPIC_NAME = "topic01";
    		
    		    public static void main(String[] args) throws Exception{
    		        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
    		        Connection connection = activeMQConnectionFactory.createConnection();
    		// 设置客户端ID。向MQ服务器注册自己的名称
    		        connection.setClientID("marrry");
    		        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    		        Topic topic = session.createTopic(TOPIC_NAME);
    		// 创建一个topic订阅者对象。一参是topic，二参是订阅者名称
    		        TopicSubscriber topicSubscriber = session.createDurableSubscriber(topic,"remark...");
    		         // 之后再开启连接
    		        connection.start();
    		        Message message = topicSubscriber.receive();
    		         while (null != message){
    		             TextMessage textMessage = (TextMessage)message;
    		             System.out.println(" 收到的持久化 topic ："+textMessage.getText());
    		             message = topicSubscriber.receive();
    		         }
    		        session.close();
    		        connection.close();
    		    }
    		}
  

消息的事务性

• 生产者开启事务后，执行commit方法，这批消息才真正的被提交。不执行commit方法，这批消息不会提交。执行rollback方法，之前的消息会回滚掉。生产者的事务机制，要高于签收机制，当生产者开启事务，签收机制不再重要。

• 消费者开启事务后，执行commit方法，这批消息才算真正的被消费。不执行commit方法，这些消息不会标记已消费，下次还会被消费。执行rollback方法，是不能回滚之前执行过的业务逻辑，但是能够回滚之前的消息，回滚后的消息，下次还会被消费。消费者利用commit和rollback方法，甚至能够违反一个消费者只能消费一次消息的原理。

• 为什么要有事务
  正常情况下可以提交，异常情况下可以回滚

• 消费者和生产者需要同时操作事务才行吗？
  消费者和生产者的事务，完全没有关联，各自是各自的事务

• 生产者代码

    			package com.activemq.demo;
    			
    			import org.apache.activemq.ActiveMQConnectionFactory;
    			import javax.jms.*;
    			
    			public class Jms_TX_Producer {
    			    private static final String ACTIVEMQ_URL = "tcp://192.168.10.130:61616";
    			    private static final String ACTIVEMQ_QUEUE_NAME = "Queue-TX";
    			
    			    public static void main(String[] args) throws JMSException {
    			        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
    			        Connection connection = activeMQConnectionFactory.createConnection();
    			        connection.start();
    			        //1.创建会话session，两个参数transacted=事务,acknowledgeMode=确认模式(签收)
    			        //设置为开启事务
    			        Session session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
    			        Queue queue = session.createQueue(ACTIVEMQ_QUEUE_NAME);
    			        MessageProducer producer = session.createProducer(queue);
    			        try {
    			            for (int i = 0; i < 3; i++) {
    			                TextMessage textMessage = session.createTextMessage("tx msg--" + i);
    			              producer.send(textMessage);
    			if(i == 2){
    			                    throw new RuntimeException("GG.....");
    			                }
    			            }
    			            // 2. 开启事务后，使用commit提交事务，这样这批消息才能真正的被提交。
    			            session.commit();
    			            System.out.println("消息发送完成");
    			        } catch (Exception e) {
    			            System.out.println("出现异常,消息回滚");
    			            // 3. 工作中一般，当代码出错，我们在catch代码块中回滚。这样这批发送的消息就能回滚。
    			            session.rollback();
    			        } finally {
    			            //4. 关闭资源
    			            producer.close();
    			            session.close();
    			            connection.close();
    			        }
    			    }
    			}
  

• 消费者代码

    		package com.activemq.demo;
    		
    		import org.apache.activemq.ActiveMQConnectionFactory;
    		import javax.jms.*;
    		import java.io.IOException;
    		
    		public class Jms_TX_Consumer {
    		    private static final String ACTIVEMQ_URL = "tcp://118.24.20.3:61626";
    		    private static final String ACTIVEMQ_QUEUE_NAME = "Queue-TX";
    		
    		    public static void main(String[] args) throws JMSException, IOException {
    		        ActiveMQConnectionFactory activeMQConnectionFactory = new ActiveMQConnectionFactory(ACTIVEMQ_URL);
    		        Connection connection = activeMQConnectionFactory.createConnection();
    		        connection.start();
    		        // 创建会话session，两个参数transacted=事务,acknowledgeMode=确认模式(签收)
    		        // 消费者开启了事务就必须手动提交，不然会重复消费消息
    		        final Session session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
    		        Queue queue = session.createQueue(ACTIVEMQ_QUEUE_NAME);
    		        MessageConsumer messageConsumer = session.createConsumer(queue);
    		        messageConsumer.setMessageListener(new MessageListener() {
    		            int a = 0;
    		            @Override
    		            public void onMessage(Message message) {
    		                if (message instanceof TextMessage) {
    		                    try {
    		                        TextMessage textMessage = (TextMessage) message;
    		                        System.out.println("***消费者接收到的消息:   " + textMessage.getText());
    		                        if(a == 0){
    		                            System.out.println("commit");
    		                            session.commit();
    		                        }
    		                        if (a == 2) {
    		                            System.out.println("rollback");
    		                            session.rollback();
    		                        }
    		                        a++;
    		                    } catch (Exception e) {
    		                        System.out.println("出现异常，消费失败，放弃消费");
    		                        try {
    		                            session.rollback();
    		                        } catch (JMSException ex) {
    		                            ex.printStackTrace();
    		                        }
    		                    }
    		                }
    		            }
    		        });
    		        //关闭资源
    		        System.in.read();
    		        messageConsumer.close();
    		        session.close();
    		        connection.close();
    		    }
    		}
  

消息的签收机制

签收方式

①　自动签收（Session.AUTO_ACKNOWLEDGE）：该方式是默认的。该种方式，无需我们程序做任何操作，框架会帮我们自动签收收到的消息。
②　手动签收（Session.CLIENT_ACKNOWLEDGE）：手动签收。该种方式，需要我们手动调用Message.acknowledge()，来签收消息。如果不签收消息，该消息会被我们反复消费，只到被签收。
③　允许重复消息（Session.DUPS_OK_ACKNOWLEDGE）：多线程或多个消费者同时消费到一个消息，因为线程不安全，可能会重复消费。该种方式很少使用到。
④　事务下的签收（Session.SESSION_TRANSACTED）：开始事务的情况下，可以使用该方式。该种方式很少使用到。

事务和签收关系

• 在事务性会话中，当一个事务被成功提交则消息被自动签收。如果事务回滚，则消息会被再次传送。事务优先于签收，开始事务后，签收机制不再起任何作用。
• 非事务性会话中，消息何时被确认取决于创建会话时的应答模式。
• 生产者事务开启，只有commit后才能将全部消息变为已消费。
• 事务偏向生产者，签收偏向消费者。也就是说，生产者使用事务更好点，消费者使用签收机制更好点

JMS可靠性的保证

持久性，事务，签收机制（防止被重复性消费），高可用（MQ集群）

JMS的点对点总结

• 点对点模型是基于队列的，生产者发消息到队列，消费者从队列接收消息，队列的存在使得消息的异步传输成为可能。和我们平时给朋友发送短信类似。
• 如果在Session关闭时有部分消息己被收到但还没有被签收(acknowledged),那当消费者下次连接到相同的队列时，这些消息还会被再次接收
• 队列可以长久地保存消息直到消费者收到消息。消费者不需要因为担心消息会丢失而时刻和队列保持激活的连接状态，充分体现了异步传输模式的优势

JMS的发布订阅总结

• (1) JMS的发布订阅总结
  JMS Pub/Sub 模型定义了如何向一个内容节点发布和订阅消息，这些节点被称作topic。
  主题可以被认为是消息的传输中介，发布者（publisher）发布消息到主题，订阅者（subscribe）从主题订阅消息。
  主题使得消息订阅者和消息发布者保持互相独立不需要解除即可保证消息的传送

• (2) 非持久订阅
  非持久订阅只有当客户端处于激活状态，也就是和MQ保持连接状态才能收发到某个主题的消息。
  如果消费者处于离线状态，生产者发送的主题消息将会丢失作废，消费者永远不会收到。
  一句话：先订阅注册才能接受到发布，只给订阅者发布消息。

• (3) 持久订阅
  客户端首先向MQ注册一个自己的身份ID识别号，当这个客户端处于离线时，生产者会为这个ID保存所有发送到主题的消息，当客户再次连接到MQ的时候，会根据消费者的ID得到所有当自己处于离线时发送到主题的消息
  当持久订阅状态下，不能恢复或重新派送一个未签收的消息。
  持久订阅才能恢复或重新派送一个未签收的消息。

• (4) 非持久和持久化订阅如何选择
  当所有的消息必须被接收，则用持久化订阅。当消息丢失能够被容忍，则用非持久订阅。

Destination

Destination可以理解为数据存储的地方，分为两种：队列和主题
- 在点对点的消息传播域中，目的地被称为队列
- 在发布订阅消息传递域中，目的地被成为队列

ActiveMQ的broker

broker

相当于一个ActiveMQ服务器实例,Broker其实就是实现了用代码的形式启动ActiveMQ将MQ嵌入到Java代码中，以便随时用随时启动，在用的时候再去启动这样能节省了资源，也保证了可用性

启动broker时指定配置文件

启动broker时指定配置文件，可以帮助我们=在=一台服务器上启动多个broker==。实际工作中一般一台服务器只启动一个broker

嵌入式的broker启动

用ActiveMQ Broker作为独立的消息服务器来构建Java应用,ActiveMQ也支持在vm中通信基于嵌入的broker，能够无缝的集成其他java应用。

MQ常见面试题

• 如何保证消息可靠性