Redstream Blog » JMS http://blog.redstream.nl Pragmatic Integrators Sat, 21 Aug 2010 11:49:12 +0000 en hourly 1 Configuring durable messages with SpringFramework 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 JBoss Messaging installation and configuration http://blog.redstream.nl/2007/04/10/jboss-messaging-installation-and-configuration/ http://blog.redstream.nl/2007/04/10/jboss-messaging-installation-and-configuration/#comments Tue, 10 Apr 2007 17:41:28 +0000 Pascal Alma http://www.pascalalma.net/?p=25 Last week I installed JBoss Messaging 1.2.0.GA on our JBoss 4.0.5.GA instance. In this blog I will state the steps we performed to install the extension and configure it for our application. I am not sure this will be THE way to do it, but this is how it worked for us. Please note that JBoss Messaging will be standard in JBoss 5, but since we are working with JBoss 4.0.5 we have to install it ourselves.

  1. Well, as usual, the first step is to download the extension at this link. After obtaining the zip we extract it in some temporary directory.
  2. Second step is necessary if you don't have Ant 1.7 running at your machine already. This version of Ant is necessary for the installation. So if it is not at your machine you can download it here. Follow the instructions supplied with it to install it.
  3. Third step is also necessary if there hasn't been set a environment variable called 'JBOSS_HOME' pointing to your JBoss root directory. This environment variable is used by the Ant script to determine where to install the JBoss extension.

When this is all set you can browse to the directory '/jboss-messaging-1.2.0.GA/util' of the extracted jboss-messaging zip file and run Ant with the following command:
ant -f release-admin.xml

With this command the extension is installed and you will see in your JBoss instance a new server directory called 'messaging'. The next steps are the steps we performed to configure some queues and make them persisting themselves in a PostgreSQL 8 database.

To have JBoss persit its messages from the queue to Postgres it needs access to the Postgres JDBC driver. Therefor you need to copy the file 'postgresql-8.1-404.jdbc3.jar' (or your version) to the directory '$JBOSS_HOME$/server/messaging/lib'.

To tell JBoss how to access the Postgres database (define a datasource) we put a file called 'postgres-ds.xml' in the directory '$JBOSS_HOME$/server/bag/deploy/'. The file has the following content:

PLAIN TEXT
XML:
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <datasources>
  3.     <local-tx-datasource>
  4.         <jndi-name>JmsDS</jndi-name>
  5.     <connection-url>jdbc:postgresql://localhost/jms</connection-url>
  6.     <driver-class>org.postgresql.Driver</driver-class>
  7.     <user-name>jms</user-name>
  8.     <password>jms</password>
  9.     <new-connection-sql>select 1</new-connection-sql>
  10.     <check-valid-connection-sql>select 1</check-valid-connection-sql>
  11.     <!-- corresponding type-mapping in the standardjbosscmp-jdbc.xml (optional) -->
  12.     <metadata>
  13.     <type-mapping>PostgreSQL 8.1</type-mapping>
  14.     </metadata>
  15.   </local-tx-datasource>
  16. </datasources>

As you can see in the file it tries to connect to a database called 'JMS' at the localhost. It uses username 'JMS' and password 'JMS'. You must make sure this database exists and the user JMS has the rights to create database objects in the database.

Now JBoss is ready and we have to define the queues in JBoss Messaging. Since we use the default ConnectionFactory we do not have to add one and we just add a MBean to the file 'destinations-service.xml' in the directory '$JBOSS_HOME/server/messaging/deploy/jboss-messaging.sar/':

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

There is one more file that must be added to the directory '$JBOSS_HOME/server/bag/deploy/jboss-messaging.sar/': 'postgresql-persistence-service.xml'. The contents of this file:

PLAIN TEXT
XML:
  1. <?xml version="1.0" encoding="utf-8"?>
  2.  
  3. <!--
  4.      Postgresql non-clustered persistence deployment descriptor.
  6.      Tested with PostgresSQL 8.1.5
  8.      $Id: postgresql-persistence-service.xml 2449 2007-02-26 19:25:34Z timfox $
  9. -->
  10.  
  11. <server>
  12.  
  13.    <mbean code="org.jboss.messaging.core.plugin.JDBCPersistenceManagerService"
  14.          name="jboss.messaging:service=PgPersistenceManager"
  15.          xmbean-dd="xmdesc/JDBCPersistenceManager-xmbean.xml">
  16.          <depends>jboss.jca:service=DataSourceBinding,name=JmsDS</depends>
  17.          <depends optional-attribute-name="TransactionManager">jboss:service=TransactionManager</depends>
  18.          <attribute name="DataSource">java:/JmsDS</attribute>
  19.          <attribute name="CreateTablesOnStartup">true</attribute>
  20.          <attribute name="UsingBatchUpdates">true</attribute>
  21.        <attribute name="SqlProperties"><![CDATA[
  22.    CREATE_MESSAGE_REFERENCE=CREATE TABLE JBM_MSG_REF (CHANNEL_ID BIGINT, MESSAGE_ID BIGINT, TRANSACTION_ID BIGINT, STATE CHAR(1), ORD BIGINT, PAGE_ORD BIGINT, DELIVERY_COUNT INTEGER, SCHED_DELIVERY BIGINT, PRIMARY KEY(CHANNEL_ID, MESSAGE_ID))
  23.    CREATE_IDX_MESSAGE_REF_TX=CREATE INDEX JBM_MSG_REF_TX ON JBM_MSG_REF (TRANSACTION_ID)
  24.    CREATE_IDX_MESSAGE_REF_ORD=CREATE INDEX JBM_MSG_REF_ORD ON JBM_MSG_REF (ORD)
  25.    CREATE_IDX_MESSAGE_REF_PAGE_ORD=CREATE INDEX JBM_MSG_REF_PAGE_ORD ON JBM_MSG_REF (PAGE_ORD)
  26.    CREATE_IDX_MESSAGE_REF_MESSAGE_ID=CREATE INDEX JBM_MSG_REF_MESSAGE_ID ON JBM_MSG_REF (MESSAGE_ID)
  27.    CREATE_IDX_MESSAGE_REF_SCHED_DELIVERY=CREATE INDEX JBM_MSG_REF_SCHED_DELIVERY ON JBM_MSG_REF (SCHED_DELIVERY)
  28.    CREATE_MESSAGE=CREATE TABLE JBM_MSG (MESSAGE_ID BIGINT, RELIABLE CHAR(1), EXPIRATION BIGINT, TIMESTAMP BIGINT, PRIORITY SMALLINT, HEADERS BYTEA, PAYLOAD BYTEA, CHANNEL_COUNT INTEGER, TYPE SMALLINT, PRIMARY KEY (MESSAGE_ID))
  29.    CREATE_TRANSACTION=CREATE TABLE JBM_TX (TRANSACTION_ID BIGINT, BRANCH_QUAL BYTEA, FORMAT_ID INTEGER, GLOBAL_TXID BYTEA, PRIMARY KEY (TRANSACTION_ID))
  30.    CREATE_COUNTER=CREATE TABLE JBM_COUNTER (NAME VARCHAR(255), NEXT_ID BIGINT, PRIMARY KEY(NAME))
  31.    INSERT_MESSAGE_REF=INSERT INTO JBM_MSG_REF (CHANNEL_ID, MESSAGE_ID, TRANSACTION_ID, STATE, ORD, PAGE_ORD, DELIVERY_COUNT, SCHED_DELIVERY) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
  32.    DELETE_MESSAGE_REF=DELETE FROM JBM_MSG_REF WHERE MESSAGE_ID=? AND CHANNEL_ID=? AND STATE='C'
  33.    UPDATE_MESSAGE_REF=UPDATE JBM_MSG_REF SET TRANSACTION_ID=?, STATE='-' WHERE MESSAGE_ID=? AND CHANNEL_ID=? AND STATE='C'
  34.    UPDATE_PAGE_ORDER=UPDATE JBM_MSG_REF SET PAGE_ORD = ? WHERE MESSAGE_ID=? AND CHANNEL_ID=?
  35.    COMMIT_MESSAGE_REF1=UPDATE JBM_MSG_REF SET STATE='C', TRANSACTION_ID = NULL WHERE TRANSACTION_ID=? AND STATE='+'
  36.    COMMIT_MESSAGE_REF2=DELETE FROM JBM_MSG_REF WHERE TRANSACTION_ID=? AND STATE='-'
  37.    ROLLBACK_MESSAGE_REF1=DELETE FROM JBM_MSG_REF WHERE TRANSACTION_ID=? AND STATE='+'
  38.    ROLLBACK_MESSAGE_REF2=UPDATE JBM_MSG_REF SET STATE='C', TRANSACTION_ID = NULL WHERE TRANSACTION_ID=? AND STATE='-'
  39.    LOAD_PAGED_REFS=SELECT MESSAGE_ID, DELIVERY_COUNT, PAGE_ORD, SCHED_DELIVERY FROM JBM_MSG_REF WHERE CHANNEL_ID = ? AND PAGE_ORD BETWEEN ? AND ? ORDER BY PAGE_ORD
  40.    LOAD_UNPAGED_REFS=SELECT MESSAGE_ID, DELIVERY_COUNT, SCHED_DELIVERY FROM JBM_MSG_REF WHERE STATE = 'C' AND CHANNEL_ID = ? AND PAGE_ORD IS NULL ORDER BY ORD
  41.    LOAD_REFS=SELECT MESSAGE_ID, DELIVERY_COUNT, SCHED_DELIVERY FROM JBM_MSG_REF WHERE STATE = 'C' AND CHANNEL_ID = ? ORDER BY ORD
  42.    UPDATE_REFS_NOT_PAGED=UPDATE JBM_MSG_REF SET PAGE_ORD = NULL WHERE PAGE_ORD BETWEEN ? AND ? AND CHANNEL_ID=?
  43.    SELECT_MIN_MAX_PAGE_ORD=SELECT MIN(PAGE_ORD), MAX(PAGE_ORD) FROM JBM_MSG_REF WHERE CHANNEL_ID = ?
  44.    SELECT_EXISTS_REF=SELECT MESSAGE_ID FROM JBM_MSG_REF WHERE CHANNEL_ID = ? AND MESSAGE_ID = ?
  45.    SELECT_EXISTS_REF_MESSAGE_ID=SELECT MESSAGE_ID FROM JBM_MSG_REF WHERE MESSAGE_ID = ?
  46.    UPDATE_DELIVERY_COUNT=UPDATE JBM_MSG_REF SET DELIVERY_COUNT = ? WHERE CHANNEL_ID = ? AND MESSAGE_ID = ?
  47.    UPDATE_CHANNEL_ID=UPDATE JBM_MSG_REF SET CHANNEL_ID = ? WHERE CHANNEL_ID = ?
  48.    LOAD_MESSAGES=SELECT MESSAGE_ID, RELIABLE, EXPIRATION, TIMESTAMP, PRIORITY, HEADERS, PAYLOAD, TYPE FROM JBM_MSG
  49.    INSERT_MESSAGE=INSERT INTO JBM_MSG (MESSAGE_ID, RELIABLE, EXPIRATION, TIMESTAMP, PRIORITY, HEADERS, PAYLOAD, CHANNEL_COUNT, TYPE) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
  50.    INC_CHANNEL_COUNT=UPDATE JBM_MSG SET CHANNEL_COUNT = CHANNEL_COUNT + 1 WHERE MESSAGE_ID=?
  51.    DEC_CHANNEL_COUNT=UPDATE JBM_MSG SET CHANNEL_COUNT = CHANNEL_COUNT - 1 WHERE MESSAGE_ID=?
  52.    DELETE_MESSAGE=DELETE FROM JBM_MSG WHERE MESSAGE_ID=? AND CHANNEL_COUNT=0
  53.    MESSAGE_ID_COLUMN=MESSAGE_ID
  54.    MESSAGE_EXISTS=SELECT MESSAGE_ID FROM JBM_MSG WHERE MESSAGE_ID = ? FOR UPDATE
  55.    INSERT_TRANSACTION=INSERT INTO JBM_TX (TRANSACTION_ID, BRANCH_QUAL, FORMAT_ID, GLOBAL_TXID) VALUES(?, ?, ?, ?)
  56.    DELETE_TRANSACTION=DELETE FROM JBM_TX WHERE TRANSACTION_ID = ?
  57.    SELECT_PREPARED_TRANSACTIONS=SELECT TRANSACTION_ID, BRANCH_QUAL, FORMAT_ID, GLOBAL_TXID FROM JBM_TX
  58.    SELECT_MESSAGE_ID_FOR_REF=SELECT MESSAGE_ID, CHANNEL_ID FROM JBM_MSG_REF WHERE TRANSACTION_ID = ? AND STATE = '+' ORDER BY ORD
  59.    SELECT_MESSAGE_ID_FOR_ACK=SELECT MESSAGE_ID, CHANNEL_ID FROM JBM_MSG_REF WHERE TRANSACTION_ID = ? AND STATE = '-' ORDER BY ORD
  60.    UPDATE_COUNTER=UPDATE JBM_COUNTER SET NEXT_ID = ? WHERE NAME=?
  61.    SELECT_COUNTER=SELECT NEXT_ID FROM JBM_COUNTER WHERE NAME=? FOR UPDATE
  62.    INSERT_COUNTER=INSERT INTO JBM_COUNTER (NAME, NEXT_ID) VALUES (?, ?)
  63.    SELECT_ALL_CHANNELS=SELECT DISTINCT(CHANNEL_ID) FROM JBM_MSG_REF
  64.        ]]></attribute>
  65.  
  66.          <attribute name="MaxParams">500</attribute>
  67.    </mbean>
  68.  
  69.    <mbean code="org.jboss.messaging.core.plugin.DefaultPostOfficeService"
  70.       name="jboss.messaging:service=PostOffice"
  71.       xmbean-dd="xmdesc/DefaultPostOffice-xmbean.xml">
  72.       <depends optional-attribute-name="ServerPeer">jboss.messaging:service=ServerPeer</depends>
  73.       <depends>jboss.jca:service=DataSourceBinding,name=JmsDS</depends>
  74.       <depends optional-attribute-name="TransactionManager">jboss:service=TransactionManager</depends>
  75.       <attribute name="PostOfficeName">JMS</attribute>
  76.       <attribute name="DataSource">java:/JmsDS</attribute>
  77.       <attribute name="CreateTablesOnStartup">true</attribute>
  78.       <attribute name="SqlProperties"><![CDATA[
  79. CREATE_POSTOFFICE_TABLE=CREATE TABLE JBM_POSTOFFICE (POSTOFFICE_NAME VARCHAR(255), NODE_ID INTEGER, QUEUE_NAME VARCHAR(1023), COND VARCHAR(1023), SELECTOR VARCHAR(1023), CHANNEL_ID BIGINT, CLUSTERED CHAR(1))
  80. INSERT_BINDING=INSERT INTO JBM_POSTOFFICE (POSTOFFICE_NAME, NODE_ID, QUEUE_NAME, COND, SELECTOR, CHANNEL_ID, CLUSTERED) VALUES (?, ?, ?, ?, ?, ?, ?)
  81. DELETE_BINDING=DELETE FROM JBM_POSTOFFICE WHERE POSTOFFICE_NAME=? AND NODE_ID=? AND QUEUE_NAME=?
  82. LOAD_BINDINGS=SELECT NODE_ID, QUEUE_NAME, COND, SELECTOR, CHANNEL_ID, CLUSTERED FROM JBM_POSTOFFICE WHERE POSTOFFICE_NAME  = ?
  83.       ]]></attribute>
  84.    </mbean>
  85.  
  86.    <mbean code="org.jboss.jms.server.plugin.JDBCJMSUserManagerService"
  87.       name="jboss.messaging:service=JMSUserManager"
  88.       xmbean-dd="xmdesc/JMSUserManager-xmbean.xml">
  89.       <depends>jboss.jca:service=DataSourceBinding,name=JmsDS</depends>
  90.       <depends optional-attribute-name="TransactionManager">jboss:service=TransactionManager</depends>
  91.       <attribute name="DataSource">java:/JmsDS</attribute>
  92.       <attribute name="CreateTablesOnStartup">true</attribute>
  93.       <attribute name="SqlProperties"><![CDATA[
  94. CREATE_USER_TABLE=CREATE TABLE JBM_USER (USER_ID VARCHAR(32) NOT NULL, PASSWD VARCHAR(32) NOT NULL, CLIENTID VARCHAR(128), PRIMARY KEY(USER_ID))
  95. CREATE_ROLE_TABLE=CREATE TABLE JBM_ROLE (ROLE_ID VARCHAR(32) NOT NULL, USER_ID VARCHAR(32) NOT NULL, PRIMARY KEY(USER_ID, ROLE_ID))
  96. SELECT_PRECONF_CLIENTID=SELECT CLIENTID FROM JBM_USER WHERE USER_ID=?
  97. POPULATE.TABLES.1=INSERT INTO JBM_USER (USER_ID,PASSWD,CLIENTID) VALUES ('dilbert','dogbert','dilbert-id')
  98.       ]]></attribute>
  99.    </mbean>
  100.  
  101. </server>

By default the file 'hsqldb-persistence-service.xml' is added to the directory to perform the persistence with HSQLDB. This file must now be removed to avoid clashes in JBoss configuration. So remove the file.

One more thing to do is to tell the JBoss Messaging to use our new persistence manager: PgPersistenceManager. To do this edit the file 'messaging-service.xml' in the directory '$JBOSS_HOME/server/bag/deploy/jboss-messaging.sar/' and replace the next line:

PLAIN TEXT
XML:
  1. <depends optional-attribute-name="PersistenceManager">jboss.messaging:service=PersistenceManager</depends>

with:

PLAIN TEXT
XML:
  1. <depends optional-attribute-name="PersistenceManager">jboss.messaging:service=PgPersistenceManager</depends>

That was the final step. You should now be able to access the JMS Queues with Spring for example as I have blogged here.

]]> http://blog.redstream.nl/2007/04/10/jboss-messaging-installation-and-configuration/feed/ 2 JMS Spring disadvantages 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 Using Spring JMS 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