import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
/**
 * Transform an ActiveMQBytesMessage to a Map
 * 
 * @param msg - bytes message to transform
 * @return map object
 * @throws JMSException
 */
protected Map transformToMap(ActiveMQBytesMessage msg) throws JMSException {
    Properties props = new Properties();

    props.putAll(transformToMap((ActiveMQMessage)msg));

    long bodyLength = msg.getBodyLength();
    byte[] msgBody;
    int i = 0;
    // Create separate bytes messages
    for (i = 0; i < (bodyLength / Integer.MAX_VALUE); i++) {
        msgBody = new byte[Integer.MAX_VALUE];
        props.setProperty(AmqMessagesUtil.JMS_MESSAGE_BODY_PREFIX + "JMSBytes:" + (i + 1), new String(msgBody));
    }
    msgBody = new byte[(int)(bodyLength % Integer.MAX_VALUE)];
    props.setProperty(AmqMessagesUtil.JMS_MESSAGE_BODY_PREFIX + "JMSBytes:" + (i + 1), new String(msgBody));

    return props;
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
@Test
public void testBytesMessageCompressionActiveMQ() throws Exception {
    sendAMQBytesMessage(TEXT);
    ActiveMQBytesMessage message = receiveAMQBytesMessage();
    int compressedSize = message.getContent().getLength();
    byte[] bytes = new byte[TEXT.getBytes("UTF8").length];
    message.readBytes(bytes);
    assertTrue(message.readBytes(new byte[255]) == -1);
    String rcvString = new String(bytes, "UTF8");
    assertEquals(TEXT, rcvString);
    assertTrue(message.isCompressed());

    sendAMQBytesMessage(TEXT, false);
    message = receiveAMQBytesMessage();
    int unCompressedSize = message.getContent().getLength();

    assertTrue("expected: compressed Size '" + compressedSize + "' < unCompressedSize '" + unCompressedSize + "'",
               compressedSize < unCompressedSize);
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
private void flushBuffer() throws IOException {
    if (count != 0) {
        try {
            ActiveMQBytesMessage msg = new ActiveMQBytesMessage();
            msg.writeBytes(buffer, 0, count);
            send(msg, false);
        } catch (JMSException e) {
            throw IOExceptionSupport.create(e);
        }
        count = 0;
    }
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
void onMessageDispatch(MessageDispatch md, String ackId) throws IOException, JMSException {
    ActiveMQMessage message = (ActiveMQMessage)md.getMessage();
    if (ackMode == CLIENT_ACK) {
        synchronized (this) {
            dispatchedMessage.put(message.getMessageId(), md);
        }
    } else if (ackMode == INDIVIDUAL_ACK) {
        synchronized (this) {
            dispatchedMessage.put(message.getMessageId(), md);
        }
    } else if (ackMode == AUTO_ACK) {
        MessageAck ack = new MessageAck(md, MessageAck.STANDARD_ACK_TYPE, 1);
        protocolConverter.getStompTransport().sendToActiveMQ(ack);
    }

    boolean ignoreTransformation = false;

    if (transformation != null && !( message instanceof ActiveMQBytesMessage ) ) {
        message.setReadOnlyProperties(false);
        message.setStringProperty(Stomp.Headers.TRANSFORMATION, transformation);
    } else {
        if (message.getStringProperty(Stomp.Headers.TRANSFORMATION) != null) {
            ignoreTransformation = true;
        }
    }

    StompFrame command = protocolConverter.convertMessage(message, ignoreTransformation);

    command.setAction(Stomp.Responses.MESSAGE);
    if (subscriptionId != null) {
        command.getHeaders().put(Stomp.Headers.Message.SUBSCRIPTION, subscriptionId);
    }

    if (ackId != null) {
        command.getHeaders().put(Stomp.Headers.Message.ACK_ID, ackId);
    }

    protocolConverter.getStompTransport().sendToStomp(command);
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
@Test
public void testBytesMessageCompression() throws Exception {

   MessageConsumer consumer1 = remoteSession.createConsumer(included);
   MessageProducer producer = localSession.createProducer(included);
   producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

   waitForConsumerRegistration(localBroker, 1, included);

   StringBuilder payload = new StringBuilder("test-");
   for (int i = 0; i < 100; ++i) {
      payload.append(UUID.randomUUID().toString());
   }

   byte[] bytes = payload.toString().getBytes(StandardCharsets.UTF_8);

   BytesMessage test = localSession.createBytesMessage();
   test.writeBytes(bytes);
   producer.send(test);
   Message msg = consumer1.receive(RECEIVE_TIMEOUT_MILLS);
   assertNotNull(msg);
   ActiveMQBytesMessage message = (ActiveMQBytesMessage) msg;
   assertTrue(message.isCompressed());
   assertTrue(message.getContent().getLength() < bytes.length);

   byte[] result = new byte[bytes.length];
   assertEquals(bytes.length, message.readBytes(result));
   assertEquals(-1, message.readBytes(result));

   for (int i = 0; i < bytes.length; ++i) {
      assertEquals(bytes[i], result[i]);
   }
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
@Test
public void testBrowseByteMessageFails() throws Exception {
   ActiveMQBytesMessage bm = new ActiveMQBytesMessage();
   bm.writeBytes("123456".getBytes());
   Object result = OpenTypeSupport.convert(bm);
   LOG.info("result : " + result);
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
private ActiveMQBytesMessage receiveAMQBytesMessage() throws Exception {
    ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(connectionURI);
    ActiveMQConnection connection = (ActiveMQConnection) factory.createConnection();
    connection.start();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    MessageConsumer consumer = session.createConsumer(getActiveMQQueue());
    ActiveMQBytesMessage rc = (ActiveMQBytesMessage) consumer.receive();
    connection.close();
    return rc;
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
@Override
public <T> T getBody(final Class<T> c) throws JMSException {
    final int len = (int) getBodyLength();
    if (len == 0) {
        return null;
    }
    final byte[] dst = new byte[len];
    if (ActiveMQBytesMessage.class.isInstance(message)) {
        System.arraycopy(ActiveMQBytesMessage.class.cast(message).getContent().getData(), 0, dst, 0, len);
    }
    return c.cast(dst);
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
@Override
public void onMessage(Message message) {
	ActiveMQBytesMessage msg = (ActiveMQBytesMessage) message;
	byte[] data = msg.getContent().getData();
	processByteMessage(data);
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
@Override
public BytesMessage createBytesMessage() throws JMSException {

    return new ActiveMQBytesMessage();
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
private void fillBuffer() throws IOException {
    if (eosReached || (buffer != null && buffer.length > pos)) {
        return;
    }
    try {
        while (true) {
            ActiveMQMessage m = receive();
            if (m != null && m.getDataStructureType() == CommandTypes.ACTIVEMQ_BYTES_MESSAGE) {
                // First message.
                long producerSequenceId = m.getMessageId().getProducerSequenceId();
                if (producerId == null) {
                    // We have to start a stream at sequence id = 0
                    if (producerSequenceId != 0) {
                        continue;
                    }
                    nextSequenceId++;
                    producerId = m.getMessageId().getProducerId();
                } else {
                    // Verify it's the next message of the sequence.
                    if (!m.getMessageId().getProducerId().equals(producerId)) {
                        throw new IOException("Received an unexpected message: invalid producer: " + m);
                    }
                    if (producerSequenceId != nextSequenceId++) {
                        throw new IOException("Received an unexpected message: expected ID: " + (nextSequenceId - 1) + " but was: " + producerSequenceId + " for message: " + m);
                    }
                }

                // Read the buffer in.
                ActiveMQBytesMessage bm = (ActiveMQBytesMessage)m;
                buffer = new byte[(int)bm.getBodyLength()];
                bm.readBytes(buffer);
                pos = 0;
                if (jmsProperties == null) {
                    jmsProperties = Collections.unmodifiableMap(new HashMap<String, Object>(bm.getProperties()));
                }
            } else {
                eosReached = true;
                if (jmsProperties == null) {
                    // no properties found
                    jmsProperties = Collections.emptyMap();
                }
            }
            return;
        }
    } catch (JMSException e) {
        eosReached = true;
        if (jmsProperties == null) {
            // no properties found
            jmsProperties = Collections.emptyMap();
        }
        throw IOExceptionSupport.create(e);
    }
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
@Override
protected String getTypeName() {
    return ActiveMQBytesMessage.class.getName();
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
@Override
public BytesMessage createBytesMessage() {
    return new ActiveMQBytesMessage();
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
/**
 * @return a new object instance
 */
public DataStructure createObject() {
    return new ActiveMQBytesMessage();
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
@Override
public Object createObject() throws Exception {
   ActiveMQBytesMessage info = new ActiveMQBytesMessage();
   populateObject(info);
   return info;
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
@Override
protected void populateObject(Object object) throws Exception {
   super.populateObject(object);
   ActiveMQBytesMessage info = (ActiveMQBytesMessage) object;

}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
/**
 * Tests transforming messages into ActiveMQ's message implementation.
 */
public void testTransformMessage() throws Exception {
   assertTrue("Transforming a BytesMessage message into an ActiveMQBytesMessage", ActiveMQMessageTransformation.transformMessage(new ActiveMQBytesMessage(), null) instanceof ActiveMQBytesMessage);

   assertTrue("Transforming a MapMessage message to an ActiveMQMapMessage", ActiveMQMessageTransformation.transformMessage(new ActiveMQMapMessage(), null) instanceof ActiveMQMapMessage);

   assertTrue("Transforming an ObjectMessage message to an ActiveMQObjectMessage", ActiveMQMessageTransformation.transformMessage(new ActiveMQObjectMessage(), null) instanceof ActiveMQObjectMessage);

   assertTrue("Transforming a StreamMessage message to an ActiveMQStreamMessage", ActiveMQMessageTransformation.transformMessage(new ActiveMQStreamMessage(), null) instanceof ActiveMQStreamMessage);

   assertTrue("Transforming a TextMessage message to an ActiveMQTextMessage", ActiveMQMessageTransformation.transformMessage(new ActiveMQTextMessage(), null) instanceof ActiveMQTextMessage);

   assertTrue("Transforming an ActiveMQMessage message to an ActiveMQMessage", ActiveMQMessageTransformation.transformMessage(new ActiveMQMessage(), null) instanceof ActiveMQMessage);
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
/**
 * Creates a <CODE>BytesMessage</CODE> object. A <CODE>BytesMessage</CODE>
 * object is used to send a message containing a stream of uninterpreted
 * bytes.
 *
 * @return the an ActiveMQBytesMessage
 * @throws JMSException if the JMS provider fails to create this message due
 *                 to some internal error.
 */
public BytesMessage createBytesMessage() throws JMSException {
    ActiveMQBytesMessage message = new ActiveMQBytesMessage();
    configureMessage(message);
    return message;
}
 

import org.apache.activemq.command.ActiveMQBytesMessage; //导入依赖的package包/类
/**
 * Return the type of Data Structure we marshal
 * @return short representation of the type data structure
 */
public byte getDataStructureType() {
    return ActiveMQBytesMessage.DATA_STRUCTURE_TYPE;
}