ActiveMQ example source code file (ActiveMQMapMessage.java)

This example ActiveMQ source code file (ActiveMQMapMessage.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - ActiveMQ tags/keywords

activemqmapmessage, byte, dataoutputstream, float, io, ioexception, jmsexception, jmsexception, messageformatexception, messageformatexception, object, object, short, string, string, util, zip

The ActiveMQ ActiveMQMapMessage.java source code

/**
 * 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.activemq.command;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectStreamException;
import java.io.OutputStream;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.InflaterInputStream;

import javax.jms.JMSException;
import javax.jms.MapMessage;
import javax.jms.MessageFormatException;
import javax.jms.MessageNotWriteableException;

import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.util.ByteArrayInputStream;
import org.apache.activemq.util.ByteArrayOutputStream;
import org.apache.activemq.util.ByteSequence;
import org.apache.activemq.util.JMSExceptionSupport;
import org.apache.activemq.util.MarshallingSupport;
import org.apache.activemq.wireformat.WireFormat;

/**
 * A <CODE>MapMessage object is used to send a set of name-value pairs.
 * The names are <CODE>String objects, and the values are primitive
 * data types in the Java programming language. The names must have a value that
 * is not null, and not an empty string. The entries can be accessed
 * sequentially or randomly by name. The order of the entries is undefined.
 * <CODE>MapMessage inherits from the Message interface
 * and adds a message body that contains a Map.
 * <P>
 * The primitive types can be read or written explicitly using methods for each
 * type. They may also be read or written generically as objects. For instance,
 * a call to <CODE>MapMessage.setInt("foo", 6) is equivalent to
 * <CODE> MapMessage.setObject("foo", new Integer(6)). Both forms are
 * provided, because the explicit form is convenient for static programming, and
 * the object form is needed when types are not known at compile time.
 * <P>
 * When a client receives a <CODE>MapMessage, it is in read-only mode.
 * If a client attempts to write to the message at this point, a
 * <CODE>MessageNotWriteableException is thrown. If
 * <CODE>clearBody is called, the message can now be both read from and
 * written to.
 * <P>
 * <CODE>MapMessage objects support the following conversion table. The
 * marked cases must be supported. The unmarked cases must throw a
 * <CODE>JMSException. The String -to-primitive
 * conversions may throw a runtime exception if the primitive's
 * <CODE>valueOf() method does not accept it as a valid
 * <CODE> String representation of the primitive.
 * <P>
 * A value written as the row type can be read as the column type. <p/>
 *
 * <PRE>
 * | | boolean byte short char int long float double String byte[] |----------------------------------------------------------------------
 * |boolean | X X |byte | X X X X X |short | X X X X |char | X X |int | X X X |long | X X |float | X X X |double | X X
 * |String | X X X X X X X X |byte[] | X |----------------------------------------------------------------------
 * <p/>
 * </PRE>
 *
 * <p/>
 * <P>
 * Attempting to read a null value as a primitive type must be treated as
 * calling the primitive's corresponding <code>valueOf(String)
 * conversion method with a null value. Since <code>char does not
 * support a <code>String conversion, attempting to read a null value
 * as a <code>char must throw a NullPointerException.
 *
 * @openwire:marshaller code="25"
 * @see javax.jms.Session#createMapMessage()
 * @see javax.jms.BytesMessage
 * @see javax.jms.Message
 * @see javax.jms.ObjectMessage
 * @see javax.jms.StreamMessage
 * @see javax.jms.TextMessage
 */
public class ActiveMQMapMessage extends ActiveMQMessage implements MapMessage {

    public static final byte DATA_STRUCTURE_TYPE = CommandTypes.ACTIVEMQ_MAP_MESSAGE;

    protected transient Map<String, Object> map = new HashMap();

    private Object readResolve() throws ObjectStreamException {
        if(this.map == null) {
            this.map = new HashMap<String, Object>();
        }
        return this;
    }

    public Message copy() {
        ActiveMQMapMessage copy = new ActiveMQMapMessage();
        copy(copy);
        return copy;
    }

    private void copy(ActiveMQMapMessage copy) {
        storeContent();
        super.copy(copy);
    }

    // We only need to marshal the content if we are hitting the wire.
    public void beforeMarshall(WireFormat wireFormat) throws IOException {
        super.beforeMarshall(wireFormat);
        storeContent();
    }

    public void clearMarshalledState() throws JMSException {
        super.clearMarshalledState();
        map.clear();
    }

    private void storeContent() {
        try {
            if (getContent() == null && !map.isEmpty()) {
                ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
                OutputStream os = bytesOut;
                ActiveMQConnection connection = getConnection();
                if (connection != null && connection.isUseCompression()) {
                    compressed = true;
                    os = new DeflaterOutputStream(os);
                }
                DataOutputStream dataOut = new DataOutputStream(os);
                MarshallingSupport.marshalPrimitiveMap(map, dataOut);
                dataOut.close();
                setContent(bytesOut.toByteSequence());
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Builds the message body from data
     *
     * @throws JMSException
     * @throws IOException
     */
    private void loadContent() throws JMSException {
        try {
            if (getContent() != null && map.isEmpty()) {
                ByteSequence content = getContent();
                InputStream is = new ByteArrayInputStream(content);
                if (isCompressed()) {
                    is = new InflaterInputStream(is);
                }
                DataInputStream dataIn = new DataInputStream(is);
                map = MarshallingSupport.unmarshalPrimitiveMap(dataIn);
                dataIn.close();
            }
        } catch (IOException e) {
            throw JMSExceptionSupport.create(e);
        }
    }

    public byte getDataStructureType() {
        return DATA_STRUCTURE_TYPE;
    }

    public String getJMSXMimeType() {
        return "jms/map-message";
    }

    /**
     * Clears out the message body. Clearing a message's body does not clear its
     * header values or property entries.
     * <P>
     * If this message body was read-only, calling this method leaves the
     * message body in the same state as an empty body in a newly created
     * message.
     */
    public void clearBody() throws JMSException {
        super.clearBody();
        map.clear();
    }

    /**
     * Returns the <CODE>boolean value with the specified name.
     *
     * @param name the name of the <CODE>boolean
     * @return the <CODE>boolean value with the specified name
     * @throws JMSException if the JMS provider fails to read the message due to
     *                 some internal error.
     * @throws MessageFormatException if this type conversion is invalid.
     */
    public boolean getBoolean(String name) throws JMSException {
        initializeReading();
        Object value = map.get(name);
        if (value == null) {
            return false;
        }
        if (value instanceof Boolean) {
            return ((Boolean)value).booleanValue();
        }
        if (value instanceof String) {
            return Boolean.valueOf(value.toString()).booleanValue();
        } else {
            throw new MessageFormatException(" cannot read a boolean from " + value.getClass().getName());
        }
    }

    /**
     * Returns the <CODE>byte value with the specified name.
     *
     * @param name the name of the <CODE>byte
     * @return the <CODE>byte value with the specified name
     * @throws JMSException if the JMS provider fails to read the message due to
     *                 some internal error.
     * @throws MessageFormatException if this type conversion is invalid.
     */
    public byte getByte(String name) throws JMSException {
        initializeReading();
        Object value = map.get(name);
        if (value == null) {
            return 0;
        }
        if (value instanceof Byte) {
            return ((Byte)value).byteValue();
        }
        if (value instanceof String) {
            return Byte.valueOf(value.toString()).byteValue();
        } else {
            throw new MessageFormatException(" cannot read a byte from " + value.getClass().getName());
        }
    }

    /**
     * Returns the <CODE>short value with the specified name.
     *
     * @param name the name of the <CODE>short
     * @return the <CODE>short value with the specified name
     * @throws JMSException if the JMS provider fails to read the message due to
     *                 some internal error.
     * @throws MessageFormatException if this type conversion is invalid.
     */
    public short getShort(String name) throws JMSException {
        initializeReading();
        Object value = map.get(name);
        if (value == null) {
            return 0;
        }
        if (value instanceof Short) {
            return ((Short)value).shortValue();
        }
        if (value instanceof Byte) {
            return ((Byte)value).shortValue();
        }
        if (value instanceof String) {
            return Short.valueOf(value.toString()).shortValue();
        } else {
            throw new MessageFormatException(" cannot read a short from " + value.getClass().getName());
        }
    }

    /**
     * Returns the Unicode character value with the specified name.
     *
     * @param name the name of the Unicode character
     * @return the Unicode character value with the specified name
     * @throws JMSException if the JMS provider fails to read the message due to
     *                 some internal error.
     * @throws MessageFormatException if this type conversion is invalid.
     */
    public char getChar(String name) throws JMSException {
        initializeReading();
        Object value = map.get(name);
        if (value == null) {
            throw new NullPointerException();
        }
        if (value instanceof Character) {
            return ((Character)value).charValue();
        } else {
            throw new MessageFormatException(" cannot read a short from " + value.getClass().getName());
        }
    }

    /**
     * Returns the <CODE>int value with the specified name.
     *
     * @param name the name of the <CODE>int
     * @return the <CODE>int value with the specified name
     * @throws JMSException if the JMS provider fails to read the message due to
     *                 some internal error.
     * @throws MessageFormatException if this type conversion is invalid.
     */
    public int getInt(String name) throws JMSException {
        initializeReading();
        Object value = map.get(name);
        if (value == null) {
            return 0;
        }
        if (value instanceof Integer) {
            return ((Integer)value).intValue();
        }
        if (value instanceof Short) {
            return ((Short)value).intValue();
        }
        if (value instanceof Byte) {
            return ((Byte)value).intValue();
        }
        if (value instanceof String) {
            return Integer.valueOf(value.toString()).intValue();
        } else {
            throw new MessageFormatException(" cannot read an int from " + value.getClass().getName());
        }
    }

    /**
     * Returns the <CODE>long value with the specified name.
     *
     * @param name the name of the <CODE>long
     * @return the <CODE>long value with the specified name
     * @throws JMSException if the JMS provider fails to read the message due to
     *                 some internal error.
     * @throws MessageFormatException if this type conversion is invalid.
     */
    public long getLong(String name) throws JMSException {
        initializeReading();
        Object value = map.get(name);
        if (value == null) {
            return 0;
        }
        if (value instanceof Long) {
            return ((Long)value).longValue();
        }
        if (value instanceof Integer) {
            return ((Integer)value).longValue();
        }
        if (value instanceof Short) {
            return ((Short)value).longValue();
        }
        if (value instanceof Byte) {
            return ((Byte)value).longValue();
        }
        if (value instanceof String) {
            return Long.valueOf(value.toString()).longValue();
        } else {
            throw new MessageFormatException(" cannot read a long from " + value.getClass().getName());
        }
    }

    /**
     * Returns the <CODE>float value with the specified name.
     *
     * @param name the name of the <CODE>float
     * @return the <CODE>float value with the specified name
     * @throws JMSException if the JMS provider fails to read the message due to
     *                 some internal error.
     * @throws MessageFormatException if this type conversion is invalid.
     */
    public float getFloat(String name) throws JMSException {
        initializeReading();
        Object value = map.get(name);
        if (value == null) {
            return 0;
        }
        if (value instanceof Float) {
            return ((Float)value).floatValue();
        }
        if (value instanceof String) {
            return Float.valueOf(value.toString()).floatValue();
        } else {
            throw new MessageFormatException(" cannot read a float from " + value.getClass().getName());
        }
    }

    /**
     * Returns the <CODE>double value with the specified name.
     *
     * @param name the name of the <CODE>double
     * @return the <CODE>double value with the specified name
     * @throws JMSException if the JMS provider fails to read the message due to
     *                 some internal error.
     * @throws MessageFormatException if this type conversion is invalid.
     */
    public double getDouble(String name) throws JMSException {
        initializeReading();
        Object value = map.get(name);
        if (value == null) {
            return 0;
        }
        if (value instanceof Double) {
            return ((Double)value).doubleValue();
        }
        if (value instanceof Float) {
            return ((Float)value).floatValue();
        }
        if (value instanceof String) {
            return Float.valueOf(value.toString()).floatValue();
        } else {
            throw new MessageFormatException(" cannot read a double from " + value.getClass().getName());
        }
    }

    /**
     * Returns the <CODE>String value with the specified name.
     *
     * @param name the name of the <CODE>String
     * @return the <CODE>String value with the specified name; if there
     *         is no item by this name, a null value is returned
     * @throws JMSException if the JMS provider fails to read the message due to
     *                 some internal error.
     * @throws MessageFormatException if this type conversion is invalid.
     */
    public String getString(String name) throws JMSException {
        initializeReading();
        Object value = map.get(name);
        if (value == null) {
            return null;
        }
        if (value instanceof byte[]) {
            throw new MessageFormatException("Use getBytes to read a byte array");
        } else {
            return value.toString();
        }
    }

    /**
     * Returns the byte array value with the specified name.
     *
     * @param name the name of the byte array
     * @return a copy of the byte array value with the specified name; if there
     *         is no item by this name, a null value is returned.
     * @throws JMSException if the JMS provider fails to read the message due to
     *                 some internal error.
     * @throws MessageFormatException if this type conversion is invalid.
     */
    public byte[] getBytes(String name) throws JMSException {
        initializeReading();
        Object value = map.get(name);
        if (value instanceof byte[]) {
            return (byte[])value;
        } else {
            throw new MessageFormatException(" cannot read a byte[] from " + value.getClass().getName());
        }
    }

    /**
     * Returns the value of the object with the specified name.
     * <P>
     * This method can be used to return, in objectified format, an object in
     * the Java programming language ("Java object") that had been stored in the
     * Map with the equivalent <CODE>setObject method call, or its
     * equivalent primitive <CODE>set type  method.
     * <P>
     * Note that byte values are returned as <CODE>byte[], not
     * <CODE>Byte[].
     *
     * @param name the name of the Java object
     * @return a copy of the Java object value with the specified name, in
     *         objectified format (for example, if the object was set as an
     *         <CODE>int, an Integer is returned); if
     *         there is no item by this name, a null value is returned
     * @throws JMSException if the JMS provider fails to read the message due to
     *                 some internal error.
     */
    public Object getObject(String name) throws JMSException {
        initializeReading();
        return map.get(name);
    }

    /**
     * Returns an <CODE>Enumeration of all the names in the
     * <CODE>MapMessage object.
     *
     * @return an enumeration of all the names in this <CODE>MapMessage
     * @throws JMSException
     */
    public Enumeration<String> getMapNames() throws JMSException {
        initializeReading();
        return Collections.enumeration(map.keySet());
    }

    protected void put(String name, Object value) throws JMSException {
        if (name == null) {
            throw new IllegalArgumentException("The name of the property cannot be null.");
        }
        if (name.length() == 0) {
            throw new IllegalArgumentException("The name of the property cannot be an emprty string.");
        }
        map.put(name, value);
    }

    /**
     * Sets a <CODE>boolean value with the specified name into the Map.
     *
     * @param name the name of the <CODE>boolean
     * @param value the <CODE>boolean value to set in the Map
     * @throws JMSException if the JMS provider fails to write the message due
     *                 to some internal error.
     * @throws IllegalArgumentException if the name is null or if the name is an
     *                 empty string.
     * @throws MessageNotWriteableException if the message is in read-only mode.
     */
    public void setBoolean(String name, boolean value) throws JMSException {
        initializeWriting();
        put(name, value ? Boolean.TRUE : Boolean.FALSE);
    }

    /**
     * Sets a <CODE>byte value with the specified name into the Map.
     *
     * @param name the name of the <CODE>byte
     * @param value the <CODE>byte value to set in the Map
     * @throws JMSException if the JMS provider fails to write the message due
     *                 to some internal error.
     * @throws IllegalArgumentException if the name is null or if the name is an
     *                 empty string.
     * @throws MessageNotWriteableException if the message is in read-only mode.
     */
    public void setByte(String name, byte value) throws JMSException {
        initializeWriting();
        put(name, Byte.valueOf(value));
    }

    /**
     * Sets a <CODE>short value with the specified name into the Map.
     *
     * @param name the name of the <CODE>short
     * @param value the <CODE>short value to set in the Map
     * @throws JMSException if the JMS provider fails to write the message due
     *                 to some internal error.
     * @throws IllegalArgumentException if the name is null or if the name is an
     *                 empty string.
     * @throws MessageNotWriteableException if the message is in read-only mode.
     */
    public void setShort(String name, short value) throws JMSException {
        initializeWriting();
        put(name, Short.valueOf(value));
    }

    /**
     * Sets a Unicode character value with the specified name into the Map.
     *
     * @param name the name of the Unicode character
     * @param value the Unicode character value to set in the Map
     * @throws JMSException if the JMS provider fails to write the message due
     *                 to some internal error.
     * @throws IllegalArgumentException if the name is null or if the name is an
     *                 empty string.
     * @throws MessageNotWriteableException if the message is in read-only mode.
     */
    public void setChar(String name, char value) throws JMSException {
        initializeWriting();
        put(name, Character.valueOf(value));
    }

    /**
     * Sets an <CODE>int value with the specified name into the Map.
     *
     * @param name the name of the <CODE>int
     * @param value the <CODE>int value to set in the Map
     * @throws JMSException if the JMS provider fails to write the message due
     *                 to some internal error.
     * @throws IllegalArgumentException if the name is null or if the name is an
     *                 empty string.
     * @throws MessageNotWriteableException if the message is in read-only mode.
     */
    public void setInt(String name, int value) throws JMSException {
        initializeWriting();
        put(name, Integer.valueOf(value));
    }

    /**
     * Sets a <CODE>long value with the specified name into the Map.
     *
     * @param name the name of the <CODE>long
     * @param value the <CODE>long value to set in the Map
     * @throws JMSException if the JMS provider fails to write the message due
     *                 to some internal error.
     * @throws IllegalArgumentException if the name is null or if the name is an
     *                 empty string.
     * @throws MessageNotWriteableException if the message is in read-only mode.
     */
    public void setLong(String name, long value) throws JMSException {
        initializeWriting();
        put(name, Long.valueOf(value));
    }

    /**
     * Sets a <CODE>float value with the specified name into the Map.
     *
     * @param name the name of the <CODE>float
     * @param value the <CODE>float value to set in the Map
     * @throws JMSException if the JMS provider fails to write the message due
     *                 to some internal error.
     * @throws IllegalArgumentException if the name is null or if the name is an
     *                 empty string.
     * @throws MessageNotWriteableException if the message is in read-only mode.
     */
    public void setFloat(String name, float value) throws JMSException {
        initializeWriting();
        put(name, new Float(value));
    }

    /**
     * Sets a <CODE>double value with the specified name into the Map.
     *
     * @param name the name of the <CODE>double
     * @param value the <CODE>double value to set in the Map
     * @throws JMSException if the JMS provider fails to write the message due
     *                 to some internal error.
     * @throws IllegalArgumentException if the name is null or if the name is an
     *                 empty string.
     * @throws MessageNotWriteableException if the message is in read-only mode.
     */
    public void setDouble(String name, double value) throws JMSException {
        initializeWriting();
        put(name, new Double(value));
    }

    /**
     * Sets a <CODE>String value with the specified name into the Map.
     *
     * @param name the name of the <CODE>String
     * @param value the <CODE>String value to set in the Map
     * @throws JMSException if the JMS provider fails to write the message due
     *                 to some internal error.
     * @throws IllegalArgumentException if the name is null or if the name is an
     *                 empty string.
     * @throws MessageNotWriteableException if the message is in read-only mode.
     */
    public void setString(String name, String value) throws JMSException {
        initializeWriting();
        put(name, value);
    }

    /**
     * Sets a byte array value with the specified name into the Map.
     *
     * @param name the name of the byte array
     * @param value the byte array value to set in the Map; the array is copied
     *                so that the value for <CODE>name  will not be
     *                altered by future modifications
     * @throws JMSException if the JMS provider fails to write the message due
     *                 to some internal error.
     * @throws NullPointerException if the name is null, or if the name is an
     *                 empty string.
     * @throws MessageNotWriteableException if the message is in read-only mode.
     */
    public void setBytes(String name, byte[] value) throws JMSException {
        initializeWriting();
        if (value != null) {
            put(name, value);
        } else {
            map.remove(name);
        }
    }

    /**
     * Sets a portion of the byte array value with the specified name into the
     * Map.
     *
     * @param name the name of the byte array
     * @param value the byte array value to set in the Map
     * @param offset the initial offset within the byte array
     * @param length the number of bytes to use
     * @throws JMSException if the JMS provider fails to write the message due
     *                 to some internal error.
     * @throws IllegalArgumentException if the name is null or if the name is an
     *                 empty string.
     * @throws MessageNotWriteableException if the message is in read-only mode.
     */
    public void setBytes(String name, byte[] value, int offset, int length) throws JMSException {
        initializeWriting();
        byte[] data = new byte[length];
        System.arraycopy(value, offset, data, 0, length);
        put(name, data);
    }

    /**
     * Sets an object value with the specified name into the Map.
     * <P>
     * This method works only for the objectified primitive object types (<code>Integer,Double,
     * <code>Long  ...), String objects, and byte
     * arrays.
     *
     * @param name the name of the Java object
     * @param value the Java object value to set in the Map
     * @throws JMSException if the JMS provider fails to write the message due
     *                 to some internal error.
     * @throws IllegalArgumentException if the name is null or if the name is an
     *                 empty string.
     * @throws MessageFormatException if the object is invalid.
     * @throws MessageNotWriteableException if the message is in read-only mode.
     */
    public void setObject(String name, Object value) throws JMSException {
        initializeWriting();
        if (value != null) {
            // byte[] not allowed on properties
            if (!(value instanceof byte[])) {
                checkValidObject(value);
            }
            put(name, value);
        } else {
            put(name, null);
        }
    }

    /**
     * Indicates whether an item exists in this <CODE>MapMessage
     * object.
     *
     * @param name the name of the item to test
     * @return true if the item exists
     * @throws JMSException if the JMS provider fails to determine if the item
     *                 exists due to some internal error.
     */
    public boolean itemExists(String name) throws JMSException {
        initializeReading();
        return map.containsKey(name);
    }

    private void initializeReading() throws JMSException {
        loadContent();
    }

    private void initializeWriting() throws MessageNotWriteableException {
        checkReadOnlyBody();
        setContent(null);
    }

    public String toString() {
        return super.toString() + " ActiveMQMapMessage{ " + "theTable = " + map + " }";
    }

    public Map<String, Object> getContentMap() throws JMSException {
        initializeReading();
        return map;
    }
}