一、什么是ActiveMQ
AciveMQ是Apache出品的目前最流行,能力强劲的开源消息总线
消息列队有两种消息模式,一种是点对点的消息模式,还有一种就是订阅的模式.
主要功能:
- 解决服务器之间的耦合性
- 使用消息队列,增加系统并发处理量
主要应用场景:
- 当系统使用短信平台、邮件平台的时候
- 当系统使用搜索平台、缓存平台的时候你
二、使用外置ActiveMQ流程:
1.官网地址:http://activemq.apache.org/
2.安装包下载完成后解压后 就是这个样子了 (注意一定要解压到全英文路径下的包内)
4.双击启动activemq.bat
5.点完之后会自动弹出来doc启动,稍等一下 如果你最后跟我的一样 说明启动成功了
6.启动成功,在浏览器中访问http://localhost:8161/ 就能访问到activemq的页面
7.登录成功后(用户名和密码都是admin),会有两个队列:topic和queue (后台创建队列,这边会实时显示)
三、两种消息模式
1.点对点的实现代码
项目使用MAVEN来构建(pom.xml)
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.itsiji</groupId>
<artifactId>activemq</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!--activemq-->
<dependencies>
<dependency>
<groupId>org.apache.activemq</groupId>
<artifactId>activemq-client</artifactId>
<version>5.13.4</version>
</dependency>
</dependencies>
<build>
<plugins>
<!-- java编译插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.2</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
</project>
1.1点对点的发送方
需要注意的:连接地址的ip和端口号是 127.0.0.1:61616
在页面管理控制台查看消息队列的ip和端口号是 127.0.0.1:8161
package com.itsiji.test.queue;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
public class TestQueueSend {
//连接账号
private String userName = "";
//连接密码
private String password = "";
//连接地址
private String brokerURL = "tcp://127.0.0.1:61616";
//connection的工厂
private ConnectionFactory factory;
//连接对象
private Connection connection;
//一个操作会话
private Session session;
//目的地,其实就是连接到哪个队列,如果是点对点,那么它的实现是Queue,如果是订阅模式,那它的实现是Topic
private Destination destination;
//生产者,就是产生数据的对象
private MessageProducer producer;
public static void main(String[] args) {
TestQueueSend send = new TestQueueSend();
send.start();
}
public void start(){
try {
//根据用户名,密码,url创建一个连接工厂
factory = new ActiveMQConnectionFactory(userName, password, brokerURL);
//从工厂中获取一个连接
connection = factory.createConnection();
//测试过这个步骤不写也是可以的,但是网上的各个文档都写了
connection.start();
//创建一个session
//第一个参数:是否支持事务,如果为true,则会忽略第二个参数,被jms服务器设置为SESSION_TRANSACTED
//第二个参数为false时,paramB的值可为Session.AUTO_ACKNOWLEDGE,Session.CLIENT_ACKNOWLEDGE,DUPS_OK_ACKNOWLEDGE其中一个。
//Session.AUTO_ACKNOWLEDGE为自动确认,客户端发送和接收消息不需要做额外的工作。哪怕是接收端发生异常,也会被当作正常发送成功。
//Session.CLIENT_ACKNOWLEDGE为客户端确认。客户端接收到消息后,必须调用javax.jms.Message的acknowledge方法。jms服务器才会当作发送成功,并删除消息。
//DUPS_OK_ACKNOWLEDGE允许副本的确认模式。一旦接收方应用程序的方法调用从处理消息处返回,会话对象就会确认消息的接收;而且允许重复确认。
session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//创建一个到达的目的地,其实想一下就知道了,activemq不可能同时只能跑一个队列吧,这里就是连接了一个名为"text-msg"的队列,这个会话将会到这个队列,当然,如果这个队列不存在,将会被创建
destination = session.createQueue("text-msg");
//从session中,获取一个消息生产者
producer = session.createProducer(destination);
//设置生产者的模式,有两种可选
//DeliveryMode.PERSISTENT 当activemq关闭的时候,队列数据将会被保存
//DeliveryMode.NON_PERSISTENT 当activemq关闭的时候,队列里面的数据将会被清空
producer.setDeliveryMode(DeliveryMode.PERSISTENT);
//创建一条消息,当然,消息的类型有很多,如文字,字节,对象等,可以通过session.create..方法来创建出来
TextMessage textMsg = session.createTextMessage("呵呵");
for(int i = 0 ; i < 100 ; i ++){
//发送一条消息
producer.send(textMsg);
}
System.out.println("发送消息成功");
//即便生产者的对象关闭了,程序还在运行哦
producer.close();
} catch (JMSException e) {
e.printStackTrace();
}
}
}
1.2点对点的接收方
package com.itsiji.test.queue;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
public class TestQueueReceive {
//连接账号
private String userName = "";
//连接密码
private String password = "";
//连接地址
private String brokerURL = "tcp://127.0.0.1:61616";
//connection的工厂
private ConnectionFactory factory;
//连接对象
private Connection connection;
//一个操作会话
private Session session;
//目的地,其实就是连接到哪个队列,如果是点对点,那么它的实现是Queue,如果是订阅模式,那它的实现是Topic
private Destination destination;
//消费者,就是接收数据的对象
private MessageConsumer consumer;
public static void main(String[] args) {
TestQueueReceive receive = new TestQueueReceive();
receive.start();
}
public void start(){
try {
//根据用户名,密码,url创建一个连接工厂
factory = new ActiveMQConnectionFactory(userName, password, brokerURL);
//从工厂中获取一个连接
connection = factory.createConnection();
//测试过这个步骤不写也是可以的,但是网上的各个文档都写了
connection.start();
//创建一个session
//第一个参数:是否支持事务,如果为true,则会忽略第二个参数,被jms服务器设置为SESSION_TRANSACTED
//第二个参数为false时,paramB的值可为Session.AUTO_ACKNOWLEDGE,Session.CLIENT_ACKNOWLEDGE,DUPS_OK_ACKNOWLEDGE其中一个。
//Session.AUTO_ACKNOWLEDGE为自动确认,客户端发送和接收消息不需要做额外的工作。哪怕是接收端发生异常,也会被当作正常发送成功。
//Session.CLIENT_ACKNOWLEDGE为客户端确认。客户端接收到消息后,必须调用javax.jms.Message的acknowledge方法。jms服务器才会当作发送成功,并删除消息。
//DUPS_OK_ACKNOWLEDGE允许副本的确认模式。一旦接收方应用程序的方法调用从处理消息处返回,会话对象就会确认消息的接收;而且允许重复确认。
session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//创建一个到达的目的地,其实想一下就知道了,activemq不可能同时只能跑一个队列吧,这里就是连接了一个名为"text-msg"的队列,这个会话将会到这个队列,当然,如果这个队列不存在,将会被创建
destination = session.createQueue("text-msg");
//根据session,创建一个接收者对象
consumer = session.createConsumer(destination);
//实现一个消息的监听器
//实现这个监听器后,以后只要有消息,就会通过这个监听器接收到
consumer.setMessageListener(new MessageListener() {
@Override
public void onMessage(Message message) {
try {
//获取到接收的数据
String text = ((TextMessage)message).getText();
System.out.println(text);
} catch (JMSException e) {
e.printStackTrace();
}
}
});
//关闭接收端,也不会终止程序哦
// consumer.close();
} catch (JMSException e) {
e.printStackTrace();
}
}
}
2.订阅/发布模式的实现代码
2.1订阅模式的发布方
package com.itsiji.test.topic;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
public class TestTopicSend {
//连接账号
private String userName = "";
//连接密码
private String password = "";
//连接地址
private String brokerURL = "tcp://127.0.0.1:61616";
//connection的工厂
private ConnectionFactory factory;
//连接对象
private Connection connection;
//一个操作会话
private Session session;
//目的地,其实就是连接到哪个队列,如果是点对点,那么它的实现是Queue,如果是订阅模式,那它的实现是Topic
private Destination destination;
//生产者,就是产生数据的对象
private MessageProducer producer;
public static void main(String[] args) {
TestTopicSend send = new TestTopicSend();
send.start();
}
public void start(){
try {
//根据用户名,密码,url创建一个连接工厂
factory = new ActiveMQConnectionFactory(userName, password, brokerURL);
//从工厂中获取一个连接
connection = factory.createConnection();
//测试过这个步骤不写也是可以的,但是网上的各个文档都写了
connection.start();
//创建一个session
//第一个参数:是否支持事务,如果为true,则会忽略第二个参数,被jms服务器设置为SESSION_TRANSACTED
//第二个参数为false时,paramB的值可为Session.AUTO_ACKNOWLEDGE,Session.CLIENT_ACKNOWLEDGE,DUPS_OK_ACKNOWLEDGE其中一个。
//Session.AUTO_ACKNOWLEDGE为自动确认,客户端发送和接收消息不需要做额外的工作。哪怕是接收端发生异常,也会被当作正常发送成功。
//Session.CLIENT_ACKNOWLEDGE为客户端确认。客户端接收到消息后,必须调用javax.jms.Message的acknowledge方法。jms服务器才会当作发送成功,并删除消息。
//DUPS_OK_ACKNOWLEDGE允许副本的确认模式。一旦接收方应用程序的方法调用从处理消息处返回,会话对象就会确认消息的接收;而且允许重复确认。
session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//创建一个到达的目的地,其实想一下就知道了,activemq不可能同时只能跑一个队列吧,这里就是连接了一个名为"text-msg"的队列,这个会话将会到这个队列,当然,如果这个队列不存在,将会被创建
//=======================================================
//点对点与订阅模式唯一不同的地方,就是这一行代码,点对点创建的是Queue,而订阅模式创建的是Topic
destination = session.createTopic("topic-text");
//=======================================================
//从session中,获取一个消息生产者
producer = session.createProducer(destination);
//设置生产者的模式,有两种可选
//DeliveryMode.PERSISTENT 当activemq关闭的时候,队列数据将会被保存
//DeliveryMode.NON_PERSISTENT 当activemq关闭的时候,队列里面的数据将会被清空
producer.setDeliveryMode(DeliveryMode.PERSISTENT);
//创建一条消息,当然,消息的类型有很多,如文字,字节,对象等,可以通过session.create..方法来创建出来
TextMessage textMsg = session.createTextMessage("哈哈");
long s = System.currentTimeMillis();
for(int i = 0 ; i < 100 ; i ++){
//发送一条消息
producer.send(textMsg);
}
long e = System.currentTimeMillis();
System.out.println("发送消息成功");
System.out.println(e - s);
//即便生产者的对象关闭了,程序还在运行哦
producer.close();
} catch (JMSException e) {
e.printStackTrace();
}
}
}
2.2订阅模式的接收方
package com.itsiji.test.topic;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnectionFactory;
public class TestTopicReceive {
//连接账号
private String userName = "";
//连接密码
private String password = "";
//连接地址
private String brokerURL = "tcp://127.0.0.1:61616";
//connection的工厂
private ConnectionFactory factory;
//连接对象
private Connection connection;
//一个操作会话
private Session session;
//目的地,其实就是连接到哪个队列,如果是点对点,那么它的实现是Queue,如果是订阅模式,那它的实现是Topic
private Destination destination;
//生产者,就是产生数据的对象
private MessageProducer producer;
public static void main(String[] args) {
TestTopicReceive send = new TestTopicReceive();
send.start();
}
public void start(){
try {
//根据用户名,密码,url创建一个连接工厂
factory = new ActiveMQConnectionFactory(userName, password, brokerURL);
//从工厂中获取一个连接
connection = factory.createConnection();
//测试过这个步骤不写也是可以的,但是网上的各个文档都写了
connection.start();
//创建一个session
//第一个参数:是否支持事务,如果为true,则会忽略第二个参数,被jms服务器设置为SESSION_TRANSACTED
//第二个参数为false时,paramB的值可为Session.AUTO_ACKNOWLEDGE,Session.CLIENT_ACKNOWLEDGE,DUPS_OK_ACKNOWLEDGE其中一个。
//Session.AUTO_ACKNOWLEDGE为自动确认,客户端发送和接收消息不需要做额外的工作。哪怕是接收端发生异常,也会被当作正常发送成功。
//Session.CLIENT_ACKNOWLEDGE为客户端确认。客户端接收到消息后,必须调用javax.jms.Message的acknowledge方法。jms服务器才会当作发送成功,并删除消息。
//DUPS_OK_ACKNOWLEDGE允许副本的确认模式。一旦接收方应用程序的方法调用从处理消息处返回,会话对象就会确认消息的接收;而且允许重复确认。
session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
//创建一个到达的目的地,其实想一下就知道了,activemq不可能同时只能跑一个队列吧,这里就是连接了一个名为"text-msg"的队列,这个会话将会到这个队列,当然,如果这个队列不存在,将会被创建
//=======================================================
//点对点与订阅模式唯一不同的地方,就是这一行代码,点对点创建的是Queue,而订阅模式创建的是Topic
destination = session.createTopic("topic-text");
//=======================================================
//从session中,获取一个消息生产者
producer = session.createProducer(destination);
//设置生产者的模式,有两种可选
//DeliveryMode.PERSISTENT 当activemq关闭的时候,队列数据将会被保存
//DeliveryMode.NON_PERSISTENT 当activemq关闭的时候,队列里面的数据将会被清空
producer.setDeliveryMode(DeliveryMode.PERSISTENT);
//创建一条消息,当然,消息的类型有很多,如文字,字节,对象等,可以通过session.create..方法来创建出来
TextMessage textMsg = session.createTextMessage("哈哈");
long s = System.currentTimeMillis();
for(int i = 0 ; i < 100 ; i ++){
//发送一条消息
textMsg.setText("哈哈" + i);
producer.send(textMsg);
}
long e = System.currentTimeMillis();
System.out.println("发送消息成功");
System.out.println(e - s);
//即便生产者的对象关闭了,程序还在运行哦
producer.close();
} catch (JMSException e) {
e.printStackTrace();
}
}
}
3.发送消息的数据类型
javax.jms.Message 这个接口,只要是这个接口的数据,都可以被发送
//纯字符串的数据
session.createTextMessage();
//序列化的对象
session.createObjectMessage();
//流,可以用来传递文件等
session.createStreamMessage();
//用来传递字节
session.createBytesMessage();
//这个方法创建出来的就是一个map,可以把它当作map来用,当你看了它的一些方法,你就懂了
session.createMapMessage();
//这个方法,拿到的是javax.jms.Message,是所有message的接口
session.createMessage();