Java MapMessage.setInt方法代码示例

import javax.jms.MapMessage; //导入方法依赖的package包/类
private void sendCompressedMapMessageUsingOpenWire() throws Exception {
   Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
   ActiveMQDestination destination = createDestination(session, ActiveMQDestination.QUEUE_TYPE);

   final ActiveMQMessageProducer producer = (ActiveMQMessageProducer) session.createProducer(destination);

   MapMessage mapMessage = session.createMapMessage();

   mapMessage.setBoolean("boolean-type", true);
   mapMessage.setByte("byte-type", (byte) 10);
   mapMessage.setBytes("bytes-type", TEXT.getBytes());
   mapMessage.setChar("char-type", 'A');
   mapMessage.setDouble("double-type", 55.3D);
   mapMessage.setFloat("float-type", 79.1F);
   mapMessage.setInt("int-type", 37);
   mapMessage.setLong("long-type", 56652L);
   mapMessage.setObject("object-type", new String("VVVV"));
   mapMessage.setShort("short-type", (short) 333);
   mapMessage.setString("string-type", TEXT);

   producer.send(mapMessage);
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
private void sendMapMessageUsingOpenWire() throws Exception {
   Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
   ActiveMQDestination destination = createDestination(session, ActiveMQDestination.QUEUE_TYPE);

   System.out.println("destination: " + destination);
   final ActiveMQMessageProducer producer = (ActiveMQMessageProducer) session.createProducer(destination);

   MapMessage mapMessage = session.createMapMessage();
   mapMessage.setBoolean("aboolean", true);
   mapMessage.setByte("abyte", (byte) 4);
   mapMessage.setBytes("abytes", new byte[]{4, 5});
   mapMessage.setChar("achar", 'a');
   mapMessage.setDouble("adouble", 4.4);
   mapMessage.setFloat("afloat", 4.5f);
   mapMessage.setInt("aint", 40);
   mapMessage.setLong("along", 80L);
   mapMessage.setShort("ashort", (short) 65);
   mapMessage.setString("astring", "hello");

   producer.send(mapMessage);
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
private void sendTestMapMessage(ActiveMQConnectionFactory factory, String message) throws JMSException {
   ActiveMQConnection connection = (ActiveMQConnection) factory.createConnection();
   Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
   MessageProducer producer = session.createProducer(queue);
   MapMessage mapMessage = session.createMapMessage();

   mapMessage.setBoolean("boolean-type", true);
   mapMessage.setByte("byte-type", (byte) 10);
   mapMessage.setBytes("bytes-type", TEXT.getBytes());
   mapMessage.setChar("char-type", 'A');
   mapMessage.setDouble("double-type", 55.3D);
   mapMessage.setFloat("float-type", 79.1F);
   mapMessage.setInt("int-type", 37);
   mapMessage.setLong("long-type", 56652L);
   mapMessage.setObject("object-type", new String("VVVV"));
   mapMessage.setShort("short-type", (short) 333);
   mapMessage.setString("string-type", TEXT);

   producer.send(mapMessage);
   connection.close();
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
@Override
protected void prepareMessage(final Message m) throws JMSException {
   super.prepareMessage(m);

   MapMessage mm = (MapMessage) m;

   mm.setBoolean("boolean", true);
   mm.setByte("byte", (byte) 3);
   mm.setBytes("bytes", new byte[]{(byte) 3, (byte) 4, (byte) 5});
   mm.setChar("char", (char) 6);
   mm.setDouble("double", 7.0);
   mm.setFloat("float", 8.0f);
   mm.setInt("int", 9);
   mm.setLong("long", 10L);
   mm.setObject("object", new String("this is an object"));
   mm.setShort("short", (short) 11);
   mm.setString("string", "this is a string");
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
@Test
public void testResendWithLargeMessage() throws Exception {
   conn = cf.createConnection();
   conn.start();

   Session sess = conn.createSession(true, Session.SESSION_TRANSACTED);
   ArrayList<Message> msgs = new ArrayList<>();

   for (int i = 0; i < 10; i++) {
      BytesMessage bm = sess.createBytesMessage();
      bm.setObjectProperty(ActiveMQJMSConstants.JMS_ACTIVEMQ_INPUT_STREAM, ActiveMQTestBase.createFakeLargeStream(2 * ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE));
      msgs.add(bm);

      MapMessage mm = sess.createMapMessage();
      mm.setBoolean("boolean", true);
      mm.setByte("byte", (byte) 3);
      mm.setBytes("bytes", new byte[]{(byte) 3, (byte) 4, (byte) 5});
      mm.setChar("char", (char) 6);
      mm.setDouble("double", 7.0);
      mm.setFloat("float", 8.0f);
      mm.setInt("int", 9);
      mm.setLong("long", 10L);
      mm.setObject("object", new String("this is an object"));
      mm.setShort("short", (short) 11);
      mm.setString("string", "this is a string");

      msgs.add(mm);
      msgs.add(sess.createTextMessage("hello" + i));
      msgs.add(sess.createObjectMessage(new SomeSerializable("hello" + i)));
   }

   internalTestResend(msgs, sess);
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
@Test
public void testResendWithMapMessagesOnly() throws Exception {
   conn = cf.createConnection();
   conn.start();

   Session sess = conn.createSession(true, Session.SESSION_TRANSACTED);
   ArrayList<Message> msgs = new ArrayList<>();

   for (int i = 0; i < 1; i++) {
      MapMessage mm = sess.createMapMessage();
      mm.setBoolean("boolean", true);
      mm.setByte("byte", (byte) 3);
      mm.setBytes("bytes", new byte[]{(byte) 3, (byte) 4, (byte) 5});
      mm.setChar("char", (char) 6);
      mm.setDouble("double", 7.0);
      mm.setFloat("float", 8.0f);
      mm.setInt("int", 9);
      mm.setLong("long", 10L);
      mm.setObject("object", new String("this is an object"));
      mm.setShort("short", (short) 11);
      mm.setString("string", "this is a string");

      msgs.add(mm);

      MapMessage emptyMap = sess.createMapMessage();
      msgs.add(emptyMap);
   }

   internalTestResend(msgs, sess);
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
private void sendMapMessageUsingCoreJms(String queueName) throws Exception {
   Connection jmsConn = null;
   try {
      jmsConn = coreCf.createConnection();
      Session session = jmsConn.createSession(false, Session.AUTO_ACKNOWLEDGE);
      MapMessage mapMessage = session.createMapMessage();
      mapMessage.setBoolean("aboolean", true);
      mapMessage.setByte("abyte", (byte) 4);
      mapMessage.setBytes("abytes", new byte[]{4, 5});
      mapMessage.setChar("achar", 'a');
      mapMessage.setDouble("adouble", 4.4);
      mapMessage.setFloat("afloat", 4.5f);
      mapMessage.setInt("aint", 40);
      mapMessage.setLong("along", 80L);
      mapMessage.setShort("ashort", (short) 65);
      mapMessage.setString("astring", "hello");

      Queue queue = session.createQueue(queueName);
      MessageProducer producer = session.createProducer(queue);

      producer.send(mapMessage);
   } finally {
      if (jmsConn != null) {
         jmsConn.close();
      }
   }

}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
private void testMapMessageSendReceive(Connection producerConnection, Connection consumerConnection) throws Throwable {
   long time = System.currentTimeMillis();

   Session session = producerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
   Queue queue = session.createQueue(getQueueName());

   MessageProducer producer = session.createProducer(queue);
   for (int i = 0; i < NUM_MESSAGES; i++) {
      System.out.println("Sending " + i);
      MapMessage message = session.createMapMessage();

      message.setInt("i", i);
      message.setIntProperty("count", i);
      producer.send(message);
   }

   Session sessionConsumer = consumerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
   Queue consumerQueue = sessionConsumer.createQueue(getQueueName());
   final MessageConsumer consumer = sessionConsumer.createConsumer(consumerQueue);

   for (int i = 0; i < NUM_MESSAGES; i++) {
      MapMessage m = (MapMessage) consumer.receive(5000);
      Assert.assertNotNull("Could not receive message count=" + i + " on consumer", m);

      Assert.assertEquals(i, m.getInt("i"));
      Assert.assertEquals(i, m.getIntProperty("count"));
   }

   long taken = (System.currentTimeMillis() - time) / 1000;
   System.out.println("taken = " + taken);
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
public void testNoSubscribers() throws Exception {
   connection = connectionFactory.createConnection(USERNAME, DEFAULT_PASSWORD);
   assertNotNull(connection);
   connection.start();
   session = connection.createSession(false, javax.jms.Session.AUTO_ACKNOWLEDGE);
   assertNotNull(session);
   destination = session.createQueue(QUEUE_NAME);
   assertNotNull(destination);
   publisher = session.createProducer(destination);
   assertNotNull(publisher);
   MapMessage msg = session.createMapMessage();
   assertNotNull(msg);
   msg.setString("key1", "value1");
   int loop;
   for (loop = 0; loop < MESSAGE_COUNT; loop++) {
      msg.setInt("key2", loop);
      publisher.send(msg, DELIVERY_MODE, DELIVERY_PRIORITY, Message.DEFAULT_TIME_TO_LIVE);
      if (loop % 500 == 0) {
         LOG.debug("Sent " + loop + " messages");
      }
   }
   Thread.sleep(1000000);
   assertEquals(loop, MESSAGE_COUNT);
   publisher.close();
   session.close();
   connection.stop();
   connection.stop();
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
public void test2ProducerTestCase() {
     /*
      * Step 2 - Establish a connection without a client id and create a
      * producer and start pumping messages. We will get hung
      */
   try {
      connection = connectionFactory.createConnection(USERNAME, DEFAULT_PASSWORD);
      assertNotNull(connection);
      session = connection.createSession(false, javax.jms.Session.CLIENT_ACKNOWLEDGE);
      assertNotNull(session);
      topic = session.createTopic(TOPIC_NAME);
      assertNotNull(topic);
      publisher = session.createProducer(topic);
      assertNotNull(publisher);
      MapMessage msg = session.createMapMessage();
      assertNotNull(msg);
      msg.setString("key1", "value1");
      int loop;
      for (loop = 0; loop < MESSAGE_COUNT; loop++) {
         msg.setInt("key2", loop);
         publisher.send(msg, DELIVERY_MODE, DELIVERY_PRIORITY, Message.DEFAULT_TIME_TO_LIVE);
         if (loop % 5000 == 0) {
            LOG.info("Sent " + loop + " messages");
         }
      }
      assertEquals(loop, MESSAGE_COUNT);
      publisher.close();
      session.close();
      connection.stop();
      connection.stop();
   } catch (JMSException ex) {
      try {
         connection.close();
      } catch (Exception ignore) {
      }
      throw new AssertionFailedError("Create Subscription caught: " + ex);
   }
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
@Test
public void testCopyOnForeignMapMessage() throws JMSException {
   ClientMessage clientMessage = new ClientMessageImpl(ActiveMQTextMessage.TYPE, true, 0, System.currentTimeMillis(), (byte) 4, 1000);
   ClientSession session = new FakeSession(clientMessage);
   MapMessage foreignMapMessage = new SimpleJMSMapMessage();
   foreignMapMessage.setInt("int", 1);
   foreignMapMessage.setString("string", "test");

   ActiveMQMapMessage copy = new ActiveMQMapMessage(foreignMapMessage, session);

   MessageHeaderTestBase.ensureEquivalent(foreignMapMessage, copy);
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
@Override
public JMSProducer send(Destination destination, Map<String, Object> body) {
   MapMessage message = context.createMapMessage();
   if (body != null) {
      try {
         for (Entry<String, Object> entry : body.entrySet()) {
            final String name = entry.getKey();
            final Object v = entry.getValue();
            if (v instanceof String) {
               message.setString(name, (String) v);
            } else if (v instanceof Long) {
               message.setLong(name, (Long) v);
            } else if (v instanceof Double) {
               message.setDouble(name, (Double) v);
            } else if (v instanceof Integer) {
               message.setInt(name, (Integer) v);
            } else if (v instanceof Character) {
               message.setChar(name, (Character) v);
            } else if (v instanceof Short) {
               message.setShort(name, (Short) v);
            } else if (v instanceof Boolean) {
               message.setBoolean(name, (Boolean) v);
            } else if (v instanceof Float) {
               message.setFloat(name, (Float) v);
            } else if (v instanceof Byte) {
               message.setByte(name, (Byte) v);
            } else if (v instanceof byte[]) {
               byte[] array = (byte[]) v;
               message.setBytes(name, array, 0, array.length);
            } else {
               message.setObject(name, v);
            }
         }
      } catch (JMSException e) {
         throw new MessageFormatRuntimeException(e.getMessage());
      }
   }
   send(destination, message);
   return this;
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
public Message marshal(EventBean eventBean, Session session,
                       long timestamp) throws EPException {
    EventType eventType = eventBean.getEventType();
    MapMessage mapMessage = null;
    try {
        mapMessage = session.createMapMessage();
        String[] properties = eventType.getPropertyNames();
        for (String property : properties) {
            if ((ExecutionPathDebugLog.isDebugEnabled) && (log.isDebugEnabled())) {
                log.debug(
                        ".Marshal EventProperty property==" + property + ", value=" +
                                eventBean.get(property));
            }
            Class clazz = eventType.getPropertyType(property);
            if (JavaClassHelper.isNumeric(clazz)) {
                Class boxedClazz = JavaClassHelper.getBoxedType(clazz);
                if (boxedClazz == Double.class) {
                    mapMessage.setDouble(property, (Double) eventBean.get(property));
                }
                if (boxedClazz == Float.class) {
                    mapMessage.setFloat(property, (Float) eventBean.get(property));
                }
                if (boxedClazz == Byte.class) {
                    mapMessage.setFloat(property, (Byte) eventBean.get(property));
                }
                if (boxedClazz == Short.class) {
                    mapMessage.setShort(property, (Short) eventBean.get(property));
                }
                if (boxedClazz == Integer.class) {
                    mapMessage.setInt(property, (Integer) eventBean.get(property));
                }
                if (boxedClazz == Long.class) {
                    mapMessage.setLong(property, (Long) eventBean.get(property));
                }
            } else if ((clazz == boolean.class) || (clazz == Boolean.class)) {
                mapMessage.setBoolean(property, (Boolean) eventBean.get(property));
            } else if ((clazz == Character.class) || (clazz == char.class)) {
                mapMessage.setChar(property, (Character) eventBean.get(property));
            } else if (clazz == String.class) {
                mapMessage.setString(property, (String) eventBean.get(property));
            } else {
                mapMessage.setObject(property, eventBean.get(property));
            }
        }
        mapMessage.setJMSTimestamp(timestamp);
    } catch (JMSException ex) {
        throw new EPException(ex);
    }
    return mapMessage;
}
 

import javax.jms.MapMessage; //导入方法依赖的package包/类
/**
 * @param type
 * @throws JMSException
 */
private Object createBodySendAndReceive(JmsMessageType type) throws JMSException {
   Object res = null;
   Message msg = null;
   switch (type) {
      case BYTE:
         BytesMessage mByte = queueProducerSession.createBytesMessage();
         final int size = 20;
         byte[] resByte = new byte[size];
         for (int i = 0; i < size; i++) {
            resByte[i] = (byte) i;
            mByte.writeByte((byte) i);
         }
         msg = mByte;
         res = resByte;
         break;
      case TEXT:
         res = "JMS2";
         msg = queueProducerSession.createTextMessage("JMS2");
         break;
      case STREAM:
         msg = queueProducerSession.createStreamMessage();
         break;
      case OBJECT:
         res = new Double(37.6);
         msg = queueProducerSession.createObjectMessage(new Double(37.6));
         break;
      case MAP:
         MapMessage msg1 = queueProducerSession.createMapMessage();
         msg1.setInt("int", 13);
         msg1.setLong("long", 37L);
         msg1.setString("string", "crocodile");
         msg = msg1;
         Map<String, Object> map = new HashMap<>();
         map.put("int", Integer.valueOf(13));
         map.put("long", Long.valueOf(37L));
         map.put("string", "crocodile");
         res = map;
         break;
      default:
         Assert.fail("no default...");
   }
   Assert.assertNotNull(msg);
   msg.setStringProperty("type", type.toString());
   queueProducer.send(msg);
   return res;
}