org.quartz.jobs.ee.jms.SendDestinationMessageJob Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of quartz-jobs Show documentation
Quartz Enterprise Job Scheduler - additional library of ready to use Jobs
There is a newer version: 2.5.0
/* 
 * All content copyright Terracotta, Inc., unless otherwise indicated. All rights reserved.
 * 
 * Licensed 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.quartz.jobs.ee.jms;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.naming.Context;

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * 
 * A Job that sends a javax.jms.Message to a
 * javax.jms.Destination. Note, this class can only be used in a
 * JMS-based environment.
 * 
 * 

 * The following properties are expected to be provided in the
 * JobDataMap:
 * 
 * 

 * JMS_CONNECTION_FACTORY_JNDI - The JNDI name of the JMS
 * Connection Factory.
 * JMS_DESTINATION_JNDI - The JNDI name of the JMS
 * destination.
 * JMS_USE_TXN - Whether or not to use a transacted
 * javax.jms.Session.
 * JMS_ACK_MODE - The acknowledgement mode for the
 * javax.jms.Session.
 * JMS_MSG_FACTORY_CLASS_NAME - The implementation class
 * name for the JmsMessageFactory.
 * 
 * 
 * 
 * The following properties are optional
 * 
 * 

 * JMS_USER - The JMS user for secure destinations.
 * 
JMS_PASSWORD - The JMS password for secure destinations.
 * 
 * 
 * 
 * The following properties can be used for JNDI support:
 * 
 * 

 * INITIAL_CONTEXT_FACTORY - The java.naming.factory.initial
 * setting for JNDI.
 * 
PROVIDER_URL - The java.naming.provider.url for JNDI.
 * 
 * 
 * @see JmsMessageFactory
 * 
 * @author Fernando Ribeiro
 * @author Weston M. Price
 * @author Frank Van Uffelen
 */
public final class SendDestinationMessageJob implements Job {

    public void execute(final JobExecutionContext jobCtx)
            throws JobExecutionException {
        Connection conn = null;

        Session sess = null;

        MessageProducer producer = null;

        try {
            final JobDataMap dataMap = jobCtx.getMergedJobDataMap();

            final Context namingCtx = JmsHelper.getInitialContext(dataMap);

            final ConnectionFactory connFactory = (ConnectionFactory) namingCtx
                    .lookup(dataMap
                            .getString(JmsHelper.JMS_CONNECTION_FACTORY_JNDI));

            if (!JmsHelper.isDestinationSecure(dataMap)) {
                conn = connFactory.createConnection();
            } else {
                final String user = dataMap.getString(JmsHelper.JMS_USER);

                final String password = dataMap
                        .getString(JmsHelper.JMS_PASSWORD);

                conn = connFactory.createConnection(user, password);
            }

            final boolean useTransaction = JmsHelper.useTransaction(dataMap);

            final int ackMode = dataMap.getInt(JmsHelper.JMS_ACK_MODE);

            sess = conn.createSession(useTransaction, ackMode);

            final Destination destination = (Destination) namingCtx
                    .lookup(dataMap.getString(JmsHelper.JMS_DESTINATION_JNDI));

            producer = sess.createProducer(destination);

            final JmsMessageFactory messageFactory = JmsHelper
                    .getMessageFactory(dataMap
                            .getString(JmsHelper.JMS_MSG_FACTORY_CLASS_NAME));

            final Message msg = messageFactory.createMessage(dataMap, sess);

            producer.send(msg);
        } catch (final Exception e) {
            throw new JobExecutionException(e);
        } finally {
            JmsHelper.closeResource(producer);

            JmsHelper.closeResource(sess);

            JmsHelper.closeResource(conn);
        }

    }

}