org.mule.transport.jms.JmsMessageUtils.java Source code

Java tutorial

Introduction

Here is the source code for org.mule.transport.jms.JmsMessageUtils.java

Source

/*
 * $Id$
 * --------------------------------------------------------------------------------------
 * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
 *
 * The software in this package is published under the terms of the CPAL v1.0
 * license, a copy of which has been included with this distribution in the
 * LICENSE.txt file.
 */

package org.mule.transport.jms;

import org.mule.api.transport.OutputHandler;
import org.mule.util.ArrayUtils;
import org.mule.util.ClassUtils;
import org.mule.util.IOUtils;
import org.mule.util.StringUtils;

import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.jms.BytesMessage;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MapMessage;
import javax.jms.Message;
import javax.jms.MessageEOFException;
import javax.jms.MessageFormatException;
import javax.jms.ObjectMessage;
import javax.jms.Queue;
import javax.jms.Session;
import javax.jms.StreamMessage;
import javax.jms.TextMessage;
import javax.jms.Topic;

import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * <code>JmsMessageUtils</code> contains helper method for dealing with JMS
 * messages in Mule.
 */
public class JmsMessageUtils {
    public static final char REPLACEMENT_CHAR = '_';

    private static final Log logger = LogFactory.getLog(JmsMessageUtils.class);

    /**
     * Encode a String so that is is a valid JMS header name
     *
     * @param name the String to encode
     * @return a valid JMS header name
     */
    public static String encodeHeader(String name) {
        // check against JMS 1.1 spec, sections 3.5.1 (3.8.1.1)
        boolean nonCompliant = false;

        if (StringUtils.isEmpty(name)) {
            throw new IllegalArgumentException("Header name to encode must not be null or empty");
        }

        int i = 0, length = name.length();
        while (i < length && Character.isJavaIdentifierPart(name.charAt(i))) {
            // zip through
            i++;
        }

        if (i == length) {
            // String is already valid
            return name;
        } else {
            // make a copy, fix up remaining characters
            StringBuffer sb = new StringBuffer(name);
            for (int j = i; j < length; j++) {
                if (!Character.isJavaIdentifierPart(sb.charAt(j))) {
                    sb.setCharAt(j, REPLACEMENT_CHAR);
                    nonCompliant = true;
                }
            }

            if (nonCompliant) {
                logger.warn(MessageFormat.format(
                        "Header: {0} is not compliant with JMS specification (sec. 3.5.1, 3.8.1.1). It will cause "
                                + "problems in your and other applications. Please update your application code to correct this. "
                                + "Mule renamed it to {1}",
                        name, sb.toString()));
            }

            return sb.toString();
        }
    }

    public static Message toMessage(Object object, Session session) throws JMSException {
        if (object instanceof Message) {
            return (Message) object;
        } else if (object instanceof String) {
            return stringToMessage((String) object, session);
        } else if (object instanceof Map<?, ?> && validateMapMessageType((Map<?, ?>) object)) {
            return mapToMessage((Map<?, ?>) object, session);
        } else if (object instanceof InputStream) {
            return inputStreamToMessage((InputStream) object, session);
        } else if (object instanceof List<?>) {
            return listToMessage((List<?>) object, session);
        } else if (object instanceof byte[]) {
            return byteArrayToMessage((byte[]) object, session);
        } else if (object instanceof Serializable) {
            return serializableToMessage((Serializable) object, session);
        } else if (object instanceof OutputHandler) {
            return outputHandlerToMessage((OutputHandler) object, session);
        } else {
            throw new JMSException(
                    "Source was not of a supported type. Valid types are Message, String, Map, InputStream, List, byte[], Serializable or OutputHandler, "
                            + "but was " + ClassUtils.getShortClassName(object, "<null>"));
        }
    }

    private static Message stringToMessage(String value, Session session) throws JMSException {
        return session.createTextMessage(value);
    }

    private static Message mapToMessage(Map<?, ?> value, Session session) throws JMSException {
        MapMessage mMsg = session.createMapMessage();

        for (Iterator<?> i = value.entrySet().iterator(); i.hasNext();) {
            Map.Entry<?, ?> entry = (Map.Entry<?, ?>) i.next();
            mMsg.setObject(entry.getKey().toString(), entry.getValue());
        }

        return mMsg;
    }

    private static Message inputStreamToMessage(InputStream value, Session session) throws JMSException {
        StreamMessage streamMessage = session.createStreamMessage();
        byte[] buffer = new byte[4096];
        int len;

        try {
            while ((len = value.read(buffer)) != -1) {
                streamMessage.writeBytes(buffer, 0, len);
            }
        } catch (IOException e) {
            throw new JMSException("Failed to read input stream to create a stream message: " + e);
        } finally {
            IOUtils.closeQuietly(value);
        }

        return streamMessage;
    }

    private static Message listToMessage(List<?> value, Session session) throws JMSException {
        StreamMessage sMsg = session.createStreamMessage();

        for (Iterator<?> iter = value.iterator(); iter.hasNext();) {
            Object o = iter.next();
            if (validateStreamMessageType(o)) {
                sMsg.writeObject(o);
            } else {
                throw new MessageFormatException(
                        String.format("Invalid type passed to StreamMessage: %s . Allowed types are: "
                                + "Boolean, Byte, Short, Character, Integer, Long, Float, Double,"
                                + "String and byte[]", ClassUtils.getShortClassName(o, "null")));
            }
        }
        return sMsg;
    }

    private static Message byteArrayToMessage(byte[] value, Session session) throws JMSException {
        BytesMessage bMsg = session.createBytesMessage();
        bMsg.writeBytes(value);

        return bMsg;
    }

    private static Message serializableToMessage(Serializable value, Session session) throws JMSException {
        ObjectMessage oMsg = session.createObjectMessage();
        oMsg.setObject(value);

        return oMsg;
    }

    private static Message outputHandlerToMessage(OutputHandler value, Session session) throws JMSException {
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        try {
            value.write(null, output);
        } catch (IOException e) {
            JMSException j = new JMSException("Could not serialize OutputHandler.");
            j.initCause(e);
            throw j;
        }

        BytesMessage bMsg = session.createBytesMessage();
        bMsg.writeBytes(output.toByteArray());

        return bMsg;
    }

    public static Object toObject(Message source, String jmsSpec, String encoding)
            throws JMSException, IOException {
        if (source instanceof ObjectMessage) {
            return ((ObjectMessage) source).getObject();
        } else if (source instanceof MapMessage) {
            Map<String, Object> map = new HashMap<String, Object>();
            MapMessage m = (MapMessage) source;

            for (Enumeration<?> e = m.getMapNames(); e.hasMoreElements();) {
                String name = (String) e.nextElement();
                Object obj = m.getObject(name);
                map.put(name, obj);
            }

            return map;
        } else if (source instanceof TextMessage) {
            return ((TextMessage) source).getText();
        } else if (source instanceof BytesMessage) {
            return toByteArray(source, jmsSpec, encoding);
        } else if (source instanceof StreamMessage) {
            List<Object> result = new ArrayList<Object>();
            try {
                StreamMessage sMsg = (StreamMessage) source;
                Object obj;
                while ((obj = sMsg.readObject()) != null) {
                    result.add(obj);
                }
            } catch (MessageEOFException eof) {
                // ignored
            } catch (Exception e) {
                throw new JMSException("Failed to extract information from JMS Stream Message: " + e);
            }
            return result;
        }

        // what else is there to do?
        return source;
    }

    /**
     * @param message the message to receive the bytes from. Note this only works for
     *                TextMessge, ObjectMessage, StreamMessage and BytesMessage.
     * @param jmsSpec indicates the JMS API version, either
     *                {@link JmsConstants#JMS_SPECIFICATION_102B} or
     *                {@link JmsConstants#JMS_SPECIFICATION_11}. Any other value
     *                including <code>null</code> is treated as fallback to
     *                {@link JmsConstants#JMS_SPECIFICATION_102B}.
     * @return a byte array corresponding with the message payload
     * @throws JMSException        if the message can't be read or if the message passed is
     *                             a MapMessage
     * @throws java.io.IOException if a failure occurs while reading the stream and
     *                             converting the message data
     */
    public static byte[] toByteArray(Message message, String jmsSpec, String encoding)
            throws JMSException, IOException {
        if (message instanceof BytesMessage) {
            BytesMessage bMsg = (BytesMessage) message;
            bMsg.reset();

            if (JmsConstants.JMS_SPECIFICATION_11.equals(jmsSpec)) {
                long bmBodyLength = bMsg.getBodyLength();
                if (bmBodyLength > Integer.MAX_VALUE) {
                    throw new JMSException("Size of BytesMessage exceeds Integer.MAX_VALUE; "
                            + "please consider using JMS StreamMessage instead");
                }

                if (bmBodyLength > 0) {
                    byte[] bytes = new byte[(int) bmBodyLength];
                    bMsg.readBytes(bytes);
                    return bytes;
                } else {
                    return ArrayUtils.EMPTY_BYTE_ARRAY;
                }
            } else {
                ByteArrayOutputStream baos = new ByteArrayOutputStream(4096);
                byte[] buffer = new byte[4096];
                int len;

                while ((len = bMsg.readBytes(buffer)) != -1) {
                    baos.write(buffer, 0, len);
                }

                if (baos.size() > 0) {
                    return baos.toByteArray();
                } else {
                    return ArrayUtils.EMPTY_BYTE_ARRAY;
                }
            }
        } else if (message instanceof StreamMessage) {
            StreamMessage sMsg = (StreamMessage) message;
            sMsg.reset();

            ByteArrayOutputStream baos = new ByteArrayOutputStream(4096);
            byte[] buffer = new byte[4096];
            int len;

            while ((len = sMsg.readBytes(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }

            return baos.toByteArray();
        } else if (message instanceof ObjectMessage) {
            ObjectMessage oMsg = (ObjectMessage) message;
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream os = new ObjectOutputStream(baos);
            os.writeObject(oMsg.getObject());
            os.flush();
            os.close();
            return baos.toByteArray();
        } else if (message instanceof TextMessage) {
            TextMessage tMsg = (TextMessage) message;
            String tMsgText = tMsg.getText();

            if (null == tMsgText) {
                // Avoid creating new instances of byte arrays, even empty ones. The
                // load on this part of the code can be high.
                return ArrayUtils.EMPTY_BYTE_ARRAY;
            } else {
                return tMsgText.getBytes(encoding);
            }
        } else {
            throw new JMSException("Cannot get bytes from Map Message");
        }
    }

    public static String getNameForDestination(Destination dest) throws JMSException {
        if (dest instanceof Queue) {
            return ((Queue) dest).getQueueName();
        } else if (dest instanceof Topic) {
            return ((Topic) dest).getTopicName();
        } else {
            return null;
        }
    }

    public static Message copyJMSProperties(Message from, Message to, JmsConnector connector) throws JMSException {
        if (connector.supportsProperty(JmsConstants.JMS_CORRELATION_ID)) {
            to.setJMSCorrelationID(from.getJMSCorrelationID());
        }
        if (connector.supportsProperty(JmsConstants.JMS_DELIVERY_MODE)) {
            to.setJMSDeliveryMode(from.getJMSDeliveryMode());
        }
        if (connector.supportsProperty(JmsConstants.JMS_DESTINATION)) {
            to.setJMSDestination(from.getJMSDestination());
        }
        if (connector.supportsProperty(JmsConstants.JMS_EXPIRATION)) {
            to.setJMSExpiration(from.getJMSExpiration());
        }
        if (connector.supportsProperty(JmsConstants.JMS_MESSAGE_ID)) {
            to.setJMSMessageID(from.getJMSMessageID());
        }
        if (connector.supportsProperty(JmsConstants.JMS_PRIORITY)) {
            to.setJMSPriority(from.getJMSPriority());
        }
        if (connector.supportsProperty(JmsConstants.JMS_REDELIVERED)) {
            to.setJMSRedelivered(from.getJMSRedelivered());
        }
        if (connector.supportsProperty(JmsConstants.JMS_REPLY_TO)) {
            to.setJMSReplyTo(from.getJMSReplyTo());
        }
        if (connector.supportsProperty(JmsConstants.JMS_TIMESTAMP)) {
            to.setJMSTimestamp(from.getJMSTimestamp());
        }
        if (connector.supportsProperty(JmsConstants.JMS_TYPE)) {
            to.setJMSType(from.getJMSType());
        }
        return to;
    }

    /**
     * {@link StreamMessage#writeObject(Object)} accepts only primitives (and wrappers), String and byte[].
     * An attempt to write anything else must fail with a MessageFormatException as per
     * JMS 1.1 spec, Section 7.3 Standard Exceptions, page 89, 1st paragraph.
     * <p/>
     * Unfortunately, some JMS vendors are not compliant in this area, enforce here for consistent behavior.
     *
     * @param candidate object to validate
     */
    protected static boolean validateStreamMessageType(Object candidate) {
        if (candidate == null || candidate instanceof Boolean || candidate instanceof Byte
                || candidate instanceof Short || candidate instanceof Character || candidate instanceof Integer
                || candidate instanceof Long || candidate instanceof Float || candidate instanceof Double
                || candidate instanceof String || candidate instanceof byte[]) {
            return true;
        }

        return false;
    }

    /**
     * <code>MapMessage#writeObject(Object)</code> accepts only primitives (and wrappers), String and byte[].
     * An attempt to write anything else must fail with a MessageFormatException as per
     * JMS 1.1 spec, Section 7.3 Standard Exceptions, page 89, 1st paragraph.
     * <p/>
     * Unfortunately, some JMS vendors are not compliant in this area, enforce here for consistent behavior.
     * Here we handle non-primitive maps as {@link ObjectMessage} rather than creating a {@link MapMessage}
     *
     * @param candidate Map to validate
     */
    protected static boolean validateMapMessageType(Map<?, ?> candidate) {
        for (Iterator<?> iterator = candidate.values().iterator(); iterator.hasNext();) {
            Object o = iterator.next();
            if (!validateStreamMessageType(o)) {
                return false;
            }
        }
        return true;
    }
}