Java BytesMessage类代码示例

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包/类
@Test
public void validateBytesConvertedToBytesMessageOnSend() throws Exception {
    final String destinationName = "testQueue";
    JmsTemplate jmsTemplate = CommonTest.buildJmsTemplateForDestination(false);

    JMSPublisher publisher = new JMSPublisher(jmsTemplate, mock(ComponentLog.class));
    publisher.publish(destinationName, "hellomq".getBytes());

    Message receivedMessage = jmsTemplate.receive(destinationName);
    assertTrue(receivedMessage instanceof BytesMessage);
    byte[] bytes = new byte[7];
    ((BytesMessage) receivedMessage).readBytes(bytes);
    assertEquals("hellomq", new String(bytes));

    ((CachingConnectionFactory) jmsTemplate.getConnectionFactory()).destroy();
}
 

import javax.jms.BytesMessage; //导入依赖的package包/类
/**
 * Convert a message into a Kafka Connect SourceRecord.
 * 
 * @param context            the JMS context to use for building messages
 * @param topic              the Kafka topic
 * @param messageBodyJms     whether to interpret MQ messages as JMS messages
 * @param message            the message
 * 
 * @return the Kafka Connect SourceRecord
 * 
 * @throws JMSException      Message could not be converted
 */
@Override public SourceRecord toSourceRecord(JMSContext context, String topic, boolean messageBodyJms, Message message) throws JMSException {
    byte[] payload;
    if (message instanceof BytesMessage) {
        payload = message.getBody(byte[].class);
    }
    else if (message instanceof TextMessage) {
        String s = message.getBody(String.class);
        payload = s.getBytes(UTF_8);
    }
    else {
        log.error("Unsupported JMS message type {}", message.getClass());
        throw new ConnectException("Unsupported JMS message type");
    }

    SchemaAndValue sv = converter.toConnectData(topic, payload);
    return new SourceRecord(null, null, topic, sv.schema(), sv.value());
}
 

import javax.jms.BytesMessage; //导入依赖的package包/类
@Test
public void client_sends_five_messages_to_queue_and_receives() throws Exception {
    try (JMSClient client = server.createClient()) {
        DummyListener listener = new DummyListener(5);
        client.addQueueListener(DUMMY_QUEUE, listener);
        client.startListening();

        for (int i = 0; i < 5; i++) {
            client.sendToQueue(DUMMY_QUEUE, i + "");
        }

        List<BytesMessage> bytesMessages = listener.awaitMessages();
        assertThat(bytesMessages.size(), is(5));
        assertNotNull(bytesMessages.get(0));

        // Ensure messages are received in the same order they were sent
        for (int i = 0; i < 5; i++) {
            assertThat(JMSHelper.objectFromMsg(bytesMessages.get(i)), is(i + ""));
        }
    }
}
 

import javax.jms.BytesMessage; //导入依赖的package包/类
@Test
public void client_sends_to_topic_and_receives() throws Exception {
    DummyListener listener = new DummyListener(1);
    try (JMSClient client = server.createClient()) {

        server.getServer().createTopic(DUMMY_TOPIC);

        client.addTopicListener(DUMMY_TOPIC, listener);
        client.startListening();

        client.sendToTopic(DUMMY_TOPIC, DUMMY_PAYLOAD);

        List<BytesMessage> bytesMessages = listener.awaitMessages();
        assertReceivedMessageIs(bytesMessages, DUMMY_PAYLOAD);
    }
}
 

import javax.jms.BytesMessage; //导入依赖的package包/类
@Test
public void client_sends_five_messages_to_topic_and_receives() throws Exception {
    DummyListener listener = new DummyListener(5);
    try (JMSClient client = server.createClient()) {

        server.getServer().createTopic(DUMMY_TOPIC);
        client.addTopicListener(DUMMY_TOPIC, listener);
        client.startListening();

        for (int i = 0; i < 5; i++) {
            client.sendToTopic(DUMMY_TOPIC, i + "");
        }

        List<BytesMessage> bytesMessages = listener.awaitMessages();

        assertNotNull(server);
        assertThat(bytesMessages.size(), is(5));
        assertNotNull(bytesMessages.get(0));

        // Ensure messages are received in the same order they were sent
        for (int i = 0; i < 5; i++) {
            assertThat(JMSHelper.objectFromMsg(bytesMessages.get(i)), is(i + ""));
        }
    }
}
 

import javax.jms.BytesMessage; //导入依赖的package包/类
@Test
public void validateBytesConvertedToBytesMessageOnSendOverJNDI() throws Exception {
    final String destinationName = "testQueue";
    JmsTemplate jmsTemplate = CommonTest.buildJmsJndiTemplateForDestination(false);

    JMSPublisher publisher = new JMSPublisher(jmsTemplate, mock(ComponentLog.class));
    publisher.publish(destinationName, "hellomq".getBytes());

    Message receivedMessage = jmsTemplate.receive(destinationName);
    assertTrue(receivedMessage instanceof BytesMessage);
    byte[] bytes = new byte[7];
    ((BytesMessage) receivedMessage).readBytes(bytes);
    assertEquals("hellomq", new String(bytes));

    ((CachingConnectionFactory) jmsTemplate.getConnectionFactory()).destroy();
}
 

import javax.jms.BytesMessage; //导入依赖的package包/类
@Test
public void validateJmsHeadersAndPropertiesAreTransferredFromFFAttributesOverJNDI() throws Exception {
    final String destinationName = "testQueue";
    JmsTemplate jmsTemplate = CommonTest.buildJmsJndiTemplateForDestination(false);

    JMSPublisher publisher = new JMSPublisher(jmsTemplate, mock(ComponentLog.class));
    Map<String, String> flowFileAttributes = new HashMap<>();
    flowFileAttributes.put("foo", "foo");
    flowFileAttributes.put(JmsHeaders.REPLY_TO, "myTopic");
    publisher.publish(destinationName, "hellomq".getBytes(), flowFileAttributes);

    Message receivedMessage = jmsTemplate.receive(destinationName);
    assertTrue(receivedMessage instanceof BytesMessage);
    assertEquals("foo", receivedMessage.getStringProperty("foo"));
    assertTrue(receivedMessage.getJMSReplyTo() instanceof Topic);
    assertEquals("myTopic", ((Topic) receivedMessage.getJMSReplyTo()).getTopicName());

    ((CachingConnectionFactory) jmsTemplate.getConnectionFactory()).destroy();
}
 

import javax.jms.BytesMessage; //导入依赖的package包/类
@Test
public void validateJmsHeadersAndPropertiesAreTransferredFromFFAttributes() throws Exception {
    final String destinationName = "testQueue";
    JmsTemplate jmsTemplate = CommonTest.buildJmsTemplateForDestination(false);

    JMSPublisher publisher = new JMSPublisher(jmsTemplate, mock(ComponentLog.class));
    Map<String, String> flowFileAttributes = new HashMap<>();
    flowFileAttributes.put("foo", "foo");
    flowFileAttributes.put(JmsHeaders.REPLY_TO, "myTopic");
    publisher.publish(destinationName, "hellomq".getBytes(), flowFileAttributes);

    Message receivedMessage = jmsTemplate.receive(destinationName);
    assertTrue(receivedMessage instanceof BytesMessage);
    assertEquals("foo", receivedMessage.getStringProperty("foo"));
    assertTrue(receivedMessage.getJMSReplyTo() instanceof Topic);
    assertEquals("myTopic", ((Topic) receivedMessage.getJMSReplyTo()).getTopicName());

    ((CachingConnectionFactory) jmsTemplate.getConnectionFactory()).destroy();
}
 

import javax.jms.BytesMessage; //导入依赖的package包/类
private void doSendBinaryMessage( final Session session, final Destination destination,
                                  final byte[] bytes,
                                  final Map<String, ?> properties ) throws JMSException {

    try {
        BytesMessage message = session.createBytesMessage();
        message.writeBytes(bytes);
        if (properties != null) {
            // Note: Setting any properties (including JMS fields) using
            // setObjectProperty might not be supported by all providers
            // Tested with: ActiveMQ
            for (final Entry<String, ?> property : properties.entrySet()) {
                message.setObjectProperty(property.getKey(), property.getValue());
            }
        }
        final MessageProducer producer = session.createProducer(destination);
        producer.send(message);
    } finally {
        releaseSession(false);
    }
}
 

import javax.jms.BytesMessage; //导入依赖的package包/类
public void send(byte[] message) {
    if (session == null) {
        logger.warning("Session is null - sending monitoring message aborted");
        return;
    }
    if (queue == null) {
        logger.warning("Queue is null - sending monitoring message aborted");
        return;
    }
    if (producer == null) {
        logger.warning("Producer is null - sending monitoring message aborted");
        return;
    }
    try {
        BytesMessage bytesMessage = session.createBytesMessage();
        bytesMessage.writeBytes(message);
        producer.send(bytesMessage);
    } catch (JMSException ex) {
        logger.log(Level.SEVERE, "Message sending error", ex);
    }
    //logger.info("Sent monitoring message");
}
 

import javax.jms.BytesMessage; //导入依赖的package包/类
@Override
public void sendMessage(final Message message) {
	this.jmsTemplate.send(createDestination(message.getDestination()), new MessageCreator() {
		@Override
		public javax.jms.Message createMessage(Session session) throws JMSException {
			BytesMessage bytesMessage = session.createBytesMessage();
			bytesMessage.writeBytes(message.getBody());
			if(!CollectionUtils.isEmpty(message.getProperties())){
				if(message.getProperties().get("JMSXGroupID") != null){
					bytesMessage.setStringProperty("JMSXGroupID", message.getProperties().get("JMSXGroupID").toString());
				}
				if(message.getProperties().get("JMSXGroupSeq") != null){
					String JMSXGroupSeq = message.getProperties().get("JMSXGroupSeq").toString();
					if(StringUtil.isNumeric(JMSXGroupSeq)){
						bytesMessage.setIntProperty("JMSXGroupSeq", Integer.valueOf(JMSXGroupSeq));
					}
				}
			}
			return bytesMessage;
		}
	});
}
 

import javax.jms.BytesMessage; //导入依赖的package包/类
void createBytesMessage() throws Exception {
  BytesMessage message = mock(BytesMessage.class);
  when(message.getBodyLength()).thenReturn((long)BYTES.length);
  when(message.readBytes(any(byte[].class))).then(new Answer<Integer>() {
    @Override
    public Integer answer(InvocationOnMock invocation) throws Throwable {
      byte[] buffer = (byte[])invocation.getArguments()[0];
      if (buffer != null) {
        assertEquals(buffer.length, BYTES.length);
        System.arraycopy(BYTES, 0, buffer, 0, BYTES.length);
      }
      return BYTES.length;
    }
  });
  this.message = message;
}
 

import javax.jms.BytesMessage; //导入依赖的package包/类
/**
 * 
 * @param session
 * @param frame
 * @return
 * @throws JMSException
 */
public Message toMessage(Session session, Frame frame) throws JMSException {
	// FIXME buffer pool
	final Message msg;
	if (frame.contains(CONTENT_LENGTH)) {
		final ByteBuffer buf = frame.body().get();
		byte[] bytes = new byte[buf.remaining()];
		buf.get(bytes);
		final BytesMessage bm = session.createBytesMessage();
		bm.writeBytes(bytes);
		msg = bm;
	} else {
		msg = session.createTextMessage(UTF_8.decode(frame.body().get()).toString());
	}
	copyHeaders(session, frame, msg);
	return msg;
}
 

import javax.jms.BytesMessage; //导入依赖的package包/类
@Test
public void toMessage_bytes() throws JMSException {
	final javax.jms.Session session = mock(javax.jms.Session.class);
	final Frame frame = mock(Frame.class);
	final ByteBuffer buffer = ByteBuffer.wrap(new byte[0]).asReadOnlyBuffer();
	when(frame.body()).thenReturn(Optional.of(buffer));
	when(frame.headers()).thenReturn(new MultivaluedHashMap<>());
	when(frame.contains(Standard.CONTENT_LENGTH)).thenReturn(true);
	final BytesMessage message = mock(BytesMessage.class);
	when(session.createBytesMessage()).thenReturn(message);

	this.factory.toMessage(session, frame);

	verify(frame).body();
	verify(frame, times(2)).headers();
	verify(frame).contains(Standard.CONTENT_LENGTH);
	verify(session).createBytesMessage();
	verify(message).setJMSCorrelationID(null);
	verify(message).writeBytes(new byte[0]);
	verifyNoMoreInteractions(session, frame, message);
}