Java MapMessage.getObject方法代码示例

import javax.jms.MapMessage; //导入方法依赖的package包/类
public static void print(Message msg) throws JMSException {
    log.info(".print received message: " + msg.getJMSMessageID());
    if (msg instanceof ObjectMessage) {
        ObjectMessage objMsg = (ObjectMessage) msg;
        log.info(".print object: " + objMsg.getObject().toString());
    } else {
        MapMessage mapMsg = (MapMessage) msg;
        HashMap map = new HashMap();
        Enumeration en = mapMsg.getMapNames();
        while (en.hasMoreElements()) {
            String property = (String) en.nextElement();
            Object mapObject = mapMsg.getObject(property);
            map.put(property, mapObject);
        }
        log.info(".print map: " + map);
    }
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
/**
 * Extracts a {@link Map} from a {@link MapMessage}
 */
public Map<String, Object> createMapFromMapMessage(MapMessage message) throws JMSException {
    Map<String, Object> answer = new HashMap<String, Object>();
    Enumeration<?> names = message.getMapNames();
    while (names.hasMoreElements()) {
        String name = names.nextElement().toString();
        Object value = message.getObject(name);
        answer.put(name, value);
    }
    return answer;
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
private void receiveMapMessage(boolean useCore) throws Exception {
   MapMessage mapMessage = (MapMessage) receiveMessage(useCore);

   boolean booleanVal = mapMessage.getBoolean("boolean-type");
   assertTrue(booleanVal);
   byte byteVal = mapMessage.getByte("byte-type");
   assertEquals((byte) 10, byteVal);
   byte[] bytesVal = mapMessage.getBytes("bytes-type");
   byte[] originVal = TEXT.getBytes();
   assertEquals(originVal.length, bytesVal.length);
   for (int i = 0; i < bytesVal.length; i++) {
      assertTrue(bytesVal[i] == originVal[i]);
   }
   char charVal = mapMessage.getChar("char-type");
   assertEquals('A', charVal);
   double doubleVal = mapMessage.getDouble("double-type");
   assertEquals(55.3D, doubleVal, 0.1D);
   float floatVal = mapMessage.getFloat("float-type");
   assertEquals(79.1F, floatVal, 0.1F);
   int intVal = mapMessage.getInt("int-type");
   assertEquals(37, intVal);
   long longVal = mapMessage.getLong("long-type");
   assertEquals(56652L, longVal);
   Object objectVal = mapMessage.getObject("object-type");
   Object origVal = new String("VVVV");
   assertTrue(objectVal.equals(origVal));
   short shortVal = mapMessage.getShort("short-type");
   assertEquals((short) 333, shortVal);
   String strVal = mapMessage.getString("string-type");
   assertEquals(TEXT, strVal);
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
@Override
@SuppressWarnings("rawtypes")
protected void assertMessageValid(int index, Message message) throws JMSException {
   assertTrue("Should be a MapMessage: " + message, message instanceof MapMessage);

   MapMessage mapMessage = (MapMessage) message;

   Object value = mapMessage.getObject("textField");
   assertEquals("textField", data[index], value);

   Map map = (Map) mapMessage.getObject("mapField");
   assertNotNull(map);
   assertEquals("mapField.a", "foo", map.get("a"));
   assertEquals("mapField.b", Integer.valueOf(23), map.get("b"));
   assertEquals("mapField.c", Long.valueOf(45), map.get("c"));

   value = map.get("d");
   assertTrue("mapField.d should be a Map", value instanceof Map);
   map = (Map) value;

   assertEquals("mapField.d.x", "abc", map.get("x"));
   value = map.get("y");
   assertTrue("mapField.d.y is a List", value instanceof List);
   List list = (List) value;
   LOG.debug("mapField.d.y: " + list);
   assertEquals("listField.size", 3, list.size());

   LOG.debug("Found map: " + map);

   list = (List) mapMessage.getObject("listField");
   LOG.debug("listField: " + list);
   assertEquals("listField.size", 3, list.size());
   assertEquals("listField[0]", "a", list.get(0));
   assertEquals("listField[1]", "b", list.get(1));
   assertEquals("listField[2]", "c", list.get(2));
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
/**
 * Constructor for a foreign MapMessage
 *
 * @param foreign
 * @throws JMSException
 */
public ActiveMQMapMessage(final MapMessage foreign, final ClientSession session) throws JMSException {
   super(foreign, ActiveMQMapMessage.TYPE, session);
   Enumeration<?> names = foreign.getMapNames();
   while (names.hasMoreElements()) {
      String name = (String) names.nextElement();
      Object obj = foreign.getObject(name);
      setObject(name, obj);
   }
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
/**  
* extract message from mapMessage and convert to Event
* @throws JMSException if jms exception occured
*/
public static Event convertToEvent(MapMessage mapMessage) throws JMSException{
	Object data = mapMessage.getObject("data");
	Object name = mapMessage.getObject("name");
	return new Event(String.valueOf(name),data);
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
private void extractContent(StringBuilder buffer, StringBuilder propBuffer,
        Message msg, boolean isLast) {
    if (msg != null) {
        try {
            if (msg instanceof TextMessage){
                buffer.append(((TextMessage) msg).getText());
            } else if (msg instanceof ObjectMessage){
                ObjectMessage objectMessage = (ObjectMessage) msg;
                if(objectMessage.getObject() != null) {
                    buffer.append(objectMessage.getObject().getClass());
                } else {
                    buffer.append("object is null");
                }
            } else if (msg instanceof BytesMessage){
                BytesMessage bytesMessage = (BytesMessage) msg;
                buffer.append(bytesMessage.getBodyLength() + " bytes received in BytesMessage");
            } else if (msg instanceof MapMessage){
                MapMessage mapm = (MapMessage) msg;
                @SuppressWarnings("unchecked") // MapNames are Strings
                Enumeration<String> enumb = mapm.getMapNames();
                while(enumb.hasMoreElements()){
                    String name = enumb.nextElement();
                    Object obj = mapm.getObject(name);
                    buffer.append(name);
                    buffer.append(",");
                    buffer.append(obj.getClass().getCanonicalName());
                    buffer.append(",");
                    buffer.append(obj);
                    buffer.append("\n");
                }
            }
            Utils.messageProperties(propBuffer, msg);
            if(!isLast && !StringUtils.isEmpty(separator)) {
                propBuffer.append(separator);
                buffer.append(separator);
            }
        } catch (JMSException e) {
            log.error(e.getMessage());
        }
    }
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
public EventBean unmarshal(EventAdapterService eventAdapterService,
                           Message message) throws EPException {
    try {
        if (message instanceof ObjectMessage) {
            ObjectMessage objmsg = (ObjectMessage) message;
            Serializable obj = objmsg.getObject();
            return eventAdapterService.adapterForBean(obj);
        } else if (message instanceof MapMessage) {
            Map<String, Object> properties = new HashMap<String, Object>();
            MapMessage mapMsg = (MapMessage) message;
            Enumeration en = mapMsg.getMapNames();
            while (en.hasMoreElements()) {
                String property = (String) en.nextElement();
                Object mapObject = mapMsg.getObject(property);
                properties.put(property, mapObject);
            }

            // Get event type property
            Object typeProperty = properties.get(InputAdapter.ESPERIO_MAP_EVENT_TYPE);
            if (typeProperty == null) {
                log.warn(".unmarshal Failed to unmarshal map message, expected type property not found: '" + InputAdapter.ESPERIO_MAP_EVENT_TYPE + "'");
                return null;
            }

            // Get event type
            String name = typeProperty.toString();
            EventType eventType = eventAdapterService.getExistsTypeByName(name);
            if (eventType == null) {
                log.warn(".unmarshal Failed to unmarshal map message, event type name '" + name + "' is not a known type");
                return null;
            }

            return eventAdapterService.adapterForTypedMap(properties, eventType);
        } else {
            String error = ".unmarshal Failed to unmarshal message of JMS type: " + message.getJMSType();
            log.error(error);
            throw new EPException(error);
        }
    } catch (JMSException ex) {
        throw new EPException("Error unmarshalling message", ex);
    }
}