Java BytesMessage.getBodyLength方法代码示例

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包/类
/**
 * 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包/类
private List<String> getQueue() throws Exception {
  List<String> rows = new ArrayList<>();

  Session session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
  Destination destination = session.createQueue(DESTINATION_NAME);
  MessageConsumer consumer = session.createConsumer(destination);

  Message temp;
  while((temp = consumer.receive(100)) != null) {
    if(temp instanceof BytesMessage) {
      BytesMessage message = (BytesMessage) temp;
      byte[] payload = new byte[(int) message.getBodyLength()];
      message.readBytes(payload);
      rows.add(new String(payload) + RECORD_SEPERATOR);
    } else if(temp instanceof TextMessage) {
      rows.add(((TextMessage) temp).getText());
    } else {
      throw new Exception("Unexpected message type");
    }
  }

  return rows;
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
@Override
protected String extractString(JMSBindingData binding) throws Exception {
    Message content = binding.getMessage();
    if (content instanceof TextMessage) {
        return TextMessage.class.cast(content).getText();
    
    } else if (content instanceof BytesMessage) {
        BytesMessage sourceBytes = BytesMessage.class.cast(content);
        if (sourceBytes.getBodyLength() > Integer.MAX_VALUE) {
            throw JCAMessages.MESSAGES.theSizeOfMessageContentExceedsBytesThatIsNotSupportedByThisOperationSelector("" + Integer.MAX_VALUE);
        }
        byte[] bytearr = new byte[(int)sourceBytes.getBodyLength()];
        sourceBytes.readBytes(bytearr);
        return new String(bytearr);

    } else if (content instanceof ObjectMessage) {
        ObjectMessage sourceObj = ObjectMessage.class.cast(content);
        return String.class.cast(sourceObj.getObject());

    } else if (content instanceof MapMessage) {
        MapMessage sourceMap = MapMessage.class.cast(content);
        return sourceMap.getString(KEY);
    } else {
        return content.getStringProperty(KEY);
    }
}
 

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包/类
/**
     * 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();
    }
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
@Override
public String apply( BytesMessage t )
{
    if( t != null )
    {
        try
        {
            long l = t.getBodyLength();
            byte b[] = new byte[(int) l];
            t.readBytes( b );
            try( Reader r = new InputStreamReader( new GZIPInputStream( new ByteArrayInputStream( b ) ) ) )
            {
                StringBuilder sb = new StringBuilder();
                char cb[] = new char[1024];
                int s = r.read( cb );
                while( s > -1 )
                {
                    sb.append( cb, 0, s );
                    s = r.read( cb );
                }
                return sb.toString();
            }
        } catch( IOException | JMSException ex )
        {
            Logger.getLogger( getClass().getName() ).log( Level.SEVERE, null, ex );
        }
    }

    return null;
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
protected byte[] createByteArrayFromBytesMessage(BytesMessage message) throws JMSException {
    if (message.getBodyLength() > Integer.MAX_VALUE) {
        LOG.warn("Length of BytesMessage is too long: {}", message.getBodyLength());
        return null;
    }
    byte[] result = new byte[(int)message.getBodyLength()];
    message.readBytes(result);
    return result;
}
 

import javax.jms.BytesMessage; //导入方法依赖的package包/类
private String getBody(BytesMessage bytesMsg) {
    try {
        long length = bytesMsg.getBodyLength();
        byte[] buf = new byte[(int) length];
        bytesMsg.readBytes(buf);
        return new String(buf);
    } catch (JMSException e) {
        String text = "Error getting message body";
        log.error(text, e);
        throw new RuntimeException(text, e);
    }
}