Table of Contents

Introduction

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

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

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

Mode of Operation

The implementation includes the following steps:

create creation of a message producer to send messages to a Message Queue serverService,
create creation of a message consumer to receive messages from a Message Queue serverService,
use using the message as part of a JS7 REST Web Service API call.

The message is assumed to be a JSON snippet that which is processed by the desired JS7 REST Web Service API. This snippet must be valid JSON and compliant with requests explained with 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 Message Queue server Service (The example uses Apache the example makes use of Active MQ)
A JS7 Controller, Agent and JOC Cockpit.
Maven (required only needed if users want to build the example as a 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 in this server.

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

Methods

The steps are divided into different methods to make the implementation more readable and reusable.

...

`write(String`

...

`text)`

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

...

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.

Code Block

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

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

createSession(Connection connection)

...

Code Block

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

private Session createSession(Connection connection){
    Session session = nullDestination destination = session.createQueue(queueName);
    try {
       MessageProducer sessionproducer = connectionsession.createSession(false, Session.AUTO_ACKNOWLEDGEcreateProducer(destination);
            // 5 sec time to live for }the catchproducer (JMSExceptionfor e)this {showcase
        LOGGER.error("JMSException occurred while trying to create Session: " , e)    producer.setTimeToLive(ttl);
            Message message = null;
    }
       return session;
}

`createDestination(Session session, String queueName)`

...

Code Block

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

public Destination createDestination(Session session, String queueName if(text != null){
    Destination destination = null;
    try {
     message = session.createTextMessage(text);
            } else{
                destinationmessage = session.createQueuecreateTextMessage(queueNameTEXT);
            }
 catch (JMSException e) {
        LOGGERproducer.error("JMSException occurred while trying to create Destination: " , e);send(message);
        } catch (Throwable e) {
    }
     return destination;
}

`createMessageProducer(Session session, Destination destination)`

...

Code Block

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

private MessageProducer createMessageProducer(Session session, Destination destination){
    MessageProducer producer = null;
    try {
LOGGER.error("JMSException occurred while trying to write Message to Destination: ");
            throw e;
        } finally {
            producerif(session != session.createProducer(destination);null) {
    } catch (JMSException e)            try {
           LOGGER.error("JMSException occurred while trying to create MessageProducer: " , esession.close();
     }        
   } return producer;
}

`write(String text, MessageProducer producer)`

...

Code Block

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

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

`close()`

...

Code Block

language	java
title	close()
linenumbers	true
collapse	true

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

The `SOSProducer` class

The below code example slightly differs from the above examples . In the below class the write(String text) method already uses the other methods for instantiation, therefore it requres fewer parameters and it closes the connection.The code in the below example includes the body for below shows the complete class. The code creates a TEXT message consisting of the body for a JS7 /orders/add API request.

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) {
        this.uri = uri;
    }
    
    privatepublic Connectionvoid createConnection()write(String text, String queueName) throws Exception {
        ConnectionFactory factory = new ActiveMQConnectionFactory(uriwrite(text, queueName, 5000L);
    }
    Connection
 connection = null;
 public void write(String text, String queueName, long try ttl) throws Exception {
          Connection  connection = factory.createConnection()null;
        }Session catchsession (JMSException e) {= null;
        try {
   LOGGER.error("JMSException occurred while trying to connect: " , e);
 ConnectionFactory factory = new ActiveMQConnectionFactory(uri);
   }
        return connection = factory.createConnection();
    }
    
    privatesession Session= connection.createSession(Connection connection){false, Session.AUTO_ACKNOWLEDGE);
        Session session = null;
 Destination destination   = session.createQueue(queueName);
   try {
        MessageProducer producer  = session = connection.createSession(false, Session.AUTO_ACKNOWLEDGEcreateProducer(destination);
        } catch (JMSException e) {
// 5 sec time to live for the producer for this showcase
   LOGGER.error("JMSException occurred while trying to create Session: " , eproducer.setTimeToLive(ttl);
        }
    Message message =  return sessionnull;
    }
    
    private Destination createDestination(Session sessionif(text != null){
              Destination  destinationmessage = nullsession.createTextMessage(text);
            try} else{
               destination message = session.createQueue(QUEUE_NAMEcreateTextMessage(TEXT);
            }
            producer.send(message);
        } catch (JMSExceptionThrowable e) {
            LOGGER.error("JMSException occurred while trying to createwrite Message to Destination: " , e);
        }
    throw e;
   return destination;
    } finally {
      
    private MessageProducer createMessageProducerif(Session session, Destination!= destinationnull) {
           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;
    }
       
    public voidif write(String text)connection != null) {
        Connection connection = createConnection();
        Session session = createSession(connection);
 try {
       Destination destination = createDestination(session);
        MessageProducer producer = createMessageProducer(session, destination connection.close();
        Message message = null;
     } catch (JMSException trye) {
            if(text != null){
      LOGGER.warn("JMSException occurred while trying to close the connection:   message = session.createTextMessage(text", e);
            } else{
                message = session.createTextMessage(TEXT);}
            }
            producer.send(message);
   }
     }
 catch (JMSException e) {
            LOGGER.error("JMSException occurred while trying to write Message to Destination: " , e);
        } finally {
            if (connection != null)
}

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;
     try {
  String textMessage = null;
        Connection connection      connection.close()= null;
        Session session = null;
     } catch (JMSException e)try {
            ConnectionFactory factory = new ActiveMQConnectionFactory(uri);
     LOGGER.error("JMSException occurred while trying to close the connection: " , e= factory.createConnection();
            session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
            Destination destination  }= session.createQueue(queueName);
            }
connection.start();
         }
   MessageConsumer consumer = session.createConsumer(destination);
        }
    while 
}

The `MessageConsumer`

This section describes how to establish a connection to a MQ server and receive a message from a queue on this server. Furthermore it describes how to establish a TCP socket connection to send the received message to a JOC Cockpit instance:

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 JOC Cockpit instance,
send the Message to a JOC Cockpit instance,
close the TCP connection.

This section shows examples for the last five steps as the first four are similar to the examples explained above for the instantiation of the MessageProducer.

The Methods

`createMessageConsumer(Session session, Destination 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(true) {
                Message receivedMessage = consumer.receive(1);
                if (receivedMessage != null) {
                    if (receivedMessage instanceof TextMessage) {
        consumer = session.createConsumer(destination);
    } catch (JMSException e) {
      message = (TextMessage) receivedMessage;
                        textMessage = LOGGERmessage.error("JMSException occurred while trying to create MessageConsumer: ", egetText();
                        LOGGER.info("Reading message: " + textMessage);
    }
         return consumer;
}

`read(MessageConsumer consumer)`

...

Code Block

language	java
title	read()
linenumbers	true
collapse	true

private String read(MessageConsumer consumer) {
    TextMessage message = nullbreak;
    String textMessage = null;
    try {
        while} (true)else {
                     Message receivedMessage = consumer.receive(1) break;
            if (receivedMessage != null) {
    }
            if (receivedMessage instanceof TextMessage) {}
            }
        message} =catch (TextMessageThrowable e) receivedMessage;{
            LOGGER.error("JMSException occurred while trying to read from  textMessage = message.getText(Destination: ");
            throw e;
       LOGGER.info("Reading message: " + textMessage);
 } finally {
            if(session !=        break;null) {
                } elsetry {
                    breaksession.close();
                }
 catch (JMSException          }e) {
        }
    } catch (JMSException e) {
        LOGGER.errorwarn("JMSException occurred while trying to readclose fromthe Destinationsession: ", e);
                }
      return textMessage;
}

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

`receiveFromQueue()`

...

Code Block

language	java
title	receiveFromQueue()
linenumbers	true
collapse	true

public String receiveFromQueue() {
    String message = null;
    try      }
            if (connection != null) {
                try {
                    connection.close();
                } catch (JMSException e) {
        connect();
        message = read();
        sendRequest(message);
        disconnect(LOGGER.warn("JMSException occurred while trying to close the connection: ", e);
    } catch (Exception e) {
        LOGGER.error("Error occured while publishing to the JOC Cockpit instance host:" + HOST + ", port:" + PORT, e);
}
            }
         }
        return messagetextMessage;
    }

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.
shows the complete class.

Code Blockcode

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";
    private String uri;
    
    public SOSConsumer (String uri) {
        this.uri = uri;
    }
    
    privatepublic ConnectionString createConnectionread(String queueName) throws Exception {
        ConnectionFactoryTextMessage factorymessage = new ActiveMQConnectionFactory(uri)null;
        ConnectionString connectiontextMessage = null;
        tryConnection {
connection = null;
        Session session connection = factory.createConnection()null;
        } catch (JMSException e)try {
            LOGGER.error("JMSException occurred while trying to connect: ", eConnectionFactory factory = new ActiveMQConnectionFactory(uri);
        }
    connection = factory.createConnection();
  return  connection;
    }

    privatesession Session= connection.createSession(Connection connection) {
false, Session.AUTO_ACKNOWLEDGE);
            SessionDestination sessiondestination = nullsession.createQueue(queueName);
        try {
    connection.start();
            MessageConsumer sessionconsumer = connectionsession.createSession(false, Session.AUTO_ACKNOWLEDGEcreateConsumer(destination);
          }  catchwhile (JMSException etrue) {
            LOGGER.error("JMSException occurred while trying toMessage createreceivedMessage Session: ", e= consumer.receive(1);
           }
     if (receivedMessage != returnnull) session;{
    }

    private Destination createDestination(Session session) {
        returnif this.createDestination(session, DEFAULT_QUEUE_NAME);(receivedMessage instanceof TextMessage) {
    }

     private Destination createDestination(Session session, String queueName) {
        Destination destinationmessage = (TextMessage) nullreceivedMessage;
          try  {
            destinationtextMessage = sessionmessage.createQueuegetText(queueName);
        } catch (JMSException e) {
            LOGGER.errorinfo("JMSException occurred while trying to create DestinationReading message: ", + etextMessage);
          }
         return destination;
    }break;

    private MessageConsumer createMessageConsumer(Session  session, Destination destination) {
        MessageConsumer consumer} =else null;{
        try  {
            consumer = session.createConsumer(destination) break;
        } catch (JMSException e) {
        }
    LOGGER.error("JMSException occurred while trying to create MessageConsumer: ", e);
     }
   }
        return consumer;}
    }

    private} Stringcatch read(Throwable e) {
        TextMessage message = null;
        String textMessage = null;

 LOGGER.error("JMSException occurred while trying to read from Destination: ");
          Connection connection =throw createConnection()e;
        } tryfinally {
            Session if(session != createSession(connection);null) {
            Destination destination = createDestination(session);
 try {
          connection.start();
          session.close();
  MessageConsumer consumer = createMessageConsumer(session, destination);
          } catch while(JMSException (truee) {
                 Message receivedMessage = consumerLOGGER.receive(1warn("JMSException occurred while trying to close the session: ", e);
                if}
 (receivedMessage != null) {
        }
            if (receivedMessageconnection instanceof!= TextMessagenull) {
                try {
       message = (TextMessage) receivedMessage;
          connection.close();
              textMessage = message.getText();
     } catch (JMSException e) {
                    LOGGER.infowarn("ReadingJMSException message:occurred "while + textMessage);
                        break;
    trying to close the connection: ", e);
                } else {
                        break;
           }
         }
            return textMessage;
    }
            }
        } catch (JMSException e) {
            LOGGER.error("JMSException occurred while trying to read from Destination: ", e);
        } finally {
            if (connection != null) {
                try {
                    connection.close();}

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\""
                } catch (JMSException e) {+ ":[{\"workflowPath\":\"/JS7Demo/01_HelloWorld/jdHelloWorld\",\"scheduledFor\":\"now\"}],\"auditLog\":{}}";
    private static final String DEFAULT_USERNAME = "root";
    private static final String DEFAULT_PWD  LOGGER.error("JMSException occurred while trying to close the connection: " , e)= "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 return textMessage= "X-Access-Token";
    }

private static final String APPLICATION_JSON = "application/json";
    private static publicfinal String receiveFromQueue() { CONTENT_TYPE = "Content-Type";
    private static final Logger LOGGER return= read(LoggerFactory.getLogger(JmsExecute.class);
    private static String jmsServerUri = }

}

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

The Java class uses the SOSProducer to create a message and send it to the message queue. It uses the SOSConsumer class to read the message from the queue. Additionally it creates an HTTP connection to a JS7 JOC Cockpit to call the /orders/add API with the JSON body from the message received.

...

Code Block

language	java
collapse	true

package com.sos.jms;

import java.io.StringReader;
import java.net.URI;
import java.util.Base64;

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 JMS_URI = "tcp://[MESSAGE_SERVER_HOST]:61616";
    private static final String JOC_API_URL = "http://[JOC_COCKPIT_HOST]:[JOC_COCKPIT_PORT]/joc/api/";
    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 JOC_API_REQUEST_BODY = "{\"controllerId\":\"testsuite\",\"orders\":[{\"workflowPath\":\"/JS7Demo/01_HelloWorld/jdHelloWorld\",\"scheduledFor\":\"now\"}],\"auditLog\":{}}";
    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);

    public static void main(String[] args) {
        if("produce".equals(args[0])) {
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 {
        SOSRestApiClient client = null;
        try {
            URL classUrl = JmsExecute.class.getProtectionDomain().getCodeSource().getLocation();
            Path classPath = Paths.get(classUrl.toURI());
            String filename = classPath.getFileName().toString().replace(".jar", ".config");
            LOGGER.info(classPath.getParent().resolve(filename).toString());
            readPropertiesFile(classPath.getParent().resolve(filename));
            if ("produce".equals(args[0])) {
                SOSProducer producer = new SOSProducer(jmsServerUri);
                LOGGER.info("message send to queue:");
                LOGGER.info(requestBody);
                producer.write(requestBody, queueName, queueTtl);
            } else if ("consume".equals(args[0])) {
                SOSConsumer consumer = new SOSConsumer(jmsServerUri);
                String consumedMessage = null;
                consumedMessage = consumer.read(queueName);
                LOGGER.info("message received from queue:");
                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 response = client.postRestService(jocUri.resolve(API_LOGIN), null);
                    LOGGER.info("HTTP status code: " + client.statusCode());
                    if (client.statusCode() == 200) {
                        JsonReader jsonReader = null;
                        String accessToken = null;
                        try {
                            jsonReader = Json.createReader(new StringReader(response));
                            JsonObject json = jsonReader.readObject();
                            accessToken = json.getString("accessToken", "");
                        } catch (Exception e) {
                            throw new Exception("Could not determine accessToken.", e);
                        } finally {
                            jsonReader.close();
                        }
                        client.addHeader(ACCESS_TOKEN_HEADER, accessToken);
                        client.addHeader(CONTENT_TYPE, APPLICATION_JSON);
                        LOGGER.info("REQUEST: " + API_ADD_ORDER);
                        LOGGER.info("PARAMS: " + consumedMessage);
                        String apiUrl = null;
                        if (!API_ADD_ORDER.toLowerCase().startsWith(jocApiUri)) {
                SOSProducer producer = new SOSProducer(JMS_URI);
        apiUrl = jocApiUri + producer.write(JOC_API_REQUESTADD_BODY)ORDER;
                 } else if ("consume".equals(args[0])) {
   }
         SOSConsumer consumer = new SOSConsumer(JMS_URI);
            String consumedMessage = consumer.receiveFromQueue(LOGGER.info("resolvedUri: " + jocUri.resolve(apiUrl).toString());
            SOSRestApiClient client = setupHttpClient();
         response =  try {client.postRestService(jocUri.resolve(apiUrl), consumedMessage);
                URI jocUri = URI.create(JOC_API_URL);
                LOGGER.info("sendHTTP loginstatus tocode: " + jocUriclient.resolvestatusCode(API_LOGIN).toString());
                      String  response = client.postRestService(jocUri.resolve(API_LOGINLOGOUT), null);
;
                        LOGGER.info("HTTP status code: " + client.statusCode());
                    }
            if (client.statusCode() == 200) {}
            }
        } JsonReadercatch jsonReader(Throwable =e) null;{
            e.printStackTrace();
         String accessToken = null System.exit(1);
        } finally {
           try {
 if (client != null) {
                client.closeHttpClient();
            }
     jsonReader = Json.createReader(new StringReader(response)); }
    }

    private static SOSRestApiClient setupHttpClient(String username, String password) {
        SOSRestApiClient JsonObjectclient json= =new jsonReader.readObjectSOSRestApiClient();
        String basicAuth = Base64.getMimeEncoder().encodeToString((username + ":" + password).getBytes());
         accessToken = json.getString("accessToken", ""client.setBasicAuthorization(basicAuth);
        return client;
    }

    private static String } catchcleanupValue(ExceptionString evalue) {
        value = value.trim();
        if (value.startsWith("\"")) {
           LOGGER.warn("Could not determine accessToken." value = value.substring(1);
        }
            } finally if (value.endsWith("\"")) {
                        jsonReader.close(value = value.substring(0, value.length() - 1);
        }
        return value;
    }

    private static void readPropertiesFile(Path path) {
        Properties props = new client.addHeader(ACCESS_TOKEN_HEADER, accessTokenProperties();
        try {
            client.addHeader(CONTENT_TYPE, APPLICATION_JSONprops.load(Files.newInputStream(path));
            jmsServerUri        LOGGER.info("REQUEST: " + API_ADD_ORDER);
        = cleanupValue(props.getProperty("jms_url"));
            LOGGER.info("PARAMScfg jms_url: " + consumedMessagejmsServerUri);
            queueName = cleanupValue(props.getProperty("jms_queue_name"));
      String apiUrl = null;
   LOGGER.info("cfg jms_queue_name: " + queueName);
            queueTtl if= (!API_ADD_ORDER.toLowerCase().startsWith(JOC_API_URL)) {
Long.parseLong(cleanupValue(props.getProperty("jms_queue_name"))); 
            LOGGER.info("cfg jms_queue_ttl: " + queueTtl.toString());
          apiUrl = JOC_API_URL + API_ADD_ORDER;
jocApiUri = cleanupValue(props.getProperty("joc_api_url"));
            LOGGER.info("cfg joc_api_url: " + jocApiUri);
      }
      controllerId = cleanupValue(props.getProperty("controller_id"));
            LOGGER.info("resolvedUricfg controller_id: " + jocUri.resolve(apiUrl).toString()controllerId);
                    responseworkflowPath = client.postRestServicecleanupValue(jocUriprops.resolve(apiUrl), consumedMessagegetProperty("workflow_path"));
                    LOGGER.info("HTTP status codecfg workflow_path: " + client.statusCode(workflowPath));
            username = cleanupValue(props.getProperty("username"));
           response pwd = client.postRestServicecleanupValue(jocUriprops.resolve(API_LOGOUT), nullgetProperty("password"));
            requestBody = "{\"controllerId\":\"" + controllerId + "\",\"orders\":[{\"workflowPath\":\"" +  LOGGER.info("HTTP status code: " + client.statusCode());
workflowPath
                              }
    + "\",\"scheduledFor\":\"now\"}],\"auditLog\":{}}";
        } catch (ExceptionIOException e) {
            LOGGER.warn("could not read  LOGGER.error(e.getMessage(), eproperties file, use defaults instead.");
            }jmsServerUri finally {= DEFAULT_JMS_URI;
            queueName    client.closeHttpClient()= DEFAULT_QUEUE_NAME;
            }

jocApiUri        }= DEFAULT_JOC_API_URL;
    }
     
   requestBody private static SOSRestApiClient setupHttpClient() {
= DEFAULT_JOC_API_REQUEST_BODY;
           SOSRestApiClient clientusername = new SOSRestApiClient()DEFAULT_USERNAME;
           String basicAuthpwd = Base64.getMimeEncoder().encodeToString(("[USERNAME]:[PASSWORD]").getBytes())DEFAULT_PWD;
        client.setBasicAuthorization(basicAuth);
    queueTtl = 5000L; 
   return client;
    }
    
}

}

Maven Configuration Example

This example shows the dependencies required to build the example above example 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 7

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 `MessageConsumer`

Methods

`read()`

The `MessageConsumer`

The Methods

`createMessageConsumer(Session session, Destination destination)`

`read(MessageConsumer consumer)`

`receiveFromQueue()`

The `SOSConsumer` class

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

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

Maven Configuration Example

Space shortcuts

Page tree

Page History

Versions Compared

Old Version 7

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 MessageConsumer

Methods

read()

The MessageConsumer

The Methods

createMessageConsumer(Session session, Destination destination)

read(MessageConsumer consumer)

receiveFromQueue()

The SOSConsumer class

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

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

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 `MessageConsumer`

`read()`

The `MessageConsumer`

`createMessageConsumer(Session session, Destination destination)`

`read(MessageConsumer consumer)`

`receiveFromQueue()`

The `SOSConsumer` class

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