ActiveMQ(一)

最新推荐文章于 2021-11-10 10:09:35 发布

霁空

最新推荐文章于 2021-11-10 10:09:35 发布

阅读量247

点赞数

分类专栏： server tools 微服务文章标签： ActiveMQ 消息队列 linux 分布式 MQ

本文链接：https://blog.csdn.net/qiang_zi_/article/details/88394489

版权

server 同时被 3 个专栏收录

31 篇文章 0 订阅

订阅专栏

tools

26 篇文章 0 订阅

订阅专栏

微服务

7 篇文章 0 订阅

订阅专栏

ActiveMQ简介

ActiveMQ是什么

ActiveMQ是Apache推出的，一款开源的，完全支持JMS1.1和J2EE 1.4规范的JMS,Provider实现的消息中间件(Message Oriented Middleware，MOM)

ActiveMQ能干什么

最主要的功能就是:实现JMS Provider，用来帮助实现高可用、高性能、可伸缩、易用和安全的企业级面向消息服务的系统

ActiveMQ特点

完全支持JMS1.1和J2EE 1.4规范 (持久化，XA消息，事务) 支持多种传送协议:in-VM,TCP,SSL,NIO,UDP,JGroups,JXTA 可插拔的体系结构，可以灵活定制，如:消息存储方式、安全管理等很容易和Application Server集成使用多种语言和协议编写客户端。语言: Java,C,C++,C#,Ruby,Perl,Python,PHP 从设计上保证了高性能的集群，客户端-服务器，点对点可以很容易的和Spring结合使用支持通过JDBC和journal提供高速的消息持久化支持与Axis的整合

MOM基本功能:将信息以消息的形式，从一个应用程序传送到另一个或多个应用程序。

MOM主要特点:

1:消息异步接受，类似手机短信的行为，消息发送者不需要等待消息接受者的响应，减少软件多系统集成的耦合度;

2:消息可靠接收，确保消息在中间件可靠保存，只有接收方收到后才删除消息，多个消息也可以组成原子事务

消息中间件的主要应用场景:

在多个系统间进行整合和通讯的时候，通常会要求:

1:可靠传输，数据不能丢失，有的时候，也会要求不能重复传输;

2:异步传输，否则各个系统同步发送接受数据，互相等待，造成系统瓶颈

目前比较知名的消息中间件:

IBM MQSeries

BEA WebLogic JMS Server

Oracle AQ

Tibco

SwiftMQ AcitveMQ:是免费的java实现的消息中间件

JMS基本概念

JMS是什么

JMS Java Message Service，Java消息服务，是Java EE中的一个技术。

JMS规范

JMS定义了Java 中访问消息中间件的接口，并没有给予实现，实现JMS 接口的消息。

中间件称为JMS Provider，例如ActiveMQ

JMS provider:实现JMS接口和规范的消息中间件

JMS message:JMS的消息，JMS消息由以下三部分组成:

1:消息头:每个消息头字段都有相应的getter和setter方法

2:消息属性:如果需要除消息头字段以外的值，那么可以使用消息属性

3:消息体:封装具体的消息数据

JMS producer:消息生产者，创建和发送JMS消息的客户端应用

JMS consumer:消息消费者，接收和处理JMS消息的客户端应用

消息的消费可以采用以下两种方法之一:

1:同步消费:通过调用消费者的receive方法从目的地中显式提取消息，receive 方法可以一直阻塞到消息到达。

2:异步消费:客户可以为消费者注册一个消息监听器，以定义在消息到达时所采取的动作

JMS domains:消息传递域，

JMS规范中定义了两种消息传递域:

点对点 (point-to- point，简写成PTP)消息传递域和发布/订阅消息传递域(publish/subscribe，简写成pub/sub)

1:点对点消息传递域的特点如下:

(1)每个消息只能有一个消费者

(2)消息的生产者和消费者之间没有时间上的相关性。无论消费者在生产者发送消息的时候是否处于运行状态，它都可以提取消息。

2:发布/订阅消息传递域的特点如下:

(1)每个消息可以有多个消费者

(2)生产者和消费者之间有时间上的相关性。订阅一个主题的消费者只能消费自它订阅之后发布的消息。JMS 规范允许客户创建持久订阅，这在一定程度上放松了时间上的相关性要求。持久订阅允许消费者消费它在未处于激活状态时发送的消息。

3:在点对点消息传递域中，目的地被称为队列(queue);在发布/订阅消息传递域中，目的地被称为主题(topic)

Connection factory:连接工厂，用来创建连接对象，以连接到JMS的provider

JMS Connection:封装了客户与JMS 提供者之间的一个虚拟的连接

JMS Session:是生产和消费消息的一个单线程上下文会话用于创建消息生产者(producer)、消息消费者(consumer)和消息 (message)等。会话提供了一个事务性的上下文，在这个上下文中，一组发送和接收被组合到了一个原子操作中。

Destination:消息发送到的目的地

Acknowledge:签收

Transaction:事务

JMS client:用来收发消息的Java应用

Non-JMS client:使用JMS provider本地API写的应用，用来替换JMS API实现收发消息的功能，通常会提供其他的一些特性，比如:CORBA、RMI等。

Administered objects:预定义的JMS对象，通常在provider规范中有定义，提供给JMS客户端来访问，比如: ConnectionFactory和Destination

JMS的消息结构

JMS 消息由以下几部分组成:消息头，属性和消息体

消息头包含消息的识别信息和路由信息，消息头包含一些标准的属性如下:

1:JMSDestination:由send方法设置

2:JMSDeliveryMode:由send方法设置

3:JMSExpiration:由send方法设置

4:JMSPriority:由send方法设置

5:JMSMessageID:由send方法设置

6:JMSTimestamp:由客户端设置

7:JMSCorrelationID :由客户端设置

8:JMSReplyTo :由客户端设置

9:JMSType :由客户端设置

10:JMSRedelivered:由JMS Provider设置

标准的 JMS 消息头包含以下属性:

1:JMSDestination:消息发送的目的地:主要是指Queue和Topic，自动分配

2:JMSDeliveryMode:传送模式。有两种 :持久模式和非持久模式。一条持久性的消息应该被传送“一次仅仅一次”，这就意味者如果JMS提供者出现故障，该消息并不会丢失，它会在服务器恢复之后再次传递。一条非持久的消息最多会传送一次，这意味这服务器出现故障，该消息将永远丢失。自动分配

3:JMSExpiration:消息过期时间，等于 Destination 的send 方法中的 timeToLive值加上发送时刻的GMT 时间值。如果timeToLive 值等于零，则 JMSExpiration 被设为零，表示该消息永不过期。如果发送后，在消息过期时间之后消息还没有被发送到目的地，则该消息被清除。自动分配

4:JMSPriority:消息优先级，从 0-9 十个级别，0-4 是普通消息，5-9 是加急消息。JMS 不要求JMS Provider 严格按照这十个优先级发送消息，但必须保证加急消息要先于普通消息到达。默认是4级。自动分配

5:JMSMessageID:唯一识别每个消息的标识，由JMS Provider 产生。自动分配 6:JMSTimestamp:一个JMS Provider在调用send()方法时自动设置的。它是消息被

发送和消费者实际接收的时间差。自动分配

7:JMSCorrelationID:用来连接到另外一个消息，典型的应用是在回复消息中连接到原消息。在大多数情况下，JMSCorrelationID用于将一条消息标记为对JMSMessageID标示的上一条消息的应答，不过，JMSCorrelationID可以是任何值，不仅仅是JMSMessageID。由开发者设置

8:JMSReplyTo:提供本消息回复消息的目的地址。由开发者设置

9:JMSType:消息类型的识别符。由开发者设置

10:JMSRedelivered:如果一个客户端收到一个设置了JMSRedelivered属性的消息，则表示可能客户端曾经在早些时候收到过该消息，但并没有签收 (acknowledged)。如果该消息被重新传送，JMSRedelivered=true反之， JMSRedelivered =false。自动设置消息体，JMS API定义了5种消息体格式，也叫消息类型，可以使用不同形式发送接收数据，并可以兼容现有的消息格式。包括:TextMessage、MapMessage、 BytesMessage、StreamMessage和ObjectMessage

消息属性，包含以下三种类型的属性:

1:应用程序设置和添加的属性，比如: Message.setStringProperty(“username”,username);

2:JMS定义的属性

使用“JMSX”作为属性名的前缀， connection.getMetaData().getJMSXPropertyNames()，方法返回所有连接支持的JMSX 属性的名字。

3:JMS供应商特定的属性

JMS定义的属性如下:

1:JMSXUserID:发送消息的用户标识，发送时提供商设置

2:JMSXAppID:发送消息的应用标识，发送时提供商设置

3:JMSXDeliveryCount:转发消息重试次数,第一次是1，第二次是2，... ，发送时提供商设置

4:JMSXGroupID:消息所在消息组的标识，由客户端设置

5:JMSXGroupSeq:组内消息的序号第一个消息是1，第二个是2，...，由客户端设置

6:JMSXProducerTXID :产生消息的事务的事务标识，发送时提供商设置

7:JMSXConsumerTXID :消费消息的事务的事务标识，接收时提供商设置

8:JMSXRcvTimestamp :JMS 转发消息到消费者的时间，接收时提供商设置

9:JMSXState:假定存在一个消息仓库，它存储了每个消息的单独拷贝，且这些消息从原始消息被发送时开始。每个拷贝的状态有:1(等待)，2(准备)，3 (到期)或4(保留)。由于状态与生产者和消费者无关，所以它不是由它们来提供。它只和在仓库中查找消息相关，因此JMS没有提供这种API。由提供商设置

JMS的可靠性机制

消息接收确认 JMS消息只有在被确认之后，才认为已经被成功地消费了。

消息的成功消费通常包含三个阶段:客户接收消息、客户处理消息和消息被确认。

在事务性会话中，当一个事务被提交的时候，确认自动发生。

在非事务性会话中，消息何时被确认取决于创建会话时的应答模式(acknowledgement mode)。

该参数有以下三个可选值:

Session.AUTO_ACKNOWLEDGE:当客户成功的从receive方法返回的时候，或者从 MessageListener.onMessage方法成功返回的时候，会话自动确认客户收到的消息。

Session.CLIENT_ACKNOWLEDGE:客户通过调用消息的acknowledge方法确认消息。需要注意的是，在这种模式中，确认是在会话层上进行，确认一个被消费的消息将自动确认所有已被会话消费的消息。例如，如果一个消息消费者消费了10 个消息，然后确认第5个消息，那么所有10个消息都被确认。

Session.DUPS_ACKNOWLEDGE:该选择只是会话迟钝的确认消息的提交。如果JMS provider失败，那么可能会导致一些重复的消息。如果是重复的消息，那么JMS provider 必须把消息头的JMSRedelivered字段设置为true

消息持久性，JMS 支持以下两种消息提交模式:

PERSISTENT:指示JMS provider持久保存消息，以保证消息不会因为JMS provider的失败而丢失

NON_PERSISTENT:不要求JMS provider持久保存消息

消息优先级

可以使用消息优先级来指示JMS provider首先提交紧急的消息。优先级分10个级别，从0(最低)到9(最高)。如果不指定优先级，默认级别是4。需要注意的是，JMS provider并不一定保证按照优先级的顺序提交消息

消息过期

可以设置消息在一定时间后过期，默认是永不过期

消息的临时目的地

可以通过会话上的createTemporaryQueue 方法和createTemporaryTopic 方法来创建临时目的地。它们的存在时间只限于创建它们的连接所保持的时间。只有创建该临时目的地的连接上的消息消费者才能够从临时目的地中提取消息

持久订阅

首先消息生产者必须使用PERSISTENT提交消息。客户可以通过会话上的createDurableSubscriber方法来创建一个持久订阅，该方法的第一个参数必须是一个topic。第二个参数是订阅的名称。

JMS provider会存储发布到持久订阅对应的topic上的消息。如果最初创建持久订阅的客户或者任何其它客户，使用相同的连接工厂和连接的客户ID，相同的主题和相同的订阅名，再次调用会话上的createDurableSubscriber方法，那么该持久订阅就会被激活。

JMS provider会向客户发送客户处于非激活状态时所发布的消息。

持久订阅在某个时刻只能有一个激活的订阅者。持久订阅在创建之后会一直保留，直到应用程序调用会话上的unsubscribe方法。

本地事务

在一个JMS客户端，可以使用本地事务来组合消息的发送和接收。

JMS Session接口提供了commit和rollback方法。

事务提交意味着生产的所有消息被发送，消费的所有消息被确认;

事务回滚意味着生产的所有消息被销毁，消费的所有消息被恢复并重新提交，除非它们已经过期。

事务性的会话总是牵涉到事务处理中，commit或rollback方法一旦被调用，一个事务就结束了，而另一个事务被开始。关闭事务性会话将回滚其中的事务。

需要注意的是，如果使用请求/回复机制，即发送一个消息，同时希望在同一个事务中等待接收该消息的回复，那么程序将被挂起，因为知道事务提交，发送操作才会真正执行。

需要注意的还有一个，消息的生产和消费不能包含在同一个事务中。

JMS的PTP模型

JMS PTP(Point-to-Point)模型定义了客户端如何向队列发送消息，从队列接收消息，以及浏览队列中的消息。

PTP模型是基于队列的，生产者发消息到队列，消费者从队列接收消息，队列的存在使得消息的异步传输成为可能。和邮件系统中的邮箱一样，队列可以包含各种消息，JMS Provider 提供工具管理队列的创建、删除。

PTP的一些特点:

1:如果在Session 关闭时，有一些消息已经被收到，但还没有被签收 (acknowledged)，那么，当消费者下次连接到相同的队列时，这些消息还会被再次接收

2:如果用户在receive 方法中设定了消息选择条件，那么不符合条件的消息会留在队列中，不会被接收到

3:队列可以长久地保存消息直到消费者收到消息。消费者不需要因为担心消息会丢失而时刻和队列保持激活的连接状态，充分体现了异步传输模式的优势

JMS的Pub/Sub模型

JMS Pub/Sub 模型定义了如何向一个内容节点发布和订阅消息，这些节点被称作topic 主题可以被认为是消息的传输中介，发布者(publisher)发布消息到主题，订阅者(subscribe) 从主题订阅消息。主题使得消息订阅者和消息发布者保持互相独立，不需要接触即可保证消息的传送。

Pub/Sub的一些特点:

1:消息订阅分为非持久订阅和持久订阅

非持久订阅只有当客户端处于激活状态，也就是和JMS Provider保持连接状态才能收到发送到某个主题的消息，而当客户端处于离线状态，这个时间段发到主题的消息将会丢失，永远不会收到。

持久订阅时，客户端向JMS 注册一个识别自己身份的ID，当这个客户端处于离线时，JMS Provider会为这个ID 保存所有发送到主题的消息，当客户再次连接到JMS Provider时，会根据自己的ID 得到所有当自己处于离线时发送到主题的消息。

2:如果用户在receive 方法中设定了消息选择条件，那么不符合条件的消息不会被接收

3:非持久订阅状态下，不能恢复或重新派送一个未签收的消息。只有持久订阅才能恢复或重新派送一个未签收的消息。

4:当所有的消息必须被接收，则用持久订阅。当丢失消息能够被容忍，则用非持久订阅

一个JMS应用的基本步骤

JMS开发的基本步骤

1:创建一个JMS connection factory

2:通过connection factory来创建JMS connection

3:启动JMS connection

4:通过connection创建JMS session

5:创建JMS destination

6:创建JMS producer,或者创建JMS message，并设置destination

7:创建JMS consumer，或者是注册一个JMS message listener

8:发送或者接受JMS message(s)

9:关闭所有的JMS资源(connection, session, producer, consumer等)

关于持久化和非持久化消息

非持久的Topic消息示例

对于非持久的Topic消息的发送基本跟前面发送队列信息是一样的，只是把创建Destination的地方，由创

建队列替换成创建Topic，例如:

Destination destination = session.createTopic("MyTopic");

对于非持久的Topic消息的接收

1:必须要接收方在线，然后客户端再发送信息，接收方才能接收到消息

2:同样把创建Destination的地方，由创建队列替换成创建Topic，例如:

Destination destination = session.createTopic("MyTopic");

3:由于不知道客户端发送多少信息，因此改成while循环的方式了，例如:

Message message = consumer.receive();
while(message!=null) {

TextMessage txtMsg = (TextMessage)message;

System.out.println("收到消息:" + txtMsg.getText());

message = consumer.receive(1000L);

}

对于持久的Topic消息的发送

ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://192.168.1.106:61616");

Connection connection = connectionFactory.createConnection();

Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);

Topic destination = session.createTopic("MyTopic");

MessageProducer producer = session.createProducer(destination);

producer.setDeliveryMode(DeliveryMode.PERSISTENT);

connection.start();

for (int i = 0; i < 2; i++) {

TextMessage message = session.createTextMessage("messagedd--" + i);

Thread.sleep(1000);

// 通过消息生产者发出消息

producer.send(message);

}

session.commit();

session.close();

connection.close();

1:要用持久化订阅，发送消息者要用 DeliveryMode.PERSISTENT 模式发现，在连接之前设定

2:一定要设置完成后，再start 这个 connection

对于持久的Topic消息的接收

ConnectionFactory cf = new ActiveMQConnectionFactory("tcp://192.168.1.106:61616");

Connection connection = cf.createConnection();

connection.setClientID("cc1");

final Session session = connection.createSession(Boolean.TRUE, Session.AUTO_ACKNOWLEDGE);

Topic destination = session.createTopic("MyTopic");

TopicSubscriber ts = session.createDurableSubscriber(destination, "T1");

connection.start();

Message message = ts.receive();

while (message != null) {

TextMessage txtMsg = (TextMessage) message;

session.commit();

System.out.println("收到消息:" + txtMsg.getText());

message = ts.receive(1000L);

}

session.close();

connection.close();

1:需要在连接上设置消费者id，用来识别消费者

2:需要创建TopicSubscriber来订阅

3:要设置好了过后再start 这个 connection

4:一定要先运行一次，等于向消息服务中间件注册这个消费者，然后再运行客户端发送信息，这个时候，

无论消费者是否在线，都会接收到，不在线的话，下次连接的时候，会把没有收过的消息都接收下来。

持久化消息

这是 ActiveMQ 的默认传送模式，此模式保证这些消息只被传送一次和成功使用一次。对于这些消息，可靠性是优先考虑的因素。可靠性的另一个重要方面是确保持久性消息传送至目标后，消息服务在向消费者传送它们之前不会丢失这些消息。

这意味着在持久性消息传送至目标时，消息服务将其放入持久性数据存储。如果消息服务由于某种原因导致失败，它可以恢复此消息并将此消息传送至相应的消费者。虽然这样增加了消息传送的开销，但却增加了可靠性。

非持久化消息

保证这些消息最多被传送一次。对于这些消息，可靠性并非主要的考虑因素。此模式并不要求持久性的数据存储，也不保证消息服务由于某种原因导致失败后消息不会丢失。

有两种方法指定传送模式:

1.使用setDeliveryMode 方法，这样所有的消息都采用此传送模式; 如:

producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

2.使用send 方法为每一条消息设置传送模式

用ActiveMQ构建应用

Broker:相当于一个ActiveMQ服务器实例

n 命令行启动参数示例如下:

1:activemq start :使用默认的activemq.xml来启动

2:activemq start xbean:file:../conf/activemq-2.xml :使用指定的配置文件

来启动 3:如果不指定file，也就是xbean:activemq-2.xml，那么xml必须在classpath下面

n 用ActiveMQ来构建Java应用

这里主要将用ActiveMQ Broker作为独立的消息服务器来构建JAVA应用。

ActiveMQ也支持在vm中通信基于嵌入式的broker，能够无缝的集成其它java应用

嵌入式Broker启动

1:Broker Service启动broker ，示例如下:

BrokerService broker = new BrokerService(); broker.setUseJmx(true); broker.addConnector("tcp://localhost:61616"); broker.start();

2:BrokerFactory启动broker ，示例如下:

String Uri = "properties:broker.properties";

BrokerService broker1 = BrokerFactory.createBroker(new URI(Uri)); broker1.addConnector("tcp://localhost:61616");

broker1.start();

3:broker.properties的内容示例如下:

useJmx=true

persistent=false
brokerName=Cheese

利用Spring集成Broker，Spring的配置文件如下: <beans>

<constructor-arg index="0" value="admin" />

<constructor-arg index="1" value="password" />

<constructor-arg index="2" value="admins,publisher,consumers" />

</bean>

<constructor-arg index="0" value="publisher" />

<constructor-arg index="1" value="password" />

<constructor-arg index="2" value="publisher,consumers" />

</bean>

<constructor-arg index="0" value="consumer" />

<constructor-arg index="1" value="password" />

<constructor-arg index="2" value="consumers" />

</bean>

<constructor-arg index="0" value="guest" />

<constructor-arg index="1" value="password" />

<constructor-arg index="2" value="guests" />

</bean>

<util:list>

</util:list>

</property>

</bean>

<list>

<value>tcp://localhost:61616</value>

</list>

</property>

<list>

</list>

</property>

</bean>

或者配置BrokerFactoryBean，示例如下:

<beans>

</bean>

</beans>

ActiveMQ的启动:

1:可以通过在应用程序中以编码的方式启动broker，例如: broker.start(); 如果需要启动多个broker，那么需要为broker设置一个名字。例如:

BrokerService broker = new BrokerService(); broker.setName("fred"); broker.addConnector("tcp://localhost:61616"); broker.start();

2:还可以通过spring来启动，前面已经演示过了

ActiveMQ结合Spring开发

Spring提供了对JMS的支持，需要添加Spring支持jms的包，如下:

<groupId>org.springframework</groupId>

<artifactId>spring-jms</artifactId>

<version>4.0.3.RELEASE</version>

</dependency>

添加ActiveMQ的pool包

<groupId>org.apache.activemq</groupId>

<artifactId>activemq-pool</artifactId>

</dependency>

然后需要在Spring的配置文件中，配置jmsTemplate，示例如下:

</property>

</bean>

</property>

</bean>

</property>

</bean>

<constructor-arg index="0" value="spring-queue" />

</bean>

//queue消息发送

//@Autowired

private JmsTemplate jt = null;

public static void main(String[] args) {

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

SpringJMSClient ct = (SpringJMSClient) ctx.getBean("springJMSClient");

ct.jt.send(new MessageCreator() {

public Message createMessage(Session s) throws JMSException {

TextMessage msg = s.createTextMessage("Spring msg===");

return msg;

}

});

}

//n queue消息接收

//@Autowired

private JmsTemplate jt = null;

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

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

SpringJMSReceiverClient ct = (SpringJMSReceiverClient) ctx.getBean("springJMSReceiverClient");

String msg = (String) ct.jt.receiveAndConvert();

System.out.println("msg===" + msg);

}

如果topic的话，首先需要修改spring的配置: 先添加topic的配置，当然，需要修改jmsTemplate配置里面的

defaultDestination，如果不想修改这个配置，那么直接把Destination注入程序，在程序

里面选择发送的Destination也可以:

<constructor-arg index="0" value="spring-topic" />

</bean>

其他的客户端发送和接收跟队列基本是一样的。

如果想要在Spring中配置消费者的话，就不需要再启动接收的客户端了，配置如下:

</bean>

</bean>

当然，需要写一个类来实现消息监听，如:

public class MyMessageListener implements MessageListener {

public void onMessage(Message arg0) {

TextMessage msg = (TextMessage) arg0;

try {

System.out.println("receive txt msg===" + msg.getText());

} catch (JMSException e) {

e.printStackTrace();

}

这样测试的时候，只需要启动消息生产者就好了

ActiveMQ结合Spring开发最佳实践和建议

1:Camel框架支持大量的企业集成模式，可以大大简化集成组件间的大量服务和复杂的消息流。而Spring框架更注重简单性，仅仅支持基本的最佳实践。

2:Spring消息发送的核心架构是JmsTemplate，隔离了像打开、关闭Session和Producer的繁琐操作，因此应用开发人员仅仅需要关注实际的业务逻辑。但是 JmsTemplate损害了ActiveMQ的PooledConnectionFactory对session和消息 producer的缓存机制而带来的性能提升。

3:新的Spring里面，可以设置 org.springframework.jms.connection.CachingConnectionFactory的 sessionCacheSize ，或者干脆使用ActiveMQ的PooledConnectionFactory

4:不建议使用JmsTemplate的receive()调用，因为在JmsTemplate上的所有调用都是同步的，这意味着调用线程需要被阻塞，直到方法返回，这对性能影响很大

5:请使用DefaultMessageListenerContainer，它允许异步接收消息并缓存session 和消息consumer，而且还可以根据消息数量动态的增加或缩减监听器的数量

连接到ActiveMQ

Connector:ActiveMQ提供的，用来实现连接通讯的功能。包括:client-to- broker、broker-to-broker。 ActiveMQ允许客户端使用多种协议来连接

配置Transport Connector，在conf/activemq.xml里面，大致如下:

</transportConnectors>

ActiveMQ支持的client-broker通讯协议如下:

1:TCP:这个也是缺省使用的协议

2:NIO

3:UDP

4:SSL

5:Http(s)

6:VM:

如果客户端和broker在一个虚拟机内的话，通过VM协议通讯在VM内通讯，从而减少网络传输的开销

ActiveMQ支持的传输协议和配置

Transmission Control Protocol (TCP)

1:这是默认的Broker配置，TCP的Client监听端口是61616。

2:在网络传输数据前，必须要序列化数据，消息是通过一个叫wire protocol的来序列化成字节流。默认情况下，ActiveMQ把wire protocol叫做OpenWire，它的目的是促使网络上的效率和数据快速交互。

3:TCP连接的URI形式:tcp://hostname:port?key=value&key=value，加粗部分是必须的

4:TCP传输的优点:

(1) TCP协议传输可靠性高，稳定性强

(2)高效性:字节流方式传递，效率很高

(3)有效性、可用性:应用广泛，支持任何平台

5:所有关于Transport协议的可配置参数，可以参见: http://activemq.apache.org/configuring-version-5-transports.html

New I/O API Protocol(NIO)

1:NIO协议和TCP协议类似，但NIO更侧重于底层的访问操作。它允许开发人员对同一资源可有更多的client调用和服务端有更多的负载。

2:适合使用NIO协议的场景:

(1)可能有大量的Client去链接到Broker上,一般情况下，大量的Client去链接Broker是被操作系统的线程数所限制的。因此， NIO的实现比TCP需要更少的线程去运行，所以建议使用NIO协议

(2)可能对于Broker有一个很迟钝的网络传输 NIO比TCP提供更好的性能

3:NIO连接的URI形式:nio://hostname:port?key=value

4:Transport Connector配置示例: <transportConnectors>

上面的配置，示范了一个TCP协议监听61616端口，一个NIO协议监听61618端口

User Datagram Protocol(UDP)

1:UDP和TCP的区别

(1)TCP是一个原始流的传递协议，意味着数据包是有保证的，换句话说，数据包是不会被复制和丢失的。UDP，另一方面，它是不会保证数据包的传递的

(2)TCP也是一个稳定可靠的数据包传递协议，意味着数据在传递的过程中不会被丢失。这样确保了在发送和接收之间能够可靠的传递。相反，UDP仅仅是一个链接协议，所以它没有可靠性之说

2:从上面可以得出:TCP是被用在稳定可靠的场景中使用的;UDP通常用在快速数据传递和不怕数据丢失的场景中，还有ActiveMQ通过防火墙时，只能用UDP

3:UDP连接的URI形式:

udp://hostname:port?key=value

4:Transport Connector配置示例: <transportConnectors>

Secure Sockets Layer Protocol (SSL)

1:连接的URI形式:ssl://hostname:port?key=value 2:Transport Connector配置示例: <transportConnectors>

Hypertext Transfer Protocol (HTTP/HTTPS)

1:像web和email等服务需要通过防火墙来访问的，Http可以使用这种场合

2:连接的URI形式:http://hostname:port?key=value或者 https://hostname:port?key=value

3:Transport Connector配置示例:

VM Protocol(VM)

1:VM transport允许在VM内部通信，从而避免了网络传输的开销。这时候采用的连接不是socket连接，而是直接的方法调用。

2:第一个创建VM连接的客户会启动一个embed VM broker，接下来所有使用相同的broker name的VM连接都会使用这个broker。当这个broker上所有的连接都关闭的时候，这个broker也会自动关闭。

3:连接的URI形式:vm://brokerName?key=value

4:Java中嵌入的方式:

vm:broker:(tcp://localhost:6000)?brokerName=embeddedbroker&persistent=false ，

定义了一个嵌入的broker名称为embededbroker以及配置了一个 tcptransprotconnector在监听端口6000上 5:使用一个加载一个配置文件来启动broker vm://localhost?brokerConfig=xbean:activemq.xml

ActiveMQ的消息存储持久化

概述 ActiveMQ不仅支持persistent和non-persistent两种方式，还支持消息的恢复( recovery )方式。 PTP Queue的存储是很简单的，就是一个FIFO的Queue

PUB/SUB

对于持久化订阅主题，每一个消费者将获得一个消息的复制。

有效的消息存储 ActiveMQ提供了一个插件式的消息存储，类似于消息的多点传播，主要实现了如下几种:

1:AMQ消息存储-基于文件的存储方式，是以前的默认消息存储

2:KahaDB消息存储-提供了容量的提升和恢复能力，是现在的默认存储方式

3:JDBC消息存储-消息基于JDBC存储的

4:Memory 消息存储-基于内存的消息存储

KahaDB Message Store概述 KahaDB是目前默认的存储方式，可用于任何场景，提高了性能和恢复能力。消息存储使用一个事务日志和仅仅用一个索引文件来存储它所有的地址。

KahaDB是一个专门针对消息持久化的解决方案，它对典型的消息使用模式进行了优化。在Kaha中，数据被追加到data logs中。当不再需要log文件中的数据的时候，log文件会被丢弃。

KahaDB基本配置例子

</persistenceAdapter>

可用的属性有:

1:director:KahaDB存放的路径，默认值activemq-data

2:indexWriteBatchSize: 批量写入磁盘的索引page数量，默认值1000

3:indexCacheSize:内存中缓存索引page的数量，默认值10000

4:enableIndexWriteAsync:是否异步写出索引，默认false

5:journalMaxFileLength:设置每个消息data log的大小，默认是32MB

6:enableJournalDiskSyncs:设置是否保证每个没有事务的内容，被同步写入磁盘，JMS持久化的时候需要，默认为true

7:cleanupInterval:在检查到不再使用的消息后，在具体删除消息前的时间，默认30000

8:checkpointInterval:checkpoint的间隔时间，默认5000

9:ignoreMissingJournalfiles:是否忽略丢失的消息日志文件，默认false 10:checkForCorruptJournalFiles:在启动的时候，将会验证消息文件是否损坏，默认false 11:checksumJournalFiles:是否为每个消息日志文件提供checksum，默认false

12:archiveDataLogs: 是否移动文件到特定的路径，而不是删除它们，默认false

13:directoryArchive:定义消息已经被消费过后，移动data log到的路径，默认null 14:databaseLockedWaitDelay:获得数据库锁的等待时间 (used by shared master/slave)，默认10000

15:maxAsyncJobs:设置最大的可以存储的异步消息队列，默认值10000，可以和concurrent MessageProducers 设置成一样的值

16:concurrentStoreAndDispatchTransactions:是否分发消息到客户端，同时事务存储消息，默认true 17:concurrentStoreAndDispatchTopics:是否分发Topic消息到客户端，同时进行存储，默认true 18:concurrentStoreAndDispatchQueues:是否分发queue消息到客户端，同时进行存储，默认true

在Java中内嵌使用Broker，使用KahaDB的例子

public class EmbeddedBrokerUsingKahaDBStoreExample {

BrokerService createEmbeddedBroker() throws Exception {

BrokerService broker = new BrokerService();

File dataFileDir = new File("target/amq-in-action/kahadb");

KahaDBStore kaha = new KahaDBStore();

kaha.setDirectory(dataFileDir);

// Using a bigger journal file

// kaha.setJournalMaxFileLength(1024*100);

// small batch means more frequent and smaller writes

// kaha.setIndexWriteBatchSize(100);

// do the index write in a separate thread

// kaha.setEnableIndexWriteAsync(true);

// broker.setPersistenceAdapter(kaha);

// create a transport connector

// broker.addConnector("tcp://localhost:61616");

// start the broker

broker.start();

return broker;

}

AMQ Message Store概述

AMQ Message Store是ActiveMQ5.0缺省的持久化存储，它是一个基于文件、事务存储设计为快速消息存储的一个结构，该结构是以流的形式来进行消息交互的。这种方式中，Messages被保存到data logs中，同时被reference store进行索引以提高存取速度。Date logs由一些单独的data log文件组成，缺省的文件大小是 32M，如果某个消息的大小超过了data log文件的大小，那么可以修改配置以增加 data log文件的大小。如果某个data log文件中所有的消息都被成功消费了，那么这个data log文件将会被标记，以便在下一轮的清理中被删除或者归档。

AMQ Message Store配置示例

</persistenceAdapter>
</broker>

使用JDBC来持久化消息 ActiveMQ支持使用JDBC来持久化消息，预定义的表如下:

1:消息表，缺省表名为ACTIVEMQ_MSGS，queue和topic都存在里面，结构如下:

2:ACTIVEMQ_ACKS表存储持久订阅的信息和最后一个持久订阅接收的消息ID，结构如下:

3:锁定表，缺省表名为ACTIVEMQ_LOCK，用来确保在某一时刻，只能有一个 ActiveMQ broker实例来访问数据库，结构如下:

使用JDBC来持久化消息的配置示例

<beans>

</persistenceAdapter>

</broker>

<value>org.gjt.mm.mysql.Driver</value>

</property>

<value>jdbc:mysql://192.168.1.100:3306/test?useUnicode=true&characterEncodi ng=UTF-8</value>

</property>

</property>

</bean>

</beans>

JDBC Message Store with ActiveMQ Journal

这种方式克服了JDBC Store的不足，使用快速的缓存写入技术，大大提高了性能。配置示例如下:

<beans>

</persistenceFactory>

</broker>

</beans>

JDBC Store和JDBC Message Store with ActiveMQ Journal的区别

1:Jdbc with journal的性能优于jdbc

2:Jdbc用于master/slave模式的数据库分享

3:Jdbc with journal不能用于master/slave模式

4:一般情况下，推荐使用jdbc with journal

Memory Message Store 内存消息存储主要是存储所有的持久化的消息在内存中。这里没有动态的缓存存在，所以你必须注意设置你的broker所在的JVM和内存限制

Memory Message Store配置示例

<beans>

</transportConnectors>

</broker>

</beans>

在Java中内嵌使用Broker，使用Memory的例子

public void createEmbeddedBroker() throws Exception {

BrokerService broker = new BrokerService();

broker.setPersistent(false);

broker.addConnector("tcp://localhost:61616");

broker.start();

}

霁空

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ActiveMQ(一)

ActiveMQ简介ActiveMQ是什么ActiveMQ是Apache推出的，一款开源的，完全支持JMS1.1和J2EE 1.4规范的JMS,Provider实现的消息中间件(Message Oriented Middleware，MOM)ActiveMQ能干什么最主要的功能就是:实现JMS Provider，用来帮助实现高可用、高性能、可伸缩、易用和安全的企业级面向消息服务...
复制链接

扫一扫