|
ActiveMQ example source code file (ActiveMQBytesMessage.java)
The ActiveMQ ActiveMQBytesMessage.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.EOFException; import java.io.FilterOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.util.zip.Deflater; import java.util.zip.DeflaterOutputStream; import java.util.zip.InflaterInputStream; import javax.jms.BytesMessage; import javax.jms.JMSException; import javax.jms.MessageFormatException; import javax.jms.MessageNotReadableException; 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.ByteSequenceData; import org.apache.activemq.util.JMSExceptionSupport; /** * A <CODE>BytesMessage object is used to send a message containing a * stream of uninterpreted bytes. It inherits from the <CODE>Message * interface and adds a bytes message body. The receiver of the message supplies * the interpretation of the bytes. * <P> * The <CODE>BytesMessage methods are based largely on those found in * <CODE>java.io.DataInputStream and * <CODE>java.io.DataOutputStream. * <P> * This message type is for client encoding of existing message formats. If * possible, one of the other self-defining message types should be used * instead. * <P> * Although the JMS API allows the use of message properties with byte messages, * they are typically not used, since the inclusion of properties may affect the * format. * <P> * The primitive types can be written explicitly using methods for each type. * They may also be written generically as objects. For instance, a call to * <CODE>BytesMessage.writeInt(6) is equivalent to * <CODE> BytesMessage.writeObject(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 the message is first created, and when <CODE>clearBody is * called, the body of the message is in write-only mode. After the first call * to <CODE>reset has been made, the message body is in read-only mode. * After a message has been sent, the client that sent it can retain and modify * it without affecting the message that has been sent. The same message object * can be sent multiple times. When a message has been received, the provider * has called <CODE>reset so that the message body is in read-only mode * for the client. * <P> * If <CODE>clearBody is called on a message in read-only mode, the * message body is cleared and the message is in write-only mode. * <P> * If a client attempts to read a message in write-only mode, a * <CODE>MessageNotReadableException is thrown. * <P> * If a client attempts to write a message in read-only mode, a * <CODE>MessageNotWriteableException is thrown. * * @openwire:marshaller code=24 * @see javax.jms.Session#createBytesMessage() * @see javax.jms.MapMessage * @see javax.jms.Message * @see javax.jms.ObjectMessage * @see javax.jms.StreamMessage * @see javax.jms.TextMessage */ public class ActiveMQBytesMessage extends ActiveMQMessage implements BytesMessage { public static final byte DATA_STRUCTURE_TYPE = CommandTypes.ACTIVEMQ_BYTES_MESSAGE; protected transient DataOutputStream dataOut; protected transient ByteArrayOutputStream bytesOut; protected transient DataInputStream dataIn; protected transient int length; public Message copy() { ActiveMQBytesMessage copy = new ActiveMQBytesMessage(); copy(copy); return copy; } private void copy(ActiveMQBytesMessage copy) { storeContent(); super.copy(copy); copy.dataOut = null; copy.bytesOut = null; copy.dataIn = null; } public void onSend() throws JMSException { super.onSend(); storeContent(); } private void storeContent() { try { if (dataOut != null) { dataOut.close(); ByteSequence bs = bytesOut.toByteSequence(); if (compressed) { int pos = bs.offset; ByteSequenceData.writeIntBig(bs, length); bs.offset = pos; } setContent(bs); bytesOut = null; dataOut = null; } } catch (IOException ioe) { throw new RuntimeException(ioe.getMessage(), ioe); // TODO verify // RuntimeException } } public byte getDataStructureType() { return DATA_STRUCTURE_TYPE; } public String getJMSXMimeType() { return "jms/bytes-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. * * @throws JMSException if the JMS provider fails to clear the message body * due to some internal error. */ public void clearBody() throws JMSException { super.clearBody(); this.dataOut = null; this.dataIn = null; this.bytesOut = null; } /** * Gets the number of bytes of the message body when the message is in * read-only mode. The value returned can be used to allocate a byte array. * The value returned is the entire length of the message body, regardless * of where the pointer for reading the message is currently located. * * @return number of bytes in the message * @throws JMSException if the JMS provider fails to read the message due to * some internal error. * @throws MessageNotReadableException if the message is in write-only mode. * @since 1.1 */ public long getBodyLength() throws JMSException { initializeReading(); return length; } /** * Reads a <code>boolean from the bytes message stream. * * @return the <code>boolean value read * @throws JMSException if the JMS provider fails to read the message due to * some internal error. * @throws MessageEOFException if unexpected end of bytes stream has been * reached. * @throws MessageNotReadableException if the message is in write-only mode. */ public boolean readBoolean() throws JMSException { initializeReading(); try { return this.dataIn.readBoolean(); } catch (EOFException e) { throw JMSExceptionSupport.createMessageEOFException(e); } catch (IOException e) { throw JMSExceptionSupport.createMessageFormatException(e); } } /** * Reads a signed 8-bit value from the bytes message stream. * * @return the next byte from the bytes message stream as a signed 8-bit * <code>byte * @throws JMSException if the JMS provider fails to read the message due to * some internal error. * @throws MessageEOFException if unexpected end of bytes stream has been * reached. * @throws MessageNotReadableException if the message is in write-only mode. */ public byte readByte() throws JMSException { initializeReading(); try { return this.dataIn.readByte(); } catch (EOFException e) { throw JMSExceptionSupport.createMessageEOFException(e); } catch (IOException e) { throw JMSExceptionSupport.createMessageFormatException(e); } } /** * Reads an unsigned 8-bit number from the bytes message stream. * * @return the next byte from the bytes message stream, interpreted as an * unsigned 8-bit number * @throws JMSException if the JMS provider fails to read the message due to * some internal error. * @throws MessageEOFException if unexpected end of bytes stream has been * reached. * @throws MessageNotReadableException if the message is in write-only mode. */ public int readUnsignedByte() throws JMSException { initializeReading(); try { return this.dataIn.readUnsignedByte(); } catch (EOFException e) { throw JMSExceptionSupport.createMessageEOFException(e); } catch (IOException e) { throw JMSExceptionSupport.createMessageFormatException(e); } } /** * Reads a signed 16-bit number from the bytes message stream. * * @return the next two bytes from the bytes message stream, interpreted as * a signed 16-bit number * @throws JMSException if the JMS provider fails to read the message due to * some internal error. * @throws MessageEOFException if unexpected end of bytes stream has been * reached. * @throws MessageNotReadableException if the message is in write-only mode. */ public short readShort() throws JMSException { initializeReading(); try { return this.dataIn.readShort(); } catch (EOFException e) { throw JMSExceptionSupport.createMessageEOFException(e); } catch (IOException e) { throw JMSExceptionSupport.createMessageFormatException(e); } } /** * Reads an unsigned 16-bit number from the bytes message stream. * * @return the next two bytes from the bytes message stream, interpreted as * an unsigned 16-bit integer * @throws JMSException if the JMS provider fails to read the message due to * some internal error. * @throws MessageEOFException if unexpected end of bytes stream has been * reached. * @throws MessageNotReadableException if the message is in write-only mode. */ public int readUnsignedShort() throws JMSException { initializeReading(); try { return this.dataIn.readUnsignedShort(); } catch (EOFException e) { throw JMSExceptionSupport.createMessageEOFException(e); } catch (IOException e) { throw JMSExceptionSupport.createMessageFormatException(e); } } /** * Reads a Unicode character value from the bytes message stream. * * @return the next two bytes from the bytes message stream as a Unicode * character * @throws JMSException if the JMS provider fails to read the message due to * some internal error. * @throws MessageEOFException if unexpected end of bytes stream has been * reached. * @throws MessageNotReadableException if the message is in write-only mode. */ public char readChar() throws JMSException { initializeReading(); try { return this.dataIn.readChar(); } catch (EOFException e) { throw JMSExceptionSupport.createMessageEOFException(e); } catch (IOException e) { throw JMSExceptionSupport.createMessageFormatException(e); } } /** * Reads a signed 32-bit integer from the bytes message stream. * * @return the next four bytes from the bytes message stream, interpreted as * an <code>int * @throws JMSException if the JMS provider fails to read the message due to * some internal error. * @throws MessageEOFException if unexpected end of bytes stream has been * reached. * @throws MessageNotReadableException if the message is in write-only mode. */ public int readInt() throws JMSException { initializeReading(); try { return this.dataIn.readInt(); } catch (EOFException e) { throw JMSExceptionSupport.createMessageEOFException(e); } catch (IOException e) { throw JMSExceptionSupport.createMessageFormatException(e); } } /** * Reads a signed 64-bit integer from the bytes message stream. * * @return the next eight bytes from the bytes message stream, interpreted * as a <code>long * @throws JMSException if the JMS provider fails to read the message due to * some internal error. * @throws MessageEOFException if unexpected end of bytes stream has been * reached. * @throws MessageNotReadableException if the message is in write-only mode. */ public long readLong() throws JMSException { initializeReading(); try { return this.dataIn.readLong(); } catch (EOFException e) { throw JMSExceptionSupport.createMessageEOFException(e); } catch (IOException e) { throw JMSExceptionSupport.createMessageFormatException(e); } } /** * Reads a <code>float from the bytes message stream. * * @return the next four bytes from the bytes message stream, interpreted as * a <code>float * @throws JMSException if the JMS provider fails to read the message due to * some internal error. * @throws MessageEOFException if unexpected end of bytes stream has been * reached. * @throws MessageNotReadableException if the message is in write-only mode. */ public float readFloat() throws JMSException { initializeReading(); try { return this.dataIn.readFloat(); } catch (EOFException e) { throw JMSExceptionSupport.createMessageEOFException(e); } catch (IOException e) { throw JMSExceptionSupport.createMessageFormatException(e); } } /** * Reads a <code>double from the bytes message stream. * * @return the next eight bytes from the bytes message stream, interpreted * as a <code>double * @throws JMSException if the JMS provider fails to read the message due to * some internal error. * @throws MessageEOFException if unexpected end of bytes stream has been * reached. * @throws MessageNotReadableException if the message is in write-only mode. */ public double readDouble() throws JMSException { initializeReading(); try { return this.dataIn.readDouble(); } catch (EOFException e) { throw JMSExceptionSupport.createMessageEOFException(e); } catch (IOException e) { throw JMSExceptionSupport.createMessageFormatException(e); } } /** * Reads a string that has been encoded using a modified UTF-8 format from * the bytes message stream. * <P> * For more information on the UTF-8 format, see "File System Safe UCS * Transformation Format (FSS_UTF)", X/Open Preliminary Specification, * X/Open Company Ltd., Document Number: P316. This information also appears * in ISO/IEC 10646, Annex P. * * @return a Unicode string from the bytes message stream * @throws JMSException if the JMS provider fails to read the message due to * some internal error. * @throws MessageEOFException if unexpected end of bytes stream has been * reached. * @throws MessageNotReadableException if the message is in write-only mode. */ public String readUTF() throws JMSException { initializeReading(); try { return this.dataIn.readUTF(); } catch (EOFException e) { throw JMSExceptionSupport.createMessageEOFException(e); } catch (IOException e) { throw JMSExceptionSupport.createMessageFormatException(e); } } /** * Reads a byte array from the bytes message stream. * <P> * If the length of array <code>value is less than the number of * bytes remaining to be read from the stream, the array should be filled. A * subsequent call reads the next increment, and so on. * <P> * If the number of bytes remaining in the stream is less than the length of * array <code>value, the bytes should be read into the array. The * return value of the total number of bytes read will be less than the * length of the array, indicating that there are no more bytes left to be * read from the stream. The next read of the stream returns -1. * * @param value the buffer into which the data is read * @return the total number of bytes read into the buffer, or -1 if there is * no more data because the end of the stream has been reached * @throws JMSException if the JMS provider fails to read the message due to * some internal error. * @throws MessageNotReadableException if the message is in write-only mode. */ public int readBytes(byte[] value) throws JMSException { return readBytes(value, value.length); } /** * Reads a portion of the bytes message stream. * <P> * If the length of array <code>value is less than the number of * bytes remaining to be read from the stream, the array should be filled. A * subsequent call reads the next increment, and so on. * <P> * If the number of bytes remaining in the stream is less than the length of * array <code>value, the bytes should be read into the array. The * return value of the total number of bytes read will be less than the * length of the array, indicating that there are no more bytes left to be * read from the stream. The next read of the stream returns -1. <p/> If * <code>length is negative, or Other ActiveMQ examples (source code examples)Here is a short list of links related to this ActiveMQ ActiveMQBytesMessage.java source code file: |
... this post is sponsored by my books ... | |
#1 New Release! |
FP Best Seller |
Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.