Java 使用CoreAPI消费后,HornetQ消息仍保留在队列中
我是大黄蜂队的新手,所以请容忍我。首先让我告诉你我的要求: 我需要一个消息队列中间件,它可以在不同的进程之间传递大约1k大小的消息,具有低延迟和持久性(也就是说,它应该能够经受住系统崩溃)。我将有多个进程写入同一队列,并且类似地有多个进程从同一队列读取 为此,我选择了HornetQ,因为它在持久性消息传递方面具有最好的评级 我目前使用的是Hornetq v2.2.2Final作为独立服务器Java 使用CoreAPI消费后,HornetQ消息仍保留在队列中,java,producer-consumer,hornetq,persistent-storage,queuing,Java,Producer Consumer,Hornetq,Persistent Storage,Queuing,我是大黄蜂队的新手,所以请容忍我。首先让我告诉你我的要求: 我需要一个消息队列中间件,它可以在不同的进程之间传递大约1k大小的消息,具有低延迟和持久性(也就是说,它应该能够经受住系统崩溃)。我将有多个进程写入同一队列,并且类似地有多个进程从同一队列读取 为此,我选择了HornetQ,因为它在持久性消息传递方面具有最好的评级 我目前使用的是Hornetq v2.2.2Final作为独立服务器 我能够使用核心api(ClientSession)成功创建持久/非持久队列,并成功将消息发布到队列(Cli
我能够使用核心api(ClientSession)成功创建持久/非持久队列,并成功将消息发布到队列(ClientProducer)。
同样,我能够使用核心api(ClientConsumer)从队列中读取消息 在此之后,当客户端读取消息时,消息仍保留在队列中,即队列中的消息数保持不变。也许我弄错了,但我的印象是,一旦消息被消费(read+ack),它就会从队列中删除。但我的情况不是这样,同样的消息会被反复阅读 此外,我还想告诉大家,我已经尝试使用非持久性队列处理非持久性消息。但问题依然存在 我正在使用的制作人代码:
public class HQProducer implements Runnable {
private ClientProducer producer;
private boolean killme;
private ClientSession session;
private boolean durableMsg;
public HQProducer(String host, int port, String address, String queueName,
boolean deleteQ, boolean durable, boolean durableMsg, int pRate) {
this.durableMsg = durableMsg;
try {
HashMap map = new HashMap();
map.put("host", host);
map.put("port", port);
TransportConfiguration config = new TransportConfiguration(NettyConnectorFactory.class.getName(), map);
ServerLocator locator = HornetQClient.createServerLocatorWithoutHA(config);
ClientSessionFactory factory = locator.createSessionFactory();
session = factory.createSession();
if (queueExists(queueName)) {
if (deleteQ) {
System.out.println("Deleting existing queue :: " + queueName);
session.deleteQueue(queueName);
System.out.println("Creating queue :: " + queueName);
session.createQueue(address, queueName, true);
}
} else {
System.out.println("Creating new queue :: " + queueName);
session.createQueue(address, queueName, durable);
}
producer = session.createProducer(SimpleString.toSimpleString(address), pRate);
killme = false;
} catch (Exception ex) {
Logger.getLogger(HQTestProducer.class.getName()).log(Level.SEVERE, null, ex);
}
}
@Override
public void run() {
long time = System.currentTimeMillis();
int cnt = 0;
long timediff;
while (!killme) {
try {
ClientMessage message = session.createMessage(durableMsg);
message.getBodyBuffer().writeString("Hello world");
producer.send(message);
cnt++;
timediff = ((System.currentTimeMillis() - time) / 1000);
if (timediff >= 1) {
System.out.println("Producer tps :: " + cnt);
cnt = 0;
time = System.currentTimeMillis();
}
} catch (HornetQException ex) {
Logger.getLogger(HQProducer.class.getName()).log(Level.SEVERE, null, ex);
}
}
try {
session.close();
} catch (HornetQException ex) {
Logger.getLogger(HQProducer.class.getName()).log(Level.SEVERE, null, ex);
}
}
public void setKillMe(boolean killme) {
this.killme = killme;
}
private boolean queueExists(String qname) {
boolean res = false;
try {
//ClientSession.BindingQuery bq = session.bindingQuery(SimpleString.toSimpleString(qname));
QueueQuery queueQuery = session.queueQuery(SimpleString.toSimpleString(qname));
if (queueQuery.isExists()) {
res = true;
}
} catch (HornetQException ex) {
res = false;
}
return res;
}
}
此外,消费者代码为:
public class HQConsumer implements Runnable {
private ClientSession session;
private ClientConsumer consumer;
private boolean killMe;
public HQConsumer(String host, int port, String queueName, boolean browseOnly) {
try {
HashMap map = new HashMap();
map.put("host", host);
map.put("port", port);
TransportConfiguration config = new TransportConfiguration(NettyConnectorFactory.class.getName(), map);
ServerLocator locator = HornetQClient.createServerLocatorWithoutHA(config);
ClientSessionFactory factory = locator.createSessionFactory();
session = factory.createSession();
session.start();
consumer = session.createConsumer(queueName, "",0,-1,browseOnly);
killMe = false;
} catch (Exception ex) {
Logger.getLogger(HQTestProducer.class.getName()).log(Level.SEVERE, null, ex);
}
}
@Override
public void run() {
long time = System.currentTimeMillis();
int cnt = 0;
long timediff;
while (!killMe) {
try {
ClientMessage msgReceived = consumer.receive();
msgReceived.acknowledge();
//System.out.println("message = " + msgReceived.getBodyBuffer().readString());
cnt++;
timediff = ((System.currentTimeMillis() - time) / 1000);
if (timediff >= 1) {
System.out.println("ConSumer tps :: " + cnt);
cnt = 0;
time = System.currentTimeMillis();
}
} catch (HornetQException ex) {
Logger.getLogger(HQConsumer.class.getName()).log(Level.SEVERE, null, ex);
}
}
try {
session.close();
} catch (HornetQException ex) {
Logger.getLogger(HQConsumer.class.getName()).log(Level.SEVERE, null, ex);
}
}
public void setKillMe(boolean killMe) {
this.killMe = killMe;
}
}
HornetQ服务器配置::
<configuration xmlns="urn:hornetq"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="urn:hornetq /schema/hornetq-configuration.xsd">
<paging-directory>${data.dir:../data}/paging</paging-directory>
<bindings-directory>${data.dir:../data}/bindings</bindings-directory>
<journal-directory>${data.dir:../data}/journal</journal-directory>
<journal-min-files>10</journal-min-files>
<large-messages-directory>${data.dir:../data}/large-messages</large-messages-directory>
<connectors>
<connector name="netty">
<factory-class>org.hornetq.core.remoting.impl.netty.NettyConnectorFactory</factory-class>
<param key="host" value="${hornetq.remoting.netty.host:localhost}"/>
<param key="port" value="${hornetq.remoting.netty.port:5445}"/>
</connector>
<connector name="netty-throughput">
<factory-class>org.hornetq.core.remoting.impl.netty.NettyConnectorFactory</factory-class>
<param key="host" value="${hornetq.remoting.netty.host:localhost}"/>
<param key="port" value="${hornetq.remoting.netty.batch.port:5455}"/>
<param key="batch-delay" value="50"/>
</connector>
</connectors>
<acceptors>
<acceptor name="netty">
<factory-class>org.hornetq.core.remoting.impl.netty.NettyAcceptorFactory</factory-class>
<param key="host" value="${hornetq.remoting.netty.host:localhost}"/>
<param key="port" value="${hornetq.remoting.netty.port:5445}"/>
</acceptor>
<acceptor name="netty-throughput">
<factory-class>org.hornetq.core.remoting.impl.netty.NettyAcceptorFactory</factory-class>
<param key="host" value="${hornetq.remoting.netty.host:localhost}"/>
<param key="port" value="${hornetq.remoting.netty.batch.port:5455}"/>
<param key="batch-delay" value="50"/>
<param key="direct-deliver" value="false"/>
</acceptor>
</acceptors>
<security-settings>
<security-setting match="#">
<permission type="createNonDurableQueue" roles="guest"/>
<permission type="deleteNonDurableQueue" roles="guest"/>
<permission type="createDurableQueue" roles="guest"/>
<permission type="deleteDurableQueue" roles="guest"/>
<permission type="consume" roles="guest"/>
<permission type="send" roles="guest"/>
</security-setting>
</security-settings>
<address-settings>
<!--default for catch all-->
<address-setting match="#">
<dead-letter-address>jms.queue.DLQ</dead-letter-address>
<expiry-address>jms.queue.ExpiryQueue</expiry-address>
<redelivery-delay>0</redelivery-delay>
<max-size-bytes>10485760</max-size-bytes>
<message-counter-history-day-limit>10</message-counter-history-day-limit>
<address-full-policy>BLOCK</address-full-policy>
</address-setting>
</address-settings>
</configuration>
${data.dir:../data}/paging
${data.dir:../data}/bindings
${data.dir:../data}/journal
10
${data.dir:../data}/大型消息
org.hornetq.core.remoting.impl.netty.NettyConnectorFactory
org.hornetq.core.remoting.impl.netty.NettyConnectorFactory
org.hornetq.core.remoting.impl.netty.NettyAcceptorFactory
org.hornetq.core.remoting.impl.netty.NettyAcceptorFactory
jms.queue.DLQ
jms.queue.ExpiryQueue
0
10485760
10
块
使用hornetq core api,您必须明确确认消息。我看不出你的测试结果
如果您没有确认,这就是您的消息被阻止的原因。我需要看看你的完整例子,给你一个完整的答案
另外:您应该使用:createSession(true,true,0)定义您的createSession
核心API具有批处理ACK的选项。您没有使用事务处理会话,因此在达到serverLocator上配置的ackBatchSize之前,不会向服务器发送ACK。这样,只要您在消息中调用acknowledge(),任何ack都将被发送到服务器 您当前使用的选项相当于具有特定DUPS_大小的JMS DUPS_OK
(与您反复讨论后,Post编辑了我的初始答案)设置
ackbatchsize
帮助我解决了这个问题。。
感谢您的帮助a/c,您需要在处理后确认邮件,您是否也这样做?
ClientMessage msgReceived=consumer.receive();msgReceived.acknowledge()代码>。。我承认core API可以选择批处理ACK。您没有使用事务处理会话,因此在达到serverLocator上配置的ackBatchSize之前,不会向服务器发送ACK。您应该使用以下命令定义createSession:createSession(true,true,0);在这个位置上,只要您在消息中调用acknowledge(),您没有返回到这个线程,任何ack都将被发送到服务器。所以我假设你的问题得到了解决?有同样的问题,这似乎解决了它。我显然不理解createSession的java文档(boolean autoCommitSends、boolean autocommitks、intAckBatchSize)。autoCommitSends和autoCommitAcks与确认部分无关,只与提交有关,对吗?@AlperAkture不确定您的问题是否得到了回答,但鉴于确认的名称,其中至少有一个与确认有关。