ActiveMQ笔记之点对点队列（Point-to-Point）
1. 点对点通信
点对点是一种一对一通信方式，更像是有一个队列，一个人往队列里放消息，另一个人从队列中取消息，其最大的特点是一个消息只会被消费一次，即使有多个消费者同时消费，他们消费的也是不同的消息。
2. 简单实现
添加依赖
添加Maven依赖：
<!-- https://mvnrepository.com/artifact/org.apache.activemq/activemq-all --> <dependency> <groupId>org.apache.activemq</groupId> <artifactId>activemq-all</artifactId> <version>5.15.2</version> </dependency>
activemq.properties
在resource下创建一个activemq.properties，用来保存activemq的用户名、密码、连接地址等信息：
username = xxx passwd = xxx url = tcp://xx.xx.xx.xx:61616
ActiveMqUtils
创建一个工具类，用来获取连接，因为工厂类一般都是比较重量级的类，不应该重复创建：
package org.cc11001100.activemq;
import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import java.io.IOException;
import java.util.Properties;
/**
* @author: CC11001100
* @date: 2017/11/8 18:20
* @email: CC11001100@qq.com
*/
public class ActiveMqUtils {
private static ConnectionFactory connectionFactory;
static{
try {
Properties properties = new Properties();
properties.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("activemq.properties"));
connectionFactory=new ActiveMQConnectionFactory(properties.getProperty("username"),
properties.getProperty("passwd"),
properties.getProperty("url"));
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 获取JMS连接
*
* @return JMS Connection
*/
public static Connection getConnection(){
try {
return connectionFactory.createConnection();
} catch (JMSException e) {
e.printStackTrace();
}
return null;
}
}
SenderUtils
创建发送消息的工具类：
package org.cc11001100.activemq;
import javax.jms.*;
import java.util.function.Function;
/**
* @author: CC11001100
* @date: 2017/11/8 18:12
* @email: CC11001100@qq.com
*/
public class SenderUtils {
/**
* 向指定的队列发送消息
*
* @param queueName 发送到哪个队列
* @param generateMessage 使用这个方法产生要发送的消息
*/
public static void send(String queueName, Function<Session, Message> generateMessage){
Connection conn=null;
Session session=null;
MessageProducer messageProducer=null;
try {
conn = ActiveMqUtils.getConnection();
assert conn != null;
conn.start();
session=conn.createSession(true, Session.AUTO_ACKNOWLEDGE);
/*队列名是区分大小写的，如果不存在的话会自动创建一个*/
Queue queue=session.createQueue(queueName);
messageProducer=session.createProducer(queue);
/*设置非持久化，持久化的意思是要求发送的时候接收方要在线*/
messageProducer.setDeliveryMode(DeliveryMode.PERSISTENT);
// 生成消息并发送
Message message = generateMessage.apply(session);
messageProducer.send(message);
/*在提交的时候消息才会真正的发出去*/
session.commit();
} catch (JMSException e) {
e.printStackTrace();
}finally{
if(messageProducer!=null){
try {
messageProducer.close();
} catch (JMSException e) {
e.printStackTrace();
}
}
if(session!=null){
try {
session.close();
} catch (JMSException e) {
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (JMSException e) {
e.printStackTrace();
}
}
}
}
}
注意：在session.commit()之前消息是不会被发送出去的。
ReceiverUtils
创建接收消息的工具类：
package org.cc11001100.activemq;
import javax.jms.*;
import java.util.function.Function;
/**
* @author: CC11001100
* @date: 2017/11/8 18:37
* @email: CC11001100@qq.com
*/
public class ReceiverUtils {
/**
* 从指定队列中接收一个消息
*
* @param queueName 队列名称
* @return 接收到的消息内容
*/
public static Message receive(String queueName){
Connection conn=null;
Session session=null;
MessageConsumer messageConsumer=null;
try {
conn=ActiveMqUtils.getConnection();
assert conn != null;
conn.start();
session=conn.createSession(true,Session.AUTO_ACKNOWLEDGE);
Queue queue=session.createQueue(queueName);
messageConsumer=session.createConsumer(queue);
/*这是一个阻塞式的方法，在接收到消息之前会一直阻塞着*/
Message message=messageConsumer.receive();
session.commit();
return message;
} catch (JMSException e) {
e.printStackTrace();
}finally{
if(messageConsumer!=null){
try {
messageConsumer.close();
} catch (JMSException e) {
e.printStackTrace();
}
}
if(session!=null){
try {
session.close();
} catch (JMSException e) {
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (JMSException e) {
e.printStackTrace();
}
}
}
return null;
}
/**
* 从指定队列接收一个消息并将它传递给回调方法处理，返回处理后的结果
*
* @param queueName 队列名称
* @param callback 处理消息的回调方法
* @param <T> 处理消息后的返回值
* @return 处理消息后的返回值
*/
public static <T> T receive(String queueName, Function<Message, T> callback){
Message message = receive(queueName);
assert message!=null;
return callback.apply(message);
}
}
Main
创建测试类：
package org.cc11001100.activemq;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.TextMessage;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
/**
* @author: CC11001100
* @date: 2017/11/8 18:49
* @email: CC11001100@qq.com
*/
public class Main {
public static void main(String[] args) {
final String QUEUE_NAME = "FOO_QUEUE";
// 生产者
new Thread(()->{
while(true){
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
SenderUtils.send(QUEUE_NAME, session -> {
try {
return session.createTextMessage(Long.toString(System.currentTimeMillis()));
} catch (JMSException e) {
e.printStackTrace();
}
return null;
});
}
}).start();
// 消费者
new Thread(()->{
while(true){
ReceiverUtils.receive(QUEUE_NAME, message->{
if(message instanceof TextMessage){
try {
TextMessage textMessage = (TextMessage) message;
System.out.println(textMessage.getText());
} catch (JMSException e) {
e.printStackTrace();
}
}
return message;
});
}
}).start();
}
}
