How to use

setText

method

in

javax.jms.TextMessage

@SuppressWarnings("resource")
@Test
public void nonSiProducer_siConsumer_sync_withReturn() throws Exception {
  ActiveMqTestUtils.prepare();
  ConfigurableApplicationContext applicationContext = new ClassPathXmlApplicationContext("Exception-nonSiProducer-siConsumer.xml", ExceptionHandlingSiConsumerTests.class);
  JmsTemplate jmsTemplate = new JmsTemplate(applicationContext.getBean("jmsConnectionFactory", ConnectionFactory.class));
  Destination request = applicationContext.getBean("requestQueueA", Destination.class);
  final Destination reply = applicationContext.getBean("replyQueueA", Destination.class);
  jmsTemplate.send(request, (MessageCreator) session -> {
    TextMessage message = session.createTextMessage();
    message.setText("echoChannel");
    message.setJMSReplyTo(reply);
    return message;
  });
  Message message = jmsTemplate.receive(reply);
  assertNotNull(message);
  applicationContext.close();
}

@SuppressWarnings("resource")
@Test
public void nonSiProducer_siConsumer_sync_withReturnNoException() throws Exception {
  ActiveMqTestUtils.prepare();
  ConfigurableApplicationContext applicationContext = new ClassPathXmlApplicationContext("Exception-nonSiProducer-siConsumer.xml", ExceptionHandlingSiConsumerTests.class);
  JmsTemplate jmsTemplate = new JmsTemplate(applicationContext.getBean("jmsConnectionFactory", ConnectionFactory.class));
  Destination request = applicationContext.getBean("requestQueueB", Destination.class);
  final Destination reply = applicationContext.getBean("replyQueueB", Destination.class);
  jmsTemplate.send(request, (MessageCreator) session -> {
    TextMessage message = session.createTextMessage();
    message.setText("echoWithExceptionChannel");
    message.setJMSReplyTo(reply);
    return message;
  });
  Message message = jmsTemplate.receive(reply);
  assertNotNull(message);
  assertEquals("echoWithException", ((TextMessage) message).getText());
  applicationContext.close();
}

String requestPayload = (String) extractPayload(message);
try {
  TextMessage replyMessage = session.createTextMessage();
  replyMessage.setText(requestPayload);
  replyMessage.setJMSCorrelationID(message.getJMSCorrelationID());
  MessageProducer producer = session.createProducer(replyDestination);
  producer.send(replyMessage);

myConnFactory = new com.sun.messaging.ConnectionFactory();
 Connection myConn = myConnFactory.createConnection();
 //Create a session within the connection.
 Session mySess = myConn.createSession(false, Session.AUTO_ACKNOWLEDGE);
 myQueue = new com.sun.messaging.Queue("world");
 //Create a message producer.
 MessageProducer myMsgProducer = mySess.createProducer(myQueue);
 //Create a message consumer. (Use if going to read from the queue)
 MessageConsumer myMsgConsumer = mySess.createConsumer(myQueue);
 //Start the Connection
 myConn.start();
 //Create and send a message to the queue.
 TextMessage myTextMsg = mySess.createTextMessage();
 myTextMsg.setText("Hello World");
 System.out.println("Sending Message: " + myTextMsg.getText());
 myMsgProducer.send(myTextMsg);
 // The rest of the code is for reading from a queue - optional
 //Receive a message from the queue. 
 Message msg = myMsgConsumer.receive();
 //Retreive the contents of the message.
 if (msg instanceof TextMessage) {
   TextMessage txtMsg = (TextMessage) msg;
   System.out.println("Read Message: " + txtMsg.getText());
 }

 public DirectJMSRemotingClient() throws JMSException {
  factory = new ActiveMQConnectionFactory(brokerURL);
  connection = factory.createConnection();
  connection.start();
  session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
  Destination destination = session.createQueue("queueName");
  producer = session.createProducer(destination);
}

public void sendMessage() throws JMSException {

  TextMessage myTextMsg = session.createTextMessage();

  myTextMsg.setText("Hello World");
  System.out.println("Sending Message: " + myTextMsg.getText());
  producer.send(myTextMsg);
}

public static void main(String[] args) throws Exception {
  DirectJMSRemotingClient client = new DirectJMSRemotingClient();
  client.sendMessage();
}

@Test
public void testClearProperties() throws Exception {
 ((TextMessage) message).setText("something");
 queueProd.send(message);
 TextMessage rm = (TextMessage) queueCons.receive();
 rm.clearProperties();
 ProxyAssertSupport.assertEquals("something", rm.getText());
}

 try {
  ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory("tcp://localhost:61616");
  Connection conn = factory.createConnection(user, password);
  Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
  MessageProducer producer = session.createProducer("test");
  MessageConsumer consumer = session.createConsumer("test");
  consumer.setMessageListener(this); // class that implements MessageListener
  conn.start();
  TextMessage message = new ActiveMQTextMessage();
  message.setText("TestMessage");
  producer.send(message);
} catch (JMSException e) {
  // somethings very wrong
}

TextMessage replyMessage = session.createTextMessage();
replyMessage.setText(requestPayload);
replyMessage.setJMSCorrelationID(message.getJMSMessageID());
MessageProducer producer = session.createProducer(replyTo);
producer.send(replyMessage);

@Test
public void testCreateTextMessageNull() throws Exception {
 conn = createConnection();
 Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
 MessageProducer prod = session.createProducer(queue1);
 prod.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
 TextMessage m = session.createTextMessage();
 m.setText("message one");
 prod.send(m);
 conn.close();
 conn = createConnection();
 session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
 MessageConsumer cons = session.createConsumer(queue1);
 conn.start();
 TextMessage rm = (TextMessage) cons.receive();
 ProxyAssertSupport.assertEquals("message one", rm.getText());
}

@Test(expected = MessageTimeoutException.class)
public void messageCorrelationBasedOnRequestMessageIdOptimized() throws Exception {
  ActiveMqTestUtils.prepare();
  ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("producer-cached-consumers.xml", this.getClass());
  try {
    RequestReplyExchanger gateway = context.getBean("standardMessageIdCopyingConsumerWithOptimization", RequestReplyExchanger.class);
    CachingConnectionFactory connectionFactory = context.getBean(CachingConnectionFactory.class);
    final JmsTemplate jmsTemplate = new JmsTemplate(connectionFactory);
    final Destination requestDestination = context.getBean("siOutQueueOptimizedA", Destination.class);
    final Destination replyDestination = context.getBean("siInQueueOptimizedA", Destination.class);
    new Thread(() -> {
      final Message requestMessage = jmsTemplate.receive(requestDestination);
      jmsTemplate.send(replyDestination, (MessageCreator) session -> {
        TextMessage message = session.createTextMessage();
        message.setText("bar");
        message.setJMSCorrelationID(requestMessage.getJMSMessageID());
        return message;
      });
    }).start();
    gateway.exchange(new GenericMessage<String>("foo"));
  }
  finally {
    context.close();
  }
}

/**
 * @param txt the message to encrypt
 * @throws JMSException    on JMS errors
 * @throws CryptoException on crypto errors
 */
public static void secureMessage(final TextMessage txt) throws JMSException, CryptoException {
  final String cryptedText = MessageCryptoUtil.crypt(txt.getText());
  txt.setText(cryptedText);
  txt.setStringProperty(MessageCryptoUtil.SIGNATURE_HEADER, MessageCryptoUtil.sign(cryptedText));
}

  @Override
  public Message createMessage(Session session) throws JMSException {
    TextMessage message = session.createTextMessage();
    message.setText(encode(event));
    log.debug("  sending log message - text={}", message.getText());
    return message;
  }
});

  @Override
  public void handleMessage(Channel channel, String msg) {
    try {
      TextMessage outMsg = session.createTextMessage();
      outMsg.setText(msg);
      sender.send(outMsg);
    } catch (JMSException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
});

@Test
public void testTextMessage() throws Exception {
 TextMessage m = queueProducerSession.createTextMessage();
 m.setText(myString);
 queueProducer.send(m);
 ProxyAssertSupport.assertEquals(myString, m2.getText());
 m = queueProducerSession.createTextMessage(myString);
 queueProducer.send(m);
 ProxyAssertSupport.assertEquals(myString, m2.getText());
   m2.setText("Should be read-only");
   ProxyAssertSupport.fail();
 } catch (MessageNotWriteableException e) {
 ProxyAssertSupport.assertNull(m2.getText());
 m2.setText("Now it is read-write");

@Test(expected = MessageTimeoutException.class)
public void messageCorrelationBasedOnRequestCorrelationIdNonOptimized() throws Exception {
  ActiveMqTestUtils.prepare();
  ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("producer-cached-consumers.xml", this.getClass());
  try {
    RequestReplyExchanger gateway = context.getBean("correlationPropagatingConsumerWithoutOptimization", RequestReplyExchanger.class);
    CachingConnectionFactory connectionFactory = context.getBean(CachingConnectionFactory.class);
    final JmsTemplate jmsTemplate = new JmsTemplate(connectionFactory);
    final Destination requestDestination = context.getBean("siOutQueueNonOptimizedD", Destination.class);
    final Destination replyDestination = context.getBean("siInQueueNonOptimizedD", Destination.class);
    new Thread(() -> {
      final Message requestMessage = jmsTemplate.receive(requestDestination);
      jmsTemplate.send(replyDestination, (MessageCreator) session -> {
        TextMessage message = session.createTextMessage();
        message.setText("bar");
        message.setJMSCorrelationID(requestMessage.getJMSCorrelationID());
        return message;
      });
    }).start();
    gateway.exchange(new GenericMessage<String>("foo"));
  }
  finally {
    context.close();
  }
}

/**
* Test that the <code>Message.clearProperties()</code> method does not clear the
* value of the Message's body.
*/
public void testClearProperties_2()
{
 try
 {
   TextMessage message = senderSession.createTextMessage();
   message.setText("foo");
   message.clearProperties();
   Assert.assertEquals("sec. 3.5.7 Clearing a message's  property entries does not clear the value of its body.\n",
             "foo",
             message.getText());
 }
 catch (JMSException e)
 {
   fail(e);
 }
}

private void postOneWayBook(Session session, Destination destination, Book book) 
  throws Exception {
  MessageProducer producer = session.createProducer(destination);
  
  TextMessage message = session.createTextMessage();
  message.setText(writeBook(book));
  producer.send(message);
  producer.close();
}

@Test
public void testSendReceiveNullBody() throws Exception {
 conn = cf.createConnection();
 Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
 MessageProducer prod = sess.createProducer(queue);
 conn.start();
 MessageConsumer cons = sess.createConsumer(queue);
 TextMessage msg1 = sess.createTextMessage(null);
 prod.send(msg1);
 TextMessage received1 = (TextMessage) cons.receive(1000);
 Assert.assertNotNull(received1);
 Assert.assertNull(received1.getText());
 TextMessage msg2 = sess.createTextMessage();
 msg2.setText(null);
 prod.send(msg2);
 TextMessage received2 = (TextMessage) cons.receive(1000);
 Assert.assertNotNull(received2);
 Assert.assertNull(received2.getText());
 TextMessage msg3 = sess.createTextMessage();
 prod.send(msg3);
 TextMessage received3 = (TextMessage) cons.receive(1000);
 Assert.assertNotNull(received3);
 Assert.assertNull(received3.getText());
}

@Test
public void messageCorrelationBasedOnRequestCorrelationIdOptimized() throws Exception {
  ActiveMqTestUtils.prepare();
  ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("producer-cached-consumers.xml", this.getClass());
  try {
    RequestReplyExchanger gateway = context.getBean("correlationPropagatingConsumerWithOptimization", RequestReplyExchanger.class);
    CachingConnectionFactory connectionFactory = context.getBean(CachingConnectionFactory.class);
    final JmsTemplate jmsTemplate = new JmsTemplate(connectionFactory);
    final Destination requestDestination = context.getBean("siOutQueueOptimizedC", Destination.class);
    final Destination replyDestination = context.getBean("siInQueueOptimizedC", Destination.class);
    new Thread(() -> {
      final Message requestMessage = jmsTemplate.receive(requestDestination);
      jmsTemplate.send(replyDestination, (MessageCreator) session -> {
        TextMessage message = session.createTextMessage();
        message.setText("bar");
        message.setJMSCorrelationID(requestMessage.getJMSCorrelationID());
        return message;
      });
    }).start();
    org.springframework.messaging.Message<?> siReplyMessage = gateway.exchange(new GenericMessage<String>("foo"));
    assertEquals("bar", siReplyMessage.getPayload());
  }
  finally {
    context.close();
  }
}

/**
 * Processes an incoming command from a console and returning the text to
 * output
 */
public String processCommandText(String line) throws Exception {
  TextMessage request = new ActiveMQTextMessage();
  request.setText(line);
  TextMessage response = new ActiveMQTextMessage();
  getHandler().processCommand(request, response);
  return response.getText();
}