Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.camel.component.sjms; import java.util.concurrent.ExecutorService; import java.util.concurrent.Future; import javax.jms.Connection; import javax.jms.Destination; import javax.jms.MessageConsumer; import javax.jms.MessageListener; import javax.jms.Session; import org.apache.camel.Endpoint; import org.apache.camel.ExchangePattern; import org.apache.camel.Processor; import org.apache.camel.component.sjms.consumer.AbstractMessageHandler; import org.apache.camel.component.sjms.consumer.InOnlyMessageHandler; import org.apache.camel.component.sjms.consumer.InOutMessageHandler; import org.apache.camel.component.sjms.jms.ConnectionResource; import org.apache.camel.component.sjms.jms.JmsObjectFactory; import org.apache.camel.component.sjms.taskmanager.TimedTaskManager; import org.apache.camel.component.sjms.tx.BatchTransactionCommitStrategy; import org.apache.camel.component.sjms.tx.DefaultTransactionCommitStrategy; import org.apache.camel.component.sjms.tx.SessionBatchTransactionSynchronization; import org.apache.camel.component.sjms.tx.SessionTransactionSynchronization; import org.apache.camel.impl.DefaultConsumer; import org.apache.camel.spi.Synchronization; import org.apache.commons.pool.BasePoolableObjectFactory; import org.apache.commons.pool.impl.GenericObjectPool; /** * The SjmsConsumer is the base class for the SJMS MessageListener pool. */ public class SjmsConsumer extends DefaultConsumer { protected GenericObjectPool<MessageConsumerResources> consumers; private ExecutorService executor; private Future<?> asyncStart; /** * A pool of MessageConsumerResources created at the initialization of the associated consumer. */ protected class MessageConsumerResourcesFactory extends BasePoolableObjectFactory<MessageConsumerResources> { /** * Creates a new MessageConsumerResources instance. * * @see org.apache.commons.pool.PoolableObjectFactory#makeObject() */ @Override public MessageConsumerResources makeObject() throws Exception { return createConsumer(); } /** * Cleans up the MessageConsumerResources. * * @see org.apache.commons.pool.PoolableObjectFactory#destroyObject(java.lang.Object) */ @Override public void destroyObject(MessageConsumerResources model) throws Exception { if (model != null) { // First clean up our message consumer if (model.getMessageConsumer() != null) { model.getMessageConsumer().close(); } // If the resource has a if (model.getSession() != null) { if (model.getSession().getTransacted()) { try { model.getSession().rollback(); } catch (Exception e) { // Do nothing. Just make sure we are cleaned up } } model.getSession().close(); } } } } public SjmsConsumer(Endpoint endpoint, Processor processor) { super(endpoint, processor); } @Override public SjmsEndpoint getEndpoint() { return (SjmsEndpoint) super.getEndpoint(); } @Override protected void doStart() throws Exception { super.doStart(); this.executor = getEndpoint().getCamelContext().getExecutorServiceManager().newDefaultThreadPool(this, "SjmsConsumer"); if (consumers == null) { consumers = new GenericObjectPool<MessageConsumerResources>(new MessageConsumerResourcesFactory()); consumers.setMaxActive(getConsumerCount()); consumers.setMaxIdle(getConsumerCount()); if (getEndpoint().isAsyncStartListener()) { asyncStart = getEndpoint().getComponent().getAsyncStartStopExecutorService().submit(new Runnable() { @Override public void run() { try { fillConsumersPool(); } catch (Throwable e) { log.warn("Error starting listener container on destination: " + getDestinationName() + ". This exception will be ignored.", e); } } @Override public String toString() { return "AsyncStartListenerTask[" + getDestinationName() + "]"; } }); } else { fillConsumersPool(); } } } private void fillConsumersPool() throws Exception { while (consumers.getNumIdle() < consumers.getMaxIdle()) { consumers.addObject(); } } @Override protected void doStop() throws Exception { super.doStop(); if (asyncStart != null && !asyncStart.isDone()) { asyncStart.cancel(true); } if (consumers != null) { if (getEndpoint().isAsyncStopListener()) { getEndpoint().getComponent().getAsyncStartStopExecutorService().submit(new Runnable() { @Override public void run() { try { consumers.close(); consumers = null; } catch (Throwable e) { log.warn("Error stopping listener container on destination: " + getDestinationName() + ". This exception will be ignored.", e); } } @Override public String toString() { return "AsyncStopListenerTask[" + getDestinationName() + "]"; } }); } else { consumers.close(); consumers = null; } } if (this.executor != null) { getEndpoint().getCamelContext().getExecutorServiceManager().shutdownGraceful(this.executor); } } /** * Creates a {@link MessageConsumerResources} with a dedicated * {@link Session} required for transacted and InOut consumers. */ private MessageConsumerResources createConsumer() throws Exception { MessageConsumerResources answer; Connection conn = getConnectionResource().borrowConnection(); try { Session session = conn.createSession(isTransacted(), isTransacted() ? Session.SESSION_TRANSACTED : Session.AUTO_ACKNOWLEDGE); Destination destination = getEndpoint().getDestinationCreationStrategy().createDestination(session, getDestinationName(), isTopic()); MessageConsumer messageConsumer = JmsObjectFactory.createMessageConsumer(session, destination, getMessageSelector(), isTopic(), getDurableSubscriptionId()); MessageListener handler = createMessageHandler(session); messageConsumer.setMessageListener(handler); answer = new MessageConsumerResources(session, messageConsumer); } catch (Exception e) { log.error("Unable to create the MessageConsumer", e); throw e; } finally { getConnectionResource().returnConnection(conn); } return answer; } /** * Helper factory method used to create a MessageListener based on the MEP * * @param session a session is only required if we are a transacted consumer * @return the listener */ protected MessageListener createMessageHandler(Session session) { TransactionCommitStrategy commitStrategy = null; if (getTransactionCommitStrategy() != null) { commitStrategy = getTransactionCommitStrategy(); } else if (getTransactionBatchCount() > 0) { commitStrategy = new BatchTransactionCommitStrategy(getTransactionBatchCount()); } else { commitStrategy = new DefaultTransactionCommitStrategy(); } Synchronization synchronization; if (commitStrategy instanceof BatchTransactionCommitStrategy) { TimedTaskManager timedTaskManager = getEndpoint().getComponent().getTimedTaskManager(); synchronization = new SessionBatchTransactionSynchronization(timedTaskManager, session, commitStrategy, getTransactionBatchTimeout()); } else { synchronization = new SessionTransactionSynchronization(session, commitStrategy); } AbstractMessageHandler messageHandler; if (getEndpoint().getExchangePattern().equals(ExchangePattern.InOnly)) { if (isTransacted()) { messageHandler = new InOnlyMessageHandler(getEndpoint(), executor, synchronization); } else { messageHandler = new InOnlyMessageHandler(getEndpoint(), executor); } } else { if (isTransacted()) { messageHandler = new InOutMessageHandler(getEndpoint(), executor, synchronization); } else { messageHandler = new InOutMessageHandler(getEndpoint(), executor); } } messageHandler.setSession(session); messageHandler.setProcessor(getAsyncProcessor()); messageHandler.setSynchronous(isSynchronous()); messageHandler.setTransacted(isTransacted()); messageHandler.setTopic(isTopic()); return messageHandler; } protected ConnectionResource getConnectionResource() { return getEndpoint().getConnectionResource(); } public int getAcknowledgementMode() { return getEndpoint().getAcknowledgementMode().intValue(); } /** * Use to determine if transactions are enabled or disabled. * * @return true if transacted, otherwise false */ public boolean isTransacted() { return getEndpoint().isTransacted(); } /** * Use to determine whether or not to process exchanges synchronously. * * @return true if synchronous */ public boolean isSynchronous() { return getEndpoint().isSynchronous(); } /** * The destination name for this consumer. * * @return String */ public String getDestinationName() { return getEndpoint().getDestinationName(); } /** * Returns the number of consumer listeners. * * @return the consumerCount */ public int getConsumerCount() { return getEndpoint().getConsumerCount(); } /** * Flag set by the endpoint used by consumers and producers to determine if * the consumer is a JMS Topic. * * @return the topic true if consumer is a JMS Topic, default is false */ public boolean isTopic() { return getEndpoint().isTopic(); } /** * Gets the JMS Message selector syntax. */ public String getMessageSelector() { return getEndpoint().getMessageSelector(); } /** * Gets the durable subscription Id. * * @return the durableSubscriptionId */ public String getDurableSubscriptionId() { return getEndpoint().getDurableSubscriptionId(); } /** * Gets the commit strategy. * * @return the transactionCommitStrategy */ public TransactionCommitStrategy getTransactionCommitStrategy() { return getEndpoint().getTransactionCommitStrategy(); } /** * If transacted, returns the nubmer of messages to be processed before * committing the transaction. * * @return the transactionBatchCount */ public int getTransactionBatchCount() { return getEndpoint().getTransactionBatchCount(); } /** * Returns the timeout value for batch transactions. * * @return long */ public long getTransactionBatchTimeout() { return getEndpoint().getTransactionBatchTimeout(); } }