redstream » Spring Framework

Unit test your Spring/Hibernate and MongoDB setup

Pascal Alma — Wed, 27 Jul 2011 08:00:12 +0000

In my previous post I described how you can setup Spring and Hibernate in combination with the MongoDB. In this post I show you how you can write your unit test for this setup including a workaround for the fact that there isn’t an embedded version of MongoDB.

Of course you can check manually if your code works by checking the content of the MongoDB. You can use the MongoDB shell or the REST interface by using ‘curl’ (when using REST make sure you start the database with the ‘–rest’ option). For example see the result of curl 'http://localhost:28017/redstream/logItem/'

pascal@~$ curl ‘http://localhost:28017/redstream/logItem/’
{
“offset” : 0,
“rows”: [
{ "_id" : { "$oid" : "4e1c2ffca0eee881985e04f0" }, "_class" : "nl.redstream.mongo.entity.LogItem", "message" : "just some text 0" } ,
{ "_id" : { "$oid" : "4e1c2ffda0eee881985e04f1" }, "_class" : "nl.redstream.mongo.entity.LogItem", "message" : "just some text 1" } ,
{ "_id" : { "$oid" : "4e1c2ffda0eee881985e04f2" }, "_class" : "nl.redstream.mongo.entity.LogItem", "message" : "just some text 2" } ,
{ "_id" : { "$oid" : "4e1c4289a0ee3d15a8af39d3" }, "_class" : "nl.redstream.mongo.entity.LogItem", "message" : "just some text 0" }
],
“total_rows” : 3 ,
“query” : {} ,
“millis” : 0
}
pascal@~$

However, when building software you want your test to be performed automatically so we use JUnit to perform the tests and checks. And I use JUnit to start and stop my local MongoDB instance. Here is how it works (I assume you have the same project setup as I created in my previous post):

Wire the Spring beans in your test context

I created a SpringContext class for testing purposes:

package nl.redstream.mongo;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
/**
 * Only to be used in test classes!!
 * 
 * @author pascal
 */
public class MyTestApplicationContext {
 
    private static MyTestApplicationContext testContext = null;
 
    ApplicationContext context = null;
 
    private MyTestApplicationContext() {
    }
 
    public static MyTestApplicationContext getInstance()
    {
        if (testContext == null) {
            testContext = new MyTestApplicationContext();
            testContext.initialise();
        }
        return testContext;
    }
 
    public void initialise() {
         context = new ClassPathXmlApplicationContext(
                new String[]{"spring-config.xml"});
    }
 
    public Object getBean(String name) {
        return context.getBean(name);
    }
 
    public ApplicationContext getSpringContext() {
        return context;
    }
}

With this class I can access my Spring beans easily in my Unit tests.

Write the test class

I use ProcessBuilder to start and stop the local MongoDB instance before the test class is executed. The base Testclass looks like this:

package nl.redstream.mongo;
 
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
 
public class MongoDBTest {
 
    private static final Logger logger = Logger.getLogger(MongoDBTest.class);
    static Process p = null;
 
    @Before
    public void setUp() throws Exception {
        //@Todo Run mongo with a test specific .js file to produce initial data state
    }
 
    @After
    public void tearDown() throws Exception {
        //@Todo Drop database
    }
 
    @BeforeClass
    public static void beforeClass() throws Exception {
        String[] command = new String[]{"/Users/pascal/development/mongodb-osx-x86_64-1.8.2/bin/mongod", "--dbpath", "/Users/pascal/development/mongodb/data", "--rest"};
 
        ProcessBuilder pb = new ProcessBuilder(command);
 
        p = pb.start();
 
        logger.debug("Process started with pid: " + p);
 
    }
 
    @AfterClass
    public static void afterClass() throws Exception {
        // Stop mongod process
        boolean processClosed = false;
 
        Thread.sleep(500);
        if (p != null) {
            while (!processClosed) {
 
                try {
                    p.destroy();
                    processClosed = true;
                    Thread.sleep(500);
                    logger.info(" Process destroyed: " + p.exitValue());
                } catch (IllegalThreadStateException itse) {
                    logger.warn(itse);
                    processClosed = false;
                }
            }
        }
    }
}

And the actual test class:

package nl.redstream.mongo;
 
import junit.framework.Assert;
import nl.redstream.mongo.entity.LogItem;
import nl.redstream.mongo.services.LogService;
import org.apache.log4j.Logger;
import org.bson.types.ObjectId;
import org.junit.Before;
import org.junit.Test;
 
public class LogServiceTest extends MongoDBTest {
 
    private static final Logger logger = Logger.getLogger(LogServiceTest.class);
    private LogService<LogItem> service = null;
 
    @Test
    public void testCreateAndFindLog() throws Exception {
 
        ObjectId id = null;
 
        for (int i = 0; i < 3; i++) {
            LogItem log = new LogItem();
            log.setMessage("just some text " + i);
 
            id = service.add(log);
            logger.debug("log.id = " + id);
        }
 
        LogItem logFound = service.get(id);
        logger.debug("log = " + logFound.toString());
        Assert.assertNotNull(logFound);
    }
 
    @Before
    public void setUp() throws Exception {
        logger.info("setting up test");
        super.setUp();
        service = (LogService<LogItem>) MyTestApplicationContext.getInstance().getBean("logService");
        //@TODO Run mongo with a test specific .js file to produce initial data state
    }
}

Run it!

The test output shows it ran successfully:

——————————————————-
T E S T S
——————————————————-
Running nl.redstream.mongo.LogServiceTest
DEBUG [main] nl.redstream.mongo.MongoDBTest: Process started with pid: java.lang.UNIXProcess@603b1d04
INFO [main] nl.redstream.mongo.LogServiceTest: setting up test
DEBUG [main] nl.redstream.mongo.services.MongoDBLoggerServiceImpl: Adding a new LogItem instance
DEBUG [main] nl.redstream.mongo.LogServiceTest: log.id = 4e2fc241a0eea3de77684fdf
DEBUG [main] nl.redstream.mongo.services.MongoDBLoggerServiceImpl: Adding a new LogItem instance
DEBUG [main] nl.redstream.mongo.LogServiceTest: log.id = 4e2fc241a0eea3de77684fe0
DEBUG [main] nl.redstream.mongo.services.MongoDBLoggerServiceImpl: Adding a new LogItem instance
DEBUG [main] nl.redstream.mongo.LogServiceTest: log.id = 4e2fc241a0eea3de77684fe1
DEBUG [main] nl.redstream.mongo.LogServiceTest: log = LogItem [id=4e2fc241a0eea3de77684fe1, message=just some text 2, timestamp=null]
INFO [main] nl.redstream.mongo.MongoDBTest: Process destroyed: 12
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.798 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

There is definitely room for improvement, like adding the possibility to run ‘.js’ scripts to set the database in a predefined state in the @Before method of the test class and remove the database in the @After method.
Another thing that bothered me is the ‘Thread.sleep’ that I had to add at some places to make it work. Nevertheless I showed how to setup a basic test case with MongoDB/Spring combination and if you have a better solution please let me know!

Use Spring and Hibernate with MongoDB

Pascal Alma — Thu, 14 Jul 2011 09:12:53 +0000

One of the requirements we have for one of our Mule ESB implementations is to log the messages that went through the ESB (especially handy during development and testing). There has been written a lot already about logging with Mule so I am not going to discuss that again. In this post I’ll only show you how you can use Spring/Hibernate and MongoDB to store your messages in the MongoDB, because a document-oriented database like MongoDB is a nice fit for this requirement.

The first thing to do is to install MongoDB on your machine (unfortunately it is not yet possible to run it embedded so we use a local instance instead). For installation see this.

After MongoDB is installed we can create a new standard Maven project and modify the generated pom.xml to the following pom.xml.

Next step is the creation of the Hibernate Entity class like this:

package nl.redstream.mongo.entity;
 
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
import org.bson.types.ObjectId;
 
/**
 * Model object 
 * @author pascal
 */
@Entity
@Table(name = "logItems")
public class LogItem implements Serializable {
 
    @Id
    private ObjectId id;
    private String message;
    private String timestamp;
 
    public ObjectId getId() {
        return id;
    }
 
    public void setId(ObjectId id) {
        this.id = id;
    }
 
    public String getMessage() {
        return message;
    }
 
    public void setMessage(final String message) {
        this.message = message;
    }
 
    public String getTimestamp() {
        return timestamp;
    }
 
    public void setTimestamp(final String timestamp) {
        this.timestamp = timestamp;
    }
 
    @Override
    public String toString() {
        return "LogItem [id=" + id + ", message=" + message + ", timestamp=" + timestamp + "]";
    }
}

As you might notice I have used the ObjectId as primary Id. I was forced to this by bug DATADOC-176 which only recently got fixed.

The Dao and Service object classes that are used to access the MongoDB are:

Now wire this all together with the following spring config files:

 version="1.0" encoding="UTF-8"?>
 xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation=
               "http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
 
     resource="spring-mongodb-config.xml"/>
 
     id="logService" class="nl.redstream.mongo.services.MongoDBLoggerServiceImpl">
         name="dao" ref="logDao"/>
    >
     id="logDao" class="nl.redstream.mongo.dao.LogItemDaoImpl">
         name="mongoTemplate" ref="mongoTemplate"/>
    >
>

and the ‘spring-mongodb-config.xml’ (as described here):

 version="1.0" encoding="UTF-8"?>
 xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mongo="http://www.springframework.org/schema/data/mongo"
       xsi:schemaLocation=
               "http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                http://www.springframework.org/schema/data/mongo
                http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd">
 
    
     host="localhost" port="27017">
        
    >
 
     dbname="redstream" mongo-ref="mongo"/>
 
     id="mongoTemplate" class="org.springframework.data.document.mongodb.MongoTemplate">
         ref="mongoDbFactory"/>
    >
>

That’s it. Now you have a foundation to start using MongoDB with Spring and Hibernate classes. In the next post I will show how you can test this setup without manually having to start and stop MongoDB.

Using StAX with Spring WS

Pascal Alma — Sat, 14 Jun 2008 06:35:12 +0000

As I have posted before we are using XFire to implement our web service. Unfortunately, we are running into some serious issues with the framework, so we decided to look after another implementation. Since XFire is no longer supported by the community (or at least at a very low profile) and ‘replaced’ by CXF, we decided to have a look at Spring WS. We also have used the Spring Framework throughout our application elsewhere, so this would be a logical choice. After a quick look at the framework it convinced us that this would be the framework to use for our web services. It was easy to set up and well documented.
In this post I will show you how to use StAX to parse and write the SOAP request and response in combination with Spring WS, Maven2 and JBoss.

Setup maven

First thing to do is to setup Maven2. I assume this won’t be a problem, so I only show the settings.xml which I use for my Maven2 installation (you can also check out this post and this one):

>
  >d:/maven2/repo/>
  >
    >
      >default-repositories>
      >
        >
          >global>
          >External Mirror of Central Repository>
          >http://repo1.maven.org/maven2>
        >
        >
          >repo.maven>
          >http://repo1.maven.org/maven2-repoclean-java.net>
        >
        >
          >jboss.maven>
          >http://repository.jboss.com/maven2/>
        >
      >
      >
        >
          >repo1org>
          >External Plugin Repository>
          >http://repo1.maven.org/maven2/>
        >
      >
    >
    >
        >dev-environment>
        >
        >true>
          >
            >env>
            >dev>
          >
        >
        >
          >d:/java/jboss-4.0.5>
          >default>
        >
    >
  >
  >
    >dev-environment>
    >default-repositories>
  >
>

Create a Maven2 web project

You can do this with this command (as described in more detail here):
mvn archetype:create -DgroupId=net.pascalalma -DartifactId=spring-ws-test -DarchetypeArtifactId=maven-archetype-webapp

Create the XML Schema’s (XSD) for the request and response SOAP messages

As an example I take the schema of the Spring WS reference documentation. The request is described there and I have added a response myself. Here is the xsd:

 xmlns:xs="http://www.w3.org/2001/XMLSchema"
        xmlns:hr="http://www.redstream.nl/hr/schemas"
        elementFormDefault="qualified"
        targetNamespace="http://www.redstream.nl/hr/schemas">
     name="HolidayRequest">
        >
            >
                 name="Holiday" type="hr:HolidayType"/>
                 name="Employee" type="hr:EmployeeType"/>
            >
        >
    >
     name="HolidayType">
        >
             name="StartDate" type="xs:date"/>
             name="EndDate" type="xs:date"/>
        >
    >
     name="EmployeeType">
        >
             name="Number" type="xs:integer"/>
             name="FirstName" type="xs:string"/>
             name="LastName" type="xs:string"/>
        >
    >
     name="HolidayResponse" type="hr:Status" />
     name="Status">
       base="xs:string">
         value="DENIED"/>
         value="PENDING"/>
         value="APPROVED"/>
      >
    >
>

I have stored this schema as ‘hr.xsd’ in the directory ‘$PROJECT_HOME$/WEB-INF/schema’.

Configure the web application

We have to reroot the incoming HTTP request to the Spring WS servlet. TO do this we define the Spring WS servlet in the web.xml, like this:

 version="1.0" encoding="UTF-8"?>

  "http://java.sun.com/dtd/web-app_2_3.dtd">
>
	
	>
		>spring-ws>
		>Spring-WS Servlet>
		>
			org.springframework.ws.transport.http.MessageDispatcherServlet
		>
		>
			>transformWsdlLocations>
			>true>
		>
	>
	>
		>spring-ws>
		>/services/*>
	>
	 id="WelcomeFileList">
		>index.html>
	>
>

Create model classes

Now it’s time to start some Java coding. First I create the model classes that will represent the Objects as described by the xsd. We will have the following classes:
The Employee.java
The Holiday.java
And the HolidayRequest.java

Create the StAX parser and writer classes

To get from the incoming XML to our Java model classes we make use of StAX parsing and writing. Here are the two classes that do the XML-Object translation and back:
HolidayRequestReader.java
HolidayResponseWriter.java

Implement endpoint/webservice

The last Java class we have to make is the Webservice implementation itself. Since we want to use StAX parsing, I simply extend the Spring class ‘AbstractStaxStreamPayloadEndpoint’:

package net.pascalalma.ws;
 
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;
 
import net.pascalalma.model.HolidayRequest;
import net.pascalalma.xml.HolidayRequestReader;
import net.pascalalma.xml.HolidayResponseWriter;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.ws.server.endpoint.AbstractStaxStreamPayloadEndpoint;
 
public class HolidayRequestService extends AbstractStaxStreamPayloadEndpoint
{
 
  private static final Log LOG = LogFactory.getLog(HolidayRequestService.class);
 
  @Override
  protected void invokeInternal(XMLStreamReader streamreader,
      XMLStreamWriter streamwriter) throws Exception
  {
    try
    {
      HolidayRequest hr = HolidayRequestReader.parseMessage(streamreader);
 
      LOG.info("Result = " + hr);
 
      HolidayResponseWriter.writeResponse(hr, streamwriter);
    } catch (Throwable t)
    {
      LOG.error("Catched exception", t);
    }
  }
}

Setup the SpringWS context

Now that we have all the Java classes in place we have to configure the Spring context that is used by our webservice implementation. In our case it looks like the following XML file that is stored under the name ‘spring-ws-servlet’ in the ‘$PROJECT_HOME$/webapp/WEB-INF’ directory:

 version="1.0" encoding="UTF-8"?>
 xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
	
		class="org.springframework.ws.server.endpoint.mapping.PayloadRootQNameEndpointMapping">
		 name="mappings">
			>
				
					key="{http://www.redstream.nl/hr/schemas}HolidayRequest">
					myEndPoint
				>
			>
		>
	>
	 id="myEndPoint"
		class="net.pascalalma.ws.HolidayRequestService" >
	>
	 id="holiday"
		class="org.springframework.ws.wsdl.wsdl11.DefaultWsdl11Definition">
		 name="schema" ref="schema" />
		 name="portTypeName" value="HumanResource" />
		 name="locationUri"
			value="http://localhost:8080/spring-ws-test/services/holidayService/" />
		 name="targetNamespace"
			value="http://www.redstream.nl/hr/definitions" />
	>
	 id="schema"
		class="org.springframework.xml.xsd.SimpleXsdSchema">
		 name="xsd" value="/WEB-INF/schemas/hr.xsd" />
	>
>

Build and deploy to jboss

With this file as the project’s POM file we can simply build, package and deploy our webservice to JBoss with the command in the command prompt:
mvn clean package jboss:harddeploy

Access wsdl in browser to test

If everything went well and JBoss is started, you can access the dynamically generated WSDL with the following url:
http://localhost:8080/spring-ws-test/services/holiday.wsdl
This should give the following WSDL in your browser:

 targetNamespace="http://www.redstream.nl/hr/definitions">
  >
     elementFormDefault="qualified" targetNamespace="http://www.redstream.nl/hr/schemas">
       name="HolidayRequest">
        >
          >
             name="Holiday" type="hr:HolidayType"/>
             name="Employee" type="hr:EmployeeType"/>
          >
        >
      >
       name="HolidayType">
        >
           name="StartDate" type="xs:date"/>
           name="EndDate" type="xs:date"/>
        >
      >
       name="EmployeeType">
        >
           name="Number" type="xs:integer"/>
           name="FirstName" type="xs:string"/>
           name="LastName" type="xs:string"/>
        >
      >
       name="HolidayResponse" type="hr:Status"/>
       name="Status">
         base="xs:string">
           value="DENIED"/>
           value="PENDING"/>
           value="APPROVED"/>
        >
      >
    >
  >
   name="HolidayResponse">
     element="sch:HolidayResponse" name="HolidayResponse">
    >
  >
   name="HolidayRequest">
     element="sch:HolidayRequest" name="HolidayRequest">
    >
  >
   name="HumanResource">
     name="Holiday">
       message="tns:HolidayRequest" name="HolidayRequest">
      >
       message="tns:HolidayResponse" name="HolidayResponse">
      >
    >
  >
   name="HumanResourceSoap11" type="tns:HumanResource">
     style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
     name="Holiday">
       soapAction=""/>
       name="HolidayRequest">
         use="literal"/>
      >
       name="HolidayResponse">
         use="literal"/>
      >
    >
  >
   name="HumanResourceService">
     binding="tns:HumanResourceSoap11" name="HumanResourceSoap11">
       location="http://localhost:8080/spring-ws-test/services/holidayService/"/>
    >
  >
>

That’s it. You can test your web service with a tool like SoapUI and create test cases based on the generated WSDL like I described here.

Weird Quartz scheduler behaviour

Pascal Alma — Wed, 25 Jul 2007 05:54:44 +0000

As I posted before here I am using Quartz scheduler to schedule some batch jobs. It seemed to work fine but now while we were testing our application it appeared Quartz was showing some weird behaviour. I have scheduled 3 jobs, each with it’s own trigger in one scheduler. However, 2 of the jobs are only triggered if the trigger of other remaining job has been fired before.
Of course I checked my configuration multiple times but I couldn’t find something wrong with it. After lots of testing and debugging I solved the issue by replacing the rescheduleJob() command with a simple deleteJob() and scheduleJob().

Here is the relevant original piece of code:

if (job == null) {
    nextRun = scheduler.scheduleJob(trigger.getJobDetail(), trigger);
} else {
    nextRun = scheduler.rescheduleJob(trigger.getFullName(), trigger.getGroup(), trigger);
}

After replacing this code with the next piece it worked fine again, although I cannot explain why….

if (job == null) {
    nextRun = scheduler.scheduleJob(trigger.getJobDetail(), trigger);
} else {
    scheduler.deleteJob(trigger.getJobDetail().getName(), trigger.getJobDetail().getGroup());
    nextRun = scheduler.scheduleJob(trigger.getJobDetail(), trigger);
}

Configuring durable messages with SpringFramework

Pascal Alma — Thu, 28 Jun 2007 04:26:27 +0000

In our project we have a webservice that receives a message, processes it and sends a response back. Very common for a webservice I think :-)
Now there was an extra request: log all messages in a database so we could get management info out of it, like in which hour of the day are we receiving the most messages, who is sending the most messages that are leading to errors, etc. In this post I will show you how I implemented this request. To have it working with the least impact on our ‘production’ system I chose to put the incoming message in a queue (actually it is a Topic). Then register a MessageListener that will pick up the posted message and log it in a separate database, along with some metadata. The reason I chose a Topic is that I expect to have more requests in the future to do something with the incoming message. By using a Topic I can just add a receiver and have that handle the new request.

We have the following Application Server setup:

JBoss 4.0.5GA
JBoss Messaging 1.2SP1

To define the Topic in JBoss Messaging I added the following section to ‘destinations-service.xml’:

 code="org.jboss.jms.server.destination.TopicService"
           name="jboss.messaging.destination:service=Topic,name=myMessageTopic"
           xmbean-dd="xmdesc/Topic-xmbean.xml">
     optional-attribute-name="ServerPeer">jboss.messaging:service=ServerPeer>
    >jboss.messaging:service=PostOffice>
     name="DLQ">jboss.messaging.destination:service=Queue,name=DLQ>
     name="ExpiryQueue">jboss.messaging.destination:service=Queue,name=ExpiryQueue>
>

(To see more details about installing JBoss Messaging see this post).
Since sending a message to a Topic is pretty straightforward I will only show how to configure the receiver. I first made the Java class which acts as receiver:

package net.pascalalma.logger;
 
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
 
import net.pascalalma.model.LogMelding;
import net.pascalalma.exceptions.StatisticsException;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
 
public class LoggerBean implements MessageListener {
 
   private static final Log LOG = LogFactory.getLog(LoggerBean.class);
 
   public void onMessage(Message msg) {
 
      LOG.info("onMessage(Message msg)");
 
      if (msg instanceof ObjectMessage) {
 
         ObjectMessage om = (ObjectMessage)msg;
         try {
            if ( om.getObject() instanceof LogMelding) {
               LogMelding lm = (LogMelding)((ObjectMessage)msg).getObject();
 
               LOG.info("LogMelding in Topic = " + lm);
            } else {
               throw new IllegalArgumentException("Only instances of LogMelding may be put in this Topic.");
            }
         } catch (JMSException je) {
            throw new StatisticsException(je);
         }
      } else {
         throw new IllegalArgumentException("Only ObjectMessages may be put in this Topic.");
      }
   }
}

Next we have to configure this MessageListener implementation in Spring. Here is my application-context:

 version="1.0" encoding="UTF-8"?>

>
   class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
     name="locations">
      >
        >classpath:statistics.properties>
      >
    >
  >
 
  
   id="jndiTemplate"
    class="org.springframework.jndi.JndiTemplate">
     name="environment">
      >
         key="java.naming.factory.initial">
          org.jnp.interfaces.NamingContextFactory
        >
         key="java.naming.provider.url">
          jnp://localhost:1099
        >
         key="java.naming.factory.url.pkgs">
          org.jboss.naming:org.jnp.interfaces
        >
      >
    >
  >
 
  
   id="jmsConnectionFactory"
    class="org.springframework.jms.connection.SingleConnectionFactory">
     name="targetConnectionFactory">
      
        class="org.springframework.jndi.JndiObjectFactoryBean">
         name="jndiTemplate" ref="jndiTemplate" />
         name="jndiName" value="myConnectionFactory" />
      >
    >
     name="clientId" value="clientID"/>
  >
  
   id="myMessageTopic"
    class="org.springframework.jndi.JndiObjectFactoryBean">
     name="jndiTemplate">
       bean="jndiTemplate" />
    >
     name="jndiName" value="${queue.log}" />
  >
 
  
   id="myMsgTopiclistener"
    class="org.springframework.jms.listener.DefaultMessageListenerContainer">
     name="concurrentConsumers" value="1" />
     name="maxConcurrentConsumers" value="1" />
     name="connectionFactory" ref="jmsConnectionFactory" />
     name="sessionTransacted" value="true" />
     name="destination" ref="myMessageTopic" />
     name="messageListener" ref="loggerBean" />
     name="subscriptionDurable" value="true"/>
     name="durableSubscriptionName" value="myMsgTopiclistener"/>
  >
 
   
    id="loggerBeanOriginal" class="net.pascalalma.logger.LoggerBean" />
 
   
    id="loggerBean" parent="txProxyParent">
       name="target" ref="loggerBeanOriginal" />
   >
>

The difference with the non-durable configuration is the property ClientId at the jmsConnectionFactory bean:

1	name="clientId" value="clientID"/>

And the following properties at the myMsgTopiclistener bean:

1 2	name="subscriptionDurable" value="true"/> name="durableSubscriptionName" value="myMsgTopiclistener"/>

If you leave these properties out you will have the non-durable variant of the message listener.

So here is another proof that Spring can make your life as developer a lot easier :-)

Scheduling with Spring and Quartz

Pascal Alma — Thu, 26 Apr 2007 06:20:56 +0000

Just a small post about something I noticed in Quartz. I wanted to offer the user a screen with functionality so they could (re)schedule a batch job which then would do all kinds of batch stuf. To schedule the job in my application I used the following Java code:

public void resetScheduleJob() throws CustomSystemException {
 
      StdScheduler scheduler = (StdScheduler)MyQueueContext.getContext().getBean("scheduler");
 
      CronTriggerBean trigger = (CronTriggerBean)MyQueueContext.getContext().getBean("batchProducerTrigger");
 
      try {
           trigger.setCronExpression(getCronExpression());
 
           scheduler.scheduleJob(trigger.getJobDetail(), trigger);
 
      } catch (ParseException pe) {
         throw new CustomSystemException (pe);
      } catch (SchedulerException se) {
         throw new CustomSystemException (se);
      }
      LOG.info("Next run will be at: " + trigger.getNextFireTime());
   }
}
private String getCronExpression() {
 
      // Small trick to get the hours of the day correct.
      String hours = null;
      if (startTime > endTime) {
         hours = endTime + "-23,0-" + startTime;
      } else if (startTime < endTime) {
         hours = startTime + "-" + endTime;
      } else {
         hours = "0";
      }
      return "0 0/" + interval + " " + hours + " ? * " + days;
   }

So this code runs fine the first time when it is called. But when you call it the second time (after the job exists) you will get:

org.quartz.ObjectAlreadyExistsException: Unable to store Job with name: 'batchProducerJob' and group: 'DEFAULT', because one already exists with this identification.

So I rewrote my code to:

 public void resetScheduleJob() throws CustomSystemException {
      StdScheduler scheduler = (StdScheduler)MyQueueContext.getContext().getBean("scheduler");
 
      CronTriggerBean trigger = (CronTriggerBean)MyQueueContext.getContext().getBean("batchProducerTrigger");
 
      try {
         trigger.setCronExpression(getCronExpression());
 
         scheduler.rescheduleJob(job.getName(), job.getGroup(), trigger);
 
         scheduler.start();
 
      } catch (ParseException pe) {
         throw new CustomSystemException (pe);
      } catch (SchedulerException se) {
         throw new CustomSystemException (se);
      }
      LOG.info("Next run will be at: " + trigger.getNextFireTime());
   }

Now this code won’t fail if you call it several times….. Actually, it doesn’t do anything! I would expect an exception if the scheduler must have an existing job before it can reschedule one. But nothing there, I only found out that my job wasn’t started at all. So the trick is to check if there is a job with the same name, and if one is found, do the reschedule, otherwise the ‘normal’ schedule. Since I wasn’t expecting this behaviour I thought may be there are more persons running into this so here is the solution:

public void resetScheduleJob() throws CustomSystemException {
      StdScheduler scheduler = (StdScheduler)MyQueueContext.getContext().getBean("scheduler");
 
      CronTriggerBean trigger = (CronTriggerBean)MyQueueContext.getContext().getBean("batchProducerTrigger");
 
      try {
         trigger.setCronExpression(getCronExpression());
 
         JobDetail job = scheduler.getJobDetail(trigger.getJobDetail().getName(), trigger.getJobDetail().getGroup());
         LOG.debug("Job found = " + job);
 
         if (job == null) {
           scheduler.scheduleJob(trigger.getJobDetail(), trigger);
         } else {
            scheduler.rescheduleJob(job.getName(), job.getGroup(), trigger);
         }
 
         scheduler.start();
 
      } catch (ParseException pe) {
         throw new CustomSystemException (pe);
      } catch (SchedulerException se) {
         throw new CustomSystemException (se);
      }
      LOG.info("Next run will be at: " + trigger.getNextFireTime());
   }

And to make this example complete here is my Spring configuration:

 version="1.0" encoding="UTF-8"?>

>
	 id="batchProducerJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
	   name="targetObject" ref="batchProducer" />
	   name="targetMethod" value="start" />
	>
	 id="batchProducerTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
	     name="jobDetail" ref="batchProducerJob" />
        >
	 id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
           
	>
         id="batchProducerScheduler" class="net.pascalalma.batch.schedulers.BatchProducerScheduler">
	     name="startTime" value="${batch.produce.starthour}" />
	     name="endTime" value="${batch.produce.endhour}" />
	     name="interval" value="${batch.produce.interval}" />
	     name="days" value="${batch.produce.days}" />
       >
>

Failure trying to catch an UncategorizedSQLException

Pascal Alma — Wed, 25 Apr 2007 04:45:06 +0000

To store information in our PostgreSQL database we use Spring and Hibernate as I mentioned earlier in my posts. Some of our tables in the database also have GIS information with them. That’s why we are also using PostGIS extension on our database. This GIS information (Geometry) is also reflected in the Hibernate objects we use to persist our data.
We have experienced that this Geometry data can be invalid, in which case the database (JDBC) is throwing an UncategorizedSQLException. This is the case, for example, when a Polygon has a different start and ending point.
In our application we have two kinds of exceptions: the CustomException (thrown and handled by ourselves) and all other exceptions not handled by us. With this distinction between the exceptions I can decide what to do when an exception occurs, for example, when storing data in the database: is it our CustomException, then it is most probably a problem with this instance and I will move to process the next instance. If there is thrown another Exception, then there is something seriously wrong and I will stop the processing.
This may sound good in theory but it appeared that when an instance with invalid geometry was stored in the database, the whole process was stopped because there occured an UncategorizedSQLException. The code we used to store our Hibernate object is this:

 public void insert(final CustomObject e) throws CustomException {
      try {
         dao.insert(e);
      } catch (UncategorizedSQLException ex) {
         // We assume the geometry was invalid
         throw new CustomSystemException(CustomErrorMessage.CSM_SYS019, ex);
      } catch (DataAccessException ex) {
         throw new SystemException(ex);
      }
   }

While this code was working fine in our unit tests it kept failing in our application. After some research we discoverd the (logical, like always) reason for this: since we are using Hibernate to persist our data it is Hibernate that determines when the data is posted to the database. And tests showed that this is done when a commit is fired. And that is the big difference between our real-world application and our unit test. In our application we perform a lot of other steps before we fire the commit. So the code has already passed the try-catch before the database is throwing the UncategorizedSQLException. In our unit test we just called this insert and performed a commit right-away, so the exception is thrown inside the try-catch.
So that was the problem but now we had to think about the solution. We came up with 3 options:

Use AOP to act on every thrown UncategorizedSQLException with a ThrowsAdvice and make it a CustomException.
To call flush() after each insert() and update() so the data is posted in the database right away.
Perform the validation of the geometry ourselves before we send it to the database.

So first we try the flush() because this one was the easiest to implement. While this gave the behaviour we wanted we didn’t like the fact that we decided when to flush the data instead of letting Hibernate decide this. This could be giving performance issues at some time so we decided to investigate the other solution too.
The second attempt was the AOP option. Because I haven’t used this before (besides the default out-of-the-box Spring functionlity) I was curious how to get it to work. Well, I got the ThrowsAdvice working for every exception that was thrown in our code, but not for the UncategorizedSQLException. I guess that that is caused by the fact that this exception is thrown by AOP itself, and therefor can not be ‘catched’ by another AOP, but I am not sure about this yet.
Finally, because of time-pressure I decided to go for the last option. We were doing all kinds of validations already on the Geometry so I added the one for the polygons. This is performance wise the best solution and I am also very sure what the implications are for the rest of the application.
But someday when I have more time, I am definitely having another look at this AOP thing, because that part is worth some more investigation.

JMS Spring disadvantages

Pascal Alma — Wed, 28 Mar 2007 18:12:52 +0000

In my previous post I was rather enthousiastic about the Spring JMS library. However, that was before we did run some performance tests. It seemed that with using JMS Spring our code was at least 10 x slower then before! Although the code may be easier to maintain, this performance issue was unacceptable. For this reason I was browsing the internet and found this post. This nice post explains that there are situations in which using JMSTemplate is not the way to go. And apparently, that was the case in our code!
So after rewriting the code we had back our performance and still used some Spring JMS. This just proves Spring is not the solution to every problem.

Using Spring JMS

Pascal Alma — Mon, 12 Mar 2007 19:59:49 +0000

Last week I discovered a piece of code in our project that didn’t use Spring yet. It was the piece of code that used JMS to access some JBoss queues. Since we did use Spring everywhere in our code where it was possible, I decided to rewrite this piece so it also uses Spring (and so it also profits of all the advantages that Spring offers).
The original code looked like this:

package net.pascalalma.jms;
 
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.ObjectMessage;
import javax.jms.Queue;
import javax.jms.QueueBrowser;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueReceiver;
import javax.jms.QueueSession;
import javax.naming.InitialContext;
import javax.naming.NamingException;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
 
public class QueueBase {
 
   private static final Log LOG = LogFactory.getLog(QueueBase.class);
 
   private static InitialContext context = null;
   private static QueueConnectionFactory qcf = null;
   private boolean transacted;
   private int ackMode;
   private String queueName;
   private boolean init = false;
   protected QueueConnection qc;
   protected QueueSession qs;
   protected Queue queue;
   protected QueueReceiver qr;
 
   protected MessageProducer mp;
 
   protected void init() throws QueueException {
      LOG.info("Queue init started");
      if (context == null) {
 
         try {
            LOG.info("QueueBase: creating InitialContext for queues (see jndi.properties)");
            context = new InitialContext();
            qcf = (QueueConnectionFactory) context.lookup("/ConnectionFactory");
         } catch (Exception e) {
            throw new QueueException(e);
         }
      }
 
      try {
         queue = (Queue) context.lookup(queueName);
         qc = qcf.createQueueConnection();
         qs = qc.createQueueSession(transacted, ackMode);
 
         assert (queue != null) : "queue is null";
         assert (qc != null) : "qc is null";
         assert (qs != null) : "qs is null";
 
         init = true;
      } catch (Exception e) {
         throw new QueueException(e);
      }
   }
 
   public QueueBase() {
      this.init = false;
   }
 
   public QueueBase(String queueName) {
      this.queueName = queueName;
      this.init = false;
   }
 
   /**
    * Constructor
    */
   public QueueBase(String queueName, boolean transacted, int ackMode) throws QueueException {
      this.queueName = queueName;
      this.transacted = transacted;
      this.ackMode = ackMode;
      this.init = false;
   }
 
   /**
    * Sends a message to the queue..
    *
    * @param msg
    * @throws QueueException
    */
   public void send(BulkMessage msg) throws QueueException {
      try {
         if ((qs != null) && (mp != null)) {
            ObjectMessage om = qs.createObjectMessage(msg);
            mp.send(om);
         } else {
            LOG.error("Queue is not running / mp==null ....");
         }
      } catch (JMSException e) {
         throw new QueueException(e);
      }
   }
 
   /*
    * Get / Receive a message from the queue The receive block at most
    *  miliseconds (0=block)
    */
   public ObjectMessage receive(long timeoutInMilisecs) throws QueueException {
 
      BulkMessage m = null;
      ObjectMessage om = null;
      try {
         if (qr != null) {
            om = (ObjectMessage) qr.receive(timeoutInMilisecs);
            if (om != null) {
               m = (BulkMessage) om.getObject();
            }
         } else {
            throw new QueueException("Queue receiver is null");
         }
      } catch (JMSException e) {
         throw new QueueException(e);
      }
      return om;
   }
 
   public QueueBrowser getBrowser() throws JMSException, QueueException {
      return qs.createBrowser(queue);
   }
 
   /**
    *
    */
   public void destroy() {
      try {
         if (qs != null) {
            qs.close();
            qs = null;
         }
         if (qc != null) {
            qc.stop();
            qc.close();
            qc = null;
         }
      } catch (Exception e) {
         LOG.error(e);
      }
   }
 
   public String getQueueName() {
      return queueName;
   }
 
   public void setQueueName(String queueName) {
      this.queueName = queueName;
   }
 
   public int getAckMode() {
      return ackMode;
   }
 
   public void setAckMode(int ackMode) {
      this.ackMode = ackMode;
   }
 
   public Queue getQueue() {
      return queue;
   }
 
   public void setQueue(Queue queue) {
      this.queue = queue;
   }
 
   public boolean isTransacted() {
      return transacted;
   }
 
   public void setTransacted(boolean transacted) {
      this.transacted = transacted;
   }
 
}

It was doing a JNDI lookup of the queuefactory, created a new session and started and closed it.
After I rewrote it to use Spring it looked like:

package nnet.pascalalma.jms;
 
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.ObjectMessage;
import javax.jms.Session;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
 
public class QueueBaseService {
 
   private static final Log LOG = LogFactory.getLog(QueueBaseService.class);
 
   private JmsTemplate jmsTemplate = null;
 
   public void setJmsTemplate(JmsTemplate jmsTemplate) {
      this.jmsTemplate = jmsTemplate;
   }
 
   public JmsTemplate getJmsTemplate() {
      return jmsTemplate;
   }
 
   public void sendMessage(final BulkMessage bm) {
      LOG.debug("sendMessage(final BulkMessage bm)");
 
      jmsTemplate.send( new MessageCreator() {
         public Message createMessage(Session session) throws JMSException {
            ObjectMessage om = session.createObjectMessage();
            om.setObject(bm);
            return om;
         }
      });
   }
 
   public ObjectMessage receiveMessage() {
      return (ObjectMessage)jmsTemplate.receive();
 
   }
 
   public String getQueueName() {
      return jmsTemplate.getDefaultDestinationName();
   }
 
   public void setAcknowledgeMode(int mode){
      jmsTemplate.setSessionAcknowledgeMode( mode);
   }
 
}

And of course some configuration of the queues and JNDI/JMS:

 version="1.0" encoding="UTF-8"?>

>
 
  
   id="jndiTemplate" class="org.springframework.jndi.JndiTemplate">
     name="environment">
      >
         key="java.naming.factory.initial">
           org.jnp.interfaces.NamingContextFactory
        >
         key="java.naming.provider.url">
           jnp://localhost:1099
        >
         key="java.naming.factory.url.pkgs">
           org.jboss.naming:org.jnp.interfaces
        >
      >
    >
  >
 
  
   id="jmsConnectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">
     name="jndiTemplate">
       bean="jndiTemplate"/>
    >
     name="jndiName">
      >ConnectionFactory>
    >
  >
 
   
   id="destination"  class="org.springframework.jndi.JndiObjectFactoryBean">
     name="jndiTemplate">
       bean="jndiTemplate"/>
    >
     name="jndiName">
      >${queue.in}>
    >
  >
 
  
   id="jmsTemplateQueue" class="org.springframework.jms.core.JmsTemplate102">
     name="connectionFactory">
       bean="jmsConnectionFactory"/>
    >
     name="defaultDestination">
       bean="destination"/>
    >
     name="receiveTimeout">
       >60000>
    >
    
     name="sessionAcknowledgeModeName">
       >AUTO_ACKNOWLEDGE>
    >
     name="sessionTransacted">
      >false>
    >
  >
 
  
   id="queueService" class="net.pascalalma.jms.QueueBaseService" >
     name="jmsTemplate">
       bean="jmsTemplateQueue" />
    >
  >
>

So not only does it take less code to achieve the same thing, it is also much less error prone. At least, that was what I would expect, but when I got back in the office one day later, started my machine and ran some unit tests (after synchronizing my code) I was running into an error:
[code]
Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'jmsConnectionFactory' defined in class path resource [jmsContext.xml]: Initialization of bean failed; nested exception is java.lang.NoSuchFieldError: doPruning
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:355)
at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:226)
at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:147)
at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(BeanDefinitionValueResolver.java:176)
... 33 more
Caused by: java.lang.NoSuchFieldError: doPruning
at org.jboss.aop.AOPClassPool.(AOPClassPool.java:49)
at java.lang.Class.forName0(Native Method)
at java.lang.Class.forName(Unknown Source)
at org.jboss.aop.instrument.InstrumentorFactory.class$(InstrumentorFactory.java:44)
at org.jboss.aop.instrument.InstrumentorFactory.(InstrumentorFactory.java:44)
at org.jboss.aop.AspectManager$2.run(AspectManager.java:316)
at java.security.AccessController.doPrivileged(Native Method)
at org.jboss.aop.AspectManager.instance(AspectManager.java:261)
at org.jboss.aop.AspectManager.instance(AspectManager.java:254)
at org.jboss.jms.client.delegate.ClientConnectionFactoryDelegate.(ClientConnectionFactoryDelegate.java)
at sun.misc.Unsafe.ensureClassInitialized(Native Method)
at sun.reflect.UnsafeFieldAccessorFactory.newFieldAccessor(Unknown Source)
at sun.reflect.ReflectionFactory.newFieldAccessor(Unknown Source)
at java.lang.reflect.Field.acquireFieldAccessor(Unknown Source)
at java.lang.reflect.Field.getFieldAccessor(Unknown Source)
at java.lang.reflect.Field.getLong(Unknown Source)
at java.io.ObjectStreamClass.getDeclaredSUID(Unknown Source)
at java.io.ObjectStreamClass.access$600(Unknown Source)
at java.io.ObjectStreamClass$2.run(Unknown Source)
at java.security.AccessController.doPrivileged(Native Method)
at java.io.ObjectStreamClass.(Unknown Source)
at java.io.ObjectStreamClass.lookup(Unknown Source)
at java.io.ObjectStreamClass.initNonProxy(Unknown Source)
at java.io.ObjectInputStream.readNonProxyDesc(Unknown Source)
at java.io.ObjectInputStream.readClassDesc(Unknown Source)
at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.defaultReadFields(Unknown Source)
at java.io.ObjectInputStream.readSerialData(Unknown Source)
at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
at java.io.ObjectInputStream.readObject0(Unknown Source)
at java.io.ObjectInputStream.readObject(Unknown Source)
at java.rmi.MarshalledObject.get(Unknown Source)
at org.jnp.interfaces.MarshalledValuePair.get(MarshalledValuePair.java:72)
at org.jnp.interfaces.NamingContext.lookup(NamingContext.java:652)
at org.jnp.interfaces.NamingContext.lookup(NamingContext.java:587)
at javax.naming.InitialContext.lookup(Unknown Source)
at org.springframework.jndi.JndiTemplate$1.doInContext(JndiTemplate.java:123)
at org.springframework.jndi.JndiTemplate.execute(JndiTemplate.java:85)
at org.springframework.jndi.JndiTemplate.lookup(JndiTemplate.java:121)
at org.springframework.jndi.JndiLocatorSupport.lookup(JndiLocatorSupport.java:71)
at org.springframework.jndi.JndiObjectLocator.lookup(JndiObjectLocator.java:106)
at org.springframework.jndi.JndiObjectFactoryBean.afterPropertiesSet(JndiObjectFactoryBean.java:125)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1003)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:348)
... 36 more
[/code]
After a short search it appeared two libraries were conflicting: I had both javassist-3.0.jar and javassist-3.2.jar at my classpath. It is only working with the 3.2 version from within Eclipse. If you’re using the older version you will get the error stack . So after solving this final issue the code not only looks better, it is also much easier to maintain.