ActiveMQ的学习整理（代码实现PTP，以及Pub/Sub）

（一）由于在实习过程中需要用到ActiveMQ，在网上看了很多文章，现在整理出来以防忘记。

（二）这篇文章比较适合之前没有接触过的同学，在看下面文章的过程中，建议先学习参考链接中的知识点，然后自己再参考我的代码来实现实现PTP，以及Pub/Sub，两遍下来基本能搞定ActiveMQ的基础知识。

（三）参考链接：https://www.jianshu.com/p/b547db55d168

 

这是关于消息中间件ActiveMQ的一个系列专题文章，将涵盖JMS、ActiveMQ的初步入门及API详细使用、两种经典的消息模式（PTP and Pub/Sub）、与Spring整合、ActiveMQ集群、监控与配置优化等。

JMS

首先来说较早以前，也就是没有JMS的那个时候，很多应用系统存在一些缺陷：

1.通信的同步性：client端发起调用后，必须等待server处理完成并返回结果后才能继续执行；

2.client 和 server 的生命周期耦合太高：client进程和server服务进程都必须可用，如果server出现问题或者网络故障，那么client端会收到异常；

3.点对点通信：client端的一次调用只能发送给某一个单独的服务对象，无法一对多；

 

JMS，即Java Message Service，通过面向消息中间件（MOM：Message Oriented Middleware）的方式很好的解决了上面的问题。大致的过程是这样的：发送者把消息发送给消息服务器，消息服务器将消息存放在若干队列/主题中，在合适的时候，消息服务器会将消息转发给接受者。在这个过程中，发送和接受是异步的，也就是发送无需等待，而且发送者和接受者的生命周期也没有必然关系；在pub/sub模式下，也可以完成一对多的通信，即让一个消息有多个接受者。

 

需要注意的是，JMS只是定义了Java访问消息中间件的接口，其实就是在包javax.jms中，你会发现这个包下除了异常定义，其他都是interface。我们可以扫一眼，比如Message：

JMS只给出接口，然后由具体的中间件去实现，比如ActiveMQ就是实现了JMS的一种Provider，还有阿里巴巴的RocketMQ（后续专题中在为大家介绍）。这些消息中间件都符合JMS规范。说起规范，自然要定义一些术语：

Provider/MessageProvider：生产者

Consumer/MessageConsumer：消费者

PTP：Point To Point，点对点通信消息模型

Pub/Sub：Publish/Subscribe，发布订阅消息模型

Queue：队列，目标类型之一，和PTP结合

Topic：主题，目标类型之一，和Pub/Sub结合

ConnectionFactory：连接工厂，JMS用它创建连接

Connnection：JMS Client到JMS Provider的连接

Destination：消息目的地，由Session创建

Session：会话，由Connection创建，实质上就是发送、接受消息的一个线程，因此生产者、消费者都是Session创建的

 

PTP模式实现

PTP模式特点：

1，每个消息只有一个消费者（Consumer）(即一旦被消费，消息就不再在消息队列中) 
2，发送者和接收者之间在时间上没有依赖性，也就是说当发送者发送了消息之后，不管接收者有没有正在运行，它不会影响到消息被发送到队列 
3，接收者在成功接收消息之后需向队列应答成功

 

（一）在IntelliJ IDEA中新建project，然后再建立两个项目，以及相应的类

（二）启动ActiveMQ

双击apache-activemq-5.5.1\bin\activemq.bat运行ActiveMQ程序。启动ActiveMQ以后，登陆：http://localhost:8161/admin/（默认账号密码为admin），创建一个Queue，命名为FirstQueue。

详细过程参考：https://www.cnblogs.com/xwdreamer/archive/2012/02/21/2360818.html

 

（三）sender与receiver的代码

sender：

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;

import javax.jms.*;
import java.util.Date;

public class sender {
    private static final int SEND_NUMBER = 5;

    public static void main(String[] args) {
        // ConnectionFactory ：连接工厂，JMS 用它创建连接
        ConnectionFactory connectionFactory;
        // Connection ：JMS 客户端到JMS Provider 的连接
        Connection connection = null;
        // Session： 一个发送或接收消息的线程
        Session session;
        // Destination ：消息的目的地;消息发送给谁.
        Destination destination;
        // MessageProducer：消息发送者
        MessageProducer producer;

        // TextMessage message;
        // 构造ConnectionFactory实例对象，此处采用ActiveMq的实现jar
        connectionFactory = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER, ActiveMQConnection.DEFAULT_PASSWORD,"tcp://localhost:61616");
        try {
            // 构造从工厂得到连接对象
            connection = connectionFactory.createConnection();
            // 启动
            connection.start();
            // 获取操作连接
            session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
            // 获取session注意参数值xingbo.xu-queue是一个服务器的queue，须在在ActiveMq的console配置
            destination = session.createQueue("FirstQueue");
            // 得到消息生成者【发送者】
            producer = session.createProducer(destination);
            // 设置不持久化，此处学习，实际根据项目决定
            producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
            // 构造消息，此处写死，项目就是参数，或者方法获取
            sendMessage(session, producer);
            session.commit();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != connection) {
                    connection.close();
                }
            } catch (Throwable ignore) {
            }
        }
    }

    public static void sendMessage(Session session, MessageProducer producer) throws Exception {
        for (int i = 1; i <= SEND_NUMBER; i++) {
            Date date = new Date();
            TextMessage message = session.createTextMessage(date + "  ActiveMQ 发送的消息:" + i);
            // 发送消息到目的地方
            System.out.println("发送消息：     " + date + "  ActiveMQ 发送的消息  " + i);
            producer.send(message);
        }
    }
}

 

receiver：

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

public class receiver {
    public static void main(String[] args) {
        // ConnectionFactory ：连接工厂，JMS 用它创建连接
        ConnectionFactory connectionFactory;
        // Connection ：JMS 客户端到JMS Provider 的连接
        Connection connection = null;
        // Session： 一个发送或接收消息的线程
        Session session;
        // Destination ：消息的目的地;消息发送给谁.
        Destination destination;
        // 消费者，消息接收者
        MessageConsumer consumer;
        connectionFactory = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER, ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");
        try {
            // 构造从工厂得到连接对象
            connection = connectionFactory.createConnection();
            // 启动
            connection.start();
            // 获取操作连接
            session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);
            // 获取session注意参数值xingbo.xu-queue是一个服务器的queue，须在在ActiveMq的console配置
            destination = session.createQueue("FirstQueue");
            consumer = session.createConsumer(destination);
            while (true) {
                //设置接收者接收消息的时间，为了便于测试，这里谁定为100s
                TextMessage message = (TextMessage) consumer.receive(100000);
                if (null != message) {
                    System.out.println("收到消息:" + message.getText());
                } else {
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != connection){
                    connection.close();
                }
            } catch (Throwable ignore) {
            }
        }
    }
}

 

（四）调试效果

 

 

 

Pub/Sub模式

Pub/Sub模式特点 

1，每个消息可以有多个消费者 
2，发布者和订阅者之间有时间上的依赖性。针对某个主题（Topic）的订阅者，它必须创建一个订阅者之后，才能消费发布者的消息，而且为了消费消息，订阅者必须保持运行的状态。 
3，为了缓和这样严格的时间相关性，JMS允许订阅者创建一个可持久化的订阅。这样，即使订阅者没有被激活（运行），它也能接收到发布者的消息。

 （一）新建项目

（二）show the code

TopicProducer：

package pub_sub;

import org.apache.activemq.*;
import javax.jms.*;
import java.util.Date;

public class TopicProducer {
    private static final int SEND_NUMBER = 5;
    public static void main(String[] args) {
        // ConnectionFactory ：连接工厂，JMS 用它创建连接
        ConnectionFactory connectionFactory;
        // Connection ：JMS 客户端到JMS Provider 的连接
        Connection connection = null;
        // Session： 一个发送或接收消息的线程
        Session session;
        // Destination ：消息的目的地;消息发送给谁.
        Destination destination;
        // MessageProducer：消息发送者
        MessageProducer producer;
        // TextMessage message;
        // 构造ConnectionFactory实例对象，此处采用ActiveMq的实现jar
        connectionFactory = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER, ActiveMQConnection.DEFAULT_PASSWORD,"tcp://localhost:61616");

        try {
            // 构造从工厂得到连接对象
            connection = connectionFactory.createConnection();
            // 启动
            connection.start();
            // 获取操作连接
            session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);

            // 获取session注意参数值是一个服务器的Topic，须在在ActiveMq的console配置
            destination = session.createTopic("FirstTopic");
            producer = session.createProducer(destination);
            // 设置不持久化，此处学习，实际根据项目决定
            producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
            // 构造消息，此处写死，项目就是参数，或者方法获取
            sendMessage(session, producer);
            session.commit();

        } catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            try {
                if (null != connection) {
                    connection.close();
                }
            } catch (Throwable ignore) {
            }
        }
    }

    public static void sendMessage(Session session, MessageProducer producer) throws Exception {
        for (int i = 1; i <= SEND_NUMBER; i++) {
            Date date = new Date();
            TextMessage message = session.createTextMessage(date + "  ActiveMQ 发送的消息:" + i);
            // 发送消息到目的地方
            System.out.println("发送消息：     " + date + "  ActiveMQ 发送的消息  " + i);
            producer.send(message);
        }
    }
}

TopicConsumer：

package receiver;

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

public class TopicConsumer{

    public static void main(String[] args) {
        // ConnectionFactory ：连接工厂，JMS 用它创建连接
        ConnectionFactory connectionFactory;
        // Connection ：JMS 客户端到JMS Provider 的连接
        Connection connection = null;
        // Session： 一个发送或接收消息的线程
        Session session;
        // Destination ：消息的目的地;消息发送给谁.
        Destination destination;
        // 消费者，消息接收者
        MessageConsumer consumer;
        connectionFactory = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER, ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");

        try {
            // 构造从工厂得到连接对象
            connection = connectionFactory.createConnection();
            // 启动
            connection.start();
            // 获取操作连接
            session = connection.createSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);
            // 获取session注意参数值是一个服务器的Topic，须在在ActiveMq的console配置
            destination = session.createTopic("FirstTopic");
            consumer = session.createConsumer(destination);
//            while (true) {
//                //设置接收者接收消息的时间，为了便于测试，这里谁定为100s
//                TextMessage message = (TextMessage) consumer.receive(100000);
//                if (null != message) {
//                    System.out.println("收到消息:" + message.getText());
//                } else {
//                    break;
//                }
//            }
            while(true){
                consumer.setMessageListener(new listern());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            try {
                if (null != connection){
                    connection.close();
                }
            } catch (JMSException e) {
                e.printStackTrace();
            }
        }
    }
}

listern:

package receiver;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

public class listern implements MessageListener {
    @Override
    public void onMessage(Message message) {
        try {
            System.out.println("收到的消息:"+((TextMessage)message).getText());
        } catch (JMSException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

 

（三）注意事项

1. 运行代码的时候要先运行订阅者代码，然后运行发布者代码。

2. Consumer中注释代码为不添加Listern的实现。