ActiveMQ的学习

1. ActiveMQ简介

(1) 什么是ActiveMQ？
ActiveMQ 是 Apache 出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个 完全支持 JMS1.1 和 J2EE 1.4 规范的 JMS Provider 实现，尽管 JMS 规范出台已经是很久 的事情了，但是 JMS 在当今的 J2EE 应用中间仍然扮演着特殊的地位
(2) 什么是消息？
“消息”是在两台计算机间传送的数据单位。消息可以非常简单，例如只包含文本字符串； 也可以更复杂，可能包含嵌入对象
(3) 什么是队列？
队列有先进先出的特点
(4) 什么是消息队列？
“消息队列”是在消息的传输过程中保存消息的容器
(5) 常见的消息服务有哪些？
1 ActiveMQ
ActiveMQ 是 Apache 出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完 全支持 JMS1.1 和 J2EE 1.4 规范的 JMS Provider 实现。
2 RabbitMQ
RabbitMQ 是一个在 AMQP 基础上完成的，可复用的企业消息系统。他遵循 Mozilla Public License 开源协议。开发语言为 Erlang。
3 RocketMQ
由阿里巴巴定义开发的一套消息队列应用服务

2. 消息服务应用场景

(1) 消息服务可应用于哪些场景？
消息队列的主要特点是异步处理，主要目的是减少请求响应时间和解耦。所以主要的使 用场景就是将比较耗时而且不需要即时（同步）返回结果的操作作为消息放入消息队列。同 时由于使用了消息队列，只要保证消息格式不变，消息的发送方和接收方并不需要彼此联系， 也不需要受对方的影响，即解耦和
(2) 如何将Solr集群中的索引库分为两片？
执行命令
http://192.168.70.147:8080/solr/admin/collections?action=CREATE&name=collec tion2&numShards=2&replicationFactor=2

3. JMS消息模型介绍

(1) 什么是JMS？
JMS（Java Messaging Service）是 Java 平台上有关面向消息中间件的技术规范，它便于消息系统中的 Java 应用程序进行消息交换,并且通过提供标准的产生、发送、接收消息的接口，简化企业应用的开发
(2) JMS中有哪些消息模型？
1 点对点模型(Point To Point)
生产者发送一条消息到 queue，只有一个消费者能收到。
2 发布订阅模型(Publish/Subscribe)
发布者发送到 topic 的消息，只有订阅了 topic 的订阅者才会收到消息

4. 安装ActiveMQ

(1) 如何安装ActiveMQ？
1 下载资源
ActiveMQ 官网： http://activemq.apache.org
2 上传至 Linux 服务器
3 解压安装文件
tar -zxf apache-activemq-5.9.0-bin.tar.gz
4 检查权限
ls -al apache-activemq-5.9.0/bin 如果权限不足,则无法执行,需要修改文件权限: chmod 755 activemq
5 复制应用至本地目录
cp -r apache-activemq-5.9.0 /usr/local/activemq
6 启动 ActiveMQ
/usr/local/activemq/bin/activemq start

5. ActiveMQ目录介绍

(1) ActiveMQ有哪些目录？没给目录的作用是什么？

6. ActiveMQ中的术语

(1) Destination是什么含义？
目的地，JMS Provider（消息中间件）负责维护，用于对 Message 进行管理的对象。 MessageProducer 需要指定 Destination 才能发送消息，MessageReceiver 需要指定 Destination 才能接收消息
(2) Producer是什么含义？
消息生成者，负责发送 Message 到目的地
(3) Consumer | Receiver是什么含义？
消息消费者，负责从目的地中消费【处理|监听|订阅】Message
(4) Message是什么含义？
消息，消息封装一次通信的内容

7. ActiveMQ中的常用API

(1) ConnectionFactory的作用是什么？
链接工厂, 用于创建链接的工厂类型.
(2) Connection的作用是什么？
链接. 用于建立访问 ActiveMQ 连接的类型, 由链接工厂创建.
(3) Session的作用是什么？
会话, 一次持久有效有状态的访问. 由链接创建.
(4) Destination & Queue的作用是什么？
目的地, 用于描述本次访问 ActiveMQ 的消息访问目的地. 即 ActiveMQ 服务中的具体队 列. 由会话创建. interface Queue extends Destination
(5) MessageProducer的作用是什么？
消息生成者, 在一次有效会话中, 用于发送消息给 ActiveMQ 服务的工具. 由会话创建.
(6) MessageConsumer的作用是什么？
消息消费者【消息订阅者，消息处理者】, 在一次有效会话中, 用于从 ActiveMQ 服务中获取消息的工具. 由会话创建.
(7) Message的作用是什么？
消息,通过消息生成者向 ActiveMQ 服务发送消息时使用的数据载体对象或消息消费者 从 ActiveMQ 服务中获取消息时使用的数据载体对象. 是所有消息【文本消息，对象消息等】 具体类型的顶级接口. 可以通过会话创建或通过会话从 ActiveMQ 服务中获取

8. ActiveMQ处理文本消息-创建消息生产者

(1) 如何创建消息生产者？

public class ProducerMessage {
    //生成消息
    public void pMessage(String messageText){
        //声明连接工厂对象
        ConnectionFactory factory = null;
        //声明连接对象
        Connection connection = null;
        //声明会话对象
        Session session = null;
        //声明目的地对象
        Destination destination = null;
        //声明消息发送者对象
        MessageProducer producer = null;
        //声明消息对象
        Message message = null;
        try{
            //创建连接工厂对象
            factory = new ActiveMQConnectionFactory("admin","admin","tcp://192.168.56.133:61616");
            //创建连接对象
            connection = factory.createConnection();
            //启动连接
            connection.start();
            /**
             * transacted:是否使用事务 可选值为：true|false
             *            true:使用事务 当设置次变量值。Session.SESSION_TRANSACTED
             *            false:不适用事务,设置次变量 则acknowledgeMode参数必须设置
             * acknowledgeMode:
             * Session.AUTO_ACKNOWLEDGE:自动消息确认机制
             * Session.CLIENT_ACKNOWLEDGE:客户端确认机制
             * Session.DUPS_OK_ACKNOWLEDGE:有副本的客户端确认消息机制
             */
            //创建会话对象
            session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
            //创建目的地对象
            destination = session.createQueue("HelloWorld-Destination");
            //创建消息生产者对象
            producer = session.createProducer(destination);
            //创建消息对象
            message = session.createTextMessage(messageText);
            //发送消息
            producer.send(message);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭资源
            if(producer!=null){
                try {
                    producer.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
            if(session!=null){
                try {
                    session.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

9. ActiveMQ处理文本消息-创建消息消费者

(1) 如何创建消息消费者？

public class ConsumerMessage {
    //接收消息
    public void cMessage(){
        //声明连接工厂对象
        ConnectionFactory factory = null;
        //声明连接对象
        Connection connection  = null;
        //声明会话对象
        Session session = null;
        //声明目的地对象
        Destination destination = null;
        //声明消费者对象
        MessageConsumer consumer = null;
        //声明消息对象
        Message message = null;
        try{
            //创建连接工厂对象
            factory = new ActiveMQConnectionFactory("admin","admin","tcp://192.168.56.133:61616");
            //创建连接对象
            connection = factory.createConnection();
            //启动连接
            connection.start();
            //创建会话对象
            session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
            //创建目的地对象
            destination = session.createQueue("HelloWorld-Destination");
            //创建消费者对象
            consumer = session.createConsumer(destination);
            //接受消息
            message = consumer.receive();
            //处理消息
            String mes = ((TextMessage)message).getText();
            System.out.println("接受到的消息为："+mes);

        }catch (Exception e){
            e.printStackTrace();
        }finally{
            //关闭资源对象
            if(consumer!=null){
                try {
                    consumer.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
            if(session!=null){
                try {
                    session.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

10. ActiveMQ处理对象消息

(1) 如何处理消息对象？

生产者：
public class ProducerMessage2 {
    //生成对象消息
    public void pMessage(User user){
        //声明连接工厂对象
        ConnectionFactory factory = null;
        //声明连接对象
        Connection connection = null;
        //声明会话对象
        Session session = null;
        //声明目的地对象
        Destination destination = null;
        //声明消息发送者对象
        MessageProducer producer = null;
        //声明消息对象
        Message message = null;
        try{
            //创建连接工厂对象
            factory = new ActiveMQConnectionFactory("admin","admin","tcp://192.168.56.133:61616");
            //创建连接对象
            connection = factory.createConnection();
            //启动连接
            connection.start();
            /**
             * transacted:是否使用事务 可选值为：true|false
             *            true:使用事务 当设置次变量值。Session.SESSION_TRANSACTED
             *            false:不适用事务,设置次变量 则acknowledgeMode参数必须设置
             * acknowledgeMode:
             * Session.AUTO_ACKNOWLEDGE:自动消息确认机制
             * Session.CLIENT_ACKNOWLEDGE:客户端确认机制
             * Session.DUPS_OK_ACKNOWLEDGE:有副本的客户端确认消息机制
             */
            //创建会话对象
            session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
            //创建目的地对象
            destination = session.createQueue("User-Destination");
            //创建消息生产者对象
            producer = session.createProducer(destination);
            //创建消息对象
            message = session.createObjectMessage(user);
            //发送消息
            producer.send(message);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭资源
            if(producer!=null){
                try {
                    producer.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
            if(session!=null){
                try {
                    session.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
消费者：
public class ConsumerMessage2 {
    //接收对象消息
    public void cMessage(){
        //声明连接工厂对象
        ConnectionFactory factory = null;
        //声明连接对象
        Connection connection  = null;
        //声明会话对象
        Session session = null;
        //声明目的地对象
        Destination destination = null;
        //声明消费者对象
        MessageConsumer consumer = null;
        //声明消息对象
        Message message = null;
        try{
            //创建连接工厂对象
            factory = new ActiveMQConnectionFactory("admin","admin","tcp://192.168.56.133:61616");
            //创建连接对象
            connection = factory.createConnection();
            //启动连接
            connection.start();
            //创建会话对象
            session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
            //创建目的地对象
            destination = session.createQueue("User-Destination");
            //创建消费者对象
            consumer = session.createConsumer(destination);
            //接受消息
            message = consumer.receive();
            //处理消息
            /*User user = (User) ((ObjectMessage)message).getObject();*/
            ObjectMessage obj = (ObjectMessage)message;
            User user = (User) obj.getObject();
            System.out.println("接受到的消息为："+user);

        }catch (Exception e){
            e.printStackTrace();
        }finally{
            //关闭资源对象
            if(consumer!=null){
                try {
                    consumer.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
            if(session!=null){
                try {
                    session.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

11. ActiveMQ实现队列服务监听处理消息

(1) ActiveMQ实现队列服务监听处理消息

生产者：
public class ProducerMessage3 {
    //生成消息
    public void pMessage(String messageText){
        //声明连接工厂对象
        ConnectionFactory factory = null;
        //声明连接对象
        Connection connection = null;
        //声明会话对象
        Session session = null;
        //声明目的地对象
        Destination destination = null;
        //声明消息发送者对象
        MessageProducer producer = null;
        //声明消息对象
        Message message = null;
        try{
            //创建连接工厂对象
            factory = new ActiveMQConnectionFactory("admin","admin","tcp://192.168.56.133:61616");
            //创建连接对象
            connection = factory.createConnection();
            //启动连接
            connection.start();
            /**
             * transacted:是否使用事务 可选值为：true|false
             *            true:使用事务 当设置次变量值。Session.SESSION_TRANSACTED
             *            false:不适用事务,设置次变量 则acknowledgeMode参数必须设置
             * acknowledgeMode:
             * Session.AUTO_ACKNOWLEDGE:自动消息确认机制
             * Session.CLIENT_ACKNOWLEDGE:客户端确认机制
             * Session.DUPS_OK_ACKNOWLEDGE:有副本的客户端确认消息机制
             */
            //创建会话对象
            session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
            //创建目的地对象
            destination = session.createQueue("my-Destination");
            //创建消息生产者对象
            producer = session.createProducer(destination);
            //创建消息对象
            message = session.createTextMessage(messageText);
            //发送消息
            producer.send(message);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //关闭资源
            if(producer!=null){
                try {
                    producer.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
            if(session!=null){
                try {
                    session.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
消费者：
public class ConsumerMessage3 {
    //接收消息
    public void cMessage(){
        //声明连接工厂对象
        ConnectionFactory factory = null;
        //声明连接对象
        Connection connection  = null;
        //声明会话对象
        Session session = null;
        //声明目的地对象
        Destination destination = null;
        //声明消费者对象
        MessageConsumer consumer = null;
        //声明消息对象
        Message message = null;
        try{
            //创建连接工厂对象
            factory = new ActiveMQConnectionFactory("admin","admin","tcp://192.168.56.133:61616");
            //创建连接对象
            connection = factory.createConnection();
            //启动连接
            connection.start();
            //创建会话对象
            session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
            //创建目的地对象
            destination = session.createQueue("my-Destination");
            //创建消费者对象
            consumer = session.createConsumer(destination);
            //接受消息
            consumer.setMessageListener(new MessageListener() {
                @Override
                public void onMessage(Message message) {
                    //处理消息
                    String mes = null;
                    try {
                        mes = ((TextMessage)message).getText();
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                    System.out.println("接受到的消息为："+mes);
                }
            });
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

12. Topic模型的使用

(1) 什么是Topic模型？
消息生产者（发布）将消息发布到 topic 中，同时有多个消息消费者（订阅）消费该消息。和点对点方式不同，发布到 topic 的消息会被所有订阅者消费。 当生产者发布消息，不管是否有消费者。都不会保存消息 一定要先有消息的消费者，后有消息的生产者