Configurando JMS + Spring + JBoss

Recentemente precisei configurar um provedor/consumidor de mensagens no projeto em que estou trabalhando, o mesmo utiliza Spring, durante minha pesquisa sobre como configurar JMS no Spring me coloquei em diversos cenários confusos, o que me motivou a escrever tanto minha perspectiva sobre o que eu li e sobre como eu solucionei o meu problema para que caso alguém tenha o mesmo problema possa solucioná-lo de forma rápida e com embasamento técnico.

Eu precisava interceptar todas as requisições http e registrar dados referentes a navegação dos usuários do sistema que estou desenvolvendo, porém devido ao grande número de requisições e em horários específicos eu poderia sobrecarregar minha base de dados ao tentar persisti-los, a solução seria algo que funcionasse como uma espécie de buffer de requisições, algo que pudesse armazenar de forma linear. Java Message Service era o que eu precisava.

Uma pessoa me indicou utilizar o Apache ActiveMQ, uma solução JMS que não depende de container. Ao pesquisar sobre ele descobri que inúmeros projetos o utilizam e que é relativamente simples de se configurar, porém devido a alguns testes de performance e algumas premissas do meu projeto não pude utilizá-lo, espero poder testa-lo ainda um dia.

Após concluir que não utilizaria o ActiveMQ o que me restava era o JBossMQ uma implementação JMS provida pelo JBoss o que é excelente dado o meu contexto pois o mesmo não tornava meu projeto dependente de uma implementação de JMS específica, e com a vantagem de poder configurar e controlar minhas Filas/Tópicos (Queues/Topics) no console web do JBoss, e em tempo de execução. Muita pesquisa, muitos testes .. leitura pra cá, leitura pra lá .. é hora de implementar hehe, tempo é dinheiro né?!

No applicationContext.xml do meu spring coloquei os seguintes trechos XML para configurar o JMS e uma fila:

Lookup JNDI para a fábrica de conexões do seu servidor de aplicação:

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:jms="http://www.springframework.org/schema/jms"
       xmlns:jee="http://www.springframework.org/schema/jee"       
       xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms-3.0.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd" default-autowire="byName">

<jee:jndi-lookup jndi-name="QueueConnectionFactory" id="jmsConnectionFactory" expected-type="javax.jms.ConnectionFactory">
</jee:jndi-lookup>

Container de listeners JMS, é possível configurar vários containers com várias configurações distintas, cada um contendo diversas Filas/Tópicos. “Mas mestre Yoda, porquê eu iria querer escrever tudo isto enquanto eu poderia resumir tudo em um único container?”, o mestre responde: “Você ouvia Justin Bieber quando eu dei a lição sobre containers JMS, não é mesmo?”. O container é quem diz quantas instancias de cada listener vão poder ser instanciadas, é nele que você poderá dizer quem irá resolver o nome de sua fila caso tenha específicado uma fila dinâmica (essa fica pra outra aula, muhahahaha) e etc. O container é muito poderoso! Eis o que eu configurei, básico e atende as minhas necessidades:

<jms:listener-container concurrency="1" connection-factory="jmsConnectionFactory">
<jms:listener destination="HttpRequestQueue" ref="httpRequestQueueListener" />
</jms:listener-container>

Notem que o container possui uma referência ao nosso listener que eu mostrarei logo abaixo. Também é preciso criar um JMSTemplate, que é uma implementação específica do Spring para abstração de mensagens JMS, notem que ele utiliza uma referência da fábrica de conexões criada anteriormente:

<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
<property name="connectionFactory" ref="jmsConnectionFactory"/>
</bean>

Para concluir precisei criar um bean para representar minha fila em um objeto e também o listener (citado a cima) e o produtor de mensagens (que utiliza o JMSTemplate + o objeto da Fila):
A fila:

<jee:jndi-lookup jndi-name="queue/HttpRequestQueue" id="httpRequestQueue" expected-type="javax.jms.Queue">
</jee:jndi-lookup>

O listener:

<bean id="httpRequestQueueListener" class="br.com.latu.frontend.jms.HttpRequestQueueListener"/>

O produtor:

<bean id="httpRequestQueueSender" class="br.com.latu.frontend.jms.HttpRequestQueueSender">
<property name="jmsTemplate">
<ref bean="jmsTemplate"/>
</property>
<property name="destination">
<ref bean="httpRequestQueue"/>
</property>
</bean>

A classe do listener:

package br.com.latu.frontend.jms;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
import javax.jms.Session;

import org.apache.log4j.Logger;
import org.springframework.jms.listener.SessionAwareMessageListener;

public class HttpRequestQueueListener implements MessageListener, SessionAwareMessageListener {

	private static final Logger log = Logger.getLogger(HttpRequestQueueListener.class);

	public void onMessage(Message message) {

		try {

			this.onMessage(message, null);

		} catch(JMSException j) {

			HttpRequestQueueListener.getLog().debug(message, j);

		}

	}

	public void onMessage(Message message, Session session) throws JMSException {

		if (message instanceof ObjectMessage) {

			// No meu caso irei pegar um objeto deste lado e irei persistir.

		}

	}

	public static Logger getLog() {
		return log;
	}

}

package br.com.latu.frontend.jms;

import javax.jms.Destination;

import org.apache.log4j.Logger;
import org.springframework.jms.core.JmsTemplate;

public class HttpRequestQueueSender {

	private static final Logger log = Logger.getLogger(HttpRequestQueueSender.class);

	private JmsTemplate jmsTemplate;
	private Destination destination;

	public void sendObjectMessage(Object object) {
		try {

			if(object == null) throw new IllegalArgumentException();
			this.getJmsTemplate().convertAndSend(this.getDestination(), object);

		} catch(IllegalArgumentException e) {

			HttpRequestQueueSender.getLog().debug("The argument object can't be null.", e);

		}
	}

	public JmsTemplate getJmsTemplate() {
		return jmsTemplate;
	}

	public Destination getDestination() {
		return destination;
	}

	public void setJmsTemplate(JmsTemplate jmsTemplate) {
		this.jmsTemplate = jmsTemplate;
	}

	public void setDestination(Destination destination) {
		this.destination = destination;
	}

	public static Logger getLog() {
		return log;
	}

}

Notem que existe no código HttpRequestQueue e queue/HttpRequestQueue em alguns lugares, esta eu configurei no xml jbossmq-destinations-service.xml, com isso você já será capaz de interceptar mensagens enviadas para esta fila e enviar também. Caso tenham dúvidas e sugestões enviem comentários, responderei o mais rápido possível. Obrigado!

http://static.springsource.org/spring/docs/2.5.x/reference/jms.html