Java BytesMessage.readBytes方法代码示例

import javax.jms.BytesMessage; //导入方法依赖的package包/类
@Override
public void onMessage(Message message) {

  try {

    if (message instanceof BytesMessage) {

      BytesMessage bytesMessage = (BytesMessage) message;
      byte[] data = new byte[(int) bytesMessage.getBodyLength()];
      bytesMessage.readBytes(data);
      LOG.info("Message received {}", new String(data));

    } else if (message instanceof TextMessage) {

      TextMessage textMessage = (TextMessage) message;
      String text = textMessage.getText();
      LOG.info("Message received {}", text);
    }

  } catch (JMSException jmsEx) {
    jmsEx.printStackTrace();
  }
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
/**
 * Read the the payload of the message and return it in a byte array.
 * 
 * @param msg
 * @return
 */
private byte[] getBytes(final Message msg) {
    byte[] data = null;
    try {
        if (msg instanceof BytesMessage) {
            final BytesMessage tmp = (BytesMessage) msg;
            int len;
            len = (int) ((BytesMessage) msg).getBodyLength();
            data = new byte[len];
            tmp.readBytes(data);
        } else if (msg instanceof TextMessage) {
            data = ((TextMessage) msg).getText().getBytes();

        }
    } catch (final JMSException e) {
        logger.error("Error getting bytes from message.", e);
    }
    return data;
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
public DataRecorderMessage(final Message message, final long timeStamp) {
    try {
        // this.setDelayMillis(delayMillis);
        this.timeStamp = new Date(timeStamp);

        // Get all the properties from the incoming message
        this.properties = getAllProperties(message);

        // Get the payload from the incoming message.
        if (message instanceof BytesMessage) {
            byte[] byteArray = null;
            final BytesMessage tmp = (BytesMessage) message;
            int len;
            len = (int) ((BytesMessage) message).getBodyLength();
            byteArray = new byte[len];
            tmp.readBytes(byteArray);
            this.body = byteArray;
        } else if (message instanceof TextMessage) {
            this.body = ((TextMessage) message).getText();
        }

    } catch (final JMSException e) {
        logger.error("Error reading from the incoming JMS message");
        logger.error("Stacktrace: ", e);
    }
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
/**
 * Convert a BytesMessage to a Java Object with the specified type.
 * @param message the input message
 * @param targetJavaType the target type
 * @return the message converted to an object
 * @throws JMSException if thrown by JMS
 * @throws IOException in case of I/O errors
 */
protected Object convertFromBytesMessage(BytesMessage message, JavaType targetJavaType)
		throws JMSException, IOException {

	String encoding = this.encoding;
	if (this.encodingPropertyName != null && message.propertyExists(this.encodingPropertyName)) {
		encoding = message.getStringProperty(this.encodingPropertyName);
	}
	byte[] bytes = new byte[(int) message.getBodyLength()];
	message.readBytes(bytes);
	try {
		String body = new String(bytes, encoding);
		return this.objectMapper.readValue(body, targetJavaType);
	}
	catch (UnsupportedEncodingException ex) {
		throw new MessageConversionException("Cannot convert bytes to String", ex);
	}
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
private String getPayload(Message message) throws Exception {
	String payload = null;
	
	if (message instanceof TextMessage) {
		payload = ((TextMessage) message).getText();
	} 
	else if(message instanceof BytesMessage) {
		BytesMessage bMessage = (BytesMessage) message;
		int payloadLength = (int)bMessage.getBodyLength();
		byte payloadBytes[] = new byte[payloadLength];
		bMessage.readBytes(payloadBytes);
		payload = new String(payloadBytes);
	}
	else {
		log.warn("Message not recognized as a TextMessage or BytesMessage.  It is of type: "+message.getClass().toString());
		payload = message.toString();
	}
	return payload;
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
@Override
public void run(SourceContext<OUT> ctx) throws Exception {
    while (runningChecker.isRunning()) {
        exceptionListener.checkErroneous();

        Message message = consumer.receive(1000);
        if (! (message instanceof BytesMessage)) {
            LOG.warn("Active MQ source received non bytes message: {}", message);
            return;
        }
        BytesMessage bytesMessage = (BytesMessage) message;
        byte[] bytes = new byte[(int) bytesMessage.getBodyLength()];
        bytesMessage.readBytes(bytes);
        OUT value = deserializationSchema.deserialize(bytes);
        synchronized (ctx.getCheckpointLock()) {
            ctx.collect(value);
            if (!autoAck) {
                addId(bytesMessage.getJMSMessageID());
                unacknowledgedMessages.put(bytesMessage.getJMSMessageID(), bytesMessage);
            }
        }
    }
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
@Override
public void onMessage(Message message) {
    try {
        if (message instanceof BytesMessage) {
            Destination source = message.getJMSDestination();
            BytesMessage bytesMsg = (BytesMessage) message;

            byte[] payload = new byte[(int) bytesMsg.getBodyLength()];
            bytesMsg.readBytes(payload);

            listeners.forEach(listener -> {
                listener.onMessage(source.toString(), payload);
            });
        } else {
            LOG.debug("Received message type we don't yet handle: {}", message);
        }

        // TODO - Handle other message types.

    } catch (Exception ex) {
        LOG.error("Error delivering incoming message to listeners: {}", ex.getMessage());
        LOG.trace("Error detail", ex);
    }
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
/**
 * Extracts the byte array from a JMS message.
 * 
 * @param message  the JMS message, not null
 * @return the extracted byte array, not null
 */
public static byte[] extractBytes(final Message message) {
  if (message instanceof BytesMessage == false) {
    throw new IllegalArgumentException("Message must be an instanceof BytesMessage");
  }
  final BytesMessage bytesMessage = (BytesMessage) message;
  final byte[] bytes;
  try {
    long bodyLength = bytesMessage.getBodyLength();
    if (bodyLength > Integer.MAX_VALUE) {
      throw new IllegalArgumentException("Message too large, maximum size is 2GB, received one of length " + bodyLength);
    }
    bytes = new byte[(int) bodyLength];
    bytesMessage.readBytes(bytes);
  } catch (JMSException jmse) {
    throw new JmsRuntimeException(jmse);
  }
  return bytes;
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
/**
 * Send a <code>BytesMessage</code> with 2 Java primitives in its body (a <code>
 * String</code> and a <code>double</code>).
 * <br />
 * Receive it and test that the values of the primitives of the body are correct
 */
@Test
public void testBytesMessage_2() {
   try {
      byte[] bytes = new String("pi").getBytes();
      BytesMessage message = senderSession.createBytesMessage();
      message.writeBytes(bytes);
      message.writeDouble(3.14159);
      sender.send(message);

      Message m = receiver.receive(TestConfig.TIMEOUT);
      Assert.assertTrue("The message should be an instance of BytesMessage.\n", m instanceof BytesMessage);
      BytesMessage msg = (BytesMessage) m;
      byte[] receivedBytes = new byte[bytes.length];
      msg.readBytes(receivedBytes);
      Assert.assertEquals(new String(bytes), new String(receivedBytes));
      Assert.assertEquals(3.14159, msg.readDouble(), 0);
   } catch (JMSException e) {
      fail(e);
   }
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
@Override
protected void assertEquivalent(final Message m, final int mode, final boolean redelivered) throws JMSException {
   super.assertEquivalent(m, mode, redelivered);

   BytesMessage bm = (BytesMessage) m;

   ProxyAssertSupport.assertEquals(true, bm.readBoolean());
   ProxyAssertSupport.assertEquals((byte) 3, bm.readByte());
   byte[] bytes = new byte[3];
   bm.readBytes(bytes);
   ProxyAssertSupport.assertEquals((byte) 4, bytes[0]);
   ProxyAssertSupport.assertEquals((byte) 5, bytes[1]);
   ProxyAssertSupport.assertEquals((byte) 6, bytes[2]);
   ProxyAssertSupport.assertEquals((char) 7, bm.readChar());
   ProxyAssertSupport.assertEquals(new Double(8.0), new Double(bm.readDouble()));
   ProxyAssertSupport.assertEquals(new Float(9.0), new Float(bm.readFloat()));
   ProxyAssertSupport.assertEquals(10, bm.readInt());
   ProxyAssertSupport.assertEquals(11L, bm.readLong());
   ProxyAssertSupport.assertEquals((short) 12, bm.readShort());
   ProxyAssertSupport.assertEquals("this is an UTF String", bm.readUTF());
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
/**
 * Deserialize a JMS message containing a Java serialized abject.
 *
 * @param message JMS input message with a serialized payload
 * @param <T>     Type of the serialized object
 * @return The de-serialized object
 * @throws RuntimeException Can be thrown if deserialization fails.
 */
public static <T extends Serializable> T objectFromMsg(@NotNull final BytesMessage message) {
    requireNonNull(message);

    try {
        byte[] rawData = new byte[(int) message.getBodyLength()];
        message.readBytes(rawData);
        return (T) convertFromBytes(rawData); // NOSONAR
    } catch (javax.jms.JMSException e) {
        throw propagate(e);
    }
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
public static byte[] getPayload(final BytesMessage bytesMessage) throws Exception {

		final int len = Long.valueOf(bytesMessage.getBodyLength()).intValue();
		final byte[] bytes = new byte[len];
		bytesMessage.readBytes(bytes, len);
		return bytes;
	}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
/**
     * Write message binary body to provided file or default one in temp directory.
     *
     * @param filePath file to write data to
     * @param message  to be read and written to provided file
     */
    public static void writeBinaryContentToFile(String filePath, Message message, int msgCounter) {
        byte[] readByteArray;
        try {
            File writeBinaryFile;
            if (filePath == null || filePath.equals("")) {
                writeBinaryFile = File.createTempFile("recv_msg_", Long.toString(System.currentTimeMillis()));
            } else {
                writeBinaryFile = new File(filePath + "_" + msgCounter);
            }

            LOG.debug("Write binary content to file '" + writeBinaryFile.getPath() + "'.");
            if (message instanceof BytesMessage) {
                BytesMessage bm = (BytesMessage) message;
                readByteArray = new byte[(int) bm.getBodyLength()];
                bm.reset(); // added to be able to read message content
                bm.readBytes(readByteArray);
                try (FileOutputStream fos = new FileOutputStream(writeBinaryFile)) {
                    fos.write(readByteArray);
                    fos.close();
                }

            } else if (message instanceof StreamMessage) {
                LOG.debug("Writing StreamMessage to");
                StreamMessage sm = (StreamMessage) message;
//        sm.reset(); TODO haven't tested this one
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(baos);
                oos.writeObject(sm.readObject());
                oos.close();
            }

        } catch (JMSException e) {
            e.printStackTrace();
        } catch (IOException e1) {
            LOG.error("Error while writing to file '" + filePath + "'.");
            e1.printStackTrace();
        }
    }
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
/**
 * Convert a BytesMessage to a Java Object with the specified type.
 * @param message the input message
 * @return the message body
 * @throws JMSException if thrown by JMS
 * @throws IOException in case of I/O errors
 */
protected String getPayloadFromBytesMessage(BytesMessage message) throws JMSException, IOException {

    String encoding = this.encoding;
    if (this.encodingPropertyName != null && message.propertyExists(this.encodingPropertyName)) {
        encoding = message.getStringProperty(this.encodingPropertyName);
    }
    byte[] bytes = new byte[(int) message.getBodyLength()];
    message.readBytes(bytes);
    try {
        return new String(bytes, encoding);
    } catch (UnsupportedEncodingException ex) {
        throw new MessageConversionException("Cannot convert bytes to String", ex);
    }
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
private void saveMessagePayload(Message msg, String baseName) throws JMSException, IOException {
    try (FileOutputStream fos = new FileOutputStream(new File(_messageFileDirectory, baseName + ".payload"))) {
        byte[] payload;
        if (msg instanceof TextMessage) {
            payload = TextMessageData.textToBytes(((TextMessage) msg).getText());
        }
        else if (msg instanceof BytesMessage) {
            BytesMessage bytesMessage = (BytesMessage) msg;
            payload = new byte[(int) bytesMessage.getBodyLength()];
            bytesMessage.readBytes(payload);
        }
        else if (msg instanceof ObjectMessage) {
            payload = _objectMessageAdapter.getObjectPayload((ObjectMessage) msg);
        }
        else if (msg instanceof MapMessage) {
            // Partial support, not all data types are handled and we may not be able to post
            MapMessage mapMessage = (MapMessage) msg;
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            Properties props = new Properties();
            for (Enumeration<?> mapNames = mapMessage.getMapNames(); mapNames.hasMoreElements();) {
                String mapName = mapNames.nextElement().toString();
                props.setProperty(mapName, mapMessage.getObject(mapName).toString());
            }
            props.store(bos, "Map message properties for " + msg.getJMSMessageID());
            payload = bos.toByteArray();
        }
        else if (msg instanceof StreamMessage) {
            _logger.warn("Can't save payload for {}, stream messages not supported!", msg.getJMSMessageID());
            payload = new byte[0];
        }
        else {
            _logger.warn("Can't save payload for {}, unsupported type {}!", msg.getJMSMessageID(),
                msg.getClass().getName());
            payload = new byte[0];
        }
        fos.write(payload);
        fos.flush();
    }
}