activemq 消息发送失败后，不能重新发送到consumer端，再次进行消费，请问 怎么解决？_百度知道
activemq 消息发送失败后，不能重新发送到consumer端，再次进行消费，请问 怎么解决？
我有更好的答案
我就放队列里发，就是不管，处理 完 消息 后，一般不知道 ActiveMQ 发消息 是异步的，你收不没收到。 所以消息 消息掉了 ，再 还一个消息给 发送端，
因此 可以 让 接收
为您推荐：
其他类似问题
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。所有回答(2)
已经解决了
我也遇到了，不知道错在哪，你是怎么解决的？
清除回答草稿
&&&您需要以后才能回答，未注册用户请先。ActiveMQ消息队列-单节点测试（点对点模式）
时间： 12:16:14
&&&& 阅读：1198
&&&& 评论：
&&&& 收藏：0
标签：ActiveMQ发送和接收消息的过程和jdbc操作数据库很类似：首先创建Connection连接对象，再获取Session会话对象，之后通过Session会话对象创建Producer、Consumer、Message等对象，只不过ActiveMQ的Connection对象是通过ActiveMQConnectionFactory工厂产生的。以下是一些场景的测试代码。
先定义一些常量数据，这些数据在后面的例子中也有用到
private&final&static&String&USERNAME&=&ActiveMQConnection.DEFAULT_USER;
private&final&static&String&PASSWORD&=&ActiveMQConnection.DEFAULT_PASSWORD;
//&节点url
private&final&static&String&BROKERURL&=&"tcp://localhost:61616";
//&队列名称
private&final&static&String&DESTINATION&&=&"com_mq_queue_test";
1、首先测试一下最简单的这种，就是消息发送方发送一则消息，然后接收方接收消息，同时消息被消费方接收之后，采用自动应答模式（Session.AUTO_ACKNOWLEDGE），反馈给消息发送发。
发送方代码：
public&void&run()&{
//&创建ActiveMQConnectionFactory工厂
ConnectionFactory&factory&=&new&ActiveMQConnectionFactory(USERNAME,&PASSWORD,&BROKERURL);
//&通过ActiveMQConnectionFactory工厂，创建Connection对象
Connection&connection&=&factory.createConnection();
//&启动Connection对象
connection.start();
//&创建Session会话
Session&session&=&connection.createSession(false,&Session.AUTO_ACKNOWLEDGE);
Destination&destination&=&session.createQueue(DESTINATION);
MessageProducer&sender&=&session.createProducer(destination);
//&设置消息的持久化模式：如果设置成持久化，则传递消息时需要消息存储起来，然后再传递。即message-&broker-&message&store-&返回给消息发送者消息是否存储成功
//&如果设置成非持久化，表示消息是异步传递，则消息的传递路径是message-broker-&返回给消息发送者和存储数据这2个步骤异步执行,性能较持久化模式快
//&DeliveryMode没有设置或者设置为NON_PERSISTENT，那么重启MQ之后消息就会丢失;PERSISTENT保证重启后会把没有发送的数据再次发送直至发送成功
&&&&&&&&sender.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
//&创建消息并发送消息
Message&message&=&session.createMessage();
message.setStringProperty("name",&"tom");
sender.send(message);
//&关闭资源
session.close();
&&&&&&&&connection.close();
&&&&}&catch(Exception&e)&{
e.printStackTrace();
//&接收方代码：
public&void&run()&{
ConnectionFactory&factory&=&new&ActiveMQConnectionFactory(USERNAME,&PASSWORD,&BROKERURL);
Connection&connection&=&factory.createConnection();
connection.start();
Session&session&=&connection.createSession(false,&Session.AUTO_ACKNOWLEDGE);
Destination&destination&=&session.createQueue(DESTINATION);
MessageConsumer&receiver&=&session.createConsumer(destination);
Message&message&=&receiver.receive();
String&name&=&message.getStringProperty("name");
System.out.println("接收到的消息体是："&+&name);
//&message.acknowledge();&&Session.AUTO_ACKNOWLEDGE时，默认自动发送确认消息
receiver.close();
&&&&&&&&session.close();
&&&&&&&&connection.close();
&&&&}&catch(Exception&e)&{
e.printStackTrace();
创建Session的时候，connection.createSession(boolean isTranscration, int acknowledge)，第一个参数表示是否使用事务、第二个参数表示采用的消息应答的模式。
为什么会有这2个参数呢？我个人的理解是这样的，首先说下事务，我们都知道事务简单来说就是保证一批操作要么全部成功，要么全部失败，不存在部分成功，部分失败。在ActiveMQ中，消息发送发也可以在一个session中，发送多个Message消息，但要保证多个消息的在一个事务中，所以就需要将isTranscration设置成true，设置好之后，需要调用 session.commit()提交事务。
而acknowledge参数表示消息应答的模式，消息发送发发出消息，接收方接收到消息后，需要反馈给发送方，然后将消息从队列中移除。acknowledge的值有AUTO_ACKNOWLEDGE、CLIENT_ACKNOWLEDGE、DUPS_OK_ACKNOWLEDGE三种。AUTO_ACKNOWLEDGE表示自动应答模式，消息消费方接收到消息之后，会自动应答给发送发；CLIENT_ACKNOWLEDGE表示由消息消费方发送应答通知，消费方接收到消息之后，需要调用Message的acknowledge()方法，否则队列不会移除该消息，这可能会造成垃圾数据。具体应答代码如下：
Message&message&=&receiver.receive();
String&name&=&message.getStringProperty("name");
System.out.println("接收到的消息体是："&+&name);
//&消息确认：否则数据不会被删除
message.acknowledge();
2、测试同一个事务（只关注消息发送方即可）
public&void&testTranscation()&{
ConnectionFactory&factory&=&new&ActiveMQConnectionFactory(USERNAME,&PASSWORD,&BROKERURL);
Connection&connection&=&factory.createConnection();
connection.start();
//&&采用事务
Session&session&=&connection.createSession(true,&Session.AUTO_ACKNOWLEDGE);
Destination&destination&=&session.createQueue(DESTINATION);
MessageProducer&sender&=&session.createProducer(destination);
sender.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
//&发送多个消息
for(int&i&=&0;&i&&&10;&i++)&{
&&&&Message&message&=&session.createMessage();
&&&&message.setStringProperty("name_"&+&i,&"yangyong_"&+&i);
&&&&sender.send(message);
&&&&if(i&==&1)&{&//&模拟异常
int&count&=&10&/&0;
//&需要调用commit方法
session.commit();
session.close();
&&&&&&&&connection.close();
&&&&}&catch(Exception&e)&{
e.printStackTrace();
代码中使用10 / 0模拟异常，测试结果表明10个消息均未发送到队列中。
3、使用数据库存储消息
如果想把消息持久化到数据库中，只需要修改activemq.xml文件，测试代码和以文件存储数据的方式一样。首先在activemq.xml文件的&broker /&标签上面添加如下配置（以mysql为例，先手动建好数据库）
&bean&id="mysql-ds"&class="org.apache.commons.dbcp.BasicDataSource"&destroy-method="close"&
&&&&&property&name="driverClassName"&value="com.mysql.jdbc.Driver"/&
&&&&&property&name="url"&value="jdbc:mysql://localhost/activemq?relaxAutoCommit=true"/&
&&&&&property&name="username"&value="root"/&
&&&&&property&name="password"&value="root"/&
&&&&&property&name="maxActive"&value="200"/&
&&&&&property&name="poolPreparedStatements"&value="true"/&
然后在&broker /&里找到&persistenceAdapter /&标签，注释掉该配置，换成如下配置
&persistenceAdapter&
&&&&&jdbcPersistenceAdapter&dataSource="#mysql-ds"&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&createTablesOnStartup="true"&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&useDatabaseLock="false"/&
&/persistenceAdapter&
4、消息过滤（selector)
ActiveMQ是一个消息总线，多个应用中的消息都可以发送到一个队列里，每个应用的消息消费方可能只关注本系统产生的消息，这时需要定义一个selector，通过属性值筛选出感兴趣的消息数据。selector可以支持多种表达式，如=，&，&等等，可参考《ActiveMQ in Action》这本书。
//&测试selector消息过滤:发送方
public&void&testSelector()&{
ConnectionFactory&factory&=&new&ActiveMQConnectionFactory(USERNAME,&PASSWORD,&BROKERURL);
Connection&connection&=&factory.createConnection();
connection.start();
Session&session&=&connection.createSession(true,&Session.AUTO_ACKNOWLEDGE);
Destination&destination&=&session.createQueue(DESTINATION);
MessageProducer&sender&=&session.createProducer(destination);
sender.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
//发送2个消息&
TextMessage&message&=&session.createTextMessage("测试selector消息过滤1");
message.setStringProperty("from",&"jack");
sender.send(message);
message&=&session.createTextMessage("测试selector消息过滤2");
message.setStringProperty("from",&"tom");
sender.send(message);
session.commit();
session.close();
&&&&&&&&connection.close();
&&&&}&catch(Exception&e)&{
e.printStackTrace();
//&测试selector消息过滤:消费方
public&void&testSelector()&{
ConnectionFactory&factory&=&new&ActiveMQConnectionFactory(USERNAME,&PASSWORD,&BROKERURL);
Connection&connection&=&factory.createConnection();
connection.start();
Session&session&=&connection.createSession(false,&Session.AUTO_ACKNOWLEDGE);
Destination&destination&=&session.createQueue(DESTINATION);
//&设置筛选条件
String&selector&=&"from=‘jack‘";
//&创建带有筛选条件的MessageConsumer对象
MessageConsumer&consumer&=&session.createConsumer(destination,&selector);
TextMessage&message&=&(TextMessage)&consumer.receive();
System.out.println("接收到的消息："&+&message.getText());
session.close();
&&&&&&&&connection.close();
&&&&}&catch(Exception&e)&{
e.printStackTrace();
测试结果表明消息消费方只能接收到发送发发出的第一个消息，第二个from=‘tom‘的消息不能被接收。
5、消费方接收消息后，发送消息给消息发出方
在消息被消费方接收后，可能消费方需要把处理结果反馈给发出方，然后发出方再执行一些业务逻辑，其流程为
//&消息发送发
public&class&QueueSender&{
&&&&public&void&testReplyTo()&{
&&&&&&&&try&{
&&&ConnectionFactory&factory&=&new&ActiveMQConnectionFactory(USERNAME,&PASSWORD,&BROKERURL);
&&&&final&Connection&connection&=&factory.createConnection();
&&&&connection.start();
&&&&final&Session&session&=&connection.createSession(false,&Session.AUTO_ACKNOWLEDGE);
&&&&Destination&destination&=&session.createQueue(DESTINATION);
&&&&MessageProducer&sender&=&session.createProducer(destination);
&&&&sender.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
&&&&TextMessage&message&=&session.createTextMessage("测试消息消费者返回处理结果给消息生产者");
&&&&sender.send(message);
&&&&//&接受消费方返回的消息
&&&&MessageConsumer&consumer&=&session.createConsumer(destination);
&&&&consumer.setMessageListener(new&MessageListener()&{
&&&&&&&&public&void&onMessage(Message&message)&{
&&&&if(message&!=&null&&&&message&instanceof&TextMessage)&{
&&&&System.out.println("消息消费方反馈的信息-&messageID："&
&&&&&&&&&&&&&&&&+&message.getJMSCorrelationID()&+&"，消息实体："&
&&&&&&&&&&&&&&&&+&((TextMessage)message).getText());
&&&&//关闭资源
&&&&session.close();
&&&&&&&&&&&&connection.close();
&&&&&&&&}&catch&(JMSException&e)&{
&&&&e.printStackTrace();
&&&&&&&&}&catch(Exception&e)&{
&&&&e.printStackTrace();
&&&public&static&void&main(String[]&args)&{
new&QueueSender().testReplyTo();
&//&&消息接收方：
&public&class&&QueueReceiver&{
&&&&&public&void&testReplyTo()&{
&&&&&&&&try&{
&&&ConnectionFactory&factory&=&new&ActiveMQConnectionFactory(USERNAME,&PASSWORD,&BROKERURL);
&&&&final&Connection&connection&=&factory.createConnection();
&&&&connection.start();
&&&&final&Session&session&=&connection.createSession(false,&Session.AUTO_ACKNOWLEDGE);
&&&&final&Destination&destination&=&session.createQueue(DESTINATION);
&&&&MessageConsumer&consumer&=&session.createConsumer(destination);
&&&&consumer.setMessageListener(new&MessageListener()&{
&&&&&&&&public&void&onMessage(Message&message)&{
&&&&if(message&!=&null&&&&message&instanceof&TextMessage)&{
&&&&&&&&try&{
&&&&System.out.println("接收到的消息-&messageID："&
&&&&&&&&&&&&&&&&+&message.getJMSMessageID()&+&"，消息实体："
&&&&&&&&&&&&&&&&+&((TextMessage)message).getText());
&&&&//&发送消息给消息生产者
&&&&MessageProducer&sender&=&session.createProducer(destination);
&&&&sender.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
&&&&TextMessage&message0&=&session.createTextMessage("消费者已经处理了您发送的消息了");
//&必须设置这些参数JMSCorrelationID:接收到的消息的ID，JMSReplyTo：消息发送到这个地址
&&&&message0.setJMSCorrelationID(message.getJMSMessageID());
&&&&message0.setJMSReplyTo(destination);
&&&&sender.send(message0);
&&&&session.close();
&&&&&&&&&&&&connection.close();
}&catch&(JMSException&e)&{
&&&&e.printStackTrace();
&&&&&&&&}&catch(Exception&e)&{
&&&&e.printStackTrace();
&&&&public&static&void&main(String[]&args)&{
new&QueueReceiver().testReplyTo();
标签：原文地址：http://my.oschina.net/u/732520/blog/507998博客分类：
是apache的一个开源JMS服务器，不仅具备标准JMS的功能，还有很多额外的功能。公司里引入ActiveMQ后，ActiveMQ成里我们公司业
务系统中最重要的一个环节。所有应用都通过jms集成，如果ActiveMQ出了故障，整个系统就瘫痪了。因此，头对ActiveMQ的性能，可靠性，以
及如何正确使用，是非常的关心的，而我就被指派来做关于ActiveMQ的调研，本文对此做了些总结。
1 使用jms需要注意的问题
一下所述的问题，不仅是对ActiveMQ，对于其他的JMS也一样有效。
1.1 不要频繁的建立和关闭连接
JMS使用长连接方式，一个程序，只要和JMS服务器保持一个连接就可以了，不要频繁的建立和关闭连接。频繁的建立和关闭连接，对程序的性能影响还是很大的。这一点和jdbc还是不太一样的。
1.2 Connection的start()和stop()方法代价很高
的Connection的start()和stop()方法代价很高，不能经常调用。我们试用的时候，写了个jms的connection
pool，每次将connection取出pool时调用start()方法，归还时调用stop()方法，然而后来用jprofiler发现，一般的
cpu时间都耗在了这两个方法上。
1.3 start()后才能收消息
Connection的start()方法调用后，才能收到jms消息。如果不调用这个方法，能发出消息，但是一直收不到消息。不知道其它的jms服务器也是这样。
1.4 显式关闭Session
果忘记了最后关闭Connection或Session对象，都会导致内存泄漏。这个在我测试的时候也发现了。本来以为关闭了Connection，由这
个Connection生成的Session也会被自动关闭，结果并非如此，Session并没有关闭，导致内存泄漏。所以一定要显式的关闭
Connection和Session。
1.5 对Session做对象池
对Session做对象池，而不是
Connection。Session也是昂贵的对象，每次使用都新建和关闭，代价也非常高。而且后来我们发现，原来Connection是线程安全的，
而Session不是，所以后来改成了对Session做对象池，而只保留一个Connection。
ActiveMQ有强大而灵活的集群功能，但是使用起来还是会有很多陷阱。
2.1 broker cluster和 master-slave
可以做broker的集群，也可以做master-slave方式的集群。前者能在多个broker之前fail-over和load-balance，
但是在某个节点出故障时，可能导致消息丢失；而后者能实时备份消息，和fail-over，但是不能load-balance。broker
cluser的方式，在一个broker上发送的消息可以在其它的broker上收到。当一个broker失效时，客户端可以自动的转到别的broker
上运行，多个broker可以同时提供服务，但是消息只存储在一个broker上，如果那个broker失效了，那么客户端直到它重新启动后才能收到该
broker上的消息，假如很不幸，那个broker的存储介质坏了，那么消息就丢失掉了。
Master-slave方式中，只有master提供服务，slave只是实时的备份master的数据，所以消息不会丢失。当master失效
时，slave会自动升为master，客户端会自动转到slave上工作，所以能fail-over。由于只有master提供服务，所以不能将负载分
到多个broker上。
其实单个broker的性能已经是相当的惊人了，在我们公司的机器上能达到每秒收发4000个消息，没个消息4K字节这样的速度，足够公司目前的需要了，而公司并不希望丢失任何数据，所以我们选择使用master-slave模式。
2.2 多种master-slave模式
master-slave也有多种实现方式。它们的不同只是在共享数据和锁机制上。
2.2.1 Pure master-slave
master-slave，显示的在配置文件中指定一个broker做为另一个broker的slave。运行时，slave同过网络自动从master
出复制数据，同时在和master失去连接时自动升级为master。当master失效，slave成为master后，如果要让原先的master重
新投入运行，需要停掉运行中的slave(现在升级为master了)，手动复制slave中的数据到master中。再重新启动master和
slave。这种方式最简单，效率也不错，但是只能有两台做集群，只能fail-over一次，而且需要停机回复master-slave结构。
2.2.2 JDBC master-slave
种方式不需要特殊的配置，只要让所有的节点都把数据存储到同一个数据库中。先拿到数据库表的锁的节点成为master，一旦它失效了，其它的节点获得锁，
就可以成为master。因为数据通过数据库共享，放在一个地方，不需要停机恢复master-slave。这种方式，需要额外的数据库服务器，如果数据
库失效了，那么就全失效了，而且速度不是很快。我们在用mysql测试时，并没有成功，master失效后，其他的节点始终没有升级成slave，可能是
数据库配置的问题。
2.2.3 Share file master-slave
这种方式类似于前者，也不需要特别的配置，只是通过共享文件系统来共享数据，靠文件锁实现只有一台成为master。共享文件系统的方式有很多，我们测试了nfs v4 (v3有bug，不行)， 最终在稳定性，效率等方面不是很满意，可能是通过网络太慢了。
试过众多master-slave模式后发现，pure方式管理起来麻烦，jdbc方式成本高，效率低，share
file方式需要高性能的共享文件，都有缺点。鉴于单台activeMQ很可靠，而我们的基础平台组愿意用硬件备份，最终还是决定不用master-
slave了，也不用broker cluster，就用单台，通过硬件冗余保证数据不会丢失，并找另外一台刀片机做冷备，在主服务器失效时顶替。
http://sulong.me/archives/207
如说：订单创建后，发送一条消息到一个队列，另一个专门发邮件的程序接受队列里消息，给用户发送邮件。事实上，所有需要给用户发邮件的地方都只要给这个队
列里发送消息就可以了。
这样做的好处在于，用户不用等到邮件发送结束，就可以先看到订单创建结果。整个系统中只有一处对立发邮件功能，其它应用都只要向这个应用发消息就行了。
步调用的本质是可以让调用者在被调用者完成之前返回，这样调用者不用等待被调用者完成调用。所以异步的第一个用途就是用来提高响应速度。比如我前面的例子
里，用户确认创建订单后，他只要知道订单被创建好了就行了，订单创建后的发邮件等一系列的事情是否发生，有没有成功执行，他不关心。用户在感觉上就是响应
速度提升了。
至于你说的可扩展性，伸缩性，等等，都得建立在他们可以异步的基础上。比如，用户登录功能，用户在提交过登录信息后，就得马上见到是否登录成功，你不能告诉他你正在登录中，半个小时候来看结果。这个时候就算异步可以提升XX性，也是不能采用的。
次，采用异步后，并不意味着就能在扩展性，伸缩性或运行效率上的提升。扩展性主要是靠良好的程序设计来实现。在良好的程序设计的基础上，你才容易在不改动
或较少改动原有代码的基础上编写出新功能。如果程序设计得不好，即便用了异步，也不容易添加新的功能。异步也只能提升系统中那些可以异步的应用的伸缩性，
并不一定能提升整个系统的伸缩性。比方说，如果发送邮件服务器的负载太高，我们可以添加新的服务器来监听消息发邮件，发送邮件的应用伸缩性是提高了；如果
创建订单应用由于设计上的原因不能通过简单的加入服务器就可以支持更多的负载，那么创建订单应用的伸缩性并没有因为异步发送邮件而有多大的改善。对于整个
系统来说，伸缩性并没有太大的改善。最后，运行效率有很多具体的指标，我觉得异步确实提升了响应速度，但是对其它的指标可能也没有多少改善。
zqjshiyingxiong
浏览: 333559 次
来自: 无锡
这还和字段是否主键，加索引，有很大关系，我对一个索引的字段查询 ...
好，就是想知道怎样将默认bash修改成nologin
“在jar中添加了字体”是什么意思？
楼主学习了，以后继续发表这类的文章，会继续光临的。。
Selenium中使用的貌似是Junit 3.x，上面的例子也 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'博客分类：
在以下三种情况中，ActiveMQ消息会被重发给客户端/消费者：
1.使用一个事务session，并且调用了rollback()方法；
2.一个事务session，关闭之前调用了commit；
3.在session中使用CLIENT_ACKNOWLEDGE签收模式，并且调用了Session.recover()方法。
Broker根据自己的规则，通过BrokerInfo命令包和客户端建立连接，向客户端传送缺省发送策略。但是客户端可以使用ActiveMQConnection.getRedeliveryPolicy()方法覆盖override这个策略设置。
RedeliveryPolicy policy = connection.getRedeliveryPolicy();
policy.setInitialRedeliveryDelay(500);
policy.setBackOffMultiplier(2);
policy.setUseExponentialBackOff(true);
policy.setMaximumRedeliveries(2);
一旦消息重发尝试超过重发策略中配置的maximumRedeliveries(缺省为6次)时，会给broker发送一个"Poison ack"，通知它，这个消息被认为是一个毒丸(a poison pill)，接着broker会将这个消息发送到DLQ(Dead Letter Queue)，以便后续分析处理。
缺省死信队列(Dead Letter Queue)叫做ActiveMQ.DLQ;所有的未送达消息都会被发送到这个队列，以致会非常难于管理。你可以设置activemq.xml文件中的destination policy map的"individualDeadLetterStrategy"属性来修改.
&broker...&
&destinationPolicy&
&policyMap&
&policyEntries&
&!-- Set the following policy on all queues using the '&' wildcard --&
&policyEntry queue="&"&
&deadLetterStrategy&
Use the prefix 'DLQ.' for the destination name, and make
the DLQ a queue rather than a topic
&individualDeadLetterStrategy
queuePrefix="DLQ." useQueueForQueueMessages="true" /&
&/deadLetterStrategy&
&/policyEntry&
&/policyEntries&
&/policyMap&
&/destinationPolicy&
自动丢弃过期消息(Expired Messages)
一些应用可能只是简单的丢弃过期消息，而不想将它们放到DLQ中，完全跳过了DLQ。在dead letter strategy死信策略上配置processExpired属性为false，可以实现这个功能。
&broker...&
&destinationPolicy&
&policyMap&
&policyEntries&
&!-- Set the following policy on all queues using the '&' wildcard --&
&policyEntry queue="&"&
Tell the dead letter strategy not to process expired messages
so that they will just be discarded instead of being sent to
&deadLetterStrategy&
&sharedDeadLetterStrategy processExpired="false" /&
&/deadLetterStrategy&
&/policyEntry&
&/policyEntries&
&/policyMap&
&/destinationPolicy&
将非持久消息(non-persistent messages)放入死信队列
ActiveMQ缺省不会将未发到的非持久消息放入死信队列。如果一个应用程序并不想将消息message设置为持久的，那么记录下来那些未发送到的消息对它来说往往也是没有价值的。不过如果想实现这个功能，可以在dead-letter strategy死信策略上设置processNonPersistent="true"
&broker...&
&destinationPolicy&
&policyMap&
&policyEntries&
&!-- Set the following policy on all queues using the '&' wildcard --&
&policyEntry queue="&"&
Tell the dead letter strategy to also place non-persisted messages
onto the dead-letter queue if they can't be delivered.
&deadLetterStrategy&
&sharedDeadLetterStrategy processNonPersistent="true" /&
&/deadLetterStrategy&
&/policyEntry&
&/policyEntries&
&/policyMap&
&/destinationPolicy&
浏览 19236
浏览: 348140 次
来自: 北京
浏览量：5579
浏览量：6186
第二条这个:2.一个事务session，关闭之前调用了comm ...
分享一款代码生成器，拖拽式组件结合流式处理，很容易的访问数据库 ...
很明显这个新政对教练没有限制，所以目测足协准备先从高水平教练打 ...
给静态变量设置Setter方法，在Setter方法上加注入操作 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'}