Como de costume o Sprint Boot vem facilitando a configuração dos projetos, no contexto de mensageria ficou ainda mais simples configurar o projeto para integrar como um sistema mensageria, onde com poucas configurações na classe de configuração do Spring e alguns parâmetros via properties é possível conectar a aplicação a um servidor de mensagem.

A Seguir, a demonstração da configuração de um projeto com Spring Boot que recebe as mensagens de um ActiveMQ standalone.

Adicionando dependências  no projeto

Adicionar a dependência do activeMQ no projeto.

pom.xml

 
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>1.4.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-activemq</artifactId>
        <version>1.4.0.RELEASE</version>
    </dependency>
</dependencies>

Configurando o acesso ao ActiveMQ

Definir as propriedades broker-url, user e password do ActiveMQ no application.properties.

/src/main/resources/application.properties

spring.activemq.broker-url=tcp://localhost:61616
spring.activemq.user=admin
spring.activemq.password=admin

É preciso utilizar o prefixo spring.activemq porque esse padrão já é mapeado na classe ActiveMQProperties do Spring Boot, dessa forma seguindo a nomenclatura definida na classe, o Spring boot interpreta os properties e configura automaticamente as configurações do ActiveMQ.

Na configuração acima, foi utilizada a URL para o ActiveMQ executado fora da aplicação, dessa forma o acesso é tcp://localhost, o que necessita que o servidor do AtiveMQ esteja sendo executado. Caso queria executar o ActiveMQ dentro da mesma instância da VM é só alterar a url para vm://localhost, mais informações podem ser encontradas no documentação de suporte ao Spring no ActiveMQ.

Observação: Caso não configurado nenhuma propriedade do activemq no properties, por padrão, seu comportamento é executar o ActiveMQ na mesma instância que o projeto, como se a URL estivesse configurada com vm://localhost.

Configurando o projeto

Para habilitar o JMS no Spring Boot é apenas preciso anotar a classe de configuração com @EnableJms e para configurar a fila(Queue) a ser utilizada, declarar um Bean que instância ActiveMQQueue, passando o nome da queue existente no ActiveMQ por parâmetro no construtor.

import org.apache.activemq.command.ActiveMQQueue;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.jms.annotation.EnableJms;

@SpringBootApplication
@ComponentScan(basePackageClasses = {Consumer.class})
@EnableJms
public class AppConfig {

    public static void main(String[] args) {
        ApplicationContext ctx = SpringApplication.run(AppConfig.class, args);
    }

    @Bean
    public Queue queue() {
        return new ActiveMQQueue("queue");
    }
}

Como foi utilizado o ActiveMQ fora da aplicação, a Queue foi configurada na própria tela de admin do ActiveMQ: http://localhost:8161/admin/queues.jsp.

Configurando Listener para recebe dados da fila

Para fazer leitura da fila, o JMS na versão 2.0 disponibiliza a anotação de Listener para que a aplicação possa escutar a fila, isso é possível anotando o método com a @JmsListener e passando o nome da fila no parâmetro destination.

 
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;

@Component
public class Consumer {

    @JmsListener(destination = "queue")
    public void receive(String msg) {
        System.out.println(msg);
    }

}

Enviando dados para a fila

Para enviar dados da aplicação para a fila, o JMS na versão 2.0 facilitou essa operação com a interface JmsMessagingTemplate, que abstrai toda configuração na classe de utilização e disponibiliza o envio através de um método send, apenas passando a queue e a mensagem desejada.

 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.stereotype.Component;

import javax.jms.Queue;

@Component
public class ArquivoSender {

    @Autowired
    private JmsMessagingTemplate jmsMessagingTemplate;

    @Autowired
    private Queue queue;

    public void send(String message) {
        this.jmsMessagingTemplate.convertAndSend(this.queue, message);
    }
}

Obs:Para injetar o JmsMessagingTemplate na classe é preciso que a anotação @EnableJms esteja na classe de configuração do Spring Boot (AppConfig).

Obs:Para injetar a Queue na classe é preciso que a configuração da Queue através de @Bean na classe de configuração do Spring Boot (AppConfig).

O Sprint Boot também tem suporte para outros sistemas de mensageria, além do ActiveMQ utilizado no post, a documentação apresenta suporte a outros como HornetQ, RabbitMQ, entre outros.