Spring 提供了JMS的集成，简化JMS的使用，提供的API封装类似于Spring的JDBC集成。

JMS的功能大体上分为两类——接收、发送消息。Spring提供了：

1. JmsTemplate来完成消息的发送、同步接收
2. 消息监听器容器（message listener containers）来异步的接收消息（事件驱动）

JmsTemplate是Spring的jms-core包的核心类，它封装了资源的创建、释放部分，简化收发消息的代码。

JmsTemplate类是线程安全的，除非需要不同的收发配置（QoS），整个系统可以仅仅使用单例的JmsTemplaet。

发送消息时，你可以提供一个MessageCreator回调来实现消息发送：

jmsTemplate.send( queueName, new MessageCreator() {
    @Override
    public Message createMessage( Session session ) throws JMSException {
        return session.createTextMessage( ... );
    }
} );

如果需要使用更加复杂的JMS API，可以调用下面的方法：

jmsTemplate.execute( new SessionCallback<Object>() {
    public Object doInJms( Session session ) throws JMSException {
        return null;
    }
} );
jmsTemplate.execute( new ProducerCallback<Object>() {
    public Object doInJms( Session session, MessageProducer producer ) throws JMSException {
        return null;
    }
} );

JMS API中有很多QoS设置项，例如优先级、TTL，这些都暴露为JmsTemplate的属性。你可以根据业务需要创建多个JmsTemplate。某些JMS实现在ConnectionFactory级别管理QoS设置，要明确指定使用JmsTemplate上的QoS选项，需要调用

jmsTemplate.setExplicitQosEnabled( true )

JmsTemplate集成了简单请求/应答模式的支持：

Message response = jmsTemplate.sendAndReceive( session -> {
    Message msg = session.createTextMessage();
    msg.setJMSReplyTo( "临时答复队列名称" );
    return msg;
} );

你需要为JmsTemplate提供一个ConnectionFactory的引用，后者属于JMS规范的一部分，任何JMS提供商都需要实现。ConnectionFactory是创建到MOM中间件连接的工厂。

标准的JMS API，在收发消息时需要使用很多中间对象：ConnectionFactory ⇨ Connection ⇨ Session ⇨ MessageProducer ⇨ send()。这些中间对象如果反复创建、销毁，会影响性能。Spring提供了一些具有缓存能力的ConnectionFactory实现：

Spring支持类似于EJB的消息驱动Bean的功能，该功能由消息监听容器实现，你可以用XML配置或者注解驱动的方式，指定POJO的方法会自动被调用以完成消息的处理。

消息监听容器负责从JMS队列/主题监听消息，并负责管理多线程的消息消费、事务管理、资源获取/是否。

消息监听容器的实现类主要有：

<!--
  container-type = default表示DefaultMessageListenerContainer
  concurrency = 1 表示每一个jms:listener对应的Session/Consumer个数（也就是线程数？）
  destination-type = durableTopic 表示目标是持久化订阅，这种情况下 client-id + subscription是必须的
  cache为缓存方式：
      none：不缓存
      connection：为每个监听器线程缓存Connection对象
      session：为每个监听器线程缓存Connection、Session对象
      consumer：为每个监听器线程缓存Connection、Session、Consumer对象
      auto：默认值，通常取值consumer，但是指定了外部事务管理器时，取值none
      transaction-manager：事务管理器
-->
<jms:listener-container container-type="default" connection-factory="cf" acknowledge="auto" concurrency="1"
                        destination-type="durableTopic" client-id="APP" cache="auto">
    <jms:listener destination="监听的主题" ref="你提供的回调Bean" method="你提供的回调方法" subscription="持久化订阅名称"/>
</jms:listener-container>

<!-- 不使用JMS名字空间时的类似配置 -->
<bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
    <property name="messageListener" ref="messageListener" />
</bean>
<bean id="messageListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
    <constructor-arg>
        <bean class="你提供的回调Bean"/>
    </constructor-arg>
    <property name="defaultListenerMethod" value="你提供的回调方法"/>
    <!-- 禁止消息类型转换 -->
    <property name="messageConverter">
        <null/>
    </property>
</bean>

编程式配置DMLC：

@Configuration
@EnableJms
public class AppConfig {

    @Bean
    public DefaultJmsListenerContainerFactory jmsListenerContainerFactory() {
        DefaultJmsListenerContainerFactory factory =
                new DefaultJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory());
        factory.setDestinationResolver(destinationResolver());
        factory.setConcurrency("3-10");
        return factory;
    }
}

监听器配置：

@Component
public class MyService {
    // 使用@Header注入单个消息头、使用@Headers注入所有消息头，接收参数必须为Map
    // 使用@Payload可以明确指定接收载荷的参数
    // Message、Session可以被注入
    @JmsListener(destination = "queue")
    public void processOrder(String data, @Header("ordertype") String orderType) {
    }
    
    
    @JmsListener(destination = "myDestination")
    @SendTo("status") // 可以指定应答队列
    public OrderStatus processOrder(Order order) {
        return status;
    }
} 

这个组件允许你把任意POJO作为MDP（消息驱动POJO）使用，而不需要实现MessageListener接口：

public class MessageListenerAdapter implements MessageListener, SessionAwareMessageListener<Message>{
    public MessageListenerAdapter(Object delegate) {
         setDelegate(delegate);
    }
}

构造方法参数delegate可以是任何对象， MessageListenerAdapter假设它实现以下接口：

public interface MessageDelegate {
    // 根据消息类型的不同，自动选择调用的方法
    void handleMessage(String message);
    void handleMessage(Map message);
    void handleMessage(byte[] message);
    void handleMessage(Serializable message);
}

delegate也可以提供其它形式的方法，但是需要指定defaultListenerMethod配置。 

回调方法可以具有参数，对应接收到的消息，也可以具有返回值，对应发送到原始消息Reply-To字段指定的，或者listener默认配置的应答队列的应答消息。

参数类型可以是各种各样的，但是需要messageConverter的配合。

Spring提供了针对单个ConnectionFactory的JmsTransactionManager，事务资源是绑定到线程的。JmsTransactionManager会自动检测到事务资源并打开之。

在JEE环境下，ConnectionFactory可能对Connection、Session进行缓存，资源因而是跨事务重用的。在独立运行环境下，使用Spring的SingleConnectionFactory会导致Connection共享，而每个事务使用独立的Session。

JmsTemplate也可以使用JtaTransactionManager + 支持XA的ConnectionFactory，以支持分布式事务。

在独立运行环境下，你需要设置JmsTemplate的sessionAcknowledgeMode、sessionTransacted来告知Spring是否使用Jms事务。当联用PlatformTransactionManager、JmsTemplate时，JmsTemplate总是提供事务性的Session对象

JmsTemplate的

convertAndSend()

receiveAndConvert()

如果要对转换后，发送前对JMS消息对象进行处理，可以使用MessagePostProcessor：

jmsTemplate.convertAndSend( queue, map, new MessagePostProcessor() {
    public Message postProcessMessage( Message message ) throws JMSException {
        message.setIntProperty( "AccountID", 1000 );
        message.setJMSCorrelationID( "123-00001" );
        return message;
    }
} );

通过JMX查看ActiveMQ队列状态，发现消息已经被消费。打开WARN级别的Spring日志，发现报方法找不到。配置的回调方法：

public void onP2PMessage( Message message ) throws Exception {
}

此问题的原因是，回调方法的参数必须是JMS消息的载荷。因此，对于TextMessage，回调参数类型应该是String。 

The post Spring对JMS的支持 appeared first on 绿色记忆.

中间件是一类连接软件组件和应用的计算机软件，它包括一组服务。 以便于运行在一台或多台机器上的多个软件通过网络进行交互。该技术所提供 的互操作性，推动了一致分布式体系架构的演进，通常用于支持并简化 那些复杂的分布式应用程序。

所谓面向消息的中间件（Message-orientedMiddleware，MOM） ，它的基本功能是：将信息以消息的形式，从一个应用程序传送到另一个或多个应用程序。其主要特征包括：

1. 消息以异步的方式发送和接收，消息发送者不需要等待消息接受者的响应
2. 可靠传输，数据不能丢失，有的时候，也会要求不能重复传输
3. 事务性以及分布式事务(XA)支持，可以和其他MOM、数据库等资源进行事 务性支持，确保操作的原子性

Java消息服务（Java Message Service，JMS）定义了Java中访问消息中间件的 接口。JMS只是接口，并没有给予实现，实现JMS接口的消息中间件称为 JMS Provider，例如ActiveMQ。

在JMS编程模型中，JMS客户端(组件或应用程序)通过JMS消息服务交换消息。 消息生产者将消息发送至消息服务，消息消费者则从消息服务接收这些消息。

这些消息的传送操作是使用一组实现JMS应用编程接口(API)的对象(由 JMSProvide提供)来执行的。

在JMS编程模型中JMS客户端使用 ConnectionFactory对象创建一个连接，向消息服务发送消息以及从消息服务接收消息均是通过此连接来进行。

Connection是客户端与消息服务的活动连接。 创建连接时，将分配通信资源以及验证客户端。这是一个相当重要的对象，大多数客户端均使用一个连接来进行所有的消息传送。连接用于创建会话。

Session是一个用于生成和使用消息的单线程上下文。它用于创建发送的生产 者和接收消息的消费者，并为所发送的消息定义发送顺序。会话通过大量确认选项或通过事务来支持可靠传送。

客户端使用MessageProducer向指定的物理目标发送消息。生产者可指定一个默认传送模式(持久性消息与非持久性消息)、优先级和有效期值，以控制生产者向物 理目标发送的所有消息。

同样，客户端使用MessageConsumer对象从指定的物 理目标(在API中表示为目标对象)接收消息。消费者可使用消息选择器，借助它，消息服务可以只向消费者发送与选择标准匹配的那些消息。消费者可以支持同步或异步消息接收。异步使用可通过向消费者注册MessageListener来 实现。当会话线程调用MessageListener对象的onMessage方法时，客户端将使用消息。

消息从一个生产者传送至一个消费者。在此传送模型中，目标是一个队列。消息首先被传送至队列目标，然后根据队列传送策略，从该队列将消息传送至向 此队列进行注册的某一个消费者，一次只传送一条消息。可以向队列目标发送 消息的生产者的数量没有限制，但每条消息只能发送至、并由一个消费者成功 使用。如果没有已经向队列目标注册的消费者，队列将保留它收到的消息，并 在某个消费者向该队列进行注册时将消息传送给该消费者。

消息从一个生产者传送至任意数量的消费者。在此传送模型中，目标是一个主 题。消息首先被传送至主题目标，然后传送至所有已订阅此主题的活动消费 者。可以向主题目标发送消息的生产者的数量没有限制，并且每个消息可以发 送至任意数量的订阅消费者。主题目标也支持持久订阅的概念。持久订阅表示 消费者已向主题目标进行注册，但在消息传送时此消费者可以处于非活动状态。 当此消费者再次处于活动状态时，它将接收此信息。

1. 创建连接使用的工厂类JMS ConnectionFactory
2. 使用管理对象 JMS ConnectionFactory 建立连接 Connection
3. 使用连接Connection建立会话Session
4. 使用会话Session和管理对象Destination创建消息生产者 MessageSender
5. 使用消息生产者MessageSender发送消息

1. 创建连接使用的工厂类JMS ConnectionFactory
2. 使用管理对象 JMS ConnectionFactory 建立连接 Connection
3. 使用连接Connection建立会话Session
4. 使用会话Session和管理对象Destination创建消息消费者MessageReceiver
5. 使用消息消费者MessageReceiver接受消息setMessageListener 将 MessageListener 接口绑定到 MessageReceiver

JMS消息只有在被确认之后，才认为已经被成功地消费了。消息的成功消费通常包含三个阶段：

1. 客户接收消息
2. 客户处理消息
3. 消息被确认

在事务性会话中，当一个事务被提交的时候，确认自动发生。在非事务性会话 中，消息何时被确认取决于创建会话时的签收模式(acknowledgement mode)。 该参数有以下三个可选值：

1. Session.AUTO_ACKNOWLEDGE 当客户成功的从receive方法返回的时候或者从MessageListener.onMessage方法成功返回的时候，会话自动确认
2. Sessiion.TRANSACTION 用session.commit()进行签收
3. Session.CLIENT_ACKNOWLEDGE 客户通过消息的acknowledge方法确认消息

ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory( "tcp://brokerHost:brokerPort" );

Connection connection = null;
try {
    //如果代理启用身份验证，这里需要指定用户、密码参数
    connection = factory.createConnection();
    connection.start();
    //创建会话时有事务和确认选项
    Session session = connection.createSession( false, Session.AUTO_ACKNOWLEDGE ); 
   //如果代理上没有队列，则创建，否则，直接使用
    Destination dest = session.createQueue( queueName );
    //创建消息生产者
    MessageProducer producer = session.createProducer( dest );
    //设置消息是否持久化
    producer.setDeliveryMode( DeliveryMode.NON_PERSISTENT ); //创建一个文本消息
    TextMessage message = session.createTextMessage( msg ); //设置消息属性
    message.setIntProperty( "id", 1 );
    producer.send( message );
} finally {
    connection.close();
}

//如果代理上没有主题，则创建，否则，直接使用
Destination dest = session.createTopic( topicName );
//创建消息生产者
MessageProducer producer = session.createProducer( dest );
//设置消息是否持久化
producer.setDeliveryMode( DeliveryMode.NON_PERSISTENT ); //创建一个文本消息
TextMessage message = session.createTextMessage(msg); producer.send( message );
session.commit();

ActiveMQConnectionFactory cf = new ActiveMQConnectionFactory(); 
Properties props = new Properties();
// 设置预读取属性
props.setProperty( "prefetchPolicy.queuePrefetch", "1000" ); 
props.setProperty( "prefetchPolicy.queueBrowserPrefetch", "500" ); 
props.setProperty( "prefetchPolicy.durableTopicPrefetch", "100" ); 
props.setProperty( "prefetchPolicy.topicPrefetch", "32766" ); 
cf.setProperties( props );

Connection connection = null;

try {

    connection = cf.createConnection();
    connection.start(); //创建会话时有事务和确认选项，如果确认选项为:SESSION_TRANSACTED，则必须启用事务
    Session session = connection.createSession( true, Session.SESSION_TRANSACTED ); //如果代理上没有队列，则创建，否则，直接使用
    Destination dest = session.createQueue( queueName );
    //创建消息生产者
    MessageConsumer consumer = session.createConsumer( dest );
    //等待队列里面有消息可消费，最多1秒，超时返回NULL
    long timeout = 1000;
    TextMessage msg = (TextMessage) consumer.receive( timeout );
    String recMsg = msg == null ? null : msg.getText(); //如果设置:Session.CLIENT_ACKNOWLEDGE，则必须手工确认:msg.acknowledge() 
    session.commit();//如果设置:Session.SESSION_TRANSACTED，则必须提交或者回滚 return recMsg;
} finally {
    connection.close();
}

public void subscribeTo1pic( String topicName, final Callback<Void, String> cb ) throws JMSException {
    Connection connection = null;
    try {
        connection = factory.createConnection();
        connection.start();
        Session session = connection.createSession( false, Session.CLIENT_ACKNOWLEDGE );
        Destination dest = session.createTopic( topicName );
        MessageConsumer consumer = session.createConsumer( dest ); 
        //注意:MessageListener亦适用于队列
        consumer.setMessageListener( new MessageListener() {
            @Override
            public void onMessage( Message message ) {
                TextMessage msg = (TextMessage) message;
                try {
                    cb.callback( msg.getText() );
                    msg.acknowledge();
                } catch ( Throwable t ) {
                    LOGGER.error( "Failed to Process message: " + t.getMessage(), t );
                }
            }
        } );
    } finally {
        connection.close();
    }
}

ActiveMQ是一个完全支持JMS1.1和J2EE1.4规范的JMS Provider实现。

1. 多种语言编写客户端:Java, C, C++, C#，Ruby, Perl, Python, PHP
2. 支持多种应用协议:OpenWire、Stomp REST、WS Notification、XMPP、AMQP
3. 完全支持JMS1.1和J2EE1.4规范(持久化，XA消息，事务)。支持分布式事务
4. 对Spring的支持,ActiveMQ可以很容易内嵌到使用Spring的系统里
5. 一支持多种传送协议:in-VM、TCP、SSL、NIO、UDP、JGroups、JXTA
6. 支持通过JDBC和journal提供高速的消息持久化
7. 支持多种集群特征:故障转移(主/从结构，HA)、ActiveMQ网络集群
8. 支持自动发现:基于组播或者ZeroConf技术，可以自动化的建立ActiveMQ 集群（Network of Brokers，代理网络），或者(客户端)连接到ActiveMQ
9. 与开源ESB产品例如Camel紧密集成
10. 安全性保证:ActiveMQ支持基于SSL的传输，在广域网上保证加密的传输，结 合数字证书，可以保证双向身份验证

即一个运行中的ActiveMQ实例，该实例可以独立运行，也可以嵌入在已有的 JVM中运行。从这个名字也可以看出基于ActiveMQ的消息系统的运行方式。

表示ActiveMQ使用的消息传递机制，这是一个混合的概念，不是简单的指网络 协议或者应用协议。用于将ActiveMQ实例暴露给客户端，或者其它代理以构建代理网络。常用 的传输包括：

在配置传输的同时，可选的可以指定在其上使用的线路协议。Openwire协议最常用，高效、可靠。

ActiveMQ使用一个叫发现代理(Discovery Agent)的机制，来用于发现远程 服务，例如远程代理。使用此机制，可以：

1. 让客户端自动连接到代理
2. 构建 代理的网络。

目前，有两种类型的发现代理：

1. Multicast：ActiveMQ内置的一种发现代理，可以定位代理的URI列表。参考本文稿后续的 Discovery传输
2. Zeroconf：Zeroconf是一种标准，基于UDP/multicast，ActiveMQ使用的是jmDNS库，该库是Zeroconf标准的实现

支持消费者的高可用性、负载均衡：

1. 如果一个Consumer死掉，该消息会转发到其它的Consumer消费的Queue上
2. 如果一个Consumer获得消息比其 它Consumer快，那么他将获得更多的消息
3. 如果一个Conseumer消费缓慢，则 其它Consumer会替换它

如果一个Broker死掉了，Client可以自动链接到其它Broker 上（可以使用故障转移传输failover:// 来配置客户端）。

构建代理集群时，可以使用：

1. 静态发现，静态指定其它代理的列表
2. 动态发现，使用动态发现（组播、零配置）机制自动获取其它代理

可以配置两个Broker的主从关系，并保证二者的状态完全一致。这种方式主要 用于提供高可用性。

ActiveMQ实例（代理）到实例的通信，是跨地域、跨网络的消息可靠传输的关键。通常的部署方式是，在每个局域网设置一个代理，代理与代理在广域网 之间进行交互，客户端与局域网内的代理交互——这样的方式尽量减少广域网 上的流量和连接数。 

代理网络是以通道的形式将一个Broker和其他的Broker链接起来通信。 代理网络默认是单向的:一个Broker在一端发送消息，另一Broker在另一端接 收消息，这就是所谓的“桥接”。

在ActiveMQ 5.x，也可以创建一个双向(duplex)的通道对于两个Broker。他将不仅发送消息而且也能从相同的通道来接收消息。 双向通道的配置，会自动传递到对方代理上。

允许用一个虚拟的destination 代表多个destinations。例如可以通过 composite destinations在一个操作中同时向12个queue发送消息。

用来支持联合的名字分层体系(federated name hierarchies)。ActiveMQ支持以下三种通配符：

1. .

   用作路径上名字间的分隔符

2. *

   用于匹配任意字符，但是不能跨越点号

3. >

   用于匹配任意字符，可以跨越点号

考虑一个报价应用的主题命名，需要区分商品类别、市场名称、商品名称：

默认选项，消息Producer不需要等待Consumer确认签收即完成发送操作。 

ActiveMQ缺省支持批量确认消息。由于批量确认会提高性能，因此这是缺省的 确认方式。 

ActiveMQ可以保证主题的所有消费者以相同的顺序接收消息。

默认的ActiveMQ会保证所有消费者以相同顺序接收来自同一生产者的消息。然而，由于多线程和异步处理，不同生产者产生的消息的接受顺序无法保证。此行为可以通过destinationPolicy实现。

这类消息由ActiveMQ系统内部使用，用于收发系统事件，例如新的消费者的注册。代理网络很大程度上依赖通知消息工作。

可以在内部进行消息格式的转换，提供MessageTransformer接口。 在ActiveMQConnectionFactory、ActiveMQConnection、ActiveMQSession、 ActiveMQMessageConsumer、ActiveMQMessageProducer等对象上调用 setTransformer方法可以设置消息消息转换器。

Queue中的消息是按照顺序被分发到consumers的。然而，当你有多个 consumers同时从相同的queue中提取消息时，你将失去这个保证。因为这些消 息是被多个线程并发的处理。有的时候，保证消息按照顺序处理是很重要的。 例如，你可能不希望在插入订单操作结束之前执行更新这个订单的操作。 ActiveMQ从4.x版本起开始支持Exclusive Consumer (或者说Exclusive Queues)。 Broker会从多个consumers中挑选一个consumer来处理queue中所 有的消息，从而保证了消息的有序处理。如果这个consumer失效，那么broker 会自动切换到其它的consumer。

设置属性JMSXGroupID，可以保证同一个组的数据，仅被发送给一个Consumer。 可以在大消息分割的场景下使用。

JMS Selectors用于在订阅中，基于消息属性和Xpath语法对进行消息的过滤。JMS Selectors由SQL92语义定义。JMS Selectors用于在订阅中，基于消息属性和Xpath语 法对进行消息的过滤。

默认的死信队列名称为:ActivemMQ.DLQ。所有不能消费的消息被传递到该死队列中。 过期消息的处理：

1. 持久化消息默认是存入死信队列，设置

   processExpired=false

   ，则直接删除
2. 非持久化消息，必须设置

   processNonPersistent=true

   才能放入死信队列

要创建分布式队列或主题，需要进行代理之间的通信，ActiveMQ支持两种类型的代理通信方式：

1. 主/从代理：用于提供高可用性，消息在主从代理之间保持复制。当主代理宕机，则从 代理自动接管并提供服务
2. 存储和转发—代理网络：消息从一个在代理之间进行传递，直到其到达消费者那里， 每个消息在一个时刻，只会属于单个代理(即时它宕掉)

分布式队列：Producer发布一个消息到代理，代理将其存储，如果该代理配置了 store/forward到其它代理，消息将会按照一定的算法转发给其它代理。注意:只有目 标代理上有该消息的消费者，消息才会被转发

分布式主题：与分布式队列类似，不同的是，每个队主题感兴趣的客户端，均会 收到一份消息的拷贝，ActiveMQ内置算法保证不会在环形网络中出现无限循环。

本章内容主要讨论ActiveMQ实例（服务器端）的管理和配置。

解压ActiveMQ二进制包到任意目录，把它的bin目录添加到PATH环境变量中。执行InstallService.bat可以安装为Windows服务。

在命令行中执行

activemq start

activemq stop

默认的Web管理控制台位于:http://localhost:8161/admin 默认用户密码均为admin。

默认的运行日志位于data/activemq.log。

默认的消息持久化数据库位于data/kahadb。

ActiveMQ独立运行时，内部维护了一个Spring IoC容器的实例，其相关服务均是以 Spring Bean的形式存在的，因此，嵌入已有JVM运行非常简单，只需要提供Spring 支持即可。 此外，ActiveMQ提供了一系列的API，方便使用纯编程的方式启动、配置实例。

只有在嵌入模式下，才可以使用VM Transport。

ActiveMQ服务器可以已硬编码的方式进行配置，而不使用XML配置文件。通常情况下不需要 使用硬编码方式，除非需要进行运行时动态的控制。 

public void start() throws Exception {
    //代理服务对象
    broker = new BrokerService();


    //基于AMQ日志的持久化适配器
    JournalPersistenceAdapterFactory jpaf = new JournalPersistenceAdapterFactory();
    //日志数量
    jpaf.setJournalLogFiles( 5 );
    //日志文件大小
    jpaf.setJournalLogFileSize( 1024 * 1024 * 128 );
    broker.setPersistenceFactory( jpaf ); //设置持久化机制
    
    // 基于KahaDB的持久化适配器
    KahaDBPersistenceAdapter pa = new KahaDBPersistenceAdapter();
    pa.setCheckForCorruptJournalFiles( true );
    File userHome = new File( System.getProperty( "user.home" ) );
    File amqDataDir = new File( userHome, "ActiveMQ/data" );
    amqDataDir.mkdirs();
    pa.setDirectory( amqDataDir );
    broker.setPersistenceAdapter( pa );

    broker.setBrokerName( "UniqueName" ); //设置代理的名称，每个代理应该具有独特的名称 
    broker.addConnector( "tcp://localhost:61616" ); //设置传输连接器 
    broker.setPersistent( false ); //如果写这一句，那么仅使用内存来存储消息 
    broker.start();
}

public void stop() throws Exception {
    broker.stop();
}

下面的代码示例了两个基于发现传输连接在一起的代理协同工作的场景：

public class DiscoveryBroker {

    public static final String QUEUE_NAME = "AMQ.BrokerB";

    public static BrokerService create( String name ) throws Exception {
        BrokerService broker = new BrokerService();

        broker.setBrokerName( name );
        broker.setPersistent( false );
        broker.setUseJmx( false );

        // 异步启动网络连接器
        broker.setStartAsync( true );

        // 基于发现机制的网络连接器：发现其它代理
        List<NetworkConnector> ncs = new ArrayList<>();
        URI discoveryURI = new URI( "multicast://default?group=pems" );
        // DiscoveryNetworkConnector是默认的网络连接器实现，不管是否基于动态发现
        NetworkConnector nc = new DiscoveryNetworkConnector( discoveryURI );
        // 允许双向通信
        nc.setDuplex( true );
        nc.setName( "NC_" + name );
        ncs.add( nc );

        // 如果使用静态URI，类似：broker.addNetworkConnector("static://tcp://host:port");
        // broker.addNetworkConnector( nc );
        
        broker.setNetworkConnectors( ncs );

        // 基于发现机制的传输连接器：让别人连接到当前代理
        List<TransportConnector> tcs = new ArrayList<>();
        TransportConnector tc = new TransportConnector();
        tc.setUri( new URI( "tcp://0.0.0.0:0" ) );
        tc.setDiscoveryUri( discoveryURI );
        tcs.add( tc );
        broker.setTransportConnectors( tcs );

        return broker;
    }
}

public class DiscoveryBrokerA extends DiscoveryBroker {

    private static final Logger LOGGER = LoggerFactory.getLogger( DiscoveryBrokerA.class );

    public static void main( String[] args ) throws Exception {
        BrokerService brokerA = DiscoveryBroker.create( "BrokerA" );
        brokerA.start();
        new Thread( new Runnable() {
            @Override
            public void run() {
                ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory( "vm://BrokerA" );
                Connection conn;
                try {
                    conn = factory.createConnection();
                    // 连接必须启动
                    conn.start();
                    Session session = conn.createSession( false, Session.AUTO_ACKNOWLEDGE );
                    Destination dest = session.createQueue( QUEUE_NAME );
                    MessageProducer producer = session.createProducer( dest );
                    producer.setDeliveryMode( DeliveryMode.NON_PERSISTENT );
                    List<String> prevChildren = new ArrayList<>();
                    int count = 0;
                    for ( ; ; ) {
                        LOGGER.debug( "Sending message to queue {}", QUEUE_NAME );
                        MapMessage msg = new ActiveMQMapMessage();
                        msg.setString( "name", "Alex" );
                        msg.setInt( "age", 30 );
                        msg.setBoolean( "married", true );
                        Map<String, Object> meng = new LinkedHashMap<>();
                        meng.put( "name", "Meng" );
                        meng.put( "age", 27 );
                        msg.setObject( "spouse", meng );
                        List<String> children = new ArrayList<>( prevChildren );
                        msg.setObject( "children", children );
                        children.add( "Child" + ++count );
                        producer.send( msg );
                        prevChildren = children;

                        TimeUnit.SECONDS.sleep( 10 );
                    }
                } catch ( Exception e ) {
                    LOGGER.error( e.getMessage(), e );
                }
            }
        } ).start();
    }
}

public class DiscoveryBrokerB extends DiscoveryBroker {

    private static final Logger LOGGER = LoggerFactory.getLogger( DiscoveryBrokerB.class );

    public static void main( String[] args ) throws Exception {
        BrokerService brokerB = DiscoveryBroker.create( "BrokerB" );
        brokerB.start();
        new Thread( new Runnable() {
            @Override
            public void run() {
                ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory( "vm://BrokerB" );
                Connection conn;
                try {
                    conn = factory.createConnection();
                    conn.start();
                    Session session = conn.createSession( false, Session.AUTO_ACKNOWLEDGE );
                    Destination dest = session.createQueue( QUEUE_NAME );
                    MessageConsumer consumer = session.createConsumer( dest );
                    consumer.setMessageListener( new MessageListener() {
                        @Override
                        public void onMessage( Message message ) {
                            MapMessage msg = (MapMessage) message;
                            Object children = null;
                            try {
                                children = msg.getObject( "children" );
                            } catch ( JMSException e ) {}
                            LOGGER.debug( "Received message from {}, children property: {}", QUEUE_NAME, children );
                        }
                    } );
                } catch ( JMSException e ) {
                    LOGGER.error( e.getMessage(), e );
                }
            }
        } ).start();
        TimeUnit.SECONDS.sleep( 600 );
    }
}

无论是独立运行还是嵌入已有VM运行，ActiveMQ的配置均是以 Springframework为基础的，整体配置框架如下：

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:amq="http://activemq.apache.org/schema/core" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core.xsd">
    <broker xmlns="http://activemq.apache.org/schema/core" brokerName="localhost" dataDirectory="data/kahadb">
        <networkConnectors>网络连接器，用于构建代理网络</networkConnectors>
        <transportConnectors>传输连接器，代理在此连接器上等待客户端、其它代理的连接</transportConnectors> 
        <persistenceAdapter>配置持久化适配器，实现消息持久化存储</persistenceAdapter> 
        <destinationPolicy>为目标设置各种控制策略</destinationPolicy> 
        <managementContext></managementContext> 
        <systemUsage>限制使用系统资源的量</systemUsage> 
        <plugins></plugins>
    </broker> 
</beans>

transportConnectors子元素用于配置ActiveMQ使用的传输，其每个子元素 transportConnector定义一种传输方式，包含name、uri等元素，可以配置多个传输方式 —— 也就是说一个ActiveMQ实例可以支持很多底层通信机制。

传输连接器可以用于：

1. 虚拟机外部的客户端连接到代理
2. 其它代理连接到当前代理

基本配置格式如下：

<transportConnectors>
    <transportConnector name="" uri=""/>
</transportConnectors>

transportConnector包含以下服务器端选项：

protocol://host:port?key=val&key=val

本节介绍客户端也支持的选项，发起连接的时候可以使用。注意这些选项：

1. 可以在传输URI中作为参数。示例

   tcp://localhost:61616?jms.useAsyncSend=true

2. 也可以通过编程方式设置ActiveMQConnectionFactory、ActiveMQConnection对象的属性
3. 当在brokerURL或者代理的传输连接器中使用这些选项时，必须加上

   jms.

   前缀

选项列表：

Message.setObjectProperty(key, value)
MapMessage.setObject(key, value)

在计算机网络领域，线路协议（wire protocol）这一术语通常和传输协议（transport protocols）—— 例如 TCP或者UDP ——进行区分，它用于在应用程序级别表示信息的方式。这些协议可以是基于文本的，也可以是二进制的。

从5.13.0开始，ActiveMQ支持在TCP、SSL、NIO、NIO SSL之上进行自动的线路协议检测，支持的线路协议包括：OpenWire、STOMP、AMQP、MQTT。

配置示例：

<!-- 在TCP之上的自动线路协议检测 -->
<transportConnector name="auto" uri="auto://localhost:5671"/>
<!-- 在启用SSL的TCP之上的自动线路协议检测 -->
<transportConnector name="auto+ssl" uri="auto+ssl://localhost:5671"/>
<!-- 在NIO TCP之上的自动线路协议检测 -->
<transportConnector name="auto+nio" uri="auto+nio://localhost:5671"/>
<!-- 在NIO SSL TCP之上的自动线路协议检测 -->
<transportConnector name="auto+nio+ssl" uri="auto+nio+ssl://localhost:5671"/>

用于支持在JVM内部进行客户端之间的连接，避免网络占用。第一个启用VM连接的 客户端，会启动一个内嵌的Broker实例。最后一个客户端断开，则会停止实例。

URI示例：

vm://brokerName?transportOptions

更复杂的URI格式：

vm:(broker:(tcp://localhost)?brokerOptions)?transportOptions

 VM传输不是基于网络套接字，而是直接的Java方法调用，因此速度很快。

此传输专有选项： 

高级消息队列协议（Advanced Message Queuing Protocol，AMQP），是提供统一消息服务的应用层标准高级消息队列协议，是一个开放标准。ActiveMQ支持该协议的1.0版本。

注意使用AMQP时，目标的地址前缀以queue://或者topic://，前者为默认，可以省略。

配置示例：

<transportConnectors>
   <transportConnector name="amqp" uri="amqp://0.0.0.0:5672"/>
</transportConnectors>

<!-- AMQP over NIO -->
<transportConnector name="amqp+nio" uri="amqp+nio://localhost:5672"/>
<!-- AMQP over SSL -->
<transportConnector name="amqp+ssl" uri="amqp+ssl://localhost:5671"/>

关于此传输的更多信息，参考ActiveMQ文档。

允许客户端基于TCP套接字连接到远程的ActiveMQ代理。示例：

# 服务器端，在传输连接器的属性中配置
tcp://localhost:61616?transport.threadName&transport.trace=false&transport.soTimeout=60000
# 客户端，在代理URI中配置
tcp://localhost:61616?threadName&trace=false&soTimeout=60000

此传输专有选项： 

此传输和普通的TCP传输很类似，区别仅仅是此传输基于Java NIO API实现，提高了性能和可扩容性。

NIO是仅服务器端的传输配置，如果在客户端使用此传输，会初始化一个常规的TCP传输。注意，最初的NIO传输是TCP + Openwire的替代，其它线路协议 —— AMQP, MQTT, Stomp ——均有自己的NIO实现，配置时协议前缀是xxx+nio，例如：

# MQTT + NIO
mqtt+nio://localhost:1883
# Openwire + NIO
nio://hostname:port?key=value

配置选项和TCP传输相同。此外，你可以设置一些JVM系统属性，来微调NIO传输的线程使用：

允许客户端使用SSL over TCP连接到代理。从5.4开始，任何SSLServerSocket类的选项可以通过?transport.xxx来设置：

ssl://localhost:61616?transport.enabledCipherSuites=SSL_RSA_WITH_RC4_128_SHA,SSL_DH_anon_WITH_3DES_EDE_CBC_SHA
ssl://localhost:61616?transport.needClientAuth=true

基于Spring的JMS客户端配置示例：

<bean id="AMQJMSConnectionFactory" class="org.apache.activemq.ActiveMQSslConnectionFactory">
    <property name="trustStore" value="/path/to/truststore.ts" />
    <property name="trustStorePassword" value="password" />
    <property name="keyStore" value="/path/to/keystore.ks" />
    <property name="keyStorePassword" value="password" />
    <property name="brokerURL" value="ssl://localhost:61616" />
    <property name="userName" value="admin" /> 
    <property name="password" value="admin" />
</bean>

除非

transport.needClientAuth=true

示例：

<transportConnectors>
    <transportConnector name="nio+ssl" uri="nio+ssl://0.0.0.0:61616"/>  
</<transportConnectors>

在客户端使用该传输，会得到一个普通的SSL传输。 

此传输的实现位于activemq-optional包中。使用XML载荷穿过HTTP隧道，可以让ActiveMQ客户端和代理穿越某些网络环境下的防火墙。

对于客户端，除了JMS之外，可以考虑ActiveMQ的REST和Ajax支持。 

从5.4开始，ActiveMQ支持基于HTML5 WebSocket，在浏览器端直接和代理进行交互。

由于JavaScript处理JSON格式很简单，因此Stomp是WebSocket传输下很好的线路协议。从5.9开始，高效的二进制协议MQTT也被支持。

配置示例：

<transportConnectors>
    <transportConnector name="websocket" uri="ws://0.0.0.0:61614"/>
</transportConnectors>
<!-- 启用安全WebSocket，5.7开始支持 -->
<transportConnectors>
    <transportConnector name="secure_websocket" uri="wss://0.0.0.0:61614"/>
</transportConnectors>

<!-- 为代理配置SSL上下文 -->
<sslContext keyStore="file:${activemq.conf}/broker.ks"
    keyStorePassword="password" trustStore="file:${activemq.conf}/broker.ts"
    trustStorePassword="password"
/>

ActiveMQ提供了一种高级别的传输，这些传输总是在上面那些基础传输的更上一层工作。

该传输是一种逻辑传输，在其他传输的上层工作，在ActiveMQ3中，称Reliable传输。 它的价值是保障高可用性，维护一组URI的列表，从中随机(默认)寻找一个进行连接 尝试，如果失败，则会尝试其他的URI。该传输的URI格式：

failover:(uri1,...,uriN)?transportOptions&nestedURIOptions
# 或者
failover:uri1,...,uriN

# 示例
failover:(tcp://localhost:61616,tcp://remotehost:61616)?initialReconnectDelay=100

该传输的选项包括：

故障转移的服务器端配置：

在任何其它传输之上工作，应用重连、复制逻辑。它使用发现传输来检测代理，并复制命令到这些代理。该传输的URI格式：

fanout:(discoveryURI)?transportOptions
# 或
fanout:discoveryURI

 该传输的选项包括：

此传输的工作方式和Failover传输类似，但是它基于所谓发现代理（discovery agent）来定位可以连接的URI的列表。Fanout传输会使用到该传输，以便发现需要复制命令的目标代理。URI格式：

discovery:(discoveryAgentURI)?transportOptions
# 或
discovery:discoveryAgentURI

 想要基于此传输发现代理，目标代理必须启用了组播发现代理。服务器配置示例：

<transportConnectors>
    <!-- 端口0表示随机选择TCP传输端口 ，discoveryUri说明发现代理使用的组播地址，默认 -->
    <!-- URI为multicast://default，即multicast://239.255.2.3:6155 -->
    <transportConnector uri="tcp://localhost:0" discoveryUri="multicast://default"/>
</transportConnectors>

该传输的选项包括：

类似于发现传输，只是它基于ZeroConf协议。URI格式：

zeroconf:serviceName?transportOptions
# 或
zeroconf:serviceName

 服务器端配置示例：

<transportConnectors>
    <transportConnector name="openwire" uri="tcp://0.0.0.0:61616" 
        discoveryUri="zeroconf:_activemq_development" />
</transportConnectors>

在进行传输配置时，你可以指定wireFormat说明要使用何种线路协议，可以指定wireFormat.*来为线路协议指定配置。

 Spring客户端配置示例：

<bean class="org.apache.activemq.ActiveMQConnectionFactory">
    <property name="brokerURL" 
        value="failover:(tcp://localhost:61616?jms.optimizeAcknowledge=false&wireFormat.maxInactivityDuration=30000)"/>
</bean>

为提供无限制可扩展性(scalability )，往往需要把若干ActiveMQ代理连接到一 起，进而让分布在各地的客户端逻辑的连接在一起进行消息交互。代理网络提供了 分布式队列与主题(distributed queues and topics)的支持。

当使用客户端/服务器模型或者星状模型时，代理可能会引起单点故障。启用代理网络后此问题不再存在。

客户端可以连接到代理网络中的任意一个代理，并在此代理出现故障时，转移到其它代理。

默认情况下，代理网络中节点之间的连接是单向的 —— 建立连接通道的代理可以向目标代理发送消息，反过来则不行。从5.x开始，通道可以配置为双向的，这样对于星状结构中位于防火墙背后的Hub可以受益。

配置代理网络最简单的方式是基于Spring的XML配置。支持两种发现代理的机制：

1. 硬编码参与网络的其它代理的URI
2. 使用发现传输

硬编码的示例：

<broker brokerName="receiver" persistent="false" useJmx="false">
    <networkConnectors>
        <!-- 这里指向其它代理通过传输连接器暴露的URI  -->
        <networkConnector uri="static:(tcp://localhost:62001,tcp://host2:62000)"/>
    </networkConnectors>
    <transportConnectors>
        <!-- 本代理暴露的URI -->
        <transportConnector uri="tcp://localhost:62002"/>
    </transportConnectors>
</broker>

基于组播发现的示例：

<broker name="sender" persistent="false" useJmx="false">
    <networkConnectors>
        <!-- 使用组播发现其它代理  -->
        <networkConnector uri="multicast://default"/>
    </networkConnectors>
    <transportConnectors>
        <!-- 所有参与网络的代理都需要这样配置 -->
        <transportConnector uri="tcp://localhost:0" discoveryUri="multicast://default"/>
    </transportConnectors>
</broker>

默认情况下，网络连接器（ network connector）作为代理启动流程的一部分、串行的初始化。如果某些网络很缓慢，会导致整个集群中代理启动都缓慢。从5.5开始你可以设置代理属性

networkConnectorStartAsync="true"

使用硬编码URI时，你可以设置initialReconnectDelay、maxReconnectDelay、useExponentialBackOff、backOffMultiplier这些选项，来控制重连操作：

uri="static:(tcp://host1:61616,tcp://host2:61616)?maxReconnectDelay=5000&useExponentialBackOff=false"

代理网络的一个常见用途是，创建一个Master和多个Slave之间的连接：

<networkConnectors>
    <networkConnector uri="masterslave:(tcp://host1:61616,tcp://host2:61616,tcp://..)"/>
</networkConnectors>

这个通常和failover传输一起使用。 

代理网络执行可靠的消息存储、转发。如果源（消息）是持久的 —— 队列上的持久消息、持久化主题订阅 —— 则代理网络仍然保证其持久性。

但是，如果源是非持久性的，则代理网络不会为其增加持久性特征。当非持久化源 —— 非持久化主题订阅、临时目标 —— 位于代理网络中时，出现故障时，正在传递中的消息可能丢失。

在代理网络中，整体的消息顺序（Total ordering）不被保留。代理网络引入了额外的消费者 —— 网络桥消费者通过producer.send(..)实现消息转发，这样，消息从其本地的队列头中取出，又放到目标代理对应队列尾部。

ActiveMQ依赖于活动消费者（订阅者，subscriptions）的信息，来决定是否在代理网络上传递消息。代理把来自远程代理的订阅、和本地的订阅同等看待，并且路由相关消息的拷贝到所有消费者。

对于主题订阅，远程代理B会把所有消息拷贝看做是合法的，因此它把这些（来自代理A的）消息路由给它的N个本地订阅（消费者）时，就会发生消息重复  —— 每个拷贝都被转发给每个本地订阅者。

ActiveMQ的默认行为是，把远程代理B上的N个匹配的订阅看成是单个订阅，避免重复消息的发生。

设置duplex=true后，连接双方使用同一连接进行通信，构成双向网桥。此双向配置会自动传递到对方，因此对方不需要任何配置。

代理网络的工作机制依赖于通知消息(advisory messages)——代理使用这些消息来 感知远程代理上的新消费者。在代理启动时，它会创建

ActiveMQ.Advisory.Consumer.>

在小型网络、少量目标、消费者的情况下没有问题，反之就会导致大量网络开销，所有，在代理网络的配置中，包含若干种过滤代理共享目标的方法：

1. dynamicallyIncludedDestinations：这意味着只有远程代理上有匹配目标的消费者时，才进行转发：
   

   <networkConnector uri="static:(tcp://host)">
       <dynamicallyIncludedDestinations>
           <!-- 仅当远程代理上存在如下目标的消费者时，才转发这些目标上的消息 -->
           <queue physicalName="include.test.foo"/>
           <topic physicalName="include.test.bar"/>
       </dynamicallyIncludedDestinations>
   </networkConnector>

2. staticallyIncludedDestinations：这意味着不管远程代理上有没有匹配目标的消费者，消息均被转发：
   

   <networkConnector uri="static:(tcp://host)" staticBridge="true">
        <staticallyIncludedDestinations>
             <queue physicalName="always.include.queue"/>
        </staticallyIncludedDestinations>
   </networkConnector>

可以通过队列/主题名称或者通配符应用一系列的策略，在destinationPolicy 元素下指定。示例：

<destinationPolicy>
    <policyMap>
        <policyEntries>
            <policyEntry queue=">" producerFlowControl="true" memoryLimit="20mb">
                <deadLetterStrategy>
                    <individualDeadLetterStrategy queuePrefix="DLQ." useQueueForQueueMessages="true"/>
                </deadLetterStrategy>
            </policyEntry>
            <policyEntry topic=">" producerFlowControl="true" memoryLimit="20mb">
            </policyEntry>
        </policyEntries>
    </policyMap>
</destinationPolicy>

支持的策略包括：

expireMessagesPeriodÈ

persistenceAdapter用于配置ActiveMQ持久化消息的方式，目前支持以下几种存 储机制：

1. AMQ消息存储:默认的消息存储。消息被存储到数据日志中，日志文件的默认 大小为32mb，如果单个消息可以超过此大小，则需要调整。如果日志文件中 的所有消息被成功消费，ActiveMQ会做标记，以便清理和归档。示例：
   

   <journalPersistenceAdapter directory="${activemq.base}/data" maxFileLength="32mb" />

2. KahaDB消息存储:提供了容量的提升和恢复能力(5.3以上采用)。示例：
   

   <kahaDB directory="${activemq.data}/kahadb" />

3. JDBC消息存储:消息使用JDBC接口，存放于数据库中，指定数据源即可。示例：
   

   <jdbcPersistenceAdapter dataSource="#mysql-ds"/> 

4. Memory消息存储:基于内存的消息存储。指定broker的属性 

   persistent="false"

   即可

ActiveMQ 4.x以上的版本，提供了可拔插的安全机制，主要包括：

1. JAAS——Java认证与授权服务
2. 一个内置的基于XML配置的简单认证(simpleAuthentication插件)

simpleAuthentication的例子(注意启用了匿名访问)：

<simpleAuthenticationPlugin anonymousAccessAllowed="true">
    <users>
        <authenticationUser username="system" password="manager" groups="users,admins"/>
        <authenticationUser username="user" password="password" groups="users"/>
        <authenticationUser username="guest" password="password" groups="guests"/>
    </users>
</simpleAuthenticationPlugin>

如果代理网络的一方启用了身份验证，那么，连接到它时，必须提供身份验证信 息：

<networkConnectors>
    <networkConnector name="brokerAbridge" userName="user" password="password"
                      uri="static://(tcp://brokerA:61616)"/>
</networkConnectors>

支持对队列、主题的3种访问权限:读(Read)、写(Write)、管理(Admin)。 其中管理权限用于动态延迟创建队列。授权配置的例子如下：

<plugins>
    <authorizationPlugin>
        <map>
            <authorizationMap>
                <authorizationEntries>
                    <authorizationEntry queue=">" read="admins" write="admins" admin="admins"/>
                    <authorizationEntry queue="USERS.>" read="users" write="users" admin="users"/>
                    <authorizationEntry queue="GUEST.>" read="guests" write="guests,users" admin="guests,users"/>
                    <authorizationEntry topic=">" read="admins" write="admins" admin="admins"/>
                    <authorizationEntry topic="USERS.>" read="users" write="users" admin="users"/>
                    <authorizationEntry topic="GUEST.>" read="guests" write="guests,users" admin="guests,users"/>
                    <authorizationEntry topic="ActiveMQ.Advisory.>" read="guests,users" write="guests,users"
                                        admin="guests,users"/>
                </authorizationEntries>
                <tempDestinationAuthorizationEntry>
                    <tempDestinationAuthorizationEntry read="tempDestinationAdmins"
                                                       write="tempDestinationAdmins" admin="tempDestinationAdmins"/>
                </tempDestinationAuthorizationEntry>
            </authorizationMap>
        </map>
    </authorizationPlugin>
</plugins>

 在某些情况下，特别是嵌入式代理，可以限制ActiveMQ使用的内存、硬盘资源的数量：

<systemUsage>
    <systemUsage>
        <!-- 内存用量，用于跟踪目的地、进行消息缓存 -->
        <memoryUsage>
            <memoryUsage limit="20 mb"/>
        </memoryUsage>
        <!-- 下面是磁盘中用于持久化消息的用量 ->
        <storeUsage>
            <storeUsage limit="1 gb" name="foo"/>
        </storeUsage>
        <!-- 下面是磁盘中用于非持久化消息的用量 -->
        <tempUsage>
            <tempUsage limit="100 mb"/>
        </tempUsage>
    </systemUsage>
</systemUsage>

SystemUsage usage = new SystemUsage();
Runtime runtime = Runtime.getRuntime();
MemoryUsage mu = new MemoryUsage();
mu.setPercentOfJvmHeap( 20 );
usage.setMemoryUsage( mu );

StoreUsage su = new StoreUsage();
su.setStore( pa );
su.setLimit( DISK_USAGE_LIMIT_DEFAULT );
usage.setStoreUsage( su );

TempUsage tu = new TempUsage();
su.setStore( pa );
su.setLimit( DISK_USAGE_LIMIT_DEFAULT );
usage.setTempUsage( tu );

broker.setSystemUsage( usage );

<amq:connectionFactory id="jmsFactory" brokerURL="vm://localhost"/>

使用PooledConnectionFactory可以提供连接池功能：连接、会话、消息生产者的实例可以被缓存，以便和Spring JmsTemplate、MessageListeners以及Camel等框架集成使用。

注意：该连接池不会缓存消息消费者，通常消息消费者在启动后即保持活动，直到必要时手工关闭。 另外，Spring自带的CachingConnectionFactory也可以作为连接池使用。

<bean id="jmsFactory" class="org.apache.activemq.pool.PooledConnectionFactory" destroy-method="stop">
    <property name="connectionFactory">
        <bean class="org.apache.activemq.ActiveMQConnectionFactory">
            <property name="brokerURL">
                <value>vm://dataSyncBroker-${appCfg.currentMonitorCenterId}</value>
            </property>
        </bean>
    </property>
</bean>

<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
    <property name="connectionFactory" ref="jmsFactory" />
    <!-- 下面的属性必须为true，才能设置Qos相关的消息头，例如deliveryMode, priority, timeToLive -->
    <property name="explicitQosEnabled" value="true" />
</bean>

 通常使用JmsTemplate来同步的生产、消费消息：

jmsTemplate.send( getDataSyncQueueName( mc ), new MessageCreator() {
    @Override
    public Message createMessage( Session session ) throws JMSException {
        TextMessage message = session.createTextMessage( msg.toJSON() );
        return message;
    }
} );

DefaultMessageListenerContainer组件不是单个类，而是一个良好抽象的、用于接收JMS消息的抽象层。其概念类似 于J2EE的消息驱动Bean(Message Driven Beans，MDB)。其包含的特性有：

1. 多层次的JMS资源缓存(连接、会话)、消费者缓存
2. 根据负载，动态增减同时处理消息的消费者数量
3. 如果代理不可用，自动重新建立连接
4. 基于Spring TaskExecutor的异步消息监听
5. 在消息接收、监听执行时，支持本地JMS事务，以及外部分布式事务管理器
6. 支持多种消息确认模式

配置示例：

<jms:listener-container container-type="default" connection-factory="jmsFactory" acknowledge="auto">
    <jms:listener destination="DATA.SYNC.1000" ref="msgTransceiver" method="onMessage" />
</jms:listener-container>

容器类型这里选择的是default，还可以选择simple，后者不支持事务处理。msgTransceiver.onMessage的方法为监听到消息后的回调：

public class MsgTransceiverImpl implements MsgTransceiver, MessageListener {

    public void onMessage( Message message ) {
        try {
            TextMessage msg = (TextMessage) message;
            String text = msg.getText();
            LOGGER.debug( "Received Message: \n" + text );
            onMsgReceived( Msg.create( text ) );
        } catch ( JMSException e ) {
            LOGGER.error( e.getMessage(), e );
        }
    }
}

除了实现JMS标准的MessageListener以外，还可以使用：

1. SessionAwareMessageListener

   ，接口提供对Session的访问，在实现请求/应答模式 时非常有用注意:你需要自行覆盖handleListenerException方法进行异常处理

2. MessageListenerAdapter

   ，使用此接口，可以避免代码与JMS有关联，可以处理类型 具体化的消息。 

The post ActiveMQ学习笔记 appeared first on 绿色记忆.

与Spring DMLC集成，进行持久化订阅时，会报此错误，报错的根源是：

@Override
public void setClientID(String newClientID) throws JMSException {
    checkClosedOrFailed();
    // false
    if (this.clientIDSet) {
        throw new IllegalStateException("The clientID has already been set");
    }
    // true
    if (this.isConnectionInfoSentToBroker) {
        // 不允许在“已经使用”的连接上执行设置clientID的操作
        throw new IllegalStateException("Setting clientID on a used Connection is not allowed");
    }

    this.info.setClientId(newClientID);
    this.userSpecifiedClientID = true;
    ensureConnectionInfoSent();
}

可以看到，状态isConnectionInfoSentToBroker变为true后，就不能再设置ClientID，修改此字段值的，只有：

protected void ensureConnectionInfoSent() throws JMSException {
    synchronized(this.ensureConnectionInfoSentMutex) {
        // Can we skip sending the ConnectionInfo packet??
        if (isConnectionInfoSentToBroker || closed.get()) {
            return;
        }
        //TODO shouldn't this check be on userSpecifiedClientID rather than the value of clientID?
        if (info.getClientId() == null || info.getClientId().trim().length() == 0) {
            // 此生成器的结果具有随机性
            info.setClientId(clientIdGenerator.generateId());
        }
        syncSendPacket(info.copy());
        // 这里修改了字段值
        this.isConnectionInfoSentToBroker = true;
        ...
    }
}

断点跟踪，发现调用栈片断：

// ActiveMQConnection.java
void ensureConnectionInfoSent();
Session createSession(boolean transacted, int acknowledgeMode);
// ConnectionPool.java 这是对单个ActiveMQConnection的封装，允许多个Session共享之
Session makeSession(SessionKey key);
ConnectionPool (Connection connection);
// JmsTemplate.java
send(final Destination destination, final MessageCreator messageCreator);
// 业务代码略

也就是说，业务代码调用JmsTemplate发送JMS消息，导致isConnectionInfoSentToBroker为true且ClientID被设置。进一步分析发现：

1. ConnectionPool只包含一个实际连接ActiveMQConnection，由多个Session共享
2. 使用的ConnectionFactory：PooledConnectionFactory，仅仅持有一个ConnectionPool，也就是仅仅一个ActiveMQConnection
3. AMQ的ClientId是在Collection级别设置的，只能在连接第一次使用前设置一次，这里由业务代码发起的JmsTemplate调用设置
4. ConnectionPool自动生成的ClientID，具有随机性，无法用于持久化订阅。因为持久化订阅者的识别方式是ClientID + subscription name

因此，使用AMQ的情况下，要进行持久化订阅，应当为DMLC提供一个可控的ConnectionFactory，比如单独分配ConnectionFactory。

报错信息示例：

[WARN ] [triggerStartAsyncNetworkBridgeCreation: remoteBroker=tcp://Zircon/127.0.1.1:38592@47262, localBroker= vm://BrokerA#19200] 2017-08-08 12:21:21 org.apache.activemq.broker.TransportConnection.processAddConnection(TransportConnection.java:770)
Failed to add Connection BrokerA->BrokerB-32884-1502096377514-3780:1
javax.jms.InvalidClientIDException: Broker: BrokerA - Client: NC_BrokerA_BrokerB_inbound_BrokerA already connected from vm://BrokerA#8

这里的情况是，BrokerA 到BrokerB之间的通道对应了一个客户端，其ID已经被占用。原因可能是BrokerB代理意外终止导致。

解决办法：设置

TransportConnector

tc.setAllowLinkStealing( true )

发现设置了异步启动

broker.setStartAsync( true )

可能相关的报错信息：

javax.jms.JMSException: peer (vm://BrokerB#3) stopped.
Caused by: org.apache.activemq.transport.TransportDisposedIOException: peer (vm://BrokerA#1) stopped.

javax.jms.IllegalStateException: The Consumer is closed

java.lang.NegativeArraySizeException
at org.apache.activemq.store.kahadb.disk.journal.DataFileAccessor.readRecord(DataFileAccessor.java:92)

服务非正常重启导致kahadb日志损坏，可以设置属性解决：

<persistenceAdapter>
    <kahaDB directory="D:/amq/datasync/kahadb" checkForCorruptJournalFiles="true" />
</persistenceAdapter>

检查以下项目：

1. 如果使用多播自动发现，检查有没有使用正确的网卡，参考：我的另一篇文章
2. 保证代理名称的唯一性

现象：不能接收到任何组播（Multicast）消息

原因：可能是因为生产者操作系统内核支持IPv6，但是网络本身、消费者操作系统内核不支持IPv6。

解决：当操作系统内核支持IPv6时，JRE会默认使用IPv6，要改变此行为，可以设置JVM系统属性：

-Djava.net.preferIPv4Stack=true

如下配置：

<transportConnector uri="tcp://localhost:0" discoveryUri="multicast://default"/>

uri中的端口指定为0，表示由ActiveMQ选择一个可用的端口。由于使用发现机制，限定端口没有必要。 

代理、队列、网络连接器、链接器的名称，都可以通过API自由设定。

假设代理名称为BrokerA，当：

1. 基于双向自动发现的网络连接器进行连接时，代理BrokerA通过NC_BrokerA连接，代理BrokerB通过NC_BrokerB连接，则BrokerB在BrokerA队列上的远程消费者的ClientID命名为：
   1. NC_BrokerA_BrokerB_inbound_BrokerA，这是由BrokerA双向网络连接（反向）产生的远程消费者
   2. NC_BrokerB_BrokerB_inbound_BrokerA，这是由BrokerB双向网络连接（正向）产生的远程消费者
2. 基于单向自动发现的网络连接器进行连接时，代理BrokerA通过NC_BrokerA连接，代理BrokerB通过NC_BrokerB连接，则BrokerB在BrokerA队列上的远程消费者的ClientID命名为：
   1. NC_BrokerA_BrokerB_inbound_BrokerA，这是由BrokerA单向网络连接产生的远程消费者
3. 基于双向静态网络连接器进行连接，代理BrokerB通过NC_BrokerB连接，则BrokerB在BrokerA队列上的远程消费者的ClientID命名为：
   1. NC_BrokerB_BrokerB_inbound_BrokerA
4. 基于单向静态网络连接器进行连接，代理BrokerB通过NC_BrokerB连接，则BrokerB在BrokerA队列上没有消费者

单向网络连接，仅能用来发送消息，不能接收网络代理发来的消息。

The post ActiveMQ知识集锦 appeared first on 绿色记忆.

service:jmx:rmi:///jndi/rmi://localhost:1099/jmxrmi

iperf -s  -u  -B 239.255.2.3 -p 6155  -i 1
------------------------------------------------------------
Server listening on UDP port 6155
Binding to local address 192.168.7.130
Receiving 1470 byte datagrams
UDP buffer size: 8.00 KByte (default)
------------------------------------------------------------

log4j.logger.org.apache.activemq.transport.discovery.multicast.MulticastDiscoveryAgent=TRACE,DataSync

[TRACE] [Thread-1] 2014-09-16 11:16:40 org.apache.activemq.transport.discovery.multicast.MulticastDiscoveryAgent.start(MulticastDiscoveryAgent.java:290)
start - discoveryURI = multicast://default
[TRACE] [Thread-1] 2014-09-16 11:16:40 org.apache.activemq.transport.discovery.multicast.MulticastDiscoveryAgent.start(MulticastDiscoveryAgent.java:302)
start - myHost = 239.255.2.3
[TRACE] [Thread-1] 2014-09-16 11:16:40 org.apache.activemq.transport.discovery.multicast.MulticastDiscoveryAgent.start(MulticastDiscoveryAgent.java:303)
start - myPort = 6155
[TRACE] [Thread-1] 2014-09-16 11:16:40 org.apache.activemq.transport.discovery.multicast.MulticastDiscoveryAgent.start(MulticastDiscoveryAgent.java:304)
start - group  = default
[TRACE] [Thread-1] 2014-09-16 11:16:40 org.apache.activemq.transport.discovery.multicast.MulticastDiscoveryAgent.start(MulticastDiscoveryAgent.java:305)
start - interface  = null
[TRACE] [Thread-1] 2014-09-16 11:16:40 org.apache.activemq.transport.discovery.multicast.MulticastDiscoveryAgent.start(MulticastDiscoveryAgent.java:306)
start - network interface  = null
[TRACE] [Thread-1] 2014-09-16 11:16:40 org.apache.activemq.transport.discovery.multicast.MulticastDiscoveryAgent.start(MulticastDiscoveryAgent.java:307)
start - join network interface  = null

public void start() throws Exception {
        
    if (started.compareAndSet(false, true)) {            
                     
        if (group == null || group.length() == 0) {
            throw new IOException("You must specify a group to discover");
        }
        String type = getType();
        if (!type.endsWith(".")) {
            LOG.warn("The type '" + type + "' should end with '.' to be a valid Discovery type");
            type += ".";
        }
        
        if (discoveryURI == null) {
            discoveryURI = new URI(DEFAULT_DISCOVERY_URI_STRING);
        }
        
        if (LOG.isTraceEnabled()) 
              LOG.trace("start - discoveryURI = " + discoveryURI);                                
          
          String myHost = discoveryURI.getHost();
          int    myPort = discoveryURI.getPort(); 
             
          if( DEFAULT_HOST_STR.equals(myHost) ) 
              myHost = DEFAULT_HOST_IP;                       
          
          if(myPort < 0 )
            myPort = DEFAULT_PORT;                
          
          if (LOG.isTraceEnabled()) {
              LOG.trace("start - myHost = " + myHost); 
              LOG.trace("start - myPort = " + myPort);       
              LOG.trace("start - group  = " + group );                         
              LOG.trace("start - interface  = " + mcInterface );
              LOG.trace("start - network interface  = " + mcNetworkInterface );
              LOG.trace("start - join network interface  = " + mcJoinNetworkInterface );
          }    
          
        this.inetAddress = InetAddress.getByName(myHost);
        this.sockAddress = new InetSocketAddress(this.inetAddress, myPort);
        mcast = new MulticastSocket(myPort);
        mcast.setLoopbackMode(loopBackMode);
        mcast.setTimeToLive(getTimeToLive());
        if (mcJoinNetworkInterface != null) {
            mcast.joinGroup(sockAddress, NetworkInterface.getByName(mcJoinNetworkInterface));
        }
        else {
            mcast.joinGroup(inetAddress);
        }
        mcast.setSoTimeout((int)keepAliveInterval);
        if (mcInterface != null) {
            mcast.setInterface(InetAddress.getByName(mcInterface));
        }
        if (mcNetworkInterface != null) {
            mcast.setNetworkInterface(NetworkInterface.getByName(mcNetworkInterface));
        }
        runner = new Thread(this);
        runner.setName(this.toString() + ":" + runner.getName());
        runner.setDaemon(true);
        runner.start();
        doAdvertizeSelf();
    }
}

/**
 * 加入指定网络接口上的多播组。
 * @param mcastaddr 准备加入的多播地址
 * @param netIf 指定用于接收多播数据报的本地网络接口。
 * 如果不指定，将使用setInterface(InetAddress)、setNetworkInterface(NetworkInterface)所指定的接口
 */
public void joinGroup(SocketAddress mcastaddr, NetworkInterface netIf) throws IOException;
/**
 * 设置相关受影响方法使用的多播网络接口，对于多重网络的主机有意义
 * @param inf IP地址对象
 */
public void setInterface(InetAddress inf) throws SocketException;
/**
 * 设置发送多播数据报使用的网络接口
 * @param netIf 网络接口对象
 */
public void setNetworkInterface(NetworkInterface netIf) throws SocketException;

protected DiscoveryAgent doCreateDiscoveryAgent(URI uri) throws IOException {
    try {
        
          if (LOG.isTraceEnabled()) {      
           LOG.trace("doCreateDiscoveryAgent: uri = " + uri.toString());               
        }
        
        MulticastDiscoveryAgent mda = new MulticastDiscoveryAgent();          
        
        mda.setDiscoveryURI(uri);            
                    
        // allow MDA's params to be set via query arguments  
        // (e.g., multicast://default?group=foo             
        Map options = URISupport.parseParameters(uri);         
        IntrospectionSupport.setProperties(mda, options);
        
        return mda;
        
    } catch (Throwable e) {
        throw IOExceptionSupport.create("Could not create discovery agent: " + uri, e);
    }
}

<broker xmlns="http://activemq.apache.org/schema/core" brokerName="dataSyncBroker" dataDirectory="D:/amq/datasync/data">
    <networkConnectors>
        <networkConnector uri="multicast://default?joinNetworkInterface=net13&networkInterface=net13&interface=192.168.0.89" dynamicOnly="true" networkTTL="3" prefetchSize="1"
            decreaseNetworkConsumerPriority="true" />
    </networkConnectors>
    <transportConnectors> 
        <transportConnector name="openwire" uri="tcp://0.0.0.0:61616" discoveryUri="multicast://default" />
    </transportConnectors>

The post ActiveMQ代理网络无法连接的问题一例 appeared first on 绿色记忆.

#ifndef AMQUTILS_H_
#define AMQUTILS_H_
#include <cms/Connection.h>
#include <cms/Session.h>
#include <decaf/lang/Exception.h>
using namespace decaf::lang;
using namespace cms;

namespace amqutils
{
    inline void closeQuitely( Connection* conn, Session* session )
    {
        if ( session ) try
        {
            session->close();
        }
        catch ( Exception& e )
        {

        }
        if ( conn ) try
        {
            conn->close();
        }
        catch ( Exception& e )
        {

        }
    }
}

#endif

#ifndef PRODUCER_H_
#define PRODUCER_H_

#include <activemq/core/ActiveMQConnectionFactory.h>

#include <boost/shared_ptr.hpp>

#include <stdlib.h>
#include <stdio.h>

using namespace activemq;
using namespace activemq::core;
using namespace decaf;
using namespace decaf::lang;
using namespace decaf::util;
using namespace decaf::util::concurrent;
using namespace cms;
using namespace std;
using namespace boost;

class Producer
{
    private:
        boost::shared_ptr<ActiveMQConnectionFactory> amqf;
        Connection* connection;
        Session* session;
    public:
        Producer( string& uri, string& userName, string& password );
        Producer( boost::shared_ptr<ActiveMQConnectionFactory> amqf );
        virtual ~Producer();
        virtual void init();
        virtual void send( string& queueName, string& msg );
        virtual void pub( string& topicName, string& msg );
};

#endif

#include "Producer.h"
#include <cms/Connection.h>
#include <boost/scoped_ptr.hpp>
#include "amqutils.h"
#include <slf4cmacros.h>

Producer::Producer( string& uri, string& userName, string& password ) :
        connection( NULL ), session( NULL )
{
    amqf = shared_ptr<ActiveMQConnectionFactory>( new ActiveMQConnectionFactory( uri, userName, password ) );
}
Producer::Producer( shared_ptr<ActiveMQConnectionFactory> amqf ) :
        amqf( amqf ), connection( NULL ), session( NULL )
{
}
Producer::~Producer()
{
    SLF_DEBUG( "准备销毁ActiveMQ连接、会话" );
    amqutils::closeQuitely( connection, session );
    delete session;
    delete connection;
}
void Producer::init()
{
    SLF_DEBUG( "准备创建ActiveMQ连接" );
    connection = amqf->createConnection();
    SLF_DEBUG( "准备创建ActiveMQ会话" );
    session = connection->createSession();
}

void Producer::send( string& queueName, string& msg )
{
    SLF_DEBUG( "准备发送ActiveMQ消息到队列" + queueName );
    scoped_ptr<Destination> dest( session->createQueue( queueName ) );
    scoped_ptr<MessageProducer> producer( session->createProducer( dest.get() ) );
    scoped_ptr<TextMessage> message( session->createTextMessage( msg ) );
    producer->send( message.get() );
}
void Producer::pub( string& topicName, string& msg )
{
    SLF_DEBUG( "准备发布ActiveMQ消息到主题" + topicName );
    scoped_ptr<Destination> dest( session->createTopic( topicName ) );
    scoped_ptr<MessageProducer> producer( session->createProducer( dest.get() ) );
    scoped_ptr<TextMessage> message( session->createTextMessage( msg ) );
    producer->send( message.get() );
}

#ifndef CONSUMER_H_
#define CONSUMER_H_

#include <activemq/core/ActiveMQConnectionFactory.h>

#include <boost/shared_ptr.hpp>

#include <stdlib.h>
#include <stdio.h>
#include <boost/ptr_container/ptr_map.hpp>
#include <boost/ptr_container/ptr_vector.hpp>

using namespace activemq;
using namespace activemq::core;
using namespace decaf;
using namespace decaf::lang;
using namespace decaf::util;
using namespace decaf::util::concurrent;
using namespace cms;
using namespace std;
using namespace boost;

class Consumer
{
    private:
        boost::shared_ptr<ActiveMQConnectionFactory> amqf;
        Connection* connection;
        Session* session;
        ptr_map<string, MessageConsumer*> consumers;
        ptr_vector<MessageListener> listeners;

    public:
        Consumer( string& uri, string& userName, string& password );
        Consumer( boost::shared_ptr<ActiveMQConnectionFactory> amqf );
        virtual ~Consumer();
        virtual void init();
        string receive( string& queueName, int timeout );
        void listen( string queueName, void (*listener)( TextMessage* ) );
};

#endif

#include "Consumer.h"
#include <cms/Connection.h>
#include <boost/scoped_ptr.hpp>
#include "amqutils.h"
#include <slf4cmacros.h>
#include <boost/lexical_cast.hpp>

Consumer::Consumer( string& uri, string& userName, string& password ) :
        connection( NULL ), session( NULL )
{
    amqf = boost::shared_ptr<ActiveMQConnectionFactory>( new ActiveMQConnectionFactory( uri, userName, password ) );
}
Consumer::Consumer( boost::shared_ptr<ActiveMQConnectionFactory> amqf ) :
        amqf( amqf ), connection( NULL ), session( NULL )
{
}
Consumer::~Consumer()
{
    SLF_DEBUG( "准备销毁ActiveMQ连接、会话" );
    amqutils::closeQuitely( connection, session );
    delete session;
    delete connection;
}
void Consumer::init()
{
    SLF_DEBUG( "准备创建ActiveMQ连接" );
    connection = amqf->createConnection();
    connection->start(); //必须，否则不会触发监听
    SLF_DEBUG( "准备创建ActiveMQ会话" );
    session = connection->createSession();
}
string Consumer::receive( string& queueName, int timeout )
{
    {
        string msg = "准备等待队列" + queueName + "并接受一条消息，超时为" + lexical_cast<string, int>( timeout ) + "秒";
        SLF_DEBUG( msg );
    }
    scoped_ptr<Destination> dest( session->createQueue( queueName ) );
    scoped_ptr<MessageConsumer> consumer( session->createConsumer( dest.get() ) );
    Message* message = consumer->receive( timeout * 1000 );
    if ( message )
    {
        TextMessage* tm = dynamic_cast<TextMessage*>( message );
        string content( tm->getText() );
        delete message;
        return content;
    }
    else
    {
        throw CMSException( "在超过时间限制之前没有获取到消息." );
    }
}
class PlainMessageListener : public MessageListener
{
    public:
        typedef void (*ListenerCallback)( TextMessage* );
        virtual void onMessage( const Message* message );
        PlainMessageListener( ListenerCallback callback ) :
                listenerCallback( callback )
        {
        }
        ~PlainMessageListener()
        {
            SLF_DEBUG( "准备销毁监听器..." );
        }
    private:
        ListenerCallback listenerCallback;
};
void PlainMessageListener::onMessage( const Message* message )
{
    const TextMessage* msg = dynamic_cast<const TextMessage*>( message );
    listenerCallback( const_cast<TextMessage*>( msg ) );
}
void Consumer::listen( string queueName, void (*listener)( TextMessage* ) )
{
    scoped_ptr<Destination> dest( session->createQueue( queueName ) );
    MessageConsumer* consumer( session->createConsumer( dest.get() ) );
    if ( consumers.count( queueName ) == 1 )
    {
        throw CMSException( "当前消费者已经在监听队列：" + queueName );
    }
    else
    {
        consumers[queueName] = consumer;
        SLF_DEBUG( "准备创建监听器..." );
        MessageListener* pml = new PlainMessageListener( listener );
        consumer->setMessageListener( pml );
        listeners.push_back( pml );
    }
}

#include "Producer.h"
#include "Consumer.h"
#include <activemq/library/ActiveMQCPP.h>
#include <boost/filesystem.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/date_time/posix_time/posix_time_duration.hpp>
#include <slf4cmacros.h>

const char* QUEUE_NAME = "DEMO.Q2";

using namespace std;

void producerRunner( boost::shared_ptr<ActiveMQConnectionFactory> amqf )
{
    Producer p( amqf );
    SLF_DEBUG( "准备初始化生产者" );
    p.init();
    string queneName( QUEUE_NAME );
    SLF_DEBUG( "准备向：" + queneName + "发送消息" );
    for ( int i = 0; i < 10; i++ )
    {
        string content( "Hello C++, " + lexical_cast<string, int>( i ) );
        p.send( queneName, content );
        SLF_DEBUG( "已发送：" + content + "，当前线程将休眠" );
        this_thread::sleep( posix_time::seconds( 5 ) );
    }
}
void consumerListener( TextMessage* msg )
{
    SLF_DEBUG( "监听到消息，内容为：" + msg->getText() );
}
void consumerRunner( boost::shared_ptr<ActiveMQConnectionFactory> amqf )
{
    Consumer c( amqf );
    SLF_DEBUG( "准备初始化消费者" );
    c.init();
    string queneName( QUEUE_NAME );
    SLF_DEBUG( "准备监听队列：" + queneName );
    c.listen( queneName, &consumerListener );
    SLF_DEBUG( "当前线程将休眠60秒，以等待消息" );
    this_thread::sleep( posix_time::seconds( 60 ) );
}
int main()
{
    SLF_DEBUG( "初始化ActiveMQ-CPP运行时库" );
    activemq::library::ActiveMQCPP::initializeLibrary();
    {
        boost::shared_ptr<ActiveMQConnectionFactory> amqf( new ActiveMQConnectionFactory( "tcp://localhost:61616" ) );
        thread_group g;
        SLF_DEBUG( "准备发动生产者线程" );
        g.create_thread( bind( &producerRunner, amqf ) );
        SLF_DEBUG( "准备发动消费者线程" );
        g.create_thread( bind( &consumerRunner, amqf ) );
        SLF_DEBUG( "等待线程子线程结束..." );
        g.join_all();
    }
    SLF_DEBUG( "销毁ActiveMQ-CPP运行时库" );
    activemq::library::ActiveMQCPP::shutdownLibrary();
}

The post 基于CMS接口的ActiveMQ CPP客户端示例 appeared first on 绿色记忆.

package cc.gmem.demo.amq.client;

import javax.jms.Connection;
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 Producer
{

    private ActiveMQConnectionFactory factory;

    public Producer( String brokerHost, int brokerPort )
    {
        factory = new ActiveMQConnectionFactory( "tcp://" + brokerHost + ":" + brokerPort );
    }

    public void sendMsgToQueue( String queueName, String msg ) throws JMSException
    {
        Connection connection = null;
        try
        {
            //如果代理启用身份验证，这里需要指定用户、密码参数
            connection = factory.createConnection();
            connection.start();
            //创建会话时有事务和确认选项
            Session session = connection.createSession( false, Session.AUTO_ACKNOWLEDGE );
            //如果代理上没有队列，则创建，否则，直接使用
            Destination dest = session.createQueue( queueName );
            //创建消息生产者
            MessageProducer producer = session.createProducer( dest );
            //设置消息是否持久化
            producer.setDeliveryMode( DeliveryMode.NON_PERSISTENT );
            //创建一个文本消息
            TextMessage message = session.createTextMessage( msg );
            producer.send( message );
        }
        finally
        {
            connection.close();
        }
    }
}

package cc.gmem.demo.amq.client;

import javax.jms.Connection;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageConsumer;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class Consumer
{

    private static final Logger       LOGGER = LoggerFactory.getLogger( Consumer.class );


    private ActiveMQConnectionFactory factory;

    public Consumer( String brokerHost, int brokerPort )
    {
        factory = new ActiveMQConnectionFactory( "tcp://" + brokerHost + ":" + brokerPort );
    }


    public String reveiveMsgFromQueue( String queueName ) throws JMSException
    {
        Connection connection = null;
        try
        {
            //如果代理启用身份验证，这里需要指定用户、密码参数
            connection = factory.createConnection();
            connection.start();
            //创建会话时有事务和确认选项，如果确认选项为：SESSION_TRANSACTED，则必须启用事务
            Session session = connection.createSession( true, Session.SESSION_TRANSACTED );
            //如果代理上没有队列，则创建，否则，直接使用
            Destination dest = session.createQueue( queueName );
            //创建消息生产者
            MessageConsumer consumer = session.createConsumer( dest );
            //等待队列里面有消息可消费，最多1秒，超时返回NULL
            long timeout = 1000;
            TextMessage msg = (TextMessage) consumer.receive( timeout );
            String recMsg = msg == null ? null : msg.getText();
            //如果设置：Session.CLIENT_ACKNOWLEDGE，则必须手工确认：msg.acknowledge()
            session.commit();//如果设置：Session.SESSION_TRANSACTED，则必须提交或者回滚
            return recMsg;
        }
        finally
        {
            connection.close();
        }
    }

}

<beans 
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:jms="http://www.springframework.org/schema/jms"
    xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms-3.0.xsd
        http://www.springframework.org/schema/task  http://www.springframework.org/schema/task/spring-task-3.0.xsd
  ">
    <!-- 启用连接池支持的连接工厂 -->
    <bean id="jmsFactory" class="org.apache.activemq.pool.PooledConnectionFactory" destroy-method="stop">
        <property name="connectionFactory">
            <bean class="org.apache.activemq.ActiveMQConnectionFactory">
                <property name="brokerURL">
                    <value>vm://localBroker</value>
                </property>
            </bean>
        </property>
    </bean>
    <!-- 以事件驱动的方式接收消息 -->
    <!--  tipsMessageListener即为监听器对象，通常实现JMS的MessageListener接口 -->
    <jms:listener-container container-type="default" connection-factory="jmsFactory" acknowledge="auto">
        <jms:listener destination="TIPS.10000.BATCH" ref="tipsMessageListener" method="onMessage" />
    </jms:listener-container>
    <!-- jmsTemplate通常用来发送消息 -->
    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="jmsFactory" />
        <property name="explicitQosEnabled" value="true" />
    </bean>
</beans>

public void onMessage( Message message )
{
    try
    {
        TextMessage msg = (TextMessage) message;
        String text = msg.getText();
        LOGGER.debug( "Received Message: \n" + text );
        onMsgReceived( msgService.create( text ) );
    }
    catch ( JMSException e )
    {
        LOGGER.error( e.getMessage(), e );
    }
}

The post 基于JMS的ActiveMQ Java客户端示例 appeared first on 绿色记忆.

CD D:\CPP\tools\boost-1.55.0\tools\build\v2
build.bat mingw
CD D:\CPP\tools\boost-1.55.0
REM 下面是静态链接的多线程支持版本，根据需要调整
bjam --build-type=complete toolset=gcc address-model=32 variant=debug,release threading=multi link=static

#在Cygwin Terminal中执行
./bjam --layout=versioned --build-type=complete toolset=gcc address-model=32 variant=debug,release threading=multi link=static

mingw32-make -f makefile.gcc UNICODE=1 SHARED=0 BUILD=release clean
mingw32-make -f makefile.gcc UNICODE=1 SHARED=0 BUILD=debug

#CPPUnit，单元测试支持，该库会安装到：/usr/local/bin/cppunit-config
cd /usr/src/cppunit-1.12.0
./configure CFLAGS="-O2 -s -mms-bitfields -march=i686" CXXFLAGS="-O2 -s -mms-bitfields -march=i686" --disable-shared
make && make install
#XML解析依赖
cd /usr/src/expat-2.0.0
./configure CFLAGS="-O2 -s -mms-bitfields -march=i686" CXXFLAGS="-O2 -s -mms-bitfields -march=i686"
make && make install
#Apache Portable Runtime，注意：-O0 -g3 用于调试，生产环境的版本注意调整
cd /usr/src/apr-1.5.1
./buildconf
./configure CFLAGS="-O0 -g3 -s -mms-bitfields -march=i686" CXXFLAGS="-O0 -g3 -s -mms-bitfields -march=i686"
make && make install

cd /usr/src/apr-util-1.5.3
./buildconf  --with-apr=../apr-1.5.1
./configure CFLAGS="-O0 -g3 -s -mms-bitfields -march=i686" CXXFLAGS="-O0 -g3 -s -mms-bitfields -march=i686"  --with-apr=/usr/local/apr/bin/apr-1-config
make && make install

cd /usr/src/apr-iconv-1.2.1
./buildconf  --with-apr=../apr-1.5.1
./configure CFLAGS="-O0 -g3 -s -mms-bitfields -march=i686" CXXFLAGS="-O0 -g3 -s -mms-bitfields -march=i686"  --with-apr=/usr/local/apr/bin/apr-1-config
make && make install

cd /usr/src/activemq-cpp-library-3.8.3
./autogen.sh
./configure CFLAGS="-O0 -g3 -s -mms-bitfields -march=i686" CXXFLAGS="-O0 -g3 -s -mms-bitfields  -std=gnu++0x -march=i686" --with-apr=/usr/local/apr/bin/apr-1-config
make && make install

MinGW

./configure CFLAGS="-O0 -g3 -s -mms-bitfields -march=i686 -DHAVE_WINSOCK2_H" CXXFLAGS="-O0 -g3 -s -mms-bitfields  -std=gnu++0x -march=i686 -DHAVE_WINSOCK2_H" --with-apr=/usr/local/apr/bin/apr-1-config

./autogen.sh
./configure  CXXFLAGS="-O0 -mms-bitfields -std=gnu++0x"
make && make install

./configure --with-pthreads=no
make
#编辑的静态库位于lib/.lib目录下

./configure
make

The post 常用C++库的编译步骤记录 appeared first on 绿色记忆.

<bean id="localLogAdministrator" class="com.atomikos.icatch.admin.imp.LocalLogAdministrator" />
<bean id="userTransactionService" class="com.atomikos.icatch.config.UserTransactionServiceImp" init-method="init"
    destroy-method="shutdownForce">
    <constructor-arg>
        <!-- 配置Atomikos属性 -->
        <props>
            <prop key="com.atomikos.icatch.service">com.atomikos.icatch.standalone.UserTransactionServiceFactory</prop>
        </props>
    </constructor-arg>
    <property name="initialLogAdministrators">
        <list>
            <ref bean="localLogAdministrator" />
        </list>
    </property>
</bean>

<!-- Atomikos 事务管理器配置 -->
<bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager" init-method="init" destroy-method="close"
    depends-on="userTransactionService">
    <property name="startupTransactionService" value="false" />
    <!-- close()时是否强制终止事务 -->
    <property name="forceShutdown" value="false" />
</bean>

<!-- Atomikos UserTransaction配置 -->
<bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp" depends-on="userTransactionService">
    <property name="transactionTimeout" value="300" />
</bean>

<!-- JTA事务管理器 -->
<bean id="jtaTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager" depends-on="userTransactionService">
    <property name="transactionManager" ref="atomikosTransactionManager" />
    <property name="userTransaction" ref="atomikosUserTransaction" />
</bean>

<bean id="xaFactory" class="org.apache.activemq.ActiveMQXAConnectionFactory">
    <property name="brokerURL" value="tcp://localhost:61616" />
</bean>
<bean id="jmsFactory" class="com.atomikos.jms.AtomikosConnectionFactoryBean" init-method="init" destroy-method="close">
    <property name="uniqueResourceName" value="amq" />
    <property name="xaConnectionFactory" ref="xaFactory" />
</bean>
<bean id="tipsMessageListener" class="cc.gmem.demo.TipsMessageListener" />
<!-- 接收消息 -->
<jms:listener-container container-type="default" connection-factory="jmsFactory"
    transaction-manager="jtaTransactionManager" session-transacted="true">
    <jms:listener destination="TIPS.10000.BATCH" ref="tipsMessageListener" method="onMessage" />
</jms:listener-container>
<!-- 发送消息 -->
<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
    <property name="connectionFactory">
        <ref bean="jmsFactory" />
    </property>
    <property name="receiveTimeout" value="1000" />
    <property name="sessionTransacted" value="true" />
</bean>

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
    <!-- 必须为Hibernate指定一个Atomikos JTA/XA 数据源 -->
    <property name="dataSource" ref="dataSource" />
</bean>
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>
<bean id="dataSource" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init" destroy-method="close">
    <property name="uniqueResourceName" value="mysqlDataSource" />
    <property name="xaDataSourceClassName">
        <value>com.mysql.jdbc.jdbc2.optional.MysqlXADataSource</value>
    </property>
    <property name="xaProperties">
        <props>
            <prop key="databaseName">gmem</prop>
            <prop key="serverName">localhost</prop>
            <prop key="port">3306</prop>
            <prop key="user">user</prop>
            <prop key="password">pswd</prop>
            <prop key="url">jdbc:mysql://localhost:3306/gmem</prop>
        </props>
    </property>
    <property name="minPoolSize" value="10">
</bean>
<bean id="dataSourceOracle" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init" destroy-method="close">
    <property name="uniqueResourceName" value="oralceDataSource" />
    <property name="xaDataSourceClassName">
        <value>oracle.jdbc.xa.client.OracleXADataSource</value>
    </property>
    <property name="xaProperties">
        <props>
            <prop key="user">gmemx</prop>
            <prop key="password">pswd</prop>
            <prop key="URL">jdbc:oracle:thin:@192.168.0.25:1521:DEV</prop>
        </props>
    </property>
</bean>

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>
    	<property name="connection.datasource">ds0</property>
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <property name="current_session_context_class">jta</property>
		<property name="transaction.manager_lookup_class">com.atomikos.icatch.jta.hibernate3.TransactionManagerLookup</property>
 		<property name="transaction.factory_class">org.hibernate.transaction.JTATransactionFactory</property>
        <property name="connection.release_mode">auto</property>

        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
        <property name="show_sql">true</property>

        <mapping resource="cc/gmem/demo/vo/User.hbm.xml"/>
    </session-factory>

</hibernate-configuration>

java.naming.factory.initial=org.apache.naming.java.javaURLContextFactory

com.atomikos.icatch.service=com.atomikos.icatch.standalone.UserTransactionServiceFactory
com.atomikos.icatch.automatic_resource_registration=true
com.atomikos.icatch.console_log_level=DEBUG

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.transaction.UserTransaction;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.atomikos.jdbc.SimpleDataSourceBean;

Context ctx = new InitialContext();
SimpleDataSourceBean ds0 = new SimpleDataSourceBean();
ds0.setUniqueResourceName("ds0");
ds0.setXaDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlXADataSource");
ds0.setXaDataSourceProperties("databaseName=gmem");
ds0.setConnectionPoolSize(10);
ctx.rebind("ds0", ds0);

SimpleDataSourceBean ds1 = = new SimpleDataSourceBean();
ds0.setUniqueResourceName("ds1");
ds0.setXaDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlXADataSource");
ds0.setXaDataSourceProperties("databaseName=gmembkp");
ds0.setConnectionPoolSize(10);
ctx.rebind("ds1", ds1);
ctx.close();

UserTransaction tx = new com.atomikos.icatch.jta.UserTransactionImp();

SessionFactory sf0 = new Configuration().configure("/hibernate0.cfg.xml").buildSessionFactory();
SessionFactory sf1 = new Configuration().configure("/hibernate1.cfg.xml").buildSessionFactory();

tx.setTransactionTimeout(60);
tx.begin();

try {
	//执行DML操作
	userTransaction.commit();
}
catch (Exception ex) {
	tx.rollback();
}

sf0.close();
sf1.close();
ds0.close();
ds1.close();

详细参考：http://www.atomikos.com/Documentation/JtaProperties
注意事务的超时设置：UserTransaction.setTransactionTimeout()
另外，超时设置无法超过最大值限制：jta.properties中的com.atomikos.icatch.max_timeout

10.x驱动无该问题，可能Oracle驱动的bug。INSERT时没有问题，UPDATE时，如果1个blob也没问题，2个就挂起。
可以禁用Hibernate批量操作来临时解决：jdbc.batch_size=0

The post 使用Atomikos来进行分布式事务(XA)开发 appeared first on 绿色记忆.