ActiveMq 学习记录

最新推荐文章于 2023-07-10 15:59:52 发布

学的是寂寞

最新推荐文章于 2023-07-10 15:59:52 发布

阅读量314

点赞数

分类专栏：微服务 java web 异步通信 Springboot 文章标签： activeMQ JMS 消息队列异步处理微服务

本文链接：https://blog.csdn.net/pangfei0/article/details/80395045

版权

java web 同时被 3 个专栏收录

11 篇文章 0 订阅

订阅专栏

Springboot

6 篇文章 0 订阅

订阅专栏

微服务

5 篇文章 0 订阅

订阅专栏

1.ActiveMq学习

JMS简介

JMS即java消息服务（Java Message Server）应用程序接口，是一个Java平台中关于面向消息中间件的API，用于两个应用之间，或者分布式系统中发送消息，进行异步通信。Java消息服务是一个与平台无关的API，绝大数MOM提供商都对JMS 提供支持。

官方定义：JMS(Java Message Service) 是java 平台上有关面向消息中间件的技术规范，它便于消息系统中的Java应用程序进行消息交换，并且通过提供标准的生产、发送接收消息的接口简化企业的开发，翻译为Java消息服务。

通过上述的介绍，JMS类似于JPA(Java Persistence API)、JDBC（Java DataBase Connectivity），是java提供的一种规范，供各个厂商去具体的实现，即JMS、JAP、JDBC是与厂商无关的访问。Hibernate 则是基于JPA规范实现的一种ORM 框架。

MQ简介

MQ全称为Message Queue，消息队列（MQ）是应用程序与应用程序通信方法。应用程序通过写入或者检索队列中的数据进行通信，无效直接调用彼此（程序间的解耦）。

JMS与ActiveMQ的关系

JMS与ActiveMQ的关系就像JPA 与Hibernate的关系一样，ActiveMq 是基于JMS 规范去实现的一个产品。ActiveMQ 是Apache出品，最流行的的，能力强劲的开源消息总线。

1.1AvtiveMQ的特性

支持多语言多协议编写客户端。
完全支持JMS1.1和J2EE1.4（持久化、Ajxa消息、事务）
对Spring的支持，ActiveMQ可以很容易内嵌到使用Spring的系统中去。
通过了常见J2EE服务器(如 Geronimo,JBoss 4, GlassFish,WebLogic)的测试,其中通过JCA 1.5 resource adaptors的配置,可以让ActiveMQ可以自动的部署到任何兼容J2EE 1.4 商业服务器上。
支持多种传送协议:in-VM,TCP,SSL,NIO,UDP,JGroups,JXTA
支持通过JDBC和journal提供高速的消息持久化
从设计上保证了高性能的集群,客户端-服务器,点对点
支持Ajax
支持与Axis的整合
可以很容易得调用内嵌JMS provider,进行测试
ActiveMQ速度非常快；一般要比jbossMQ快10倍。

ActiveMQ的应用场景

不同语言应用集成

ActiveMq中间件虽然是java语言编写的，java客户端必不可少，但ActiveMQ 同样实现对其他语言支持的客户端，如C/C++、.NET、PHP等。当我们考虑集成不同语言的应用程序时，ActiveMQ对多语言的支持是使其拥有莫大的优势。

做为RPC的替代

使用RPC同步调用的应用十分普遍。假设大多数客户端服务器应用使用RPC，包括ATM、大多数WEB应用、信用卡系统、销售点系统等等。尽管很多系统很成功，但是转换使用异步消息可以带来很多好处，而且也不会放弃响应保证。使用同步请求的系统在规模上有较大的限制，因为请求会被阻塞，从而导致整个系统变慢。如果使用异步消息替代，可以很容易增加额外的消息接收者，使得消息能被并发消耗，从而加快请求处理。当然，你的系统应用间应该是解耦的。

应用之间的解耦

应用之间的通信通过中间件ActiveMq

最为事件驱架构的组件

异步架构中的系统通常通过代理服务器去配置更多的客户端，内存来夸大自己的系统，也就纵向扩展，而不是通过夸大更多的代理服务器，即横向扩展。

提高系统的扩展性

与前三个使用场景类似，通过ActiveMQ来提供系统的性能。

ActiveMQ消息持久化机制

为了避免意外宕机以后丢失信息，需要做到重启后可以恢复消息队列，消息系统一般都会采用持久化机制。ActiveMQ的消息持久化机制有JDBC，AMQ，KahaDB和LevelDB，无论使用哪种持久化方式，消息的存储逻辑都是一致的。

就是在发送者将消息发送出去后，消息中心首先将消息存储到本地数据文件、内存数据库或者远程数据库等，然后试图将消息发送给接收者，发送成功则将消息从存储中删除，失败则继续尝试。消息中心启动以后首先要检查指定的存储位置，如果有未发送成功的消息，则需要把消息发送出去。

JDBC持久化方式

使用JDBC持久化方式，数据库会创建3个表：activemq_msgs，activemq_acks和activemq_lock。 activemq_msgs用于存储消息，Queue和Topic都存储在这个表中。

（1）配置方式

<persistenceAdapter> 
<jdbcPersistenceAdapter dataSource="#mysql-ds" createTablesOnStartup="false" /> 
</persistenceAdapter>

dataSource指定持久化数据库的bean，createTablesOnStartup是否在启动的时候创建数据表，默认值是true，这样每次启动都会去创建数据表了，一般是第一次启动的时候设置为true，之后改成false。使用MySQL配置JDBC持久化:

<beans>
<broker brokerName="test-broker" persistent="true" xmlns="http://activemq.apache.org/schema/core">
<persistenceAdapter>
<jdbcPersistenceAdapter dataSource="#mysql-ds" createTablesOnStartup="false"/>
</persistenceAdapter>
</broker>
<bean id="mysql-ds" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost/activemq?relaxAutoCommit=true"/>
<property name="username" value="activemq"/>
<property name="password" value="activemq"/>
<property name="maxActive" value="200"/>
<property name="poolPreparedStatements" value="true"/>
</bean>
</beans>

（2）数据库表信息

activemq_msgs用于存储消息，Queue和Topic都存储在这个表中： ID：自增的数据库主键 CONTAINER：消息的Destination MSGID_PROD：消息发送者客户端的主键 MSG_SEQ：是发送消息的顺序，MSGID_PROD+MSG_SEQ可以组成JMS的MessageID EXPIRATION：消息的过期时间，存储的是从1970-01-01到现在的毫秒数 MSG：消息本体的Java序列化对象的二进制数据 PRIORITY：优先级，从0-9，数值越大优先级越高

activemq_acks用于存储订阅关系。如果是持久化Topic，订阅者和服务器的订阅关系在这个表保存：主要的数据库字段如下： CONTAINER：消息的Destination SUB_DEST：如果是使用Static集群，这个字段会有集群其他系统的信息 CLIENT_ID：每个订阅者都必须有一个唯一的客户端ID用以区分 SUB_NAME：订阅者名称 SELECTOR：选择器，可以选择只消费满足条件的消息。条件可以用自定义属性实现，可支持多属性AND和OR操作 LAST_ACKED_ID：记录消费过的消息的ID。

表activemq_lock在集群环境中才有用，只有一个Broker可以获得消息，称为Master Broker，其他的只能作为备份等待Master Broker不可用，才可能成为下一个Master Broker。这个表用于记录哪个Broker是当前的Master Broker。

AMQ方式

性能高于JDBC，写入消息时，会将消息写入日志文件，由于是顺序追加写，性能很高。为了提升性能，创建消息主键索引，并且提供缓存机制，进一步提升性能。每个日志文件的大小都是有限制的（默认32m，可自行配置）。当超过这个大小，系统会重新建立一个文件。当所有的消息都消费完成，系统会删除这个文件或者归档（取决于配置）。主要的缺点是AMQ Message会为每一个Destination创建一个索引，如果使用了大量的Queue，索引文件的大小会占用很多磁盘空间。而且由于索引巨大，一旦Broker崩溃，重建索引的速度会非常慢。

配置片段如下：

<persistenceAdapter>
 <amqPersistenceAdapter directory="${activemq.data}/activemq-data" maxFileLength="32mb"/>
</persistenceAdapter>

虽然AMQ性能略高于下面的KahaDB方式，但是由于其重建索引时间过长，而且索引文件占用磁盘空间过大，所以已经不推荐使用。

KahaDB方式

KahaDB是从ActiveMQ 5.4开始默认的持久化插件，也是我们项目现在使用的持久化方式。

KahaDb恢复时间远远小于其前身AMQ并且使用更少的数据文件，所以可以完全代替AMQ。 kahaDB的持久化机制同样是基于日志文件，索引和缓存。

<persistenceAdapter>
<kahaDB directory="${activemq.data}/activemq-data" journalMaxFileLength="16mb"/>
</persistenceAdapter>

directory : 指定持久化消息的存储目录 journalMaxFileLength : 指定保存消息的日志文件大小，具体根据你的实际应用配置　

（1）KahaDB主要特性

日志形式存储消息；
消息索引以B-Tree结构存储，可以快速更新；
完全支持JMS事务；
支持多种恢复机制；

（2）KahaDB的结构消息存储在基于文件的数据日志中。如果消息发送成功，变标记为可删除的。系统会周期性的清除或者归档日志文件。消息文件的位置索引存储在内存中，这样能快速定位到。定期将内存中的消息索引保存到metadata store中，避免大量消息未发送时，消息索引占用过多内存空间。

Data logs：

Data logs用于存储消息日志，消息的全部内容都在Data logs中。同AMQ一样，一个Data logs文件大小超过规定的最大值，会新建一个文件。同样是文件尾部追加，写入性能很快。每个消息在Data logs中有计数引用，所以当一个文件里所有的消息都不需要了，系统会自动删除文件或放入归档文件夹。

Metadata cache ：

缓存用于存放在线消费者的消息。如果消费者已经快速的消费完成，那么这些消息就不需要再写入磁盘了。 Btree索引会根据MessageID创建索引，用于快速的查找消息。这个索引同样维护持久化订阅者与Destination的关系，以及每个消费者消费消息的指针。

Metadata store

在db.data文件中保存消息日志中消息的元数据，也是以B-Tree结构存储的，定时从Metadata cache更新数据。Metadata store中也会备份一些在消息日志中存在的信息，这样可以让Broker实例快速启动。即便metadata store文件被破坏或者误删除了。broker可以读取Data logs恢复过来，只是速度会相对较慢些。

目前最新的持久化是基于LevelDB方式，尚未研究。

ActiveMQ 常见的几种使用模式

P2P模式（点对点模式）

P2P模式中消息域使用的是queue作为Destination，消息可以被同步或者异步接收，每个消息只被一个消费者消费，消息消费方可以实现同步消费和异步消费，同步消费只需要通过MessageConsumer.receive()不间断的去获取消息（通过不断轮询），异步消费需要创建一个监听器，并且将监听器注册到MessageConsumer中：messageConsumer.setMessageListener(new MyMessageListener()); 下图是P2P模式图：

发布/订阅模式

发布订阅与P2P模式最大的区别在于，每个消息被所有订阅了同一个topic的消费者消费，并且消息如果一但被某些或者部分消费者消费（哪怕没有消费者去消费），后期上线的消费者将不会接受到消息，除非将消息持久化（P2P模式中，如果生产者的消息没有被消费，消息将一直存储起来，指导有消费者消费此消息）。下图是发布订阅模式图：

ActiveMQ Docker安装

寻找activeMQ 镜像

打开镜像库网站：https://hub.docker.com/search/，搜索activemq

选择第一个 webcenter.activemq，点击进入，会看到详细的镜像介绍：复制Docker pull webcenter/activemq 命令到linux环境中，下载成功后，输入 docker images 即可看到该镜像：

根据镜像生产可运行容器

我们可以根据该镜像的信息介绍去生成对应的容器，有兴趣可以去关注一下，下面我就直接生成容器了。运行如下命令：

docker run --name='activemq' -it --rm -P webcenter/activemq:latest

我们可以通：

docker ps -a

这个命令查看说有的容器信息运行改命令后：

如上图说明了容器已经生成，并且启动了，同时将容器内的多个端口映射到主机的响应端口。

这样我们就成功的部署了一个activemq应用。

注意：
端口61616是供服务者或者消费者连接的端口，或者称为数据传输端口，映射为主机端口为：32768
端口322771 是activemq 的web管理端端口。通过此端口可以通关web管理activemq。
（这个几个端口的映射是在一个范围之内随机的，可以参考镜像的详细介绍）

activemq web管理端

下图是activemq的web管理端页面：（默认用户名和密码是admin，可参考镜像介绍）：

我们可以看到web端对应的端口，在界面中我么可以看到 P2P模式的queue，发布订阅模式中的Topic 和Subscribers。

Activemq两种模式的Java实现

代码结构

下图为代码结构：

其中：

MyListener 是消息监听器，用于异步监听生产者发送的消息。
P2P->P2PReceive 端对端模式消费者；P2P->P2PSender 端对端模式生产者。
sub->TOPReceive 订阅发布模式消费者；sub->TOPSender 订阅发布模式生产者。

本实例运行方式，先执行生产者，进行消息的生产，在运行消费者对消息的消费。

P2P模式实现（异步模式）

消费者代码：

import org.apache.activemq.ActiveMQConnectionFactory;

import javax.jms.*;

/**
 * @Author: pangfei
 * @description:
 * @Date: Create in 17:13 2018/2/9
 */
public class P2PReceive {

/**
 * mq 连接用户名
 */
private  String username="admin";
/**
 * mq连接密码
 */
private  String password="admin";
/**
 * mq地址
 */
private  String url="tcp://172.20.46.99:32768";
/**
 * 连接工厂
 */
private ConnectionFactory connectionFactory;
/**
 * 连接对象
 */
private Connection connection;
/**
 * 回话
 */
private Session session;
/**
 * 目的queue或者Topic
 */
private Destination destination;
/**
 * 生产者，就是生产数据的对象
 */
private MessageConsumer messageConsumer;

public static void main(String args[])
{
  P2PReceive receive=new P2PReceive();
  receive.init();
}
public void init()
{
    connectionFactory=new ActiveMQConnectionFactory(username,password,url);
    try {
        connection=connectionFactory.createConnection();
        session=connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
        connection.start();
        destination = session.createQueue("one");
        messageConsumer=session.createConsumer(destination);
        TextMessage msg=null;
       // 同步执行
        //while(true)
       // {
        //    msg=(TextMessage) messageConsumer.receive();
        //    System.out.println(msg.getText());
       // }
        //异步执行
        messageConsumer.setMessageListener(new MyMessageListener());
       // messageConsumer.close();
    } catch (JMSException e) {
        e.printStackTrace();
    }

}


}

消息生产者

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

/**
* @Author: pangfei
* @description:
* @Date: Create in 16:20 2018/2/9
*/
public class P2PSender {

/**
 * mq 连接用户名
 */
private  String username="admin";
/**
 * mq连接密码
 */
private  String password="admin";
/**
 * mq地址
 */
private  String url="tcp://172.20.46.99:32768";
/**
 * 连接工厂
 */
private  ConnectionFactory connectionFactory;
/**
 * 连接对象
 */
private  Connection connection;
/**
 * 回话
 */
private  Session session;
/**
 * 目的queue或者Topic
 */
private Destination destination;
/**
 * 生产者，就是生产数据的对象
 */
private MessageProducer messageProducer;

public static void main(String args[])
{
   P2PSender ps=new P2PSender();
   ps.init();
}

public void init()
{
    //根据用户名，密码，url创建一个连接工厂
    connectionFactory=new ActiveMQConnectionFactory(username,password,url);
    try {
        //从工厂中获取一个连接
        connection=connectionFactory.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("one");
        //从session中，获取一个消息生产者
        messageProducer=session.createProducer(destination);
        //设置生产者的模式，有两种可选
        //DeliveryMode.PERSISTENT 当activemq关闭的时候，队列数据将会被保存
        //DeliveryMode.NON_PERSISTENT 当activemq关闭的时候，队列里面的数据将会被清空
        messageProducer.setDeliveryMode(DeliveryMode.PERSISTENT);
        TextMessage textMessage=session.createTextMessage("hello!呵呵");
        System.out.println("开始发送消息......");
        for (int i=0;i<20;i++)
        {
            System.out.println("开始:"+i);
            messageProducer.send(textMessage);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("开始发送消息完毕......");
        //messageProducer.close();

    } catch (JMSException e) {
        e.printStackTrace();
    }}

发布与订阅模式实现（异步模式）

消费者实现代码

import Listener.MyMessageListener;
import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;
/**
 * @Author: pangfei
 * @description:
 * @Date: Create in 19:00 2018/2/9
 */
public class TOPReveive {

/**
 * mq 连接用户名
 */
private  String username="admin";
/**
 * mq连接密码
 */
private  String password="admin";
/**
 * mq地址
 */
private  String url="tcp://172.20.46.99:32780";
/**
 * 连接工厂
 */
private ConnectionFactory connectionFactory;
/**
 * 连接对象
 */
private Connection connection;
/**
 * 回话
 */
private Session session;
/**
 * 目的queue或者Topic
 */
private Destination destination;
/**
 * 生产者，就是生产数据的对象
 */
private MessageConsumer messageConsumer;

public static void main(String args[])
{
    TOPReveive receive=new TOPReveive();
    receive.init();
}
public void init()
{
    connectionFactory=new ActiveMQConnectionFactory(username,password,url);
    try {
        connection=connectionFactory.createConnection();
        session=connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
        connection.start();
        destination = session.createTopic("topicOne");
        messageConsumer=session.createConsumer(destination);
        messageConsumer.setMessageListener(new MyMessageListener());
       // messageConsumer.close();
    } catch (JMSException e) {
        e.printStackTrace();
    }

}}

生产者代码实现

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

/**
 * @Author: pangfei
 * @description:
 * @Date: Create in 18:56 2018/1/10
 */
public class TOPSend {
/**
 * mq 连接用户名
 */
private  String username="admin";
/**
 * mq连接密码
 */
private  String password="admin";
/**
 * mq地址
 */
private  String url="tcp://172.20.46.99:32780";
/**
 * 连接工厂
 */
private ConnectionFactory connectionFactory;
/**
 * 连接对象
 */
private Connection connection;
/**
 * 回话
 */
private Session session;
/**
 * 目的queue或者Topic
 */
private Destination destination;
/**
 * 生产者，就是生产数据的对象
 */
private MessageProducer messageProducer;

public static void main(String args[])
{
    TOPSend ps=new  TOPSend();
    ps.init();
}

public void init()
{
    //根据用户名，密码，url创建一个连接工厂
    connectionFactory=new ActiveMQConnectionFactory(username,password,url);
    try {
        //从工厂中获取一个连接
        connection=connectionFactory.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.createTopic("topicOne");
        //从session中，获取一个消息生产者
        messageProducer=session.createProducer(destination);
        //设置生产者的模式，有两种可选
        //DeliveryMode.PERSISTENT 当activemq关闭的时候，队列数据将会被保存
        //DeliveryMode.NON_PERSISTENT 当activemq关闭的时候，队列里面的数据将会被清空
        messageProducer.setDeliveryMode(DeliveryMode.PERSISTENT);

        System.out.println("开始发送消息......");
        for (int i=0;i<20;i++)
        {
            TextMessage textMessage=session.createTextMessage("hello"+i);
            System.out.println( textMessage.getText()+new Date());
            messageProducer.send(textMessage);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("开始发送消息完毕......");
        messageProducer.close();

    } catch (JMSException e) {
        e.printStackTrace();
    }
}}

注意：以上代码中的set和get方法都已经省略。若需获取源码请点击：https://coding.net/u/pangfei/p/mq/git获取。

以上就是最近对ActiveMQ的学习，谢谢。

学的是寂寞

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
ActiveMq 学习记录

# 1.ActiveMq学习 ### JMS简介 ##JMS即java消息服务（Java Message Server）应用程序接口，是一个Java平台中关于面向消息中间件的API，用于两个应用之间，或者分布式系统中发送消息，进行异步通信。Java消息服务是一个与平台无关的API，绝大数MOM提供商都对JMS 提供支持。&gt; 官方定义：JMS(Java Message Service) 是ja...
复制链接

扫一扫