Java JmsUtils.commitIfNecessary方法代码示例

import org.springframework.jms.support.JmsUtils; //导入方法依赖的package包/类
/**
 * Send the given JMS message.
 * @param session the JMS Session to operate on
 * @param destination the JMS Destination to send to
 * @param messageCreator callback to create a JMS Message
 * @throws JMSException if thrown by JMS API methods
 */
protected void doSend(Session session, Destination destination, MessageCreator messageCreator)
		throws JMSException {

	Assert.notNull(messageCreator, "MessageCreator must not be null");
	MessageProducer producer = createProducer(session, destination);
	try {
		Message message = messageCreator.createMessage(session);
		if (logger.isDebugEnabled()) {
			logger.debug("Sending created message: " + message);
		}
		doSend(producer, message);
		// Check commit - avoid commit call within a JTA transaction.
		if (session.getTransacted() && isSessionLocallyTransacted(session)) {
			// Transacted session created by this template -> commit.
			JmsUtils.commitIfNecessary(session);
		}
	}
	finally {
		JmsUtils.closeMessageProducer(producer);
	}
}
 

import org.springframework.jms.support.JmsUtils; //导入方法依赖的package包/类
private Object doSendToDestination(final Destination destination,
                                   final MessageCreator messageCreator,
                                   final MessageSentCallback callback,
                                   final Session session) throws JMSException {

    Assert.notNull(messageCreator, "MessageCreator must not be null");
    MessageProducer producer = createProducer(session, destination);
    Message message;
    try {
        message = messageCreator.createMessage(session);
        doSend(producer, message);
        if (message != null && callback != null) {
            callback.sent(session, message, destination);
        }
        // Check commit - avoid commit call within a JTA transaction.
        if (session.getTransacted() && isSessionLocallyTransacted(session)) {
            // Transacted session created by this template -> commit.
            JmsUtils.commitIfNecessary(session);
        }
    } finally {
        JmsUtils.closeMessageProducer(producer);
    }
    return null;
}
 

import org.springframework.jms.support.JmsUtils; //导入方法依赖的package包/类
/**
 * Invoke the specified listener as Spring SessionAwareMessageListener,
 * exposing a new JMS Session (potentially with its own transaction)
 * to the listener if demanded.
 * @param listener the Spring SessionAwareMessageListener to invoke
 * @param session the JMS Session to operate on
 * @param message the received JMS Message
 * @throws JMSException if thrown by JMS API methods
 * @see SessionAwareMessageListener
 * @see #setExposeListenerSession
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
protected void doInvokeListener(SessionAwareMessageListener listener, Session session, Message message)
		throws JMSException {

	Connection conToClose = null;
	Session sessionToClose = null;
	try {
		Session sessionToUse = session;
		if (!isExposeListenerSession()) {
			// We need to expose a separate Session.
			conToClose = createConnection();
			sessionToClose = createSession(conToClose);
			sessionToUse = sessionToClose;
		}
		// Actually invoke the message listener...
		listener.onMessage(message, sessionToUse);
		// Clean up specially exposed Session, if any.
		if (sessionToUse != session) {
			if (sessionToUse.getTransacted() && isSessionLocallyTransacted(sessionToUse)) {
				// Transacted session created by this container -> commit.
				JmsUtils.commitIfNecessary(sessionToUse);
			}
		}
	}
	finally {
		JmsUtils.closeSession(sessionToClose);
		JmsUtils.closeConnection(conToClose);
	}
}
 

import org.springframework.jms.support.JmsUtils; //导入方法依赖的package包/类
/**
 * 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, 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();
	}
}
 

import org.springframework.jms.support.JmsUtils; //导入方法依赖的package包/类
/**
 * Actually receive a JMS message.
 * @param session the JMS Session to operate on
 * @param consumer the JMS MessageConsumer to receive with
 * @return the JMS Message received, or {@code null} if none
 * @throws JMSException if thrown by JMS API methods
 */
protected Message doReceive(Session session, MessageConsumer consumer) throws JMSException {
	try {
		// Use transaction timeout (if available).
		long timeout = getReceiveTimeout();
		JmsResourceHolder resourceHolder =
				(JmsResourceHolder) TransactionSynchronizationManager.getResource(getConnectionFactory());
		if (resourceHolder != null && resourceHolder.hasTimeout()) {
			timeout = Math.min(timeout, resourceHolder.getTimeToLiveInMillis());
		}
		Message message = doReceive(consumer, timeout);
		if (session.getTransacted()) {
			// Commit necessary - but avoid commit call within a JTA transaction.
			if (isSessionLocallyTransacted(session)) {
				// Transacted session created by this template -> commit.
				JmsUtils.commitIfNecessary(session);
			}
		}
		else if (isClientAcknowledge(session)) {
			// Manually acknowledge message, if any.
			if (message != null) {
				message.acknowledge();
			}
		}
		return message;
	}
	finally {
		JmsUtils.closeMessageConsumer(consumer);
	}
}
 

import org.springframework.jms.support.JmsUtils; //导入方法依赖的package包/类
protected List<Message> doBatchReceive(Session session, MessageConsumer consumer, int batchSize)
        throws JMSException {

    try {
        final List<Message> result;
        long timeout = determineTimeout();

        Message message = doReceive(consumer, timeout);

        if (message == null) {
            result = new ArrayList<Message>(0);
        } else {
            result = new ArrayList<Message>(batchSize);
            result.add(message);
            for (int i = 1; i < batchSize; i++) {
                message = doReceive(consumer, RECEIVE_TIMEOUT_NO_WAIT);
                if (message == null) {
                    break;
                }
                result.add(message);
            }
        }

        if (session.getTransacted()) {
            if (isSessionLocallyTransacted(session)) {
                JmsUtils.commitIfNecessary(session);
            }
        } else if (isClientAcknowledge(session)) {
            if (message != null) {
                message.acknowledge();
            }
        }
        return result;
    } finally {
        JmsUtils.closeMessageConsumer(consumer);
    }
}
 

import org.springframework.jms.support.JmsUtils; //导入方法依赖的package包/类
/**
 * Variant of {@link AbstractMessageListenerContainer#commitIfNecessary(Session, Message)} that performs the activity for a batch of messages.
 * @param session the JMS Session to commit
 * @param messages the messages to acknowledge
 * @throws javax.jms.JMSException in case of commit failure
 */
protected void commitIfNecessary(Session session, List<Message> messages) 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 (messages != null && isClientAcknowledge(session)) {
        for (Message message : messages) {
            message.acknowledge();
        }
    }
}