Java JMSProducer.send方法代码示例

import javax.jms.JMSProducer; //导入方法依赖的package包/类
@Test
public void testStringBodyIsApplied() throws JMSException {
    JMSProducer producer = context.createProducer();

    final String bodyValue = "String-Value";
    final AtomicBoolean bodyValidated = new AtomicBoolean();

    MockJMSConnection connection = (MockJMSConnection) context.getConnection();
    connection.addConnectionListener(new MockJMSDefaultConnectionListener() {

        @Override
        public void onMessageSend(MockJMSSession session, Message message) throws JMSException {
            assertEquals(bodyValue, message.getBody(String.class));
            bodyValidated.set(true);
        }
    });

    producer.send(JMS_DESTINATION, bodyValue);
    assertTrue(bodyValidated.get());
}
 

import javax.jms.JMSProducer; //导入方法依赖的package包/类
@Test
public void testMapBodyIsApplied() throws JMSException {
    JMSProducer producer = context.createProducer();

    final Map<String, Object> bodyValue = new HashMap<String, Object>();

    bodyValue.put("Value-1", "First");
    bodyValue.put("Value-2", "Second");

    final AtomicBoolean bodyValidated = new AtomicBoolean();

    MockJMSConnection connection = (MockJMSConnection) context.getConnection();
    connection.addConnectionListener(new MockJMSDefaultConnectionListener() {

        @Override
        public void onMessageSend(MockJMSSession session, Message message) throws JMSException {
            assertEquals(bodyValue, message.getBody(Map.class));
            bodyValidated.set(true);
        }
    });

    producer.send(JMS_DESTINATION, bodyValue);
    assertTrue(bodyValidated.get());
}
 

import javax.jms.JMSProducer; //导入方法依赖的package包/类
@Test
public void testSerializableBodyIsApplied() throws JMSException {
    JMSProducer producer = context.createProducer();

    final UUID bodyValue = UUID.randomUUID();
    final AtomicBoolean bodyValidated = new AtomicBoolean();

    MockJMSConnection connection = (MockJMSConnection) context.getConnection();
    connection.addConnectionListener(new MockJMSDefaultConnectionListener() {

        @Override
        public void onMessageSend(MockJMSSession session, Message message) throws JMSException {
            assertEquals(bodyValue, message.getBody(UUID.class));
            bodyValidated.set(true);
        }
    });

    producer.send(JMS_DESTINATION, bodyValue);
    assertTrue(bodyValidated.get());
}
 

import javax.jms.JMSProducer; //导入方法依赖的package包/类
@Test
public void testRuntimeExceptionFromSendMessage() throws JMSException {
    JMSProducer producer = context.createProducer();

    MockJMSConnection connection = (MockJMSConnection) context.getConnection();
    connection.addConnectionListener(new MockJMSDefaultConnectionListener() {

        @Override
        public void onMessageSend(MockJMSSession session, Message message) throws JMSException {
            throw new IllegalStateException("Send Failed");
        }
    });

    try {
        producer.send(context.createTemporaryQueue(), context.createMessage());
        fail("Should have thrown an exception");
    } catch (IllegalStateRuntimeException isre) {}
}
 

import javax.jms.JMSProducer; //导入方法依赖的package包/类
@Test
public void testRuntimeExceptionFromSendByteBody() throws JMSException {
    JMSProducer producer = context.createProducer();

    MockJMSConnection connection = (MockJMSConnection) context.getConnection();
    connection.addConnectionListener(new MockJMSDefaultConnectionListener() {

        @Override
        public void onMessageSend(MockJMSSession session, Message message) throws JMSException {
            throw new IllegalStateException("Send Failed");
        }
    });

    try {
        producer.send(context.createTemporaryQueue(), new byte[0]);
        fail("Should have thrown an exception");
    } catch (IllegalStateRuntimeException isre) {}
}
 

import javax.jms.JMSProducer; //导入方法依赖的package包/类
@Test
public void testRuntimeExceptionFromSendMapBody() throws JMSException {
    JMSProducer producer = context.createProducer();

    MockJMSConnection connection = (MockJMSConnection) context.getConnection();
    connection.addConnectionListener(new MockJMSDefaultConnectionListener() {

        @Override
        public void onMessageSend(MockJMSSession session, Message message) throws JMSException {
            throw new IllegalStateException("Send Failed");
        }
    });

    try {
        producer.send(context.createTemporaryQueue(), Collections.<String, Object>emptyMap());
        fail("Should have thrown an exception");
    } catch (IllegalStateRuntimeException isre) {}
}
 

import javax.jms.JMSProducer; //导入方法依赖的package包/类
@Test
public void testRuntimeExceptionFromSendSerializableBody() throws JMSException {
    JMSProducer producer = context.createProducer();

    MockJMSConnection connection = (MockJMSConnection) context.getConnection();
    connection.addConnectionListener(new MockJMSDefaultConnectionListener() {

        @Override
        public void onMessageSend(MockJMSSession session, Message message) throws JMSException {
            throw new IllegalStateException("Send Failed");
        }
    });

    try {
        producer.send(context.createTemporaryQueue(), UUID.randomUUID());
        fail("Should have thrown an exception");
    } catch (IllegalStateRuntimeException isre) {}
}
 

import javax.jms.JMSProducer; //导入方法依赖的package包/类
@Test
public void testRuntimeExceptionFromSendStringBody() throws JMSException {
    JMSProducer producer = context.createProducer();

    MockJMSConnection connection = (MockJMSConnection) context.getConnection();
    connection.addConnectionListener(new MockJMSDefaultConnectionListener() {

        @Override
        public void onMessageSend(MockJMSSession session, Message message) throws JMSException {
            throw new IllegalStateException("Send Failed");
        }
    });

    try {
        producer.send(context.createTemporaryQueue(), "test");
        fail("Should have thrown an exception");
    } catch (IllegalStateRuntimeException isre) {}
}
 

import javax.jms.JMSProducer; //导入方法依赖的package包/类
@Test
public void testSendNullMessageThrowsMFRE() throws JMSException {
    JMSProducer producer = context.createProducer();

    try {
        producer.send(JMS_DESTINATION, (Message) null);
        fail("Should throw a MessageFormatRuntimeException");
    } catch (MessageFormatRuntimeException mfre) {
    } catch (Exception e) {
        fail("Should throw a MessageFormatRuntimeException");
    }
}
 

import javax.jms.JMSProducer; //导入方法依赖的package包/类
public void doTestSendAppliesDeliveryModeWithMessageBody(Class<?> bodyType) throws JMSException {
    JMSProducer producer = context.createProducer();

    final AtomicBoolean nonPersistentMessage = new AtomicBoolean();
    final AtomicBoolean persistentMessage = new AtomicBoolean();

    MockJMSConnection connection = (MockJMSConnection) context.getConnection();
    connection.addConnectionListener(new MockJMSDefaultConnectionListener() {

        @Override
        public void onMessageSend(MockJMSSession session, Message message) throws JMSException {
            if (!persistentMessage.get()) {
                assertEquals(DeliveryMode.PERSISTENT, message.getJMSDeliveryMode());
                persistentMessage.set(true);
            } else {
                assertEquals(DeliveryMode.NON_PERSISTENT, message.getJMSDeliveryMode());
                nonPersistentMessage.set(true);
            }
        }
    });

    producer.setDeliveryMode(DeliveryMode.PERSISTENT);
    producer.send(JMS_DESTINATION, "text");

    producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
    producer.send(JMS_DESTINATION, "text");

    assertTrue(persistentMessage.get());
    assertTrue(nonPersistentMessage.get());
}
 

import javax.jms.JMSProducer; //导入方法依赖的package包/类
private void doTestSendAppliesPriorityWithMessageBody(Class<?> bodyType) throws JMSException {
    JMSProducer producer = context.createProducer();

    final AtomicBoolean lowPriority = new AtomicBoolean();
    final AtomicBoolean highPriority = new AtomicBoolean();

    MockJMSConnection connection = (MockJMSConnection) context.getConnection();
    connection.addConnectionListener(new MockJMSDefaultConnectionListener() {

        @Override
        public void onMessageSend(MockJMSSession session, Message message) throws JMSException {
            if (!lowPriority.get()) {
                assertEquals(0, message.getJMSPriority());
                lowPriority.set(true);
            } else {
                assertEquals(7, message.getJMSPriority());
                highPriority.set(true);
            }
        }
    });

    producer.setPriority(0);
    producer.send(JMS_DESTINATION, "text");

    producer.setPriority(7);
    producer.send(JMS_DESTINATION, "text");

    assertTrue(lowPriority.get());
    assertTrue(highPriority.get());
}
 

import javax.jms.JMSProducer; //导入方法依赖的package包/类
private void doTestSendAppliesTimeToLiveWithMessageBody(Class<?> bodyType) throws JMSException {
    JMSProducer producer = context.createProducer();

    final AtomicBoolean nonDefaultTTL = new AtomicBoolean();
    final AtomicBoolean defaultTTL = new AtomicBoolean();

    MockJMSConnection connection = (MockJMSConnection) context.getConnection();
    connection.addConnectionListener(new MockJMSDefaultConnectionListener() {

        @Override
        public void onMessageSend(MockJMSSession session, Message message) throws JMSException {
            if (!nonDefaultTTL.get()) {
                assertTrue(message.getJMSExpiration() > 0);
                nonDefaultTTL.set(true);
            } else {
                assertTrue(message.getJMSExpiration() == 0);
                defaultTTL.set(true);
            }
        }
    });

    producer.setTimeToLive(2000);
    producer.send(JMS_DESTINATION, "text");

    producer.setTimeToLive(Message.DEFAULT_TIME_TO_LIVE);
    producer.send(JMS_DESTINATION, "text");

    assertTrue(nonDefaultTTL.get());
    assertTrue(defaultTTL.get());
}
 

import javax.jms.JMSProducer; //导入方法依赖的package包/类
@Test
public void testBytesBodyIsApplied() throws JMSException {
    JMSProducer producer = context.createProducer();

    final byte[] bodyValue = new byte[] { 0, 1, 2, 3, 4 };
    final AtomicBoolean bodyValidated = new AtomicBoolean();

    MockJMSConnection connection = (MockJMSConnection) context.getConnection();
    connection.addConnectionListener(new MockJMSDefaultConnectionListener() {

        @Override
        public void onMessageSend(MockJMSSession session, Message message) throws JMSException {
            byte[] payload = message.getBody(byte[].class);
            assertNotNull(payload);
            assertEquals(bodyValue.length, payload.length);

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

            bodyValidated.set(true);
        }
    });

    producer.send(JMS_DESTINATION, bodyValue);
    assertTrue(bodyValidated.get());
}
 

import javax.jms.JMSProducer; //导入方法依赖的package包/类
@Test
@RunAsClient
public void testListener() throws JMSException, NamingException, InterruptedException {
	final Properties env = new Properties();
	env.put(INITIAL_CONTEXT_FACTORY, "org.jboss.naming.remote.client.InitialContextFactory");
	env.put(PROVIDER_URL, "http-remoting://127.0.0.1:8080");

	Context namingContext = new InitialContext(env);

	ConnectionFactory connectionFactory = (ConnectionFactory) namingContext.lookup(CONNECTION_FACTORY);
	logger.info("Got ConnectionFactory " + CONNECTION_FACTORY);

	Destination destination = (Destination) namingContext.lookup(REMOTE_QUEUE_LOOKUP);
	logger.info("Got JMS Endpoint " + REMOTE_QUEUE_LOOKUP);

	String question = "how many components in your family?";
	String response = "they are four";

	// Create the JMS context
	JMSContext context = connectionFactory.createContext(USER_NAME, USER_PASSWORD);
	Questionary questionary = new Questionary();
	questionary.setQuestion(question);
	questionary.setResponse(response);
	assertFalse("questionary is not approved", questionary.isApproved());
	JMSProducer producer = context.createProducer();
	producer.send(destination, questionary);

	JMSConsumer consumer = context.createConsumer(destination);
	MessageQueueListener messageQueueListener = new MessageQueueListener();
	consumer.setMessageListener(messageQueueListener);
	sleep(100);
	questionary = messageQueueListener.getQuestionary();
	assertEquals("the question is: ", question, questionary.getQuestion());
	assertEquals("the response is: ", response, questionary.getResponse());
	assertTrue("the message is approved: ", questionary.isApproved());
}