ActiveMQ com Spring Boot - Iniciando com esse Broker JMS

Você já utilizou ActiveMQ com Spring Boot em algum projeto? este broker é um poderoso sistema de mensagens de código aberto que fornece uma infraestrutura flexível e escalável para a comunicação entre diferentes aplicações. Baseado no protocolo Java Message Service (JMS), o ActiveMQ facilita a troca de mensagens entre componentes de software de forma assíncrona, confiável e eficiente.

Uma das principais características do ActiveMQ é sua capacidade de suportar uma variedade de padrões de integração, incluindo mensagens ponto a ponto, publish-subscribe (publicar e assinar) e filas de mensagens.

Isso permite que as aplicações se comuniquem de maneira flexível, independentemente de estarem distribuídas em diferentes plataformas, linguagens de programação ou localizações geográficas.

Como funciona o ActiveMQ?

O funcionamento do ActiveMQ pode ser resumido da seguinte forma:

Produtores de Mensagens: As aplicações que desejam enviar mensagens para outras aplicações são conhecidas como “produtores”. Essas mensagens podem conter informações, comandos, atualizações ou qualquer tipo de dados que precisam ser compartilhados com outras partes do sistema.
Consumidores de Mensagens: As aplicações que recebem e processam as mensagens são conhecidas como “consumidores”. Eles se conectam ao ActiveMQ para receber mensagens de determinados destinos, como filas ou tópicos.
Destinos: O ActiveMQ usa destinos para armazenar as mensagens. Existem dois tipos principais de destinos:
- Filas (Queues): Segue o modelo ponto a ponto, em que cada mensagem é entregue para um único consumidor. As mensagens em fila aguardam até que um consumidor as receba.
- Tópicos (Topics): Segue o modelo publish-subscribe (publicar e assinar), em que as mensagens são transmitidas para vários consumidores interessados no mesmo assunto (assinantes). Os tópicos permitem que várias aplicações recebam as mesmas mensagens.
Conexões e Sessões: As aplicações se conectam ao ActiveMQ por meio de conexões e criam sessões para enviar ou receber mensagens. Uma sessão define um contexto para troca de mensagens, permitindo que produtores criem mensagens e consumidores recebam essas mensagens.
Protocolos de Comunicação: O ActiveMQ suporta diferentes protocolos de comunicação, como TCP, HTTP, SSL, entre outros, para permitir a conexão de aplicações distribuídas em redes heterogêneas.

Passos de instalação do Apache ActiveMQ:

Antes de iniciar as configurações do projeto Spring Boot, precisamos baixar o ActiveMQ em nossa máquina, podemos baixar de 2 formas, pelo site oficinal do ActiveMQ ou se preferir vamos baixar uma imagem diretamente pelo Docker, seguindo os passos a seguir:

1. Baixar e executar o contêiner do ActiveMQ:

Abra um terminal ou prompt de comando e execute o seguinte comando para baixar e iniciar o contêiner do ActiveMQ:

docker run -p 61616:61616 -p 8161:8161 --name activemq webcenter/activemq:latest

-p 61616:61616: Mapeia a porta padrão do ActiveMQ para que seja acessível do host. A porta 61616 é a porta padrão para conexões JMS.
-p 8161:8161: Mapeia a porta do console web administrativo para acesso via navegador.
–name activemq: Define um nome para o contêiner (neste caso, “activemq”).
webcenter/activemq:latest: Especifica a imagem Docker usada para criar o contêiner. Esta é a imagem oficial do ActiveMQ mantida pelo Webcenter.

2. Acesso ao console Administrativo

Após executar o contêiner, você pode acessar o console administrativo do ActiveMQ no navegador da web digitando o seguinte endereço: http://localhost:8161/admin.

Use as credenciais padrão:

Usuário: admin
Senha: admin

Você irá se deparar com a pagina Home do ActiveMQ:

Passo 3: Configurar e Usar o ActiveMQ com Java

Adicionar dependência Maven

Se você estiver usando Maven, adicione a dependência do ActiveMQ ao seu arquivo pom.xml

<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-all</artifactId>
    <version>5.16.3</version>
</dependency>

Com a dependência geral em nosso projeto, precisamos criar um produtor de mensagens simples que enviará mensagens para uma fila do ActiveMQ:

package br.com.virandoprogramador.activemq

import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

public class MessageProducer {
    public static void main(String[] args) throws JMSException {
        // Conexão com o ActiveMQ
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        Connection connection = connectionFactory.createConnection();
        connection.start();

        // Criação de uma sessão
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

        // Criação de uma fila de destino
        Destination destination = session.createQueue("QUEUE.NAME");

        // Criação de um produtor
        MessageProducer producer = session.createProducer(destination);

        // Criação e envio de uma mensagem
        TextMessage message = session.createTextMessage("Teste MSG - Virando Programador");
        producer.send(message);

        // Fechamento das conexões
        session.close();
        connection.close();
    }
}

A classe MessageProducer é utilizada para enviar mensagens para um destino específico (como uma fila ou um tópico) em um sistema de mensageria baseado em JMS (Java Message Service). Ela desempenha um papel fundamental na comunicação entre aplicações através do envio de mensagens para o Apache ActiveMQ ou outros sistemas de mensageria que seguem o padrão JMS.

Após enviar todas as mensagens desejadas, é uma boa prática fechar a sessão e a conexão com o sistema de mensageria utilizando os métodos close() da sessão e da conexão, para liberar os recursos adequadamente.

Agora vamos criar a classe para consumir a mensagem:

package br.com.virandoprogramador.activemq

import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

public class MessageConsumer {
    public static void main(String[] args) throws JMSException {
        // Conexão com o ActiveMQ
        ConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
        Connection connection = connectionFactory.createConnection();
        connection.start();

        // Criação de uma sessão
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

        // Criação de uma fila de destino
        Destination destination = session.createQueue("QUEUE.NAME");

        // Criação de um consumidor
        MessageConsumer consumer = session.createConsumer(destination);

        // Recebimento e processamento de mensagens
        Message message = consumer.receive();
        if (message instanceof TextMessage) {
            TextMessage textMessage = (TextMessage) message;
            System.out.println("Mensagem recebida: " + textMessage.getText());
        }

        // Fechamento das conexões
        session.close();
        connection.close();
    }
}

Observações:

Não se esqueça de ter o ActiveMQ em execução antes de executar seus aplicativos Java.
Gerencie exceções e feche as conexões corretamente em suas aplicações para garantir a integridade e a liberação de recursos.
Este é um exemplo simples para demonstrar o funcionamento básico do ActiveMQ com Java. Em ambientes de produção, você pode precisar configurar segurança, transações, entre outros recursos avançados.

Espero que este guia básico seja útil para começar a trabalhar com o Apache ActiveMQ em conjunto com Java!

Para finalizar sobre o ActiveMQ com Spring Boot

O Apache ActiveMQ é uma plataforma de mensageria robusta e flexível que oferece uma infraestrutura confiável para a troca de mensagens assíncronas entre diferentes sistemas e aplicações. Baseado no padrão Java Message Service (JMS), o ActiveMQ facilita a comunicação confiável, escalável e eficiente, permitindo a integração de sistemas distribuídos em ambientes complexos.

Em resumo, o ActiveMQ opera utilizando filas (queues) e tópicos (topics) para o envio e recebimento de mensagens, seguindo o modelo ponto a ponto e o modelo publish-subscribe (publicar e assinar), respectivamente.

Em outras palavras seus principais pontos de funcionamento incluem a criação de conexões, sessões, produtores (MessageProducers) para envio de mensagens e consumidores (MessageConsumers) para recebimento e processamento das mensagens, ele não fica para traz se comparado com outros brokers como Kafka e RabbitMQ, cada um tem um modelo diferente para se trabalhar.

Pontos Positivos do ActiveMQ:

Padrão JMS: Segue o padrão Java Message Service, permitindo a interoperabilidade entre diferentes sistemas e linguagens de programação.
Flexibilidade e Escalabilidade: Oferece suporte a diversos modelos de mensageria, como filas e tópicos, e pode ser dimensionado conforme a demanda.
Confiabilidade: Garante a entrega confiável das mensagens, com opções de persistência e garantias de qualidade de serviço (QoS).
Ampla Comunidade e Suporte: Como uma solução de código aberto, possui uma comunidade ativa de desenvolvedores, oferecendo suporte, atualizações e recursos adicionais.
Recursos Avançados: Oferece recursos avançados, como clustering para alta disponibilidade, balanceamento de carga, suporte a transações distribuídas e integração com outros frameworks.

Pontos Negativos do ActiveMQ:

Complexidade de Configuração: Em ambientes complexos, a configuração e o gerenciamento podem se tornar complexos.
Desempenho em Grandes Cargas: Em situações de altas cargas, pode ser necessário ajustar configurações para otimizar o desempenho.
Possíveis Problemas de Conectividade: Dependendo da rede e do ambiente, podem surgir problemas de conectividade que precisam ser tratados.

Em geral, o Apache ActiveMQ é uma ferramenta poderosa para a implementação de sistemas de mensageria que oferece uma base sólida para a comunicação assíncrona e eficiente em ambientes distribuídos.

Seus pontos positivos superam seus desafios, especialmente quando configurado e gerenciado adequadamente, proporcionando uma comunicação confiável e escalável entre diferentes partes de um sistema distribuído.

5/5 - (1 vote)