I fixed the issue by adding the following dependencies to the project's pom.xml:

If I don't add this dependencies, apparently Spring WS is using the JBossWS libraries as default, and these libraries can't handle the StAX parsing/writing abilities of Spring WS.
So, after adding the necessary dependencies and redeploying the web service I got the expected response:

I don't know about other J(2)EE Servers but for this JBoss version you need these dependencies to get it working.

1. 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):

PLAIN TEXT
XML:
1. <settings>
2.   <localRepository>d:/maven2/repo/</localRepository>
3.   <profiles>
4.     <profile>
5.       <id>default-repositories</id>
6.       <repositories>
7.         <repository>
8.           <id>global</id>
9.           <name>External Mirror of Central Repository</name>
10.           <url>http://repo1.maven.org/maven2</url>
11.         </repository>
12.         <repository>
13.           <id>repo.maven</id>
14.           <url>http://repo1.maven.org/maven2-repoclean-java.net</url>
15.         </repository>
16.         <repository>
17.           <id>jboss.maven</id>
18.           <url>http://repository.jboss.com/maven2/</url>
19.         </repository>
20.       </repositories>
21.       <pluginRepositories>
22.         <pluginRepository>
23.           <id>repo1org</id>
24.           <name>External Plugin Repository</name>
25.           <url>http://repo1.maven.org/maven2/</url>
26.         </pluginRepository>
27.       </pluginRepositories>
28.     </profile>
29.     <profile>
30.         <id>dev-environment</id>
31.         <activation>
32.         <activeByDefault>true</activeByDefault>
33.           <property>
34.             <name>env</name>
35.             <value>dev</value>
36.           </property>
37.         </activation>
38.         <properties>
39.           <appserver.home>d:/java/jboss-4.0.5</appserver.home>
40.           <server.name>default</server.name>
41.         </properties>
42.     </profile>
43.   </profiles>
44.   <activeProfiles>
45.     <activeProfile>dev-environment</activeProfile>
46.     <activeProfile>default-repositories</activeProfile>
47.   </activeProfiles>
48. </settings>
2. 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

3. 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:

PLAIN TEXT
XML:
1. <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
2.         xmlns:hr="http://www.pascalalma.net/hr/schemas"
3.         elementFormDefault="qualified"
4.         targetNamespace="http://www.pascalalma.net/hr/schemas">
5.     <xs:element name="HolidayRequest">
6.         <xs:complexType>
7.             <xs:all>
8.                 <xs:element name="Holiday" type="hr:HolidayType"/>
9.                 <xs:element name="Employee" type="hr:EmployeeType"/>
10.             </xs:all>
11.         </xs:complexType>
12.     </xs:element>
13.     <xs:complexType name="HolidayType">
14.         <xs:sequence>
15.             <xs:element name="StartDate" type="xs:date"/>
16.             <xs:element name="EndDate" type="xs:date"/>
17.         </xs:sequence>
18.     </xs:complexType>
19.     <xs:complexType name="EmployeeType">
20.         <xs:sequence>
21.             <xs:element name="Number" type="xs:integer"/>
22.             <xs:element name="FirstName" type="xs:string"/>
23.             <xs:element name="LastName" type="xs:string"/>
24.         </xs:sequence>
25.     </xs:complexType>
26.     <xs:element name="HolidayResponse" type="hr:Status" />
27.     <xs:simpleType name="Status">
28.       <xs:restriction base="xs:string">
29.         <xs:enumeration value="DENIED"/>
30.         <xs:enumeration value="PENDING"/>
31.         <xs:enumeration value="APPROVED"/>
32.       </xs:restriction>
33.     </xs:simpleType>
34. </xs:schema>

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

4. 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:

PLAIN TEXT
XML:
1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
3.   "http://java.sun.com/dtd/web-app_2_3.dtd">
4. <web-app>
5.     <!-- === Servlets === -->
6.     <servlet>
7.         <servlet-name>spring-ws</servlet-name>
8.         <display-name>Spring-WS Servlet</display-name>
9.         <servlet-class>
10.             org.springframework.ws.transport.http.MessageDispatcherServlet
11.         </servlet-class>
12.         <init-param>
13.             <param-name>transformWsdlLocations</param-name>
14.             <param-value>true</param-value>
15.         </init-param>
16.     </servlet>
17.     <servlet-mapping>
18.         <servlet-name>spring-ws</servlet-name>
19.         <url-pattern>/services/*</url-pattern>
20.     </servlet-mapping>
21.     <welcome-file-list id="WelcomeFileList">
22.         <welcome-file>index.html</welcome-file>
23.     </welcome-file-list>
24. </web-app>
5. 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

6. 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

7. 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':

PLAIN TEXT
JAVA:
1. package net.pascalalma.ws;
2.  
3. import javax.xml.stream.XMLStreamReader;
4. import javax.xml.stream.XMLStreamWriter;
5.  
6. import net.pascalalma.model.HolidayRequest;
7. import net.pascalalma.xml.HolidayRequestReader;
8. import net.pascalalma.xml.HolidayResponseWriter;
9.  
10. import org.apache.commons.logging.Log;
11. import org.apache.commons.logging.LogFactory;
12. import org.springframework.ws.server.endpoint.AbstractStaxStreamPayloadEndpoint;
13.  
14. public class HolidayRequestService extends AbstractStaxStreamPayloadEndpoint
15. {
16.  
17.   private static final Log LOG = LogFactory.getLog(HolidayRequestService.class);
18.  
19.   @Override
20.   protected void invokeInternal(XMLStreamReader streamreader,
21.       XMLStreamWriter streamwriter) throws Exception
22.   {
23.     try
24.     {
25.       HolidayRequest hr = HolidayRequestReader.parseMessage(streamreader);
26.  
27.       LOG.info("Result = " + hr);
28.  
29.       HolidayResponseWriter.writeResponse(hr, streamwriter);
30.     } catch (Throwable t)
31.     {
32.       LOG.error("Catched exception", t);
33.     }
34.   }
35. }
8. 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:

PLAIN TEXT
XML:
1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
5.     <bean
6.         class="org.springframework.ws.server.endpoint.mapping.PayloadRootQNameEndpointMapping">
7.         <property name="mappings">
8.             <props>
9.                 <prop
10.                     key="{http://www.pascalalma.net/hr/schemas}HolidayRequest">
11.                     myEndPoint
12.                 </prop>
13.             </props>
14.         </property>
15.     </bean>
16.     <bean id="myEndPoint"
17.         class="net.pascalalma.ws.HolidayRequestService">
18.     </bean>
19.     <bean id="holiday"
20.         class="org.springframework.ws.wsdl.wsdl11.DefaultWsdl11Definition">
21.         <property name="schema" ref="schema" />
22.         <property name="portTypeName" value="HumanResource" />
23.         <property name="locationUri"
24.             value="http://localhost:8080/spring-ws-test/services/holidayService/" />
25.         <property name="targetNamespace"
26.             value="http://www.pascalalma.net/hr/definitions" />
27.     </bean>
28.     <bean id="schema"
29.         class="org.springframework.xml.xsd.SimpleXsdSchema">
30.         <property name="xsd" value="/WEB-INF/schemas/hr.xsd" />
31.     </bean>
32. </beans>
9. 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

10. 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:

PLAIN TEXT
XML:
1. <wsdl:definitions targetNamespace="http://www.pascalalma.net/hr/definitions">
2.   <wsdl:types>
3.     <xs:schema elementFormDefault="qualified" targetNamespace="http://www.pascalalma.net/hr/schemas">
4.       <xs:element name="HolidayRequest">
5.         <xs:complexType>
6.           <xs:all>
7.             <xs:element name="Holiday" type="hr:HolidayType"/>
8.             <xs:element name="Employee" type="hr:EmployeeType"/>
9.           </xs:all>
10.         </xs:complexType>
11.       </xs:element>
12.       <xs:complexType name="HolidayType">
13.         <xs:sequence>
14.           <xs:element name="StartDate" type="xs:date"/>
15.           <xs:element name="EndDate" type="xs:date"/>
16.         </xs:sequence>
17.       </xs:complexType>
18.       <xs:complexType name="EmployeeType">
19.         <xs:sequence>
20.           <xs:element name="Number" type="xs:integer"/>
21.           <xs:element name="FirstName" type="xs:string"/>
22.           <xs:element name="LastName" type="xs:string"/>
23.         </xs:sequence>
24.       </xs:complexType>
25.       <xs:element name="HolidayResponse" type="hr:Status"/>
26.       <xs:simpleType name="Status">
27.         <xs:restriction base="xs:string">
28.           <xs:enumeration value="DENIED"/>
29.           <xs:enumeration value="PENDING"/>
30.           <xs:enumeration value="APPROVED"/>
31.         </xs:restriction>
32.       </xs:simpleType>
33.     </xs:schema>
34.   </wsdl:types>
35.   <wsdl:message name="HolidayResponse">
36.     <wsdl:part element="sch:HolidayResponse" name="HolidayResponse">
37.     </wsdl:part>
38.   </wsdl:message>
39.   <wsdl:message name="HolidayRequest">
40.     <wsdl:part element="sch:HolidayRequest" name="HolidayRequest">
41.     </wsdl:part>
42.   </wsdl:message>
43.   <wsdl:portType name="HumanResource">
44.     <wsdl:operation name="Holiday">
45.       <wsdl:input message="tns:HolidayRequest" name="HolidayRequest">
46.       </wsdl:input>
47.       <wsdl:output message="tns:HolidayResponse" name="HolidayResponse">
48.       </wsdl:output>
49.     </wsdl:operation>
50.   </wsdl:portType>
51.   <wsdl:binding name="HumanResourceSoap11" type="tns:HumanResource">
52.     <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
53.     <wsdl:operation name="Holiday">
54.       <soap:operation soapAction=""/>
55.       <wsdl:input name="HolidayRequest">
56.         <soap:body use="literal"/>
57.       </wsdl:input>
58.       <wsdl:output name="HolidayResponse">
59.         <soap:body use="literal"/>
60.       </wsdl:output>
61.     </wsdl:operation>
62.   </wsdl:binding>
63.   <wsdl:service name="HumanResourceService">
64.     <wsdl:port binding="tns:HumanResourceSoap11" name="HumanResourceSoap11">
65.       <soap:address location="http://localhost:8080/spring-ws-test/services/holidayService/"/>
66.     </wsdl:port>
67.   </wsdl:service>
68. </wsdl:definitions>

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.

]]> http://blog.redstream.nl/2008/06/14/using-stax-with-spring-ws/feed/ 6 http://blog.redstream.nl/2007/07/25/weird-quartz-scheduler-behaviour/ http://blog.redstream.nl/2007/07/25/weird-quartz-scheduler-behaviour/#comments Wed, 25 Jul 2007 05:54:44 +0000 Pascal Alma http://www.pascalalma.net/?p=55 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:

PLAIN TEXT
JAVA:
1. if (job == null) {
2.     nextRun = scheduler.scheduleJob(trigger.getJobDetail(), trigger);
3. } else {
4.     nextRun = scheduler.rescheduleJob(trigger.getFullName(), trigger.getGroup(), trigger);
5. }

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

PLAIN TEXT
JAVA:
1. if (job == null) {
2.     nextRun = scheduler.scheduleJob(trigger.getJobDetail(), trigger);
3. } else {
4.     scheduler.deleteJob(trigger.getJobDetail().getName(), trigger.getJobDetail().getGroup());
5.     nextRun = scheduler.scheduleJob(trigger.getJobDetail(), trigger);
6. }
]]> http://blog.redstream.nl/2007/07/25/weird-quartz-scheduler-behaviour/feed/ 0 http://blog.redstream.nl/2007/06/28/configuring-durable-messages-with-springframework/ http://blog.redstream.nl/2007/06/28/configuring-durable-messages-with-springframework/#comments Thu, 28 Jun 2007 04:26:27 +0000 Pascal Alma http://www.pascalalma.net/?p=41 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':

PLAIN TEXT
XML:
1. <mbean code="org.jboss.jms.server.destination.TopicService"
2.            name="jboss.messaging.destination:service=Topic,name=myMessageTopic"
3.            xmbean-dd="xmdesc/Topic-xmbean.xml">
4.     <depends optional-attribute-name="ServerPeer">jboss.messaging:service=ServerPeer</depends>
5.     <depends>jboss.messaging:service=PostOffice</depends>
6.     <attribute name="DLQ">jboss.messaging.destination:service=Queue,name=DLQ</attribute>
7.     <attribute name="ExpiryQueue">jboss.messaging.destination:service=Queue,name=ExpiryQueue</attribute>
8. </mbean>

(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:

PLAIN TEXT
JAVA:
1. package net.pascalalma.logger;
2.  
3. import javax.jms.JMSException;
4. import javax.jms.Message;
5. import javax.jms.MessageListener;
6. import javax.jms.ObjectMessage;
7.  
8. import net.pascalalma.model.LogMelding;
9. import net.pascalalma.exceptions.StatisticsException;
10.  
11. import org.apache.commons.logging.Log;
12. import org.apache.commons.logging.LogFactory;
13.  
14. public class LoggerBean implements MessageListener {
15.  
16.    private static final Log LOG = LogFactory.getLog(LoggerBean.class);
17.  
18.    public void onMessage(Message msg) {
19.  
20.       LOG.info("onMessage(Message msg)");
21.  
22.       if (msg instanceof ObjectMessage) {
23.  
24.          ObjectMessage om = (ObjectMessage)msg;
25.          try {
26.             if ( om.getObject() instanceof LogMelding) {
27.                LogMelding lm = (LogMelding)((ObjectMessage)msg).getObject();
28.  
29.                LOG.info("LogMelding in Topic = " + lm);
30.             } else {
31.                throw new IllegalArgumentException("Only instances of LogMelding may be put in this Topic.");
32.             }
33.          } catch (JMSException je) {
34.             throw new StatisticsException(je);
35.          }
36.       } else {
37.          throw new IllegalArgumentException("Only ObjectMessages may be put in this Topic.");
38.       }
39.    }
40. }

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

PLAIN TEXT
XML:
1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE beans SYSTEM "../dtd/spring-beans.dtd">
3. <beans>
4.   <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
5.     <property name="locations">
6.       <list>
7.         <value>classpath:statistics.properties</value>
8.       </list>
9.     </property>
10.   </bean>
11.  
12.   <!--  JNDI properties -->
13.   <bean id="jndiTemplate"
14.     class="org.springframework.jndi.JndiTemplate">
15.     <property name="environment">
16.       <props>
17.         <prop key="java.naming.factory.initial">
18.           org.jnp.interfaces.NamingContextFactory
19.         </prop>
20.         <prop key="java.naming.provider.url">
21.           jnp://localhost:1099
22.         </prop>
23.         <prop key="java.naming.factory.url.pkgs">
24.           org.jboss.naming:org.jnp.interfaces
25.         </prop>
26.       </props>
27.     </property>
28.   </bean>
29.  
30.   <!--  JNDI Connection Factory -->
31.   <bean id="jmsConnectionFactory"
32.     class="org.springframework.jms.connection.SingleConnectionFactory">
33.     <property name="targetConnectionFactory">
34.       <bean
35.         class="org.springframework.jndi.JndiObjectFactoryBean">
36.         <property name="jndiTemplate" ref="jndiTemplate" />
37.         <property name="jndiName" value="myConnectionFactory" />
38.       </bean>
39.     </property>
40.     <property name="clientId" value="clientID"/>
41.   </bean>
42.   <!--  Destination for the incoming messages -->
43.   <bean id="myMessageTopic"
44.     class="org.springframework.jndi.JndiObjectFactoryBean">
45.     <property name="jndiTemplate">
46.       <ref bean="jndiTemplate" />
47.     </property>
48.     <property name="jndiName" value="${queue.log}" />
49.   </bean>
50.  
51.   <!-- The messageListenerContainer -->
52.   <bean id="myMsgTopiclistener"
53.     class="org.springframework.jms.listener.DefaultMessageListenerContainer">
54.     <property name="concurrentConsumers" value="1" />
55.     <property name="maxConcurrentConsumers" value="1" />
56.     <property name="connectionFactory" ref="jmsConnectionFactory" />
57.     <property name="sessionTransacted" value="true" />
58.     <property name="destination" ref="myMessageTopic" />
59.     <property name="messageListener" ref="loggerBean" />
60.     <property name="subscriptionDurable" value="true"/>
61.     <property name="durableSubscriptionName" value="myMsgTopiclistener"/>
62.   </bean>
63.  
64.    <!-- === Business Layer === -->
65.    <bean id="loggerBeanOriginal" class="net.pascalalma.logger.LoggerBean" />
66.  
67.    <!--  Business Layer Service is transactional -->
68.    <bean id="loggerBean" parent="txProxyParent">
69.       <property name="target" ref="loggerBeanOriginal" />
70.    </bean>
71. </beans>

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

PLAIN TEXT
XML:
1. <property name="clientId" value="clientID"/>

And the following properties at the myMsgTopiclistener bean:

PLAIN TEXT
XML:
1. <property name="subscriptionDurable" value="true"/>
2.   <property 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 :-)

]]> http://blog.redstream.nl/2007/06/28/configuring-durable-messages-with-springframework/feed/ 0 http://blog.redstream.nl/2007/04/26/scheduling-with-spring-and-quartz/ http://blog.redstream.nl/2007/04/26/scheduling-with-spring-and-quartz/#comments Thu, 26 Apr 2007 06:20:56 +0000 Pascal Alma http://www.pascalalma.net/?p=31 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:
PLAIN TEXT
JAVA:
1. public void resetScheduleJob() throws CustomSystemException {
2.  
3.       StdScheduler scheduler = (StdScheduler)MyQueueContext.getContext().getBean("scheduler");
4.  
5.       CronTriggerBean trigger = (CronTriggerBean)MyQueueContext.getContext().getBean("batchProducerTrigger");
6.  
7.       try {
8.            trigger.setCronExpression(getCronExpression());
9.  
10.            scheduler.scheduleJob(trigger.getJobDetail(), trigger);
11.  
12.       } catch (ParseException pe) {
13.          throw new CustomSystemException (pe);
14.       } catch (SchedulerException se) {
15.          throw new CustomSystemException (se);
16.       }
17.       LOG.info("Next run will be at: " + trigger.getNextFireTime());
18.    }
19. }
20. private String getCronExpression() {
21.  
22.       // Small trick to get the hours of the day correct.
23.       String hours = null;
24.       if (startTime> endTime) {
25.          hours = endTime + "-23,0-" + startTime;
26.       } else if (startTime <endTime) {
27.          hours = startTime + "-" + endTime;
28.       } else {
29.          hours = "0";
30.       }
31.       return "0 0/" + interval + " " + hours + " ? * " + days;
32.    }


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:

PLAIN TEXT
JAVA:
1. public void resetScheduleJob() throws CustomSystemException {
2.       StdScheduler scheduler = (StdScheduler)MyQueueContext.getContext().getBean("scheduler");
3.  
4.       CronTriggerBean trigger = (CronTriggerBean)MyQueueContext.getContext().getBean("batchProducerTrigger");
5.  
6.       try {
7.          trigger.setCronExpression(getCronExpression());
8.  
9.          scheduler.rescheduleJob(job.getName(), job.getGroup(), trigger);
10.  
11.          scheduler.start();
12.  
13.       } catch (ParseException pe) {
14.          throw new CustomSystemException (pe);
15.       } catch (SchedulerException se) {
16.          throw new CustomSystemException (se);
17.       }
18.       LOG.info("Next run will be at: " + trigger.getNextFireTime());
19.    }

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:

PLAIN TEXT
JAVA:
1. public void resetScheduleJob() throws CustomSystemException {
2.       StdScheduler scheduler = (StdScheduler)MyQueueContext.getContext().getBean("scheduler");
3.  
4.       CronTriggerBean trigger = (CronTriggerBean)MyQueueContext.getContext().getBean("batchProducerTrigger");
5.  
6.       try {
7.          trigger.setCronExpression(getCronExpression());
8.  
9.          JobDetail job = scheduler.getJobDetail(trigger.getJobDetail().getName(), trigger.getJobDetail().getGroup());
10.          LOG.debug("Job found = " + job);
11.  
12.          if (job == null) {
13.            scheduler.scheduleJob(trigger.getJobDetail(), trigger);
14.          } else {
15.             scheduler.rescheduleJob(job.getName(), job.getGroup(), trigger);
16.          }
17.  
18.          scheduler.start();
19.  
20.       } catch (ParseException pe) {
21.          throw new CustomSystemException (pe);
22.       } catch (SchedulerException se) {
23.          throw new CustomSystemException (se);
24.       }
25.       LOG.info("Next run will be at: " + trigger.getNextFireTime());
26.    }

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

PLAIN TEXT
XML:
1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE beans SYSTEM "../dtd/spring-beans.dtd">
3. <beans>
4.     <bean id="batchProducerJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
5.       <property name="targetObject" ref="batchProducer" />
6.       <property name="targetMethod" value="start" />
7.     </bean>
8.     <bean id="batchProducerTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
9.         <property name="jobDetail" ref="batchProducerJob" />
10.         </bean>
11.     <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
12.            <!-- intentionally left empty -->
13.     </bean>
14.         <bean id="batchProducerScheduler" class="net.pascalalma.batch.schedulers.BatchProducerScheduler">
15.         <property name="startTime" value="${batch.produce.starthour}" />
16.         <property name="endTime" value="${batch.produce.endhour}" />
17.         <property name="interval" value="${batch.produce.interval}" />
18.         <property name="days" value="${batch.produce.days}" />
19.        </bean>
20. </beans>
]]> http://blog.redstream.nl/2007/04/26/scheduling-with-spring-and-quartz/feed/ 8 http://blog.redstream.nl/2007/04/25/failure-trying-catching-an-uncategorizedsqlexception/ http://blog.redstream.nl/2007/04/25/failure-trying-catching-an-uncategorizedsqlexception/#comments Wed, 25 Apr 2007 04:45:06 +0000 Pascal Alma http://www.pascalalma.net/?p=30 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:
PLAIN TEXT
JAVA:
1. public void insert(final CustomObject e) throws CustomException {
2.       try {
3.          dao.insert(e);
4.       } catch (UncategorizedSQLException ex) {
5.          // We assume the geometry was invalid
6.          throw new CustomSystemException(CustomErrorMessage.CSM_SYS019, ex);
7.       } catch (DataAccessException ex) {
8.          throw new SystemException(ex);
9.       }
10.    }

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:

1. Use AOP to act on every thrown UncategorizedSQLException with a ThrowsAdvice and make it a CustomException.
2. To call flush() after each insert() and update() so the data is posted in the database right away.
3. 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.

]]> http://blog.redstream.nl/2007/04/25/failure-trying-catching-an-uncategorizedsqlexception/feed/ 0 http://blog.redstream.nl/2007/03/28/jms-spring-disadvantages/ http://blog.redstream.nl/2007/03/28/jms-spring-disadvantages/#comments Wed, 28 Mar 2007 18:12:52 +0000 Pascal Alma http://www.pascalalma.net/?p=24 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.
]]> http://blog.redstream.nl/2007/03/28/jms-spring-disadvantages/feed/ 0 http://blog.redstream.nl/2007/03/12/using-spring-jms/ http://blog.redstream.nl/2007/03/12/using-spring-jms/#comments Mon, 12 Mar 2007 19:59:49 +0000 Pascal Alma http://www.pascalalma.net/?p=23 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:
PLAIN TEXT
JAVA:
1. package net.pascalalma.jms;
2.  
3. import javax.jms.JMSException;
4. import javax.jms.MessageProducer;
5. import javax.jms.ObjectMessage;
6. import javax.jms.Queue;
7. import javax.jms.QueueBrowser;
8. import javax.jms.QueueConnection;
9. import javax.jms.QueueConnectionFactory;
10. import javax.jms.QueueReceiver;
11. import javax.jms.QueueSession;
12. import javax.naming.InitialContext;
13. import javax.naming.NamingException;
14.  
15. import org.apache.commons.logging.Log;
16. import org.apache.commons.logging.LogFactory;
17.  
18. public class QueueBase {
19.  
20.    private static final Log LOG = LogFactory.getLog(QueueBase.class);
21.  
22.    private static InitialContext context = null;
23.    private static QueueConnectionFactory qcf = null;
24.    private boolean transacted;
25.    private int ackMode;
26.    private String queueName;
27.    private boolean init = false;
28.    protected QueueConnection qc;
29.    protected QueueSession qs;
30.    protected Queue queue;
31.    protected QueueReceiver qr;
32.  
33.    protected MessageProducer mp;
34.  
35.    protected void init() throws QueueException {
36.       LOG.info("Queue init started");
37.       if (context == null) {
38.  
39.          try {
40.             LOG.info("QueueBase: creating InitialContext for queues (see jndi.properties)");
41.             context = new InitialContext();
42.             qcf = (QueueConnectionFactory) context.lookup("/ConnectionFactory");
43.          } catch (Exception e) {
44.             throw new QueueException(e);
45.          }
46.       }
47.  
48.       try {
49.          queue = (Queue) context.lookup(queueName);
50.          qc = qcf.createQueueConnection();
51.          qs = qc.createQueueSession(transacted, ackMode);
52.  
53.          assert (queue != null) : "queue is null";
54.          assert (qc != null) : "qc is null";
55.          assert (qs != null) : "qs is null";
56.  
57.          init = true;
58.       } catch (Exception e) {
59.          throw new QueueException(e);
60.       }
61.    }
62.  
63.    public QueueBase() {
64.       this.init = false;
65.    }
66.  
67.    public QueueBase(String queueName) {
68.       this.queueName = queueName;
69.       this.init = false;
70.    }
71.  
72.    /**
73.     * Constructor
74.     */
75.    public QueueBase(String queueName, boolean transacted, int ackMode) throws QueueException {
76.       this.queueName = queueName;
77.       this.transacted = transacted;
78.       this.ackMode = ackMode;
79.       this.init = false;
80.    }
81.  
82.    /**
83.     * Sends a message to the queue..
84.     *
85.     * @param msg
86.     * @throws QueueException
87.     */
88.    public void send(BulkMessage msg) throws QueueException {
89.       try {
90.          if ((qs != null) && (mp != null)) {
91.             ObjectMessage om = qs.createObjectMessage(msg);
92.             mp.send(om);
93.          } else {
94.             LOG.error("Queue is not running / mp==null ....");
95.          }
96.       } catch (JMSException e) {
97.          throw new QueueException(e);
98.       }
99.    }
100.  
101.    /*
102.     * Get / Receive a message from the queue The receive block at most
103.     * <timeoutInMilisecs> miliseconds (0=block)
104.     */
105.    public ObjectMessage receive(long timeoutInMilisecs) throws QueueException {
106.  
107.       BulkMessage m = null;
108.       ObjectMessage om = null;
109.       try {
110.          if (qr != null) {
111.             om = (ObjectMessage) qr.receive(timeoutInMilisecs);
112.             if (om != null) {
113.                m = (BulkMessage) om.getObject();
114.             }
115.          } else {
116.             throw new QueueException("Queue receiver is null");
117.          }
118.       } catch (JMSException e) {
119.          throw new QueueException(e);
120.       }
121.       return om;
122.    }
123.  
124.    public QueueBrowser getBrowser() throws JMSException, QueueException {
125.       return qs.createBrowser(queue);
126.    }
127.  
128.    /**
129.     *
130.     */
131.    public void destroy() {
132.       try {
133.          if (qs != null) {
134.             qs.close();
135.             qs = null;
136.          }
137.          if (qc != null) {
138.             qc.stop();
139.             qc.close();
140.             qc = null;
141.          }
142.       } catch (Exception e) {
143.          LOG.error(e);
144.       }
145.    }
146.  
147.    public String getQueueName() {
148.       return queueName;
149.    }
150.  
151.    public void setQueueName(String queueName) {
152.       this.queueName = queueName;
153.    }
154.  
155.    public int getAckMode() {
156.       return ackMode;
157.    }
158.  
159.    public void setAckMode(int ackMode) {
160.       this.ackMode = ackMode;
161.    }
162.  
163.    public Queue getQueue() {
164.       return queue;
165.    }
166.  
167.    public void setQueue(Queue queue) {
168.       this.queue = queue;
169.    }
170.  
171.    public boolean isTransacted() {
172.       return transacted;
173.    }
174.  
175.    public void setTransacted(boolean transacted) {
176.       this.transacted = transacted;
177.    }
178.  
179. }

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:

PLAIN TEXT
JAVA:
1. package nnet.pascalalma.jms;
2.  
3. import javax.jms.JMSException;
4. import javax.jms.Message;
5. import javax.jms.ObjectMessage;
6. import javax.jms.Session;
7.  
8. import org.apache.commons.logging.Log;
9. import org.apache.commons.logging.LogFactory;
10. import org.springframework.jms.core.JmsTemplate;
11. import org.springframework.jms.core.MessageCreator;
12.  
13. public class QueueBaseService {
14.  
15.    private static final Log LOG = LogFactory.getLog(QueueBaseService.class);
16.  
17.    private JmsTemplate jmsTemplate = null;
18.  
19.    public void setJmsTemplate(JmsTemplate jmsTemplate) {
20.       this.jmsTemplate = jmsTemplate;
21.    }
22.  
23.    public JmsTemplate getJmsTemplate() {
24.       return jmsTemplate;
25.    }
26.  
27.    public void sendMessage(final BulkMessage bm) {
28.       LOG.debug("sendMessage(final BulkMessage bm)");
29.  
30.       jmsTemplate.send( new MessageCreator() {
31.          public Message createMessage(Session session) throws JMSException {
32.             ObjectMessage om = session.createObjectMessage();
33.             om.setObject(bm);
34.             return om;
35.          }
36.       });
37.    }
38.  
39.    public ObjectMessage receiveMessage() {
40.       return (ObjectMessage)jmsTemplate.receive();
41.  
42.    }
43.  
44.    public String getQueueName() {
45.       return jmsTemplate.getDefaultDestinationName();
46.    }
47.  
48.    public void setAcknowledgeMode(int mode){
49.       jmsTemplate.setSessionAcknowledgeMode( mode);
50.    }
51.  
52. }

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

PLAIN TEXT
XML:
1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE beans SYSTEM "../dtd/spring-beans.dtd">
3. <beans>
4.  
5.   <!--  JNDI properties -->
6.   <bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate">
7.     <property name="environment">
8.       <props>
9.         <prop key="java.naming.factory.initial">
10.            org.jnp.interfaces.NamingContextFactory
11.         </prop>
12.         <prop key="java.naming.provider.url">
13.            jnp://localhost:1099
14.         </prop>
15.         <prop key="java.naming.factory.url.pkgs">
16.            org.jboss.naming:org.jnp.interfaces
17.         </prop>
18.       </props>
19.     </property>
20.   </bean>
21.  
22.   <!--  JNDI Connection Factory -->
23.   <bean id="jmsConnectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">
24.     <property name="jndiTemplate">
25.       <ref bean="jndiTemplate"/>
26.     </property>
27.     <property name="jndiName">
28.       <value>ConnectionFactory</value>
29.     </property>
30.   </bean>
31.  
32.    <!-- The default queue, for incoming bulk messages-->
33.   <bean id="destination"  class="org.springframework.jndi.JndiObjectFactoryBean">
34.     <property name="jndiTemplate">
35.       <ref bean="jndiTemplate"/>
36.     </property>
37.     <property name="jndiName">
38.       <value>${queue.in}</value>
39.     </property>
40.   </bean>
41.  
42.   <!-- Queue Access Object, for the default queue -->
43.   <bean id="jmsTemplateQueue" class="org.springframework.jms.core.JmsTemplate102">
44.     <property name="connectionFactory">
45.       <ref bean="jmsConnectionFactory"/>
46.     </property>
47.     <property name="defaultDestination">
48.       <ref bean="destination"/>
49.     </property>
50.     <property name="receiveTimeout">
51.        <value>60000</value>
52.     </property>
53.     <!--  this value can be overwritten by setting this parameter at business level-->
54.     <property name="sessionAcknowledgeModeName">
55.        <value>AUTO_ACKNOWLEDGE</value>
56.     </property>
57.     <property name="sessionTransacted">
58.       <value>false</value>
59.     </property>
60.   </bean>
61.  
62.   <!-- Queue service for the default queue -->
63.   <bean id="queueService" class="net.pascalalma.jms.QueueBaseService">
64.     <property name="jmsTemplate">
65.       <ref bean="jmsTemplateQueue" />
66.     </property>
67.   </bean>
68. </beans>

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:

PLAIN TEXT
CODE:
1. 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
2.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:355)
3.     at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:226)
4.     at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:147)
5.     at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveReference(BeanDefinitionValueResolver.java:176)
6.     ... 33 more
7. Caused by: java.lang.NoSuchFieldError: doPruning
8.     at org.jboss.aop.AOPClassPool.<clinit>(AOPClassPool.java:49)
9.     at java.lang.Class.forName0(Native Method)
10.     at java.lang.Class.forName(Unknown Source)
11.     at org.jboss.aop.instrument.InstrumentorFactory.class$(InstrumentorFactory.java:44)
12.     at org.jboss.aop.instrument.InstrumentorFactory.<clinit>(InstrumentorFactory.java:44)
13.     at org.jboss.aop.AspectManager$2.run(AspectManager.java:316)
14.     at java.security.AccessController.doPrivileged(Native Method)
15.     at org.jboss.aop.AspectManager.instance(AspectManager.java:261)
16.     at org.jboss.aop.AspectManager.instance(AspectManager.java:254)
17.     at org.jboss.jms.client.delegate.ClientConnectionFactoryDelegate.<clinit>(ClientConnectionFactoryDelegate.java)
18.     at sun.misc.Unsafe.ensureClassInitialized(Native Method)
19.     at sun.reflect.UnsafeFieldAccessorFactory.newFieldAccessor(Unknown Source)
20.     at sun.reflect.ReflectionFactory.newFieldAccessor(Unknown Source)
21.     at java.lang.reflect.Field.acquireFieldAccessor(Unknown Source)
22.     at java.lang.reflect.Field.getFieldAccessor(Unknown Source)
23.     at java.lang.reflect.Field.getLong(Unknown Source)
24.     at java.io.ObjectStreamClass.getDeclaredSUID(Unknown Source)
25.     at java.io.ObjectStreamClass.access$600(Unknown Source)
26.     at java.io.ObjectStreamClass$2.run(Unknown Source)
27.     at java.security.AccessController.doPrivileged(Native Method)
28.     at java.io.ObjectStreamClass.<init>(Unknown Source)
29.     at java.io.ObjectStreamClass.lookup(Unknown Source)
30.     at java.io.ObjectStreamClass.initNonProxy(Unknown Source)
31.     at java.io.ObjectInputStream.readNonProxyDesc(Unknown Source)
32.     at java.io.ObjectInputStream.readClassDesc(Unknown Source)
33.     at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
34.     at java.io.ObjectInputStream.readObject0(Unknown Source)
35.     at java.io.ObjectInputStream.defaultReadFields(Unknown Source)
36.     at java.io.ObjectInputStream.readSerialData(Unknown Source)
37.     at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
38.     at java.io.ObjectInputStream.readObject0(Unknown Source)
39.     at java.io.ObjectInputStream.readObject(Unknown Source)
40.     at java.rmi.MarshalledObject.get(Unknown Source)
41.     at org.jnp.interfaces.MarshalledValuePair.get(MarshalledValuePair.java:72)
42.     at org.jnp.interfaces.NamingContext.lookup(NamingContext.java:652)
43.     at org.jnp.interfaces.NamingContext.lookup(NamingContext.java:587)
44.     at javax.naming.InitialContext.lookup(Unknown Source)
45.     at org.springframework.jndi.JndiTemplate$1.doInContext(JndiTemplate.java:123)
46.     at org.springframework.jndi.JndiTemplate.execute(JndiTemplate.java:85)
47.     at org.springframework.jndi.JndiTemplate.lookup(JndiTemplate.java:121)
48.     at org.springframework.jndi.JndiLocatorSupport.lookup(JndiLocatorSupport.java:71)
49.     at org.springframework.jndi.JndiObjectLocator.lookup(JndiObjectLocator.java:106)
50.     at org.springframework.jndi.JndiObjectFactoryBean.afterPropertiesSet(JndiObjectFactoryBean.java:125)
51.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1003)
52.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:348)
53.     ... 36 more

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.

]]> http://blog.redstream.nl/2007/03/12/using-spring-jms/feed/ 5