Table of Contents

Introduction

This document article describes the implementation required for sending messages to a Java Message Queue Service queuewhich:

to send sends and receive receives messages,
to add adds an order to a JS7 workflow as an JS7 JOC by a JS7 - REST Web Service API call with a JSON body extracted from a message.

A separate implementation is used to send the API call - JS7 libraries are not needed for the example.

The Apache Active MQ server The following Message Queue Service is used in this example: https://activemq.apache.org/.

Mode of Operation

The implementation enables includes the following steps:

Creation creation of a message producer to send messages to a Message Queue server (MQ server).Service,
creation Creation of a message consumer to receive messages from an MQ server.a Message Queue Service,
using the message as part of a JS7 REST Web Service API callSending the message to a JS7 JOC API.

The message has is assumed to be a JSON snippet to be which is processed by the desired JS7 JOC REST Web Service API. This snippet must be valid JSON and compliant with the JOC APIrequests explained in the Technical Documentation of the REST Web Service API article.

Most of the implementation work is done with the standard JMS implementation of Java. The only class from the Active MQ implementation is the ActiveMQConnectionFactory class. It shouldn´t be too complex to change the implementation to the ConnectionFactory of your desired message queue servicepreferred Message Queue Service.

Download

A zip file of this example as a complete maven project implementation is available for download: js7-jms-example-js7-project.zip.

Prerequisites

A running Message Queue server Service (The example uses Apache the example makes use of Active MQ)
A running JS7 Controller, Agent and JOC Cockpit.
Maven (required only needed if you users want to build the example as a maven Maven project)

The `MessageProducer`

This example describes how to build establish a connection to an MQ server a Message Queue Service and send a message to a queue on this server.

Create create a connection.,Create
create a session.,
Create create a destination.,Create
create a producer.,
Send send a message with the producer.,
Close close the connection.

...

Methods

The steps are separated into different methods to make the implementation more readable as well as reusable.

...

`write(String`

...

`text)`

This method instantiates a ConnectionFactory object with an ActiveMQConnectionFactory object and creates a Connection object through the factory method createConnection().

The ActiveMQConnectionFactory object has to be instantiated with the URL of the MQ server.

The method is called with the message to be sent to the server. The message is a String object. The method instantiates a Message object with the text to be sent.

Code Block

language	java
title	createConnectionwrite(String urltext)
linenumbers	true
collapse	true

    public Connectionvoid createConnectionwrite(String uri)text, String queueName, long ttl) throws Exception {
    ConnectionFactory factory    Connection connection = new ActiveMQConnectionFactory(uri)null;
        ConnectionSession connectionsession = null;
        try {
            ConnectionFactory connectionfactory = factory.createConnection(new ActiveMQConnectionFactory(uri);
    } catch (JMSException e) {
    connection = factory.createConnection();
    LOGGER.error("JMSException occurred while trying to connect: " , e        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    }
        Destination destination return connection;
}

createSession(Connection connection)

The method is called with an already instantiated Connection object and initiates a Session object through the Connection objects createSession(boolean transacted, int acknowledgeMode) method.

Code Block

language	java
title	createSession(Connection connection)
linenumbers	true
collapse	true

private Session createSession(Connection connection){
    Session session = null;
    try {
        session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    } catch (JMSException e) {
= session.createQueue(queueName);
            MessageProducer producer = session.createProducer(destination);
            // 5 sec time to live for the producer for this showcase
            producer.setTimeToLive(ttl);
            Message message = null;
            if(text != null){
         LOGGER.error("JMSException occurred while trying to create Session: "message , e= session.createTextMessage(text);
    }
      return session;
}

`createDestination(Session session, String queueName)`

This method creates a Destination object. It is called with an active Session object and the name of the queue to write to. The Destination object is initiated through the createQueue(String name) method of the Session object.

Code Block

language	java
title	createDestination(Session session)
linenumbers	true
collapse	true

public Destination createDestination(Session session, String queueName){
    Destination destination = null } else{
                message = session.createTextMessage(TEXT);
    try {        }
        destination   = sessionproducer.createQueuesend(queueNamemessage);
        } catch (JMSExceptionThrowable e) {
            LOGGER.error("JMSException occurred while trying to createwrite Message to Destination: " ,);
            throw e);
        } finally {
    return destination;
}

`createMessageProducer(Session session, Destination destination)`

This method is called with an already active Session object as well as an instantiated Destination object. It instantiates a MessageProducer object with the given session and destination.

Code Block

language	java
title	createProducer(Session session, Destination destination)
linenumbers	true
collapse	true

private MessageProducer createMessageProducer(Session session, Destination destination)        if(session != null) {
    MessageProducer producer = null;
    try     try {
            producer =        session.createProducerclose(destination);
                } catch (JMSException e) {
                    LOGGER.errorwarn("JMSException occurred while trying to close createthe MessageProducersession: " , e);
                }
            }
           return producer;
}

`write(String text, MessageProducer producer)`

The method is called with the message to send to the server and the MessageProducer object to use for publishing. The message is a String object. The method instantiates a Message object with the text to send.

Code Block

language	java
title	write(String text)
linenumbers	true
collapse	true

public void write(String text, MessageProducer producer) if (connection != null) {
    Message message = null;
     try {
   try {
    if(text != null){
            message = sessionconnection.createTextMessageclose(text);
         } else{
      } catch (JMSException e) {
  message = session.createTextMessage(DEFAULT_TEXT);
        }
        producerLOGGER.send(message);
    } catch (JMSException e) {warn("JMSException occurred while trying to close the connection: ", e);
        LOGGER.error("JMSException occurred while trying to write Message to Destination: " , e);
       }
            }
        }
    }

`close()`

The `SOSProducer` class

The code example below shows the complete class. The code creates a TEXT message consisting of the body for a JS7 /orders/add API requestThis method makes sure that the connection used will be closed after a message has been sent.

Code Block

language	java
title	close()SOSProducer.java
linenumbers	true
collapse	true

private void close(Connection connection){
    if (connection != null) {
        try {
            connection.close();
        } catch (JMSException e) {
            LOGGER.error("JMSException occurred while trying to close the connection: " , e);
        }
    }
}

The `SOSProducer` class

The code example below slightly differs from the examples above. In the class below the write(String text) method already uses the other methods for instantiation, therefore it needs less parameters and it closes the connection itself.

The text in the example below consists of a JobScheduler add_order XML, which can later be used to send to a JobScheduler.

Code Block

language	java
title	SOSProducer.java
linenumbers	true
collapse	true

package com.sos.jms.producer;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Session;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.log4j.Logger;


public class SOSProducer {

    private static final Logger LOGGER = Logger.getLogger(SOSProducer.class);
    private static final String QUEUE_NAME = "test_queue";
    private static final String TEXT = "{\"controllerId\":\"testsuite\",\"orders\":[{\"workflowPath\":\"/JS7Demo/01_HelloWorld/jdHelloWorld\",\"scheduledFor\":\"now\"}],\"auditLog\":{}}";
    private String uri;
    
    public SOSProducer(String uri) {package com.sos.jms.producer;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageProducer;
import javax.jms.Session;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.log4j.Logger;


public class SOSProducer {

    private static final Logger LOGGER = Logger.getLogger(SOSProducer.class);
    private static final String TEXT = "{\"controllerId\":\"testsuite\",\"orders\":[{\"workflowPath\":\"/JS7Demo/01_HelloWorld/jdHelloWorld\",\"scheduledFor\":\"now\"}],\"auditLog\":{}}";
    private String uri;
    
    public SOSProducer(String uri) {
        this.uri = uri;
    }
    
    public void write(String text, String queueName) throws Exception {
        write(text, queueName, 5000L);
    }
    
    public void write(String text, String queueName, long ttl) throws Exception {
        Connection connection = null;
        Session session = null;
        try {
            ConnectionFactory factory = new ActiveMQConnectionFactory(uri);
            connection = factory.createConnection();
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        this.uri = uri;
  Destination destination }
    = session.createQueue(queueName);
    private Connection createConnection(){
      MessageProducer producer ConnectionFactory factory = new ActiveMQConnectionFactory(urisession.createProducer(destination);
        Connection  connection = null;
// 5 sec time to live for the tryproducer {
for this showcase
          connection = factoryproducer.createConnectionsetTimeToLive(ttl);
         }   catchMessage (JMSExceptionmessage e)= {null;
            LOGGER.error("JMSException occurred while trying to connect: " , e);
if(text != null){
              }
  message = session.createTextMessage(text);
    return connection;
    }
   } else{
    private Session createSession(Connection connection){
        Session sessionmessage = nullsession.createTextMessage(TEXT);
        try  {
  }
          session = connectionproducer.createSession(false, Session.AUTO_ACKNOWLEDGEsend(message);
        } catch (JMSExceptionThrowable e) {
            LOGGER.error("JMSException occurred while trying to createwrite Session:Message "to ,Destination: e");
        }
    throw e;
   return session;
    } finally {
    
      private Destination createDestination(Session session)if(session != null) {
        Destination destination = null;
     try {
  try    {
            destination = session.createQueueclose(QUEUE_NAME);
                } catch (JMSException e) {
                    LOGGER.errorwarn("JMSException occurred while trying to close createthe Destinationsession: " , e);
        }
        }
 return destination;
           }
     
      private MessageProducerif createMessageProducer(Sessionconnection session, Destination destination)!= null) {
        MessageProducer    producer = null;
  try {
     try {
            producer = sessionconnection.createProducerclose(destination);
                } catch (JMSException e) {
                    LOGGER.errorwarn("JMSException occurred while trying to close createthe MessageProducerconnection: " , e);
        }        }
          return  producer;}
        }
    
    public void write(String text){
        Connection connection = createConnection();
        Session session = createSession(connection);
        Destination destination = createDestination(session);}
    
}

The `MessageConsumer`

This section describes how to establish a connection to a Message Queue Service and receive a message from a queue. Furthermore it shows how to connect to a JOC Cockpit instance via HTTP to send an API request:

create a connection,
create a session,
create a destination.
create a consumer,
receive a message with the consumer,
close the (MQ) connection,
login to a JOC Cockpit instance via a HTTP REST API call,
send a ./orders/add API request to a JOC Cockpit instance,
close the connection.

Methods

`read()`

The method instantiates a MessageConsumer object to receive a message from the Message Queue Service. It extracts the value from the Message object as a string representation via the Message objects getText() method.

Code Block

language	java
title	read()
linenumbers	true
collapse	true

    public String read(String queueName) throws Exception {
        TextMessage message = null;
        String textMessage = null;
        Connection connection = null;
        Session session = null;
        try {
            ConnectionFactory factory = new ActiveMQConnectionFactory(uri);
            connection = factory.createConnection();
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            Destination destination = session.createQueue(queueName);
            connection.start();
            MessageConsumer consumer = session.createConsumer(destination);
            while (true) {
                Message receivedMessage = consumer.receive(1);
                if (receivedMessage != null) {
                    if (receivedMessage instanceof TextMessage) {
                        message = (TextMessage) receivedMessage;
                        textMessage = message.getText();
                        LOGGER.info("Reading message: " + textMessage);
                        break;
                    } else {
                        break;
                    }
                }
            }
        } catch (Throwable e) {
            LOGGER.error("JMSException occurred while trying to read from Destination: ");
            throw e;
        } finally {
            if(session != null) {
                try {
                    session.close();
                } catch (JMSException e) {
                    LOGGER.warn("JMSException occurred while trying to close the session: ", e);
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (JMSException e) {
                    LOGGER.warn("JMSException occurred while trying to close the connection: ", e);
                }
            }
         }
        return textMessage;
    }

The `SOSConsumer` class

The code example below shows the complete class.

Code Block

language	java
title	SOSConsumer
linenumbers	true
collapse	true

package com.sos.jms.consumer;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SOSConsumer {

    private static final Logger LOGGER = LoggerFactory.getLogger(SOSConsumer.class);
    private String uri;
    
    public SOSConsumer (String uri) {
        this.uri = uri;
    }
    
    public String read(String queueName) throws Exception {
        TextMessage message = null;
        String textMessage = null;
        Connection connection = null;
        Session session = null;
        try {
            ConnectionFactory factory = new ActiveMQConnectionFactory(uri);
            connection = factory.createConnection();
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            Destination destination = session.createQueue(queueName);
            connection.start();
            MessageConsumer consumer = session.createConsumer(destination);
            while (true) {
                Message receivedMessage = consumer.receive(1);
                if (receivedMessage != null) {
                    if (receivedMessage instanceof TextMessage) {
                        message = (TextMessage) receivedMessage;
                        textMessage = message.getText();
                        LOGGER.info("Reading message: " + textMessage);
                        break;
                    } else {
                        break;
                    }
                }
            }
        } catch (Throwable e) {
            LOGGER.error("JMSException occurred while trying to read from Destination: ");
            throw e;
        } finally {
            if(session != null) {
                try {
                    session.close();
                } catch (JMSException e) {
                    LOGGER.warn("JMSException occurred while trying to close the session: ", e);
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (JMSException e) {
                    LOGGER.warn("JMSException occurred while trying to close the connection: ", e);
                }
            }
         }
        return textMessage;
    }

}

Java Class with a `main(String[] args)` method (example `JmsExecute.java`)

The Java class makes use of the SOSProducer to create a message and send it to the message queue. It then uses the SOSConsumer class to read the message from the queue. In addition, it creates an HTTP connection to a JS7 JOC Cockpit instance to call the /orders/add API with the JSON body from the message received.

The example class uses the SOSRestApiClient to create the HTTP connection. The SOSRestApiClient is based on the org.apache.httpcomponents::httpclient. Users can use their own HTTP client implementation.

Code Block

language	java
title	JmsExecute.java
collapse	true

package com.sos.jms;

import java.io.IOException;
import java.io.StringReader;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Base64;
import java.util.Properties;

import javax.json.Json;
import javax.json.JsonObject;
import javax.json.JsonReader;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.sos.commons.httpclient.SOSRestApiClient;
import com.sos.jms.consumer.SOSConsumer;
import com.sos.jms.producer.SOSProducer;

public class JmsExecute {

    private static final String DEFAULT_JMS_URI = "tcp://activemq-5-15:61616";
    private static final String DEFAULT_JOC_API_URL = "http://centostest_primary.sos:7446/joc/api/";
    private static final String DEFAULT_JOC_API_REQUEST_BODY = "{\"controllerId\":\"testsuite\",\"orders\""
            + ":[{\"workflowPath\":\"/JS7Demo/01_HelloWorld/jdHelloWorld\",\"scheduledFor\":\"now\"}],\"auditLog\":{}}";
    private static final String DEFAULT_USERNAME = "root";
    private static final String DEFAULT_PWD = "root";
    private static final String DEFAULT_QUEUE_NAME = "test_queue";
    private static final String API_ADD_ORDER = "orders/add";
    private static final String API_LOGIN = "authentication/login";
    private static final String API_LOGOUT = "authentication/logout";
    private static final String ACCESS_TOKEN_HEADER = "X-Access-Token";
    private static final String APPLICATION_JSON = "application/json";
    private static final String CONTENT_TYPE = "Content-Type";
    private static final Logger LOGGER = LoggerFactory.getLogger(JmsExecute.class);
    private static String jmsServerUri = null;
    private static String jocApiUri = null;
    private static String controllerId = null;
    private static String workflowPath = null;
    private static String requestBody = null;
    private static String username = null;
    private static String pwd = null;
    private static String queueName = null;
    private static Long queueTtl = null;

    public static void main(String[] args) throws URISyntaxException {
        MessageProducerSOSRestApiClient producerclient = createMessageProducer(session, destination)null;
        try Message{
    message = null;
      URL classUrl try {
= JmsExecute.class.getProtectionDomain().getCodeSource().getLocation();
            Path if(textclassPath != null){Paths.get(classUrl.toURI());
            String    messagefilename = session.createTextMessage(textclassPath.getFileName().toString().replace(".jar", ".config");
            } else{
LOGGER.info(classPath.getParent().resolve(filename).toString());
            readPropertiesFile(classPath.getParent().resolve(filename));
           message = session.createTextMessage(TEXT);if ("produce".equals(args[0])) {
            }
    SOSProducer producer =      producer.send(messagenew SOSProducer(jmsServerUri);
        } catch (JMSException e) {
            LOGGER.errorinfo("JMSExceptionmessage occurredsend while trying to write Message to Destination: " , equeue:");
        } finally {
            if (connection != null) {
    LOGGER.info(requestBody);
            try {
   producer.write(requestBody, queueName, queueTtl);
            } else if connection.close();
("consume".equals(args[0])) {
                SOSConsumer consumer }= catchnew SOSConsumer(JMSException e) {jmsServerUri);
                String consumedMessage   LOGGER.error("JMSException occurred while trying to close the connection: " , e);
= null;
                consumedMessage    }= consumer.read(queueName);
            }
    LOGGER.info("message received   }from queue:");
    }
    
}

The `MessageConsumer`

This section describes how to build a connection to a MQ server and receive a message from a queue on this server. Furthermore it describes how to build a TCP socket connection to send the received message to a JobScheduler.

Create a connection.
Create a session.
Create a destination.
Create a consumer.
Receive a message with the consumer.
Close the (MQ) connection.
Open a TCP connection to a JobScheduler instance.
Send the Message to the JobScheduler
Close the (TCP) connection.

This section shows examples for the last 5 steps as the first four are similar to the examples already shown above for the instantiation of the MessageProducer.

The Methods

`createMessageConsumer(Session session, Destination destination)`

This method is called with an already active Session object as well as an instantiated Destination object. It instantiates a MessageConsumer object with the given session and destination.

Code Block

language	java
title	createMessageConsumer(Session session, Destination destination)
linenumbers	true
collapse	true

private MessageConsumer createMessageConsumer(Session session, Destination destination) {
    MessageConsumer consumer = null;
    try {
            LOGGER.info(consumedMessage);
                if (consumedMessage != null) {
                    client = setupHttpClient(username, pwd);
                    URI jocUri = URI.create(jocApiUri);
                    LOGGER.info("send login to: " + jocUri.resolve(API_LOGIN).toString());
                    String consumerresponse = session.createConsumer(destinationclient.postRestService(jocUri.resolve(API_LOGIN), null);
    } catch (JMSException e) {
        LOGGER.error("JMSException occurred while trying to create MessageConsumer: ", e);
    }
    return consumer;
}

`read(MessageConsumer consumer)`

The method is called with an already instantiated MessageConsumer object to receive a message from the MQ server. It extracts the value from the Message object as a string representation via the Message objects getText() method.

Code Block

language	java
title	read()
linenumbers	true
collapse	true

private String read(MessageConsumer consumer) {
    TextMessage message = null;
    String textMessage = null;
    try {
 LOGGER.info("HTTP status code: " + client.statusCode());
                    if (client.statusCode() == 200) {
          while (true) {
            MessageJsonReader receivedMessagejsonReader = consumer.receive(1)null;
            if  (receivedMessage != null) {
       String accessToken = null;
      if (receivedMessage instanceof TextMessage) {
              try {
     message = (TextMessage) receivedMessage;
                    textMessagejsonReader = message.getText()Json.createReader(new StringReader(response));
                    LOGGER.info("Reading message: " + textMessage);
    JsonObject json = jsonReader.readObject();
             break;
               accessToken } else {= json.getString("accessToken", "");
                    break;
    } catch (Exception e) {
        }
            }
        }
throw new Exception("Could not } catch (JMSExceptiondetermine accessToken.", e);
 {
         LOGGER.error("JMSException occurred while trying to read from Destination: ", e);
              } finally {
    return textMessage;
}

Note
Don´t forget to clean up (call `close()`) after the message has been received.

`receiveFromQueue()`

The receiveFromQueue() method uses the methods described above to connect to a host running a JobScheduler instance, read from a message queue, send the received message to the JobScheduler instance and close the session to the JobScheduler instance.

Code Block

language	java
title	receiveFromQueue()
linenumbers	true
collapse	true

public String receiveFromQueue() {
    String message = null;
    try {
                        jsonReader.close();
                        }
                        connect(client.addHeader(ACCESS_TOKEN_HEADER, accessToken);
        message = read();
        sendRequest(message);
        disconnect(client.addHeader(CONTENT_TYPE, APPLICATION_JSON);
    } catch (Exception e) {
        LOGGER.error("Error occured while publishing to the JobScheduler instance host:" + HOST + ", port: LOGGER.info("REQUEST: " + PORT, eAPI_ADD_ORDER);
         }
    return message;
}

The `SOSConsumer` class

The code example below slightly differs from the examples above. In the class below the read() method already uses the other method for instantiation, therefore it needs less parameters and it closes the connection itself.

Code Block

language	java
title	SOSConsumer
linenumbers	true
collapse	true

package com.sos.jms.consumer;

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SOSConsumer {

    private static final Logger LOGGER = LoggerFactory.getLogger(SOSConsumer.class);
    private static final String DEFAULT_QUEUE_NAME = "test_queue"          LOGGER.info("PARAMS: " + consumedMessage);
                        String apiUrl = null;
    private String uri;
    
    public SOSConsumer (String uri) {
        this.uri = uri;
    }if (!API_ADD_ORDER.toLowerCase().startsWith(jocApiUri)) {
    
    private Connection createConnection() {
        ConnectionFactory factory = new ActiveMQConnectionFactory(uri);
     apiUrl = jocApiUri Connection connection = null+ API_ADD_ORDER;
        try  {
            connection = factory.createConnection(); }
        } catch (JMSException e) {
            LOGGER.errorinfo("JMSExceptionresolvedUri: occurred" while trying to connect: ", e+ jocUri.resolve(apiUrl).toString());
        }
        return connection;
    }

   response private Session createSession(Connection connection) {= client.postRestService(jocUri.resolve(apiUrl), consumedMessage);
        Session session = null;
        try {
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        } catch (JMSException e) {LOGGER.info("HTTP status code: " + client.statusCode());
            LOGGER.error("JMSException occurred while trying to create Session: ", e);
    response =   }client.postRestService(jocUri.resolve(API_LOGOUT), null);
        return session;
    }

    private Destination createDestination(Session session) {
   LOGGER.info("HTTP status code: " + return thisclient.createDestination(session, DEFAULT_QUEUE_NAMEstatusCode());
    }

    private Destination createDestination(Session session, String queueName) {
      }
  Destination destination = null;
        try {
  }
          destination = session.createQueue(queueName); }
        } catch (JMSExceptionThrowable e) {
            LOGGERe.error("JMSException occurred while trying to create Destination: ", eprintStackTrace();
        }
        return destination;
    }

System.exit(1);
    private MessageConsumer createMessageConsumer(Session session, Destination} destination)finally {
            MessageConsumerif consumer(client != null;) {
        try {
          client.closeHttpClient();
          consumer = session.createConsumer(destination); }
        }
 catch (JMSException e) {}

    private static SOSRestApiClient setupHttpClient(String username, String password) {
    LOGGER.error("JMSException occurred while trying toSOSRestApiClient createclient MessageConsumer:= ",new eSOSRestApiClient();
        }
String basicAuth = Base64.getMimeEncoder().encodeToString((username + ":"   return consumer+ password).getBytes());
    }

    private String read() {client.setBasicAuthorization(basicAuth);
        TextMessagereturn messageclient;
 = null;
  }

    private static String textMessage = null;

        Connection connection = createConnectioncleanupValue(String value) {
        value = value.trim();
        if   try (value.startsWith("\"")) {
            Sessionvalue session = createSessionvalue.substring(connection1);
            Destination destination = createDestination(session);}
            connection.start();if (value.endsWith("\"")) {
            MessageConsumer consumervalue = createMessageConsumervalue.substring(session, destination);
0, value.length() - 1);
        }
       while (true) {return value;
    }

    private static void readPropertiesFile(Path path) {
   Message receivedMessage = consumer.receive(1);
  Properties props = new Properties();
        try {
 if (receivedMessage != null) {
       props.load(Files.newInputStream(path));
            jmsServerUri if= (receivedMessage instanceof TextMessage) {
cleanupValue(props.getProperty("jms_url"));
            LOGGER.info("cfg jms_url: " + jmsServerUri);
            messagequeueName = (TextMessage) receivedMessagecleanupValue(props.getProperty("jms_queue_name"));
            LOGGER.info("cfg jms_queue_name: " + queueName);
           textMessage queueTtl = message.getText();
           Long.parseLong(cleanupValue(props.getProperty("jms_queue_name"))); 
             LOGGER.info("Reading messagecfg jms_queue_ttl: " + textMessagequeueTtl.toString());
            jocApiUri            break= cleanupValue(props.getProperty("joc_api_url"));
            LOGGER.info("cfg joc_api_url: " + jocApiUri);
     } else {
     controllerId = cleanupValue(props.getProperty("controller_id"));
            LOGGER.info("cfg controller_id: " +  breakcontrollerId);
            workflowPath = cleanupValue(props.getProperty("workflow_path"));
      }
      LOGGER.info("cfg workflow_path: " + workflowPath);
      }
      username = cleanupValue(props.getProperty("username"));
    }
        }pwd catch= (JMSException e) {cleanupValue(props.getProperty("password"));
            LOGGER.error("JMSException occurred while trying to read from Destination: ", e);requestBody = "{\"controllerId\":\"" + controllerId + "\",\"orders\":[{\"workflowPath\":\"" + workflowPath
        } finally {
            if (connection != null) {+ "\",\"scheduledFor\":\"now\"}],\"auditLog\":{}}";
        } catch (IOException      try e) {
            LOGGER.warn("could not read properties file, use defaults  connectioninstead.close(");
            jmsServerUri    } catch (JMSException e) {= DEFAULT_JMS_URI;
            queueName = DEFAULT_QUEUE_NAME;
      LOGGER.error("JMSException occurred while trying to close the connection: "jocApiUri , e)= DEFAULT_JOC_API_URL;
            requestBody = DEFAULT_JOC_API_REQUEST_BODY;
  }
          username = }DEFAULT_USERNAME;
         }
   pwd = DEFAULT_PWD;
   return textMessage;
    }

    publicqueueTtl String receiveFromQueue() {= 5000L; 
        return read();}
    }

}

...

Maven Configuration Example

This example shows the dependency needed dependencies required to build the example above as a Maven project.

Code Block

language	xml
title	Maven Configuration
collapse	true

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>


	<groupId>com.sos-berlin</groupId>
	<artifactId>activeMQ-example</artifactId>
	<version>0.0.1-SNAPSHOT</version>


	<dependencies>
		<dependency>
			<groupId>org.apache.activemq</groupId>
			<artifactId>activemq-all</artifactId>
			<version>5.15.0</version>
		</dependency>
	</dependencies>
</project>

...

Space shortcuts

Page tree

Versions Compared

Old Version 4

New Version Current

Key

Introduction

Mode of Operation

Download

Prerequisites

The `MessageProducer`

Methods

`write(String`

`text)`

createSession(Connection connection)

`createDestination(Session session, String queueName)`

`createMessageProducer(Session session, Destination destination)`

`write(String text, MessageProducer producer)`

`close()`

The `SOSProducer` class

The `SOSProducer` class

The `MessageConsumer`

Methods

`read()`

The `SOSConsumer` class

Java Class with a `main(String[] args)` method (example `JmsExecute.java`)

The `MessageConsumer`

The Methods

`createMessageConsumer(Session session, Destination destination)`

`read(MessageConsumer consumer)`

`receiveFromQueue()`

The `SOSConsumer` class

Maven Configuration Example

Space shortcuts

Page tree

Page History

Versions Compared

Old Version 4

New Version Current

Key

Introduction

Mode of Operation

Download

Prerequisites

The MessageProducer

Methods

write(String

text)

createSession(Connection connection)

createDestination(Session session, String queueName)

createMessageProducer(Session session, Destination destination)

write(String text, MessageProducer producer)

close()

The SOSProducer class

The SOSProducer class

The MessageConsumer

Methods

read()

The SOSConsumer class

Java Class with a main(String[] args) method (example JmsExecute.java)

The MessageConsumer

The Methods

createMessageConsumer(Session session, Destination destination)

read(MessageConsumer consumer)

receiveFromQueue()

The SOSConsumer class

Maven Configuration Example

The `MessageProducer`

`write(String`

`text)`

`createDestination(Session session, String queueName)`

`createMessageProducer(Session session, Destination destination)`

`write(String text, MessageProducer producer)`

`close()`

The `SOSProducer` class

The `SOSProducer` class

The `MessageConsumer`

`read()`

The `SOSConsumer` class

Java Class with a `main(String[] args)` method (example `JmsExecute.java`)

The `MessageConsumer`

`createMessageConsumer(Session session, Destination destination)`

`read(MessageConsumer consumer)`

`receiveFromQueue()`

The `SOSConsumer` class