bytesmessage.java

JAVA 消息服务(JMS)定义了Java 中访问消息中间件的接口,里边有实现消息服务的基础源码,可以开发高级应用

    /** Reads a byte array from the bytes message stream.
      *
      * <P>If the length of array <code>value</code> 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</code>, 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
      *
      * @exception JMSException if the JMS provider fails to read the message 
      *                         due to some internal error.
      * @exception MessageNotReadableException if the message is in write-only 
      *                                        mode.
      */ 

    int
    readBytes(byte[] value) throws JMSException;


    /** Reads a portion of the bytes message stream.
      *
      * <P>If the length of array <code>value</code> 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</code>, 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</code> is negative, or
      * <code>length</code> is greater than the length of the array
      * <code>value</code>, then an <code>IndexOutOfBoundsException</code> is
      * thrown. No bytes will be read from the stream for this exception case.
      *  
      * @param value the buffer into which the data is read
      * @param length the number of bytes to read; must be less than or equal to
      *        <code>value.length</code>
      * 
      * @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
      *  
      * @exception JMSException if the JMS provider fails to read the message 
      *                         due to some internal error.
      * @exception MessageNotReadableException if the message is in write-only 
      *                                        mode.
      */ 

    int
    readBytes(byte[] value, int length) 
			throws JMSException;


    /** Writes a <code>boolean</code> to the bytes message stream as a 1-byte 
      * value.
      * The value <code>true</code> is written as the value 
      * <code>(byte)1</code>; the value <code>false</code> is written as 
      * the value <code>(byte)0</code>.
      *
      * @param value the <code>boolean</code> value to be written
      *
      * @exception JMSException if the JMS provider fails to write the message
      *                         due to some internal error.
      * @exception MessageNotWriteableException if the message is in read-only 
      *                                         mode.
      */

    void 
    writeBoolean(boolean value) 
			throws JMSException;


    /** Writes a <code>byte</code> to the bytes message stream as a 1-byte 
      * value.
      *
      * @param value the <code>byte</code> value to be written
      *
      * @exception JMSException if the JMS provider fails to write the message
      *                         due to some internal error.
      * @exception MessageNotWriteableException if the message is in read-only 
      *                                         mode.
      */ 

    void 
    writeByte(byte value) throws JMSException;


    /** Writes a <code>short</code> to the bytes message stream as two bytes,
      * high byte first.
      *
      * @param value the <code>short</code> to be written
      *
      * @exception JMSException if the JMS provider fails to write the message
      *                         due to some internal error.
      * @exception MessageNotWriteableException if the message is in read-only 
      *                                         mode.
      */ 

    void 
    writeShort(short value) throws JMSException;


    /** Writes a <code>char</code> to the bytes message stream as a 2-byte
      * value, high byte first.
      *
      * @param value the <code>char</code> value to be written
      *
      * @exception JMSException if the JMS provider fails to write the message
      *                         due to some internal error.
      * @exception MessageNotWriteableException if the message is in read-only 
      *                                         mode.
      */ 

    void 
    writeChar(char value) throws JMSException;


    /** Writes an <code>int</code> to the bytes message stream as four bytes, 
      * high byte first.
      *
      * @param value the <code>int</code> to be written
      *
      * @exception JMSException if the JMS provider fails to write the message
      *                         due to some internal error.
      * @exception MessageNotWriteableException if the message is in read-only 
      *                                         mode.
      */ 

    void 
    writeInt(int value) throws JMSException;


    /** Writes a <code>long</code> to the bytes message stream as eight bytes, 
      * high byte first.
      *
      * @param value the <code>long</code> to be written
      *
      * @exception JMSException if the JMS provider fails to write the message
      *                         due to some internal error.
      * @exception MessageNotWriteableException if the message is in read-only 
      *                                         mode.
      */ 

    void 
    writeLong(long value) throws JMSException;


    /** Converts the <code>float</code> argument to an <code>int</code> using 
      * the
      * <code>floatToIntBits</code> method in class <code>Float</code>,
      * and then writes that <code>int</code> value to the bytes message
      * stream as a 4-byte quantity, high byte first.
      *
      * @param value the <code>float</code> value to be written
      *
      * @exception JMSException if the JMS provider fails to write the message
      *                         due to some internal error.
      * @exception MessageNotWriteableException if the message is in read-only 
      *                                         mode.
      */ 

    void 
    writeFloat(float value) throws JMSException;


    /** Converts the <code>double</code> argument to a <code>long</code> using 
      * the
      * <code>doubleToLongBits</code> method in class <code>Double</code>,
      * and then writes that <code>long</code> value to the bytes message
      * stream as an 8-byte quantity, high byte first.
      *
      * @param value the <code>double</code> value to be written
      *
      * @exception JMSException if the JMS provider fails to write the message
      *                         due to some internal error.
      * @exception MessageNotWriteableException if the message is in read-only 
      *                                         mode.
      */ 

    void 
    writeDouble(double value) throws JMSException;


    /** Writes a string to the bytes message stream using UTF-8 encoding in a 
      * machine-independent manner.
      *
      * <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. 
      *
      * @param value the <code>String</code> value to be written
      *
      * @exception JMSException if the JMS provider fails to write the message
      *                         due to some internal error.
      * @exception MessageNotWriteableException if the message is in read-only 
      *                                         mode.
      */ 

    void 
    writeUTF(String value) throws JMSException;


    /** Writes a byte array to the bytes message stream.
      *
      * @param value the byte array to be written
      *
      * @exception JMSException if the JMS provider fails to write the message
      *                         due to some internal error.
      * @exception MessageNotWriteableException if the message is in read-only 
      *                                         mode.
      */ 

    void
    writeBytes(byte[] value) throws JMSException;


    /** Writes a portion of a byte array to the bytes message stream.
      *  
      * @param value the byte array value to be written
      * @param offset the initial offset within the byte array
      * @param length the number of bytes to use
      *
      * @exception JMSException if the JMS provider fails to write the message
      *                         due to some internal error.
      * @exception MessageNotWriteableException if the message is in read-only 
      *                                         mode.
      */ 
 
    void
    writeBytes(byte[] value, int offset, int length) 
			throws JMSException;


    /** Writes an object to the bytes message stream.
      *
      * <P>This method works only for the objectified primitive
      * object types (<code>Integer</code>, <code>Double</code>, 
      * <code>Long</code>&nbsp;...), <code>String</code> objects, and byte 
      * arrays.
      *
      * @param value the object in the Java programming language ("Java 
      *              object") to be written; it must not be null
      *
      * @exception JMSException if the JMS provider fails to write the message
      *                         due to some internal error.
      * @exception MessageFormatException if the object is of an invalid type.
      * @exception MessageNotWriteableException if the message is in read-only 
      *                                         mode.
      * @exception java.lang.NullPointerException if the parameter 
      *                                           <code>value</code> is null.
      */ 

    void 
    writeObject(Object value) throws JMSException;


    /** Puts the message body in read-only mode and repositions the stream of 
      * bytes to the beginning.
      *  
      * @exception JMSException if the JMS provider fails to reset the message
      *                         due to some internal error.
      * @exception MessageFormatException if the message has an invalid
      *                         format.
      */ 

    void
    reset() throws JMSException;
}