/** * Ack the message. * * @param msg the message * @throws JMSException the JMS exception in case of error */ protected void doAck(final Message msg) throws JMSException { msg.acknowledge(); LOG.debug("JMS message acked"); }
@Override protected void doAck(final Message msg) throws JMSException { // if there are no more pending consumed messages // and storm delivered ack for all if (getPendingAcks().isEmpty()) { msg.acknowledge(); LOG.debug("JMS message acked"); } else { LOG.debug("Not acknowledging the JMS message " + "since there are pending messages in the session"); } } }
private void acknowledge(final Message message, final Session session) throws JMSException { if (message != null && session.getAcknowledgeMode() == Session.CLIENT_ACKNOWLEDGE) { message.acknowledge(); } }
/** * Perform a commit or message acknowledgement, as appropriate. * @param session the JMS Session to commit * @param message the Message to acknowledge * @throws javax.jms.JMSException in case of commit failure */ protected void commitIfNecessary(Session session, @Nullable Message message) throws JMSException { // Commit session or acknowledge message. if (session.getTransacted()) { // Commit necessary - but avoid commit call within a JTA transaction. if (isSessionLocallyTransacted(session)) { // Transacted session created by this container -> commit. JmsUtils.commitIfNecessary(session); } } else if (message != null && isClientAcknowledge(session)) { message.acknowledge(); } }
@Override public void acknowledge() { checkSession(); if (closed) throw new IllegalStateRuntimeException("Context is closed"); try { if (lastMessagesWaitingAck != null) { lastMessagesWaitingAck.acknowledge(); } } catch (JMSException e) { throw JmsExceptionUtils.convertToRuntimeException(e); } }
@Override public void success(TransactionAttempt tx) { @SuppressWarnings("unchecked") List<Message> messages = (List<Message>) batchMessageMap.remove(tx.getTransactionId()); if (messages != null) { if (!messages.isEmpty()) { LOG.debug("Success for batch with transaction id " + tx.getTransactionId() + "/" + tx.getAttemptId() + " for " + name); } for (Message msg : messages) { String messageId = "UnknownId"; try { messageId = msg.getJMSMessageID(); msg.acknowledge(); LOG.trace("Acknowledged message " + messageId); } catch (JMSException e) { LOG.warn("Failed to acknowledge message " + messageId, e); } } } else { LOG.warn("No messages found in batch with transaction id " + tx.getTransactionId() + "/" + tx.getAttemptId()); } }
if (batchSize > 0 && received > 0 && received % batchSize == 0) { LOG.info("Acknowledging last " + batchSize + " messages; messages so far = " + received); msg.acknowledge();
/** * spec section 3.6 acking a message with automation acks has no effect. * @throws Exception */ public void testAckMessageInTx() throws Exception { Message[] outbound = new Message[] {session.createTextMessage("First Message")}; // sends a message beginTx(); producer.send(outbound[0]); outbound[0].acknowledge(); commitTx(); outbound[0].acknowledge(); // receives the first message beginTx(); ArrayList<Message> messages = new ArrayList<Message>(); LOG.info("About to consume message 1"); Message message = consumer.receive(1000); messages.add(message); LOG.info("Received: " + message); // validates that the rollbacked was not consumed commitTx(); Message inbound[] = new Message[messages.size()]; messages.toArray(inbound); assertTextMessagesEqual("Message not delivered.", outbound, inbound); }
message.acknowledge(); } catch(Exception e) { jmsConnector.handleConnectionFailure(getConnnectionForConsumer());
@Override public void onMessage(Message message) { TextMessage textMessage = (TextMessage)message; try { System.out.println(textMessage.getText()); //...... //执行成功后,确认消息 message.acknowledge(); } catch (Exception e) { throw new RuntimeException(e); } }
if (clientAcknowledge && lastMessage != null) { try { lastMessage.acknowledge(); // acknowledge all received messages by acknowledging only the last. } catch (final JMSException e) { logger.error("Failed to acknowledge {} JMS Message(s). This may result in duplicate messages. Reason for failure: {}",
@Override public void handleEventProcessingError(Message errorEvent, Throwable exception) { LOGGER.error("An error occurred processing event: [" + errorEvent + "]", exception); try { errorEvent.acknowledge(); } catch (JMSException ex) { LOGGER.error("An error occured acknowledging bad JMS message [" + errorEvent + "]", ex); } } }
@Override public void onComplete(Exchange exchange) { LOG.info("Using JMS client acknowledge to accept the JMS message consumed: {}", jms); try { jms.acknowledge(); } catch (JMSException e) { LOG.warn("JMS client acknowledge failed due: " + e.getMessage(), e); } } });
protected void acknowledgeMessage(Message message, MockSession session) throws JMSException { if(session.isAutoAcknowledge()) { message.acknowledge(); } } }
@Override public Object call() throws Exception { JMSContext.this.latestMessage.jmsMessage().acknowledge(); return null; } });
@Override public void onMessage(Message message) { try { message.acknowledge(); done.countDown(); } catch (JMSException ex) { LOG.info("Caught exception.", ex); } } });
@Override public void acknowledge() { session(); try { if (lastMessagesWaitingAck != null) { lastMessagesWaitingAck.acknowledge(); } } catch (final JMSException e) { throw toRuntimeException(e); } }
/** * Acknowledge * * @throws JMSException Thrown if an error occurs */ @Override public void acknowledge() throws JMSException { if (ActiveMQRALogger.LOGGER.isTraceEnabled()) { ActiveMQRALogger.LOGGER.trace("acknowledge()"); } session.getSession(); // Check for closed message.acknowledge(); }
/** * Commit/Acknowledge messages that have been received.<br/> * @throws javax.jms.JMSException */ protected void acknowledge() throws JMSException { if (isTransacted()) { getSession().commit(); } else if (getSessionAckMode(getAckMode()) == Session.CLIENT_ACKNOWLEDGE) { lastMsg.acknowledge(); // acknowledge all consumed messages till now } }