Spring | Using TIBCO EMS with Spring framework

-
TIBCO EMS can be use with Spring Framework to support message publishing and subscription. Spring provides JMS template to send JMS messages and @JmsListener/ MessageListener to subscribe it.

Steps 1 : Create new project in eclipse or IntelliJ Idea

Create new project with Spring dependency. We can use maven to add all required libs for this project. Maven takes care of adding referred java libs to build path. TIBCO JMS jars need to be added to build path.

Pom.xml will be as follows.

<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/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.springapp</groupId>
<artifactId>HelloWorld</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>HelloWorld</name>
<properties>
<spring.version>4.2.0.RELEASE</spring.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.0.1</version>
</dependency>
<dependency>
<groupId>com.tibco</groupId>
<artifactId>tibco-jms</artifactId>
<version>4.4.3</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jms</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>javax.jms</groupId>
<artifactId>jms</artifactId>
<version>1.4.0</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.5</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.5</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>
<build>
<finalName>HelloWorld</finalName>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.6</source>
<target>1.6</target>
</configuration>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<includes>
<include>**/*Tests.java</include>
</includes>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>2.6</version>
<configuration>
<outputDirectory>${project.basedir}/target</outputDirectory>
</configuration>
</plugin>
</plugins>
</build>
</project>
view raw pom.xml hosted with ❤ by GitHub
As you can see in above pom file we have added TIBCO JMS and Spring JMS dependency.

Step 2 : Create JMS bean configuration file(Jms-conf.xml)

Next we will create bean configuration file. It will set JNDI and JMS properties.

We can use same JMS listener class to subscribe multiple queues and topics. Spring bean configuration take care of JMS transport setup. Env variables values can be provided via properties file.
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jms="http://www.springframework.org/schema/jms"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!--component-scan is added to support annotation based bean configuration-->
<context:component-scan base-package="com.main.services"/>
<!--JndiTemplate will define JMS connection details-->
<bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate">
<property name="environment">
<props>
<prop key="java.naming.factory.initial">com.tibco.tibjms.naming.TibjmsInitialContextFactory</prop>
<prop key="java.naming.provider.url">tcp://localhost:7222</prop>
<prop key="java.naming.security.principal">admin</prop>
<!--<prop key="java.naming.security.credentials"></prop>-->
</props>
</property>
</bean>
<!--JndiObjectFactoryBean will define JMS queue factory which will be use for sending msg on queue-->
<bean id="internalJmsQueueConnectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiTemplate">
<ref bean="jndiTemplate"/>
</property>
<property name="jndiName">
<value>QeueConnectionFactory</value>
</property>
</bean>
<!--JndiObjectFactoryBean will define JMS topic factory which will be use for publishing msg on topic-->
<bean id="internalJmsTopicConnectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiTemplate">
<ref bean="jndiTemplate"/>
</property>
<property name="jndiName">
<value>TopicConnectionFactory</value>
</property>
</bean>
<!--We will also define queue name. $queues.<<name>> will be used to resolve ambiguity between queues and topics-->
<bean id="queue1" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiTemplate">
<ref bean="jndiTemplate"/>
</property>
<property name="jndiName">
<value>$queues.test.abc</value>
</property>
</bean>
<bean id="queue2" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiTemplate">
<ref bean="jndiTemplate"/>
</property>
<property name="jndiName">
<value>$queues.sample.queue</value>
</property>
</bean>
<!--We will also define topic name.-->
<bean id="topic1" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiTemplate">
<ref bean="jndiTemplate"/>
</property>
<property name="jndiName">
<value>sample.topic</value>
</property>
</bean>
<!--JmsTemplate object will use factory & queue define above to send message-->
<bean id="jmsTemplateQueueTest1" class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory">
<ref bean="internalJmsQueueConnectionFactory"/>
</property>
<property name="defaultDestination">
<ref bean="queue1"/>
</property>
<property name="receiveTimeout">
<value>30000</value>
</property>
</bean>
<bean id="jmsTemplateQueueTest2" class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory">
<ref bean="internalJmsQueueConnectionFactory"/>
</property>
<property name="defaultDestination">
<ref bean="queue2"/>
</property>
<property name="receiveTimeout">
<value>30000</value>
</property>
</bean>
<!--JmsTemplate object will use factory & topic define above to publish message-->
<bean id="jmsTemplateTopicTest1" class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory">
<ref bean="internalJmsTopicConnectionFactory"/>
</property>
<property name="defaultDestination">
<ref bean="topic1"/>
</property>
<property name="receiveTimeout">
<value>30000</value>
</property>
</bean>
<!--This is bean for com.main.services.QueueMsgSender class. We will inject JmsTemplate-Queue created above. -->
<bean id="qeueMsgSender" class="com.main.services.QueueMsgSender">
<property name="jmsTemplate" ref="jmsTemplateQueueTest1"/>
</bean>
<!--This is bean for com.main.services.TopicMsgSender class. We will inject JmsTemplate-Topic created above. -->
<bean id="topicMsgSender" class="com.main.services.TopicMsgSender">
<property name="jmsTemplate" ref="jmsTemplateQueueTest2"/>
</bean>
<!--This is bean for creating Jms queue listener-->
<bean id="jmsQueueReciever1" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="destination" ref="queue1"/>
<property name="connectionFactory" ref="internalJmsQueueConnectionFactory"/>
<property name="concurrentConsumers" value="1"/>
<property name="maxConcurrentConsumers" value="1"/>
<property name="messageListener" ref="msgListner"/>
</bean>
<!--This is bean for creating Jms topic listener-->
<bean id="jmsTopicReciever" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="destination" ref="topic1"/>
<property name="connectionFactory" ref="internalJmsTopicConnectionFactory"/>
<property name="concurrentConsumers" value="1"/>
<property name="maxConcurrentConsumers" value="1"/>
<property name="messageListener" ref="msgListner"/>
</bean>
</beans>
view raw Jms-conf.xml hosted with ❤ by GitHub


Step 3 : Create JMS Queue/Topic sender and Listner

/* Sender Class wired with bean id="queueMsgSender" */
package com.main.services;
/**
* Created by rohan on 2017/10/18.
*/
import javax.jms.*;
import org.apache.log4j.Logger;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import org.springframework.stereotype.Component;
@Component(value = "queueMsgSender")
public class QueueMsgSender {
private JmsTemplate jmsTemplate;
private static Logger logger = org.apache.log4j.Logger.getLogger(QueueMsgSender.class);
public void sendMessage(final String message, final String CorrId) {
logger.info("preparing to send queue jms message");
jmsTemplate.send(new MessageCreator() {
@Override
public Message createMessage(Session session) throws JMSException {
TextMessage msg = session.createTextMessage(message);
msg.setJMSCorrelationID(CorrId);
return msg;
}
});
}
public JmsTemplate getJmsTemplate() {
return jmsTemplate;
}
public void setJmsTemplate(JmsTemplate jmsTemplate) {
this.jmsTemplate = jmsTemplate;
}
}
/* Listener Class wired with bean id="msgListner" */
package com.main.services;
/**
* Created by rohan on 2017/10/17.
*/
import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;
@Component
public class MsgListner implements MessageListener {
private static Logger logger = org.apache.log4j.Logger.getLogger(MsgListner.class);
@Override
public void onMessage(Message message) {
if (message instanceof TextMessage) {
try {
logger.info("Queue : " + message.getJMSDestination() + "Message recieved is : " + ((TextMessage) message).getText() + " CorrId : " + message.getJMSCorrelationID() + " JMSPriority : " + message.getJMSPriority());
message.acknowledge();
}
catch (JMSException ex) {
throw new RuntimeException(ex);
}
}
else {
throw new IllegalArgumentException("Message must be of type TextMessage");
}
}
}
/* Test Class to test above code. */
package com.springapp.mvc;
/**
* Created by rohan on 2017/10/18.
*/
import com.main.services.QueueMsgSender;
import com.main.services.TopicMsgSender;
import org.springframework.context.support.GenericXmlApplicationContext;
import java.util.UUID;
public class TestJmsSender {
public static void main(String[] args) {
GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
ctx.load("classpath:Jms-conf.xml");
ctx.refresh();
try {
QueueMsgSender queueMsgSender = ctx.getBean("queueMsgSender", QueueMsgSender.class);
queueMsgSender.sendMessage("Queue msg 1", UUID.randomUUID().toString());
TopicMsgSender topicMsgSender = ctx.getBean("topicMsgSender", TopicMsgSender.class);
topicMsgSender.sendMessage("Queue msg2", UUID.randomUUID().toString());
} catch (Exception ae) {
System.out.print("Error " + ae);
}
}
}
view raw JMSSenderReceiver.java hosted with ❤ by GitHub

In above code we have used Spring Auto-wiring to inject objects of other classes. More on Auto-wiring can be found here.

Step 4 : Deploy it to Application Server

Finally, we can build the project and copy war file to tomcat or any other application server.

Once you run the test process it will start msg listener.

2017-10-20 08:42:08,684 INFO [QueueMsgSender] preparing to send queue jms message
2017-10-20 08:42:08,714 INFO [MsgListner] Queue : Queue[test.abc]Message recieved is : Queue msg 1 CorrId : fdb49949-b7f4-4ed3-98e0-308f736d8c30 JMSPriority : 4
2017-10-20 08:42:08,722 INFO [QueueMsgSender] preparing to send topic jms message
2017-10-20 08:42:08,738 INFO [MsgListner] Queue : Topic[sample.topic]Message recieved is : Queue msg2 CorrId : 422921bc-0018-4ceb-9398-4aa62a28a9a0 JMSPriority : 4
2017-10-20 08:44:50,892 INFO [MsgListner] Queue : Topic[sample.topic]Message recieved is : Test topic message CorrId : vdvd JMSPriority : 4
2017-10-20 08:45:19,516 INFO [MsgListner] Queue : Queue[test.abc]Message recieved is : Test queue message CorrId : grgs JMSPriority : 4
Process finished with exit code 137
view raw jms-logs.log hosted with ❤ by GitHub

Comments

Post a Comment

Popular posts from this blog

TIBCO | For Loop - Accumulate output

-
Image
In this post we will check how TIBCO for loop works. TIBCO provides Group Activity to iterate over processes or activities. Loops can be different types eg. For Loop, While util loop, if loop, repeat on error etc. TIBCO group can loop over sub-process and accumulate output in end activity to be used by next activities. TIBCO For loop with Accumulate output repeats over process/activity and return output of each iteration in output activity. This is helpful where we want to call sub-process repeatably with different input parameters and store each output in some variable.
Read more

TIBCO | JNDI Server & JMS Instance creation

-
Image
In this post we will be creating TIBCO JNDI server and other instance pointed to JNDI server. First lets see what is mean by JNDI. It is   Java API for a directory service that allows Java software clients to discover and look up data and objects via a name. TIBCO EMS uses JNDI concept to lookup for EMS objects and its relations in messaging service. While developing enterprise level TIBCO solution it is advise or say standard practice to create one JNDI server(also one backup JNDI server) and other instance servers according to the functionality or domains. In this tutorial we will be creating one JNDI server and two domain servers.
Read more