ActiveMQ学习文档

消息的传递在我们的日常生活中至关重要，如老板说了一条要涨工资的消息，然后你就高兴的屁颠屁颠的，在计算机中也存在消息，消息的传递类型和生活中的大致差不多，大致可分为如下三种：

p2p（person-person）一对一且无响应

A发送消息，B接收消息，且B对A不做回应

比如打LOL，A对B说，B你去下路带兵线，然后B就去了，B清完也没告诉A，A屏幕坏了也看不到B的情况……

p2s(publish-subscribe) 一对多且无响应

A发送消息给B、C、D，且B、C、D均不做回应

又比如打LOL，A猛点大龙区域，然后B、C、D就去打大龙了，然后A的屏幕又坏了……

r2r(request-repones) 一来一回响应模式

A发送消息给B，B接收到消息并响应

再比如打LOL，A跟B说：走，我们去拿一血，B告诉A说：别去，他们可能就躲在草丛呢

一下是我理解的工作原理图

今天我们主要讲一下ActivMQ，小编也是刚学习，肯定有很多不对的地方，希望大神能够指正，希望学习者酌情接受。

在讨论具体方式的时候，我们先看看使用activemq需要启动服务的主要过程。

    按照JMS的规范，我们首先需要获得一个JMS connection factory.，通过这个connection factory来创建connection.在这个基础之上我们再创建session, destination, producer和consumer。因此主要的几个步骤如下：

1. 获得JMS connection factory. 通过我们提供特定环境的连接信息来构造factory。

2. 利用factory构造JMS connection

3. 启动connection

4. 通过connection创建JMSsession.

5. 指定JMS destination.

6. 创建JMS producer或者创建JMSmessage并提供destination.

7. 创建JMS consumer或注册JMSmessage listener.

8. 发送和接收JMS message.

9. 关闭所有JMS资源，包括connection, session, producer,consumer等。

 

流程我们明白了，那么下面我们就直接上代码了

 

JMSUtils.java

package com.hackerant.util;

import java.util.ArrayList;
import java.util.UUID;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TemporaryQueue;
import javax.jms.TextMessage;
import javax.jms.Topic;

import org.apache.activemq.ActiveMQConnectionFactory;

public class JMSUtils {

	/**
	 * 建立连接
	 * 
	 * @param userName
	 * @param password
	 * @param brokerURL
	 * @return
	 * @throws Exception
	 */
	public static Connection getConnect(String userName, String password,
			String brokerURL) throws Exception {
		ConnectionFactory connFactory = new ActiveMQConnectionFactory(userName,
				password, brokerURL);
		Connection connection = connFactory.createConnection();
		// 启动
		connection.start();
		// 获取操作连接
		return connection;
	}

	/**
	 * 一对一模式发送消息
	 * 
	 * @param connection
	 * @param queueName
	 * @param messages
	 * @throws Exception
	 */
	public static void p2pSendMessage(Connection connection, String queueName,
			ArrayList<String> messages) throws Exception {
		// 建立session连接
		Session session = connection.createSession(Boolean.TRUE,
				Session.AUTO_ACKNOWLEDGE);
		// 设置队列名称
		Destination destination = session.createQueue(queueName);
		MessageProducer producer = session.createProducer(destination);
		producer.setDeliveryMode(DeliveryMode.PERSISTENT);
		// 发送消息
		System.out.println("*****p2p发送消息开始********");
		for (int i = 0; i < messages.size(); i++) {
			String messTextString = messages.get(i);
			System.out.println(messTextString);
			TextMessage message = session.createTextMessage(messTextString);
			producer.send(message);
		}
		System.out.println("*****p2p发送消息结束********");
		// 提交
		session.commit();
	}

	/**
	 * 一对一模式接收消息
	 * 
	 * @param connection
	 * @param queueName
	 * @param maxNum
	 * @return
	 * @throws Exception
	 */
	public static void p2pReceMessage(Connection connection, String queueName,
			int maxNum) throws Exception {
		// 建立session连接
		Session session = connection.createSession(Boolean.FALSE,
				Session.AUTO_ACKNOWLEDGE);
		// 设置队列名称
		Destination destination = session.createQueue(queueName);
		MessageConsumer consumer = session.createConsumer(destination);
		// 接收消息
		System.out.println("*****p2p接收消息开始********");
		for (int i = 0; i < maxNum; i++) {
			TextMessage message = (TextMessage) consumer.receive(500);
			if (message == null) {
				break;
			} else {
				System.out.println(message.getText());
			}
		}
		System.out.println("*****p2p接收消息结束********");
	}

	/**
	 * 发布订阅模式发送消息
	 * 
	 * @param connection
	 * @param messages
	 * @throws Exception
	 */
	public static void p2sSendMessage(Connection connection,String topicName,
			ArrayList<String> messages) throws Exception {
		// 建立session连接
		Session session = connection.createSession(Boolean.TRUE,
				Session.AUTO_ACKNOWLEDGE);
		// 注意：此处变成了createTopic
		Topic topic = session.createTopic(topicName);

		MessageProducer producer = session.createProducer(topic);
		producer.setDeliveryMode(DeliveryMode.PERSISTENT);
		// 发送消息
		System.out.println("*****p2s发送消息开始********");
		for (int i = 0; i < messages.size(); i++) {
			String messText = messages.get(i);
			System.out.println(messText);
			TextMessage message = session.createTextMessage(messText);
			producer.send(topic, message);
		}
		System.out.println("*****p2s发送消息结束********");
		// 提交
		session.commit();
	}

	/**
	 * 发布订阅模式接收消息
	 * 
	 * @param connection
	 * @param queueName
	 * @param maxNum
	 * @throws Exception
	 */
	public static void p2sReceMessage(Connection connection, final int maxNum,String topicName)
			throws Exception {
		// 建立session连接
		Session session = connection.createSession(Boolean.TRUE,
                Session.AUTO_ACKNOWLEDGE);
        
        Topic topic = session.createTopic(topicName);
        
        final MessageConsumer consumer = session.createConsumer(topic);
        
       consumer.setMessageListener(new MessageListener() {
		
		@Override
		public void onMessage(Message message) {
			// 接收消息
			System.out.println("*****p2s接收消息开始********");
			 TextMessage tm = (TextMessage)message;
             try {
                 System.out.println(tm.getText());
             } catch (JMSException e) {
                 e.printStackTrace();
             }
             System.out.println("*****p2s接收消息结束********");
		}
	});
	}
	
	/**
	 * 应答模式发送消息
	 * @param connection
	 * @param queueName
	 * @param messages
	 * @throws Exception
	 */
	public static void r2rSendMessage(Connection connection, String queueName,
			ArrayList<String> messages) throws Exception {
		// 建立session连接
		Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Destination destination = session.createQueue(queueName);

        TemporaryQueue temporaryQueue = session.createTemporaryQueue();

        MessageProducer producer = session.createProducer(destination);
        producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
        MessageConsumer consumer = session.createConsumer(temporaryQueue);
        consumer.setMessageListener(new MessageListener() {
			//相应消息
			@Override
			public void onMessage(Message arg0) {
				try {
	                if (arg0 instanceof TextMessage) {
	                    String messageText = ((TextMessage) arg0).getText();
	                    System.out.println("我是A，我接收到B的消息是：" + messageText.toUpperCase());
	                }
	            } catch (JMSException e) {
	                e.printStackTrace();
	            }
				
			}
		});
        //发送消息
        for (int i = 0; i < messages.size(); i++) {
            System.out.println("我是A，我发送的消息是: " + messages.get(i));

            TextMessage textMessage = session.createTextMessage();
            textMessage.setText(messages.get(i));

            textMessage.setJMSReplyTo(temporaryQueue);

            textMessage.setJMSCorrelationID(UUID.randomUUID().toString());

           producer.send(textMessage);
		}
	}

	/**
	 * 应答模式接收消息
	 * @param connection
	 * @param maxNum
	 * @param topicName
	 * @throws Exception
	 */
	public static void r2rReceMessage(Connection connection, final int maxNum,String topicName)
			throws Exception {
		
		// 建立session连接
		final Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Destination destination = session.createQueue(topicName);
        final MessageProducer producer = session.createProducer(null);
        producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

        MessageConsumer consumer = session.createConsumer(destination);
        consumer.setMessageListener(new MessageListener() {
			//相应消息
			@Override
			public void onMessage(Message message) {
				try {
	                TextMessage response = session.createTextMessage();
	                if (message instanceof TextMessage) {
	                    String messageText = ((TextMessage) message).getText();
	                    response.setText("我是B，接收到A的消息并转发出去： " + messageText);
	                    System.out.println("我是B，我收到的消息是：" + messageText.toUpperCase());
	                }
	                response.setJMSCorrelationID(message.getJMSCorrelationID());
	                //将接到的消息发出去,
	                producer.send(message.getJMSReplyTo(), response);
	            } catch (JMSException e) {
	                e.printStackTrace();
	            }
				
			}
		});
        
       
	}
	
	/**
	 * 关闭连接
	 * 
	 * @param connection
	 */
	public static void closeConnection(Connection connection) {
		try {
			if (connection != null) {
				connection.close();
			}
		} catch (JMSException e) {
			e.printStackTrace();
		}
	}

}

TestMQ.java

package com.hackerant.activemq;

import java.util.ArrayList;

import javax.jms.Connection;

import com.hackerant.util.JMSUtils;

public class TestMQ {

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

		ArrayList<String> mesList = new ArrayList<String>();
		for (int i = 0; i < 5; i++) {
			mesList.add("我是消息" + i);
		}
		
		String userName = "admin";
		String userPwd = "admin";
		String mqUrl = "tcp://localhost:61616";
		String queueName = "FirstQueue";
		String topicName = "MessageTopic";
		String replyName = "Reply";
		Connection connection = JMSUtils.getConnect(userName, userPwd, mqUrl);
		
//		//测试p2p
//		JMSUtils.p2pSendMessage(connection, queueName, mesList);
//		
//		JMSUtils.p2pReceMessage(connection, queueName, mesList.size());
		
		//测试p2s，服务器先开启
		JMSUtils.p2sReceMessage(connection, mesList.size(), topicName);
		
		JMSUtils.p2sSendMessage(connection, topicName, mesList);
		
//		JMSUtils.r2rReceMessage(connection, mesList.size(), replyName);
//		
//		JMSUtils.r2rSendMessage(connection, replyName, mesList);
		
		
//		JMSUtils.closeConnection(connection);
		
	}

}

代码中含注释和注意事项，就不再赘述了，下面是运行结果图