activeMQ零基础入门

一：activeMQ概述

http://www.cnblogs.com/hoojo/p/active_mq_jms_apache_activeMQ.html
大概意思就是它是Apache下的一个消息系统，有自己的消息发送端和消息接收端，可以简单整合当前较流行的技术，如spring，ajax等

二：下载运行

去官方网站下载： http://activemq.apache.org/

运行： 解压，双击apache-activemq-5.14.5\bin\win64\activemq.bat运行ActiveMQ程序

apache-activemq-5.14.5\conf\jettty.xml配置服务器端口（8161）

tcp访问端口默认61616，apache-activemq-5.14.5\conf\activemq.xml 配置文件里修改该端口

三：通讯方式：

activeMQ有三种通讯方式：p2p（点对点）,publish-subscribe(发布/订阅模式)，request-response(请求响应模式)

前两种是遵守jms规范做的，而后者不是，jms规范如下：

开发运行环境：（这只是我当时用的环境，jdk1.8和activeMQ5.14.5没问题，其他环境你们可以试试）

System：Windows

JDK：1.8

IDE：eclipse

apache ActiveMQ 5.14.5

看代码：

1.queue（点对点方式）
发送端：
 package com.queue;

import javax.jms.MapMessage;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.Session;

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

public class Sender {

    private static final int SEND_NUM = 5;
    private static final String QUEUE_URL="tcp://localhost:61616";

    public static void main(String[] args) throws Exception {
        run();
    }

    private static void send(QueueSession session, QueueSender destination) throws Exception {
        for (int i = 0; i < SEND_NUM; i++) {
            
            StringBuilder message = new StringBuilder().append("发送队列消息第").append(i + 1).append("条");
            MapMessage mapMessage = session.createMapMessage();
            mapMessage.setString("text", message.toString());
            mapMessage.setLong("time", System.currentTimeMillis());
            // 发送消息
            destination.send(mapMessage);
            System.out.println(message);
        }
    }

    private static void run() throws Exception {
        // 消息队列连接
        QueueConnection connection = null;
        // 消息回话
        QueueSession session = null;
        QueueSender sender = null;
        try {
            // 消息队列连接工厂初始化，参数：默认用户名和密码：admin，admin 访问地址
            QueueConnectionFactory connectionFactory = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER,
                    ActiveMQConnection.DEFAULT_PASSWORD, QUEUE_URL);
            // 消息队列连接工厂创建一个连接
            connection = connectionFactory.createQueueConnection();
            connection.start();
            // 消息队列连接创建会话，connection.createQueueSession(paramA,paramB)
            // paramA表示是否支持事务 paramB 取值，Session.AUTO_ACKNOWLEDGE为自动确认，客户端发送和接收消息时自动确认是否接收
            session = connection.createQueueSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
            // 创建一个HelloWorld消息队列，消息队列命名
            Queue queue = session.createQueue("HelloWorld");
            sender = session.createSender(queue);
            send(session, sender);
            session.commit();
        } catch (Exception e) {
            throw e;
        } finally {
            if (session != null) {
                session.close();
            }
            if (connection != null) {
                connection.close();
            }
            if (sender != null) {
                sender.close();
            }
        }
    }
}
接收端：
package com.queue;

import javax.jms.JMSException;
import javax.jms.MapMessage;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueReceiver;
import javax.jms.QueueSession;
import javax.jms.Session;

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

public class Receiver implements Runnable{
    private static final String QUEUE_URL = "tcp://localhost:61616";

    public static void main(String[] args) throws Exception {
        Receiver receiver1 = new Receiver("thread1");
        Receiver receiver2 = new Receiver("thread2");
        Receiver receiver3 = new Receiver("thread3");
        Thread t1 = new Thread(receiver1);
        Thread t2 = new Thread(receiver2);
        Thread t3 = new Thread(receiver3);
        t1.start();
        t2.start();
        t3.start();
    }

    private String ThreadName;
    public Receiver(String ThreadName){
        this.ThreadName = ThreadName;
    }
    private void receive(QueueReceiver receiver, QueueSession session) throws Exception {
        receiver.setMessageListener(new MessageListener() {
            public void onMessage(Message msg) {
                if (msg != null) {
                    MapMessage map = (MapMessage) msg;
                    try {
                        System.out.println("线程"+ThreadName +"  :  "+map.getLong("time") + "接收:" + map.getString("text"));
                    } catch (JMSException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        // 休眠100ms再关闭
        Thread.sleep(1000 * 100);
        // 提交会话
        session.commit();
    }

    @Override
    public void run(){
        QueueConnection connection = null;
        QueueSession session = null;
        QueueReceiver receiver = null;
        try {
            QueueConnectionFactory connectionFactory = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER,
                    ActiveMQConnection.DEFAULT_PASSWORD, QUEUE_URL);
            connection = connectionFactory.createQueueConnection();
            connection.start();
            session = connection.createQueueSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
            Queue queue = session.createQueue("HelloWorld");
            receiver = session.createReceiver(queue);
            receive(receiver, session);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (session != null) {
                    session.close();
                }
                if (connection != null) {
                    connection.close();
                }
                if (receiver != null) {
                    receiver.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
    }
}

注意：

1.发送端发送消息时，接收端不需要处于启动状态，当接收端启动时，自动接收发送端的消息

2.一条发送消息只会对应一个接收端

2.topic方式（发布/订阅方式）
发送端：
package com.topic;

import javax.jms.MapMessage;
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 org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;

public class Publisher {
    public static void main(String[] args) throws Exception{
        run();
    }

    private static void run() throws Exception{
        TopicConnection connection = null;
        TopicSession session = null;
        TopicPublisher publisher = null;
        try {
            TopicConnectionFactory connectionFactory = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER,
                    ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");
            connection = connectionFactory.createTopicConnection();
            connection.start();
            session = connection.createTopicSession(Boolean.FALSE, Session.AUTO_ACKNOWLEDGE);
            Topic topic = session.createTopic("chy");
            publisher = session.createPublisher(topic);
            sendMessage(session,publisher);
            session.commit();
        } catch (Exception e) {
            throw e;
        }finally {
            if(session != null){
                session.close();
            }
            if(connection != null){
                connection.close();
            }
            if(publisher != null){
                publisher.close();
            }
        }
    }
    private static void sendMessage(TopicSession session ,TopicPublisher publisher) throws Exception{
        for(int i=0;i<5;i++){
            StringBuilder message = new StringBuilder().append("发送队列消息第").append(i + 1).append("条");
            MapMessage mapMessage = session.createMapMessage();
            mapMessage.setString("text", message.toString());
            mapMessage.setLong("time", System.currentTimeMillis());
            publisher.send(mapMessage);
        }
    }
}

接收端：
package com.topic;

import javax.jms.JMSException;
import javax.jms.MapMessage;
import javax.jms.Message;
import javax.jms.MessageListener;
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 org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;

//启动三个线程，每个线程都接收5条发送消息
public class Receiver implements Runnable{
    public static void main(String[] args) throws Exception {
        Receiver receiver1 = new Receiver("thread1");
        Receiver receiver2 = new Receiver("thread2");
        Receiver receiver3 = new Receiver("thread3");
        Thread t1 = new Thread(receiver1);
        Thread t2 = new Thread(receiver2);
        Thread t3 = new Thread(receiver3);
        t1.start();
        t2.start();
        t3.start();
    }

    private String ThreadName;
    public Receiver(String ThreadName){
        this.ThreadName = ThreadName;
    }
    @Override
    public void run(){
        TopicConnection connection = null;
        TopicSession session = null;
        TopicSubscriber subscriber = null;
        try {
            TopicConnectionFactory connectionFactory = new ActiveMQConnectionFactory(ActiveMQConnection.DEFAULT_USER,
                    ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");
            connection = connectionFactory.createTopicConnection();
            connection.start();
            session = connection.createTopicSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);
            Topic topic = session.createTopic("chy");
            subscriber = session.createSubscriber(topic);
            subscriber.setMessageListener(new MessageListener() {

                @Override
                public void onMessage(Message message) {
                    if (message != null) {
                        MapMessage mapMessage = (MapMessage) message;
                        try {
                            System.out.println("线程"+ThreadName +"  :  "+mapMessage.getLong("time") + " 接收：" + mapMessage.getString("text"));
                        } catch (JMSException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
            Thread.sleep(1000 * 20);
            session.commit();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (session != null) {
                    session.close();
                }
                if (connection != null) {
                    connection.close();
                }
                if (subscriber != null) {
                    subscriber.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
            
        }
    }
}

注意：

1.发送端发送消息时，接收端必须启动，否则接收不到数据

2.接收端可以有多个，且每个接收端都能接收到所有发送消息

3.request-response(请求响应模式)：

参考： http://greemranqq.iteye.com/blog/2194051#comments
这种模式我没有很深入的了解过，网上资料也很少，我照着这个例子做了一个简单的请求响应

实际应用场景：

模拟两台机器上测试，开启两个eclipse进行测试数据的交互（这里不好讲，有问题可以问我）

扩展（这是我开始学习activeMQ时参考的一些资料）：

queue和topic在ActiveMQ里面的实现和对比，可以参考： http://blog.youkuaiyun.com/studyforir/article/details/48340619

想学习更多消息队列（RabbitMQ和Kafka）：http://www.cnblogs.com/charlesblc/p/6045238.html

有完整queue和topic对比的代码可以看这里 http://blog.youkuaiyun.com/zmx729618/article/details/51082844

activeMQ整合spring： http://blog.youkuaiyun.com/jiuqiyuliang/article/details/48758203

入门学习参考： http://www.cnblogs.com/xwdreamer/archive/2012/02/21/2360818.html