content: /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.camel.component.sjms.support;
  
  import java.security.SecureRandom;
  
  import jakarta.jms.Connection;
  import jakarta.jms.ConnectionFactory;
  import jakarta.jms.DeliveryMode;
  import jakarta.jms.Destination;
  import jakarta.jms.JMSException;
  import jakarta.jms.Message;
  import jakarta.jms.MessageConsumer;
  import jakarta.jms.MessageListener;
  import jakarta.jms.MessageProducer;
  import jakarta.jms.Session;
  import jakarta.jms.TextMessage;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   *
   */
  public class MyInOutTestConsumer implements MessageListener {
  
      private static final Logger LOG = LoggerFactory.getLogger(MyInOutTestConsumer.class);
      private static int ackMode;
      private static String clientQueueName;
  
      private boolean transacted;
      private MessageProducer producer;
  
      static {
          clientQueueName = "client.messages.MyInOutTestConsumer";
          ackMode = Session.AUTO_ACKNOWLEDGE;
      }
  
      public MyInOutTestConsumer(ConnectionFactory connectionFactory) {
          Connection connection;
          try {
              connection = connectionFactory.createConnection();
              connection.start();
              Session session = connection.createSession(transacted, ackMode);
              Destination adminQueue = session.createQueue(clientQueueName);
  
              //Setup a message producer to send message to the queue the server is consuming from
              producer = session.createProducer(adminQueue);
              producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
  
              //Create a temporary queue that this client will listen for responses on then create a consumer
              //that consumes message from this temporary queue...for a real application a client should reuse
              //the same temp queue for each message to the server...one temp queue per client
              Destination tempDest = session.createTemporaryQueue();
              MessageConsumer responseConsumer = session.createConsumer(tempDest);
  
              //This class will handle the messages to the temp queue as well
              responseConsumer.setMessageListener(this);
  
              //Now create the actual message you want to send
              TextMessage txtMessage = session.createTextMessage();
              txtMessage.setText("MyProtocolMessage");
  
              //Set the reply to field to the temp queue you created above, this is the queue the server
              //will respond to
              txtMessage.setJMSReplyTo(tempDest);
  
              //Set a correlation ID so when you get a response you know which sent message the response is for
              //If there is never more than one outstanding message to the server then the
              //same correlation ID can be used for all the messages...if there is more than one outstanding
              //message to the server you would presumably want to associate the correlation ID with this
              //message somehow...a Map works good
              String correlationId = createRandomString();
              txtMessage.setJMSCorrelationID(correlationId);
              producer.send(txtMessage);
          } catch (JMSException e) {
              //Handle the exception appropriately
          }
      }
  
      private String createRandomString() {
          SecureRandom random = new SecureRandom();
          long randomLong = random.nextLong();
          return Long.toHexString(randomLong);
      }
  
      @Override
      public void onMessage(Message message) {
          String messageText = null;
          try {
              if (message instanceof TextMessage) {
                  TextMessage textMessage = (TextMessage) message;
                  messageText = textMessage.getText();
                  LOG.info("messageText = {}", messageText);
              }
          } catch (JMSException e) {
              //Handle the exception appropriately
          }
      }
  
  }
  