Multi threaded JMS with Lingo and Jencks

In the previous article about Lingo JMS with Lingo we took care of a simple Lingo implementation. In that article we discussed that Lingo does not support out of the box a multi threaded server side. This article will discuss the steps to take to get your Lingo implementation to the next level.

To get the server side to process server calls on multiple threads we going to use Jencks. Jencks is a implementation of the J2EE Connector Architecture (JCA). For now we are just going to implement a simple multi threaded solution without transactions.

The client side is exactly the same as discused in JMS with Lingo, for more info about how to setup the Lingo client site I refer to this article.

The server side is also the same as discused in JMS with Lingo, but additinal to this configuration for Jecks needs some configuration to take care of multi threading part.

<!-- JCA container -->
<bean id="jencks" class="org.jencks.JCAContainer">

  <!-- lets use the default configuration of work manager and transaction manager-->
  <property name="bootstrapContext">
    <bean class="org.jencks.factory.BootstrapContextFactoryBean">
      <property name="threadPoolSize" value="25" />
    </bean>
  </property>


  <!-- the JCA Resource Adapter -->
  <property name="resourceAdapter">
    <bean id="activeMQResourceAdapter"
      class="org.apache.activemq.ra.ActiveMQResourceAdapter">
      <property name="serverUrl" value="tcp://localhost:61626" />
    </bean>
  </property>
</bean>

<!-- an inbound message connector using a stateless, thread safe MessageListener -->
<bean id="inboundMessageA" class="org.jencks.JCAConnector">

  <property name="jcaContainer" ref="jencks" />

  <!-- subscription details -->
  <property name="activationSpec">
    <bean class="org.apache.activemq.ra.ActiveMQActivationSpec">
      <property name="destination"
        value="org.isthisjava.service.jca.ExampleService" />
      <property name="destinationType" value="javax.jms.Queue" />
    </bean>
  </property>

  <property name="ref" value="exampleService" />
</bean>

When you want more details for the multi threaded client and server, the complete source code is added at the end of this page. If you want to see it in action just drop the server end client binaries into tomcat. and point your browser to http://locahost:8080/somepathtothemultithreadedclient

TODO add source and binaries

JMS with Lingo

Lingo is one of those little projects what make life a lot easier for a java developer. According to the Lingo people Lingo is a lightweight POJO based remoting and messaging library based on Spring's Remoting which extends it to support JMS. Lingo can support a wide range of message exchange patterns including both synchronous and asynchronous message exchange.

I came across Lingo when I was searching for a really simple JMS solution. Ofcourse I looked into Spring but I didn't like what they offered. In my opinion spring JMS (Message Driven POJO) was still to low level for me. I was searching for a real POJO based solution what handles all the messaging for me, and that is just the thing Lingo does.

This article is focused around how to setup Lingo correctly in your environment. At the bottom you find a link to the source code with a sample client implementation, and a sample server implementation. These project are both web based, they where tested in a default Tomcat 5.5.23, and a default Active MQ 4.1.1. Active MQ is used as a JMS message broker.

The client consist out of two pages, the first page will initiate the call to the server, the second page will present the result to the user. A sample of the client side spring config is represented below. For Lingo client side 3 beans are defined, the actual service, the JMS broker, and the queue where to send the message to. The last two must also be present in the server side spring config.

  <!-- client side proxy-->
  <bean id="exampleService" class="org.logicblaze.lingo.jms.JmsProxyFactoryBean">

    <property name="serviceInterface" value="org.isthisjava.service.ExampleService"/>
    <property name="connectionFactory" ref="jmsFactory"/>
    <property name="destination" ref="exampleDestination"/>
  </bean>

  <!-- JMS ConnectionFactory to use -->
  <bean id="jmsFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
    <property name="brokerURL" value="tcp://localhost:61616"/>
  </bean>

  <bean id="exampleDestination" class="org.apache.activemq.command.ActiveMQQueue">
    <constructor-arg index="0" value="org.isthisjava.service.ExampleService"/>
  </bean>

For the Lingo server side consist out of 4 beans, the actual POJO implementation of the service, a setup for the POJO so that it will listen to incomming messages, and the JMS broker and the queue definition. The last two are also in the client configuration. Take in account that this configuration is a single threaded solution. A single threaded solution is okee for the client side, but the server side should be multi threaded. How to make your server side multi threaded will be discussed in a later article.

  <!-- the server side -->
  <bean class="org.logicblaze.lingo.jms.JmsServiceExporter">
    <property name="service" ref="serverImpl"/>
    <property name="serviceInterface" value="org.isthisjava.service.ExampleService"/>
    <property name="connectionFactory" ref="jmsFactory"/>
    <property name="destination" ref="exampleDestination"/>
  </bean>

  <!-- the actual implementation of the service - which is only made public for testing purposes -->
  <bean id="exampleServiceImpl" class="org.isthisjava.service.ExampleServiceImpl" singleton="true"/>

In the source code added to this article you will find the ExampleService and a simple implementation of this service. For more details please look into the source code.

If you just want to see a demo please install Active MQ and drop the two wars (see binary) in your Tomcat, and navigate to http://localhost:8080/jmswithlingoclient

jmswithlingoclient-src-1.0.zip
jmswithlingoclient-bin-1.0.zip
jmswithlingoserver-src-1.0.zip
jmswithlingoserver-bin-1.0.zip