Das einfachste Queue-Modell in Java RabbitMQ besteht aus einem Produzenten und einem Konsumenten.

RabbitMQ Simple Queue

Aktuell werden Java-Operationen mit RabbitMQ hauptsächlich über das spring-boot-starter-amqp-Paket von Spring Boot ausgeführt, das im Wesentlichen Spring AMQP zur Queue-Verwaltung verwendet.

1. Voraussetzungen Tutorial

Bitte lesen Sie die folgenden Kapitel, um das relevante Wissen zu verstehen:

2. Abhängigkeitspaket

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

3. Konfigurieren von RabbitMQ

Bearbeiten Sie die application.yml-Konfiguration:

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

4. Queue deklarieren

Konfigurieren Sie die Warteschlange über die Konfigurationsklasse von 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() {
        // Deklariere die Warteschlange, und der Warteschlangenname muss eindeutig sein
        return new Queue("hello");
    }
}

Tipp: Sie können je nach Geschäftsbedarf mehrere Queues definieren. Der Warteschlangenname und die Bean-ID der Warteschlange müssen sich nur unterscheiden. Hier ist der Methodenname die Bean-ID.

5. Nachricht senden

Das Senden von Nachrichten erfordert die RabbitTemplate-Klasse, die Spring Boot bereits für uns initialisiert hat. Injizieren Sie einfach die Instanz:

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 {
    // Injizieren Sie die RabbitTemplate-Instanz
    @Autowired
    private RabbitTemplate template;
    
    // Injizieren Sie die zuvor definierte Warteschlange
    @Autowired
    @Qualifier("helloQueue")
    private Queue helloQueue;
    
    // Zur Demonstration verwenden wir die eingebaute geplante Aufgabe von Spring, um regelmäßig Nachrichten zu senden (eine Nachricht pro Sekunde)
    @Scheduled(fixedDelay = 1000, initialDelay = 1000)
    public void send() {
        // Nachrichteninhalt
        String nachricht = "Hallo Welt!";
        // Sende die Nachricht
        // Der erste Parameter ist der Routing-Key, hier verwenden wir den Warteschlangennamen als Routing-Key
        // Der zweite Parameter ist der Nachrichteninhalt, der jede Art von Typ unterstützt, solange er serialisierbar ist
        template.convertAndSend(helloQueue.getName(), nachricht);
        System.out.println("Sende Nachricht '" + nachricht + "'");
    }
}

Tipp: Hier verwenden wir den Austausch nicht direkt. Der zugrunde liegende Standardaustausch (Direkter Austausch) wird verwendet.

6. Nachricht empfangen

Auch für den Konsumenten ist das Empfangen von Nachrichten einfach:

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
// Deklariere den Nachrichtenempfänger, gibt die zu lauschende Warteschlange durch das `queues`-Parameter an, der mit dem vorherigen Warteschlangennamen übereinstimmen muss
@RabbitListener(queues = "hello")
public class HelloListener {
	// Verwende RabbitHandler, um den Nachrichtenhandler zu kennzeichnen, der zur Ausführung der Nachrichtenverarbeitungslogik verwendet wird
    @RabbitHandler
    public void empfangen(String nachricht) {
        System.out.println("Konsument - Erhaltene Nachricht '" + nachricht + "'");
    }
}

7. Benutzerdefinierter Nachrichtentyp

Zuvor haben wir eine Nachricht vom Typ String gesendet. In tatsächlichen Geschäftsszenarien würden wir es vorziehen, direkt verschiedene benutzerdefinierte Java-Objekttypen von Daten zu senden.

Definiere ein Entity-Objekt

package com.tizi365.rabbitmq.domain;

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

// Bloginhalt
@Data
public class Blog implements Serializable {
    // id
    private Integer id;
    // titel
    private String titel;
}

Senden von benutzerdefinierten Nachrichten

Blog blog = new Blog();
blog.setId(100);
blog.setTitel("Tizi365 RabbitMQ Tutorial");

// Nachricht senden
template.convertAndSend(helloQueue.getName(), blog);

Empfangen von benutzerdefinierten Nachrichtentypen

@RabbitHandler
// Ändern Sie einfach den Methodenparameter auf den benutzerdefinierten Nachrichtentyp
public void receive(Blog msg) {
    System.out.println("Consumer - Nachricht erhalten: '" + msg.getTitle() + "'");
}

Verwendung von JSON-Serialisierung für Nachrichteninhalt

Wenn RabbitMQ Java-Objektdaten sendet, verwendet es standardmäßig das JDK-Objektserialisierungstool. Wir können es ändern, um JSON-Format für die Datenserialisierung zu verwenden, was es anderen Sprachen ermöglicht, von Java gesendete Nachrichten zu konsumieren und das Nachrichtenformat lesbarer macht.

Ändern Sie die frühere Konfigurationsklasse und fügen Sie die folgende Konfiguration hinzu, um den Jackson JSON-Parser für die Serialisierung und Deserialisierung von Nachrichtendaten zu verwenden.

@Bean
public Jackson2JsonMessageConverter messageConverter() {
    // Setze den Standard-Message-Konverter
    return new Jackson2JsonMessageConverter();
}