Le mode de file d'attente le plus simple dans Java RabbitMQ se compose d'un producteur et d'un consommateur.

RabbitMQ Simple Queue

Actuellement, les opérations Java avec RabbitMQ utilisent principalement le package spring-boot-starter-amqp de Spring Boot, qui utilise essentiellement Spring AMQP pour opérer la file d'attente.

1. Tutoriel préalable

Veuillez lire les chapitres suivants pour comprendre les connaissances pertinentes :

2. Package de dépendances

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

3. Configuration de RabbitMQ

Modifier la configuration application.yml :

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest

4. Déclaration de la file d'attente

Configurer la file d'attente via la classe de configuration de Spring Boot :

package com.tizi365.rabbitmq.config;

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class QueueConfig {
    @Bean
    public Queue helloQueue() {
        // Déclarer la file d'attente, le nom de la file d'attente doit être unique
        return new Queue("hello");
    }
}

Astuce : Vous pouvez définir plusieurs files d'attente en fonction des besoins métier. Le nom de la file d'attente et l'identifiant du bean de Queue doivent simplement être différents. Ici, le nom de la méthode est l'identifiant du bean.

5. Envoyer un message

L'envoi de messages nécessite la classe RabbitTemplate, qui a déjà été initialisée par Spring Boot. Il suffit d'injecter l'instance :

package com.tizi365.rabbitmq.service;

import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

@Service
public class SendService {
    // Injecter l'instance RabbitTemplate
    @Autowired
    private RabbitTemplate template;
    
    // Injecter la file d'attente précédemment définie
    @Autowired
    @Qualifier("helloQueue")
    private Queue helloQueue;
    
    // Pour la démonstration, nous utilisons la tâche planifiée intégrée de Spring pour envoyer régulièrement des messages (un message par seconde)
    @Scheduled(fixedDelay = 1000, initialDelay = 1000)
    public void send() {
        // Contenu du message
        String message = "Bonjour le monde !";
        // Envoyer le message
        // Le premier paramètre est la clé de routage, ici nous utilisons le nom de la file d'attente comme clé de routage
        // Le deuxième paramètre est le contenu du message, prenant en charge n'importe quel type tant qu'il prend en charge la sérialisation
        template.convertAndSend(helloQueue.getName(), message);
        System.out.println("Envoi du message '" + message + "'");
    }
}

Astuce : Ici, nous n'utilisons pas directement l'échange. L'échange par défaut sous-jacent (échange direct) sera utilisé.

6. Recevoir un message

Il est également simple pour le consommateur de recevoir des messages :

package com.tizi365.rabbitmq.listener;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
// Déclarer le récepteur de message, spécifier la file d'attente à écouter à travers le paramètre `queues`, qui doit être cohérent avec le nom de la file d'attente précédente
@RabbitListener(queues = "hello")
public class HelloListener {
	// Utiliser RabbitHandler pour marquer le gestionnaire de message, utilisé pour exécuter la logique de traitement du message
    @RabbitHandler
    public void receive(String msg) {
        System.out.println("Consommateur - Message reçu '" + msg + "'");
    }
}

7. Type de message personnalisé

Auparavant, nous avons envoyé un message de type chaîne. Dans des scénarios métier réels, nous préférerions envoyer directement différents types d'objets Java personnalisés.

Définir un objet entité

package com.tizi365.rabbitmq.domain;

import java.io.Serializable;
import lombok.Data;

// Contenu du blog
@Data
public class Blog implements Serializable {
    // identifiant
    private Integer id;
    // titre
    private String title;
}

Envoyer des messages de type personnalisé

Blog blog = new Blog();
blog.setId(100);
blog.setTitle("Tutoriel RabbitMQ Tizi365");

// Envoyer le message
template.convertAndSend(helloQueue.getName(), blog);

Recevoir des messages de type personnalisé

@RabbitHandler
// Modifiez simplement le paramètre de la méthode pour le type de message personnalisé
public void receive(Blog msg) {
    System.out.println("Consommateur - Message reçu : '" + msg.getTitle() + "'");
}

Utiliser la sérialisation JSON pour le contenu des messages

Lorsque RabbitMQ envoie des données d'objet entité Java, il utilise par défaut l'outil de sérialisation d'objet JDK. Nous pouvons le modifier pour utiliser le format JSON pour la sérialisation des données, ce qui permet à d'autres langages de consommer les messages envoyés par Java et rend le format du message plus lisible.

Modifiez la classe de configuration précédente et ajoutez la configuration suivante pour utiliser le parseur JSON Jackson pour la sérialisation et la désérialisation des données des messages.

@Bean
public Jackson2JsonMessageConverter messageConverter() {
    // Définir le convertisseur de message par défaut
    return new Jackson2JsonMessageConverter();
}