Es ist lange her, Freunde, und heute werde ich wieder Trockenwaren mit euch teilen. Wir wissen, dass RabbitMQ über einen einfachen Modus, einen Arbeitswarteschlangenmodus, einen Veröffentlichungsabonnementmodus, einen Routingmodus, einen Themenmodus, einen Remoteprozeduraufrufmodus, einen Herausgeberbestätigungsmodus usw. verfügt. Bei so vielen Modi kann es für Sie schwierig sein, sie alle auf einmal zu verstehen. Heute stellt Herr Yuan hauptsächlich den relevanten Inhalt des Publish/Subscribe-Modus Publish/Subscribe vor.
SpringBoot integriert die RabbitMQ-Middleware, um den Nachrichtendienst zu realisieren, der hauptsächlich aus drei Teilen besteht: benutzerdefinierte Middleware, Nachrichtensender sendet Nachrichten und Nachrichtenkonsumenten empfangen Nachrichten. Unter anderem ist die Anpassung der Middleware eine umständliche Arbeit und muss vorab angepasst werden.
Im Folgenden wird als Beispiel das Szenario des gleichzeitigen Sendens von E-Mail-Benachrichtigungen und SMS-Benachrichtigungen nach erfolgreicher Benutzerregistrierung verwendet. Dabei werden API-basierte, konfigurationsbasierte und annotationsbasierte Methoden verwendet, um die Integration des Publish/Subscribe-Arbeitsmodus zu realisieren .
API-basierter Ansatz
Die API-basierte Methode bezieht sich auf die Verwendung der vom Spring-Framework bereitgestellten API-Verwaltungsklasse AmqpAdmin, um die Nachrichtensendekomponente anzupassen und die Nachricht zu senden. Diese Methode zum Anpassen von Komponenten zum Senden von Nachrichten entspricht im Wesentlichen der Implementierung von Komponentenoperationen über das entsprechende Bedienfeld auf der visuellen Benutzeroberfläche von RabbitMQ. Sie verwendet die Identität des Administrators, um den Switch, die Warteschlange, den Routing-Schlüssel usw. im Voraus manuell zu deklarieren. Stellen Sie dann die Nachrichtenwarteschlange zusammen und rufen Sie das Anwendungsprogramm auf, um den Nachrichtendienst zu realisieren. Im Folgenden erklären und demonstrieren wir diesen API-basierten Ansatz.
1. Verwenden Sie AmqpAdmin, um die Komponenten zum Senden von Nachrichten anzupassen
Wir öffnen zunächst die Testklasse Chapter08ApplicationTests des Projekts Chapter08 und stellen die Nachrichtenkomponenten vor, die die AmqpAdmin-Verwaltungsklasse benötigt, um den Publish/Subscribe-Arbeitsmodus in der Testklasse anzupassen.
package com.ytx;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.core.AmqpAdmin;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class Chapter08ApplicationTests {
@Autowired
private AmqpAdmin amqpAdmin;
@Test
void contextLoads() {
}
/** 使用AmqpAdmin管理员API定制消息组件 */
@Test
public void amqpAdmin() {
// 1.定义fanout类型的交换器
amqpAdmin.declareExchange(new FanoutExchange("fanout_exchange"));
// 2.定义两个默认持久化队列，分别处理email和sms
amqpAdmin.declareQueue(new Queue("fanout_queue_email"));
amqpAdmin.declareQueue(new Queue("fanout_queue_sms"));
// 3.将队列分别与交换器进行绑定
amqpAdmin.declareBinding(new Binding("fanout_queue_email", Binding.DestinationType.QUEUE, "fanout_exchange", "", null));
amqpAdmin.declareBinding(new Binding("fanout_queue_sms", Binding.DestinationType.QUEUE, "fanout_exchange", "", null));
}
}Führen Sie die obige Komponententestmethode amqpAdmin() aus, um den Anpassungseffekt der RabbitMQ-Nachrichtenkomponente zu überprüfen. Nachdem die Unit-Test-Methode erfolgreich ausgeführt wurde, können Sie den Effekt über das Bedienfeld „Exchanges“ der visuellen Verwaltungsseite von RabbitMQ anzeigen.
Wie aus der obigen Abbildung ersichtlich ist, wird im Bedienfeld „Austausche“ der visuellen Verwaltungsseite von RabbitMQ ein neuer Schalter mit dem Namen fanout_exchange angezeigt (die anderen 7 Schalter sind von RabbitMQ integriert), und sein Typ ist der von uns festgelegte Fanout-Typ. Wir können auf die Börse fanout_exchange klicken, um sie anzuzeigen.
Wie aus der obigen Abbildung ersichtlich ist, werden auf der Austauschdetailseite von fanout_exchange die spezifischen Informationen des Austauschs sowie die beiden daran gebundenen Nachrichtenwarteschlangen fanout_queue_email und fanout_queue_sms angezeigt, die mit den im Programm festgelegten Bindungsregeln übereinstimmen. Wechseln Sie zur Bedienfeldseite „Warteschlangen“, um die benutzerdefinierten Informationen zur Nachrichtenwarteschlange anzuzeigen.
Wie aus der obigen Abbildung ersichtlich ist, werden die Informationen zur benutzerdefinierten Nachrichtenwarteschlange auf der Seite des Warteschlangenfensters „Warteschlangen“ angezeigt, was mit der benutzerdefinierten Nachrichtenwarteschlange im Programm übereinstimmt. Wir können auf den Namen der Nachrichtenwarteschlange klicken, um die Details jeder Warteschlange anzuzeigen.
Durch die oben genannten Vorgänge kann festgestellt werden, dass die benutzerdefinierten Funktionen des Nachrichtenkomponentenaustauschers und der Warteschlange auf der Verwaltungsseite bereitgestellt werden. Unter Verwendung der vom Spring-Framework im Programm bereitgestellten Administrator-API-Komponente AmqpAdmin ist das Anpassen der Nachrichtenkomponente im Wesentlichen dasselbe wie das manuelle Anpassen der Nachrichtenkomponente auf der Verwaltungsseite.
2. Der Absender der Nachricht sendet die Nachricht
Erstellen Sie nach Abschluss der Anpassung der Nachrichtenkomponente einen Nachrichtensender, um Nachrichten an die Nachrichtenwarteschlange zu senden. Beim Senden einer Nachricht können wir eine Entitätsklasse verwenden, um die Nachricht zu übergeben, und wir müssen im Voraus ein Entitätsklassenobjekt erstellen.
Erstellen Sie zunächst ein Paket mit dem Namen com.cy.domain im Projekt Chapter08 und erstellen Sie unter diesem Paket eine Entitätsklasse User.
package com.ytx.domain;
/** 发布消息的实体类可以通过实现Serializable序列化接口进行发布 */
public class User {
private Integer id;
private String username;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
'}';
}
}Zweitens verwenden wir in der Projekttestklasse Chapter08ApplicationTests die vom Spring-Framework bereitgestellte RabbitTemplate-Vorlagenklasse, um das Senden von Nachrichten zu implementieren.
@Autowired
private RabbitTemplate rabbitTemplate;
/** 1.Publish/Subscribe工作模式消息发送端 */
@Test
public void subPublisher() {
User user = new User();
user.setId(1);
user.setUsername("小明");
rabbitTemplate.convertAndSend("fanout_exchange", "", user);
}Im obigen Code verwenden wir zunächst die Annotation @Autowired, um das von der Nachrichten-Middleware verwaltete RabbitTemplate-Komponentenobjekt einzuführen, und verwenden dann die Methode „convertAndSend“ (String Exchange, String RoutingKey, Object Object) der Template-Tool-Klasse, um die Nachricht zu veröffentlichen. Der erste Parameter in dieser Methode gibt den Austausch an, der die Nachricht sendet, und der Wert dieses Parameters muss mit dem zuvor angepassten Austauschnamen übereinstimmen. Der zweite Parameter gibt den Routing-Schlüssel an, da er den Publish/Subscribe-Arbeitsmodus implementiert muss nicht angegeben werden; Der dritte Parameter ist der Inhalt der zu sendenden Nachricht und der Objekttyp, der empfangen wird.
Führen Sie dann die Testmethode subPublisher () des obigen Nachrichtenversands aus. Der Konsolenausführungseffekt ist in der folgenden Abbildung dargestellt.
Wie aus der obigen Abbildung ersichtlich ist, tritt im Programm beim Senden einer Objektnachricht der Entitätsklasse eine Ausnahme auf. Aus den Ausnahmeinformationen „SimpleMessageConverter unterstützt nur String-, Byte[]- und Serialisierbare Nutzlasten“ ist ersichtlich, dass der SimpleMessageConverter-Konverter vorhanden ist Wird standardmäßig für die Nachrichtenkonvertierung während des Nachrichtensendeprozesses verwendet. Bei der Speicherung unterstützt der Konverter nur serialisierte Nachrichten von Zeichenfolgen oder Entitätsklassenobjekten. Da es sich bei der in der Testklasse gesendeten Nachricht jedoch um die Objektnachricht der Benutzerentitätsklasse handelt, tritt eine Ausnahme auf.
Wenn wir die oben genannten Anomalien in der Nachrichten-Middleware, die Nachrichten der Entitätsklasse sendet, beheben möchten, können wir normalerweise zwei Lösungen anwenden: Die erste besteht darin, die mit JDK gelieferte serialisierbare Serialisierungsschnittstelle zu implementieren; die zweite darin, andere Arten von Nachrichtenkonvertern anzupassen. Beide Implementierungsmethoden sind machbar. Im Vergleich zur zweiten Implementierungsmethode ist der Visualisierungseffekt der ersten Methode nach der Implementierung schlecht und die konvertierte Nachricht kann nicht erkannt werden, sodass im Allgemeinen die zweite Methode verwendet wird.
Dann erstellen wir ein Paket mit dem Namen com.ytx.config im Projekt Chapter08 und erstellen unter diesem Paket eine RabbitMQ-Nachrichtenkonfigurationsklasse RabbitMQConfig.
package com.ytx.config;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/** RabbitMQ消息配置类 */
@Configuration
public class RabbitMQConfig {
/** 定制JSON格式的消息转换器 */
@Bean
public MessageConverter messageConverter() {
return new Jackson2JsonMessageConverter();
}
}Erstellen Sie im Code eine RabbitMQ-Nachrichtenkonfigurationsklasse RabbitMQConfig und passen Sie eine Nachrichtenkonverterkomponente vom Typ Jackson2JsonMessageConverter über die @Bean-Annotation in der Konfigurationsklasse an. Der Rückgabewert dieser Komponente muss vom Typ MessageConverter sein.
Führen Sie die Methode subPublisher() erneut aus. Nachdem die Methode erfolgreich ausgeführt wurde, sehen Sie sich die Informationen im Bereich „Warteschlangen“ auf der visuellen Verwaltungsseite von RabbitMQ an.
Wie aus der obigen Abbildung ersichtlich ist, muss nach dem Senden der Nachricht jede der beiden im Publish/Subscribe-Arbeitsmodus gebundenen Nachrichtenwarteschlangen eine Nachricht empfangen. Da noch kein Nachrichtenkonsument bereitgestellt wurde, wird die von gesendete Nachricht gesendet Die Testklasse befindet sich gerade vorübergehend in der Warteschlange. Gehen Sie zur Seite mit den Warteschlangendetails, um Nachrichten anzuzeigen.
3. Der Nachrichtenkonsument empfängt die Nachricht
Erstellen Sie im Projekt Chapter08 ein Paket mit dem Namen com.ytx.service und erstellen Sie einen RabbitMQService der Business-Klasse zum Empfangen und Verarbeiten von Nachrichten für die RabbitMQ-Nachrichten-Middleware unter diesem Paket.
package com.ytx.chapter08.service;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;
/** RabbitMQ消息接收处理的业务类 */
@Service
public class RabbitMQService {
/** Publish/Subscribe工作模式接收，处理邮件业务 */
@RabbitListener(queues = "fanout_queue_email")
public void subConsumerEmail(Message message) {
byte[] body = message.getBody();
String msg = new String(body);
System.out.println("邮件业务接收到消息：" + msg);
}
/** Publish/Subscribe工作模式接收，处理短信业务 */
@RabbitListener(queues = "fanout_queue_sms")
public void subConsumerSms(Message message) {
byte[] body = message.getBody();
String msg = new String(body);
System.out.println("短信业务接收到消息：" + msg);
}
}Im obigen Code wird eine Geschäftsverarbeitungsklasse RabbitMQService erstellt, die RabbitMQ-Nachrichten empfängt und verarbeitet. Mithilfe der vom Spring-Framework in dieser Klasse bereitgestellten Annotation @RabbitListener können wir Nachrichten abhören, deren Warteschlangennamen fanout_queue_email und fanout_queue_sms sind. Die beiden Warteschlangen zu Die zu überwachenden Werte sind die vorherigen. Gibt die Nachrichtenwarteschlange an, an die Nachrichten gesendet und gespeichert werden sollen.
Es ist zu beachten, dass nach der Verwendung der @RabbitListener-Annotation zum Abhören von Warteschlangennachrichten, sobald der Dienst startet und überwacht, dass sich eine Nachricht in der angegebenen Warteschlange befindet (derzeit befindet sich in jeder der beiden Warteschlangen eine identische Nachricht), die entsprechende Methode Die Anmerkung erhält sie sofort und konsumiert Nachrichten aus der Warteschlange. Darüber hinaus kann bei der Methode zum Empfangen einer Nachricht der Parametertyp mit dem gesendeten Nachrichtentyp übereinstimmen oder der Objekttyp und der Nachrichtentyp verwendet werden. Wenn die Nachricht mit Parametern empfangen wird, die dem Nachrichtentyp entsprechen, können nur die spezifischen Nachrichtentextinformationen abgerufen werden. Wenn die Nachricht mit Objekt- oder Nachrichtentypparametern empfangen wird, können auch andere Nachrichtenparameterinformationen als MessageProperties der Nachricht abgerufen werden.
Starten Sie das Projekt Chapter08. Der auf der Konsole angezeigte Nachrichtenverbrauchseffekt ist in der folgenden Abbildung dargestellt.
Wie aus der obigen Abbildung ersichtlich ist, hört der Nachrichtenkonsument nach erfolgreichem Projektstart die beiden Nachrichten in der Nachrichtenwarteschlange ab und verbraucht sie jeweils. Gleichzeitig können Sie im Bereich „Warteschlangen“ der visuellen Verwaltungsseite von RabbitMQ den Status der Warteschlangennachrichten anzeigen und feststellen, dass die in den beiden Warteschlangen gespeicherten Nachrichten verbraucht wurden. Bisher wurde ein vollständiger Geschäftsfall des Publish/Subscribe-Modus (Publish/Subscribe-Modus) des Nachrichtenversands, der Nachrichten-Middleware-Speicherung und des Nachrichtenverbrauchs realisiert.
Beachten Sie, dass der Nachrichtenkonsument beim Starten des Projekts Chapter08 beim Empfang der Nachricht den folgenden Fehler meldet, wenn die Abhängigkeit des Spring Web-Moduls nicht eingeführt wird.
Caused by: org.springframework.beans.BeanInstantiationException: Failed to instantiate [org.springframework.amqp.support.converter.MessageConverter]: Factory method 'messageConverter' threw exception; nested exception is java.lang.NoClassDefFoundError: com/fasterxml/jackson/databind/ObjectMapper
at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:185) ~[spring-beans-5.3.25.jar:5.3.25]
at org.springframework.beans.factory.support.ConstructorResolver.instantiate(ConstructorResolver.java:653) ~[spring-beans-5.3.25.jar:5.3.25]
... 18 common frames omittedHinweis:
Im obigen Code wird die in der Entwicklung häufig verwendete Annotation @RabbitListener verwendet, um den Nachrichtenstatus der angegebenen Namenswarteschlange zu überwachen. Diese Methode wird unmittelbar nach dem Abhören der Existenz von Nachrichten in der angegebenen Warteschlange konsumiert und verarbeitet. Darüber hinaus können wir auch die Methode „receiveAndConvert(String queueName)“ der Vorlagenklasse „RabbitTemplate“ verwenden, um Nachrichten in der angegebenen Warteschlange manuell zu konsumieren.
Klassenbasierter Ansatz
Basierend auf der Konfigurationsklasse geht es hauptsächlich um die Verwendung der vom SpringBoot-Framework bereitgestellten @Configuration-Annotation zum Konfigurieren benutzerdefinierter Komponenten zum Senden von Nachrichten und zum Senden von Nachrichten. Lassen Sie uns diesen konfigurationsbasierten Ansatz erklären und demonstrieren.
Öffnen Sie die RabbitMQ-Nachrichtenkonfigurationsklasse RabbitMQConfig und verwenden Sie die auf Konfigurationsklassen basierende Methode, um die Komponenten für das Senden von Nachrichten in dieser Konfigurationsklasse anzupassen.
package com.ytx.config;
import org.springframework.amqp.core.*;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/** RabbitMQ消息配置类 */
@Configuration
public class RabbitMQConfig {
/** 定制JSON格式的消息转换器 */
@Bean
public MessageConverter messageConverter() {
return new Jackson2JsonMessageConverter();
}
/** 使用基于配置类的方式定制消息中间件 */
// 1.定义fanout类型的交换器
@Bean
public Exchange fanoutExchange() {
return ExchangeBuilder.fanoutExchange("fanout_exchange").build();
}
// 2.定义两个不同名称的消息队列
@Bean
public Queue fanoutQueueEmail() {
return new Queue("fanout_queue_email");
}
@Bean
public Queue fanoutQueueSms() {
return new Queue("fanout_queue_sms");
}
// 3.将两个不同名称的消息队列与交换器进行绑定
@Bean
public Binding bindingEmail() {
return BindingBuilder.bind(fanoutQueueEmail()).to(fanoutExchange()).with("").noargs();
}
@Bean
public Binding bindingSms() {
return BindingBuilder.bind(fanoutQueueSms()).to(fanoutExchange()).with("").noargs();
}
}Im obigen Code werden drei Arten von Bean-Komponenten mithilfe der @Bean-Annotation angepasst. Diese drei Komponenten repräsentieren jeweils den Austausch, die Nachrichtenwarteschlange und die Bindung zwischen der Nachrichtenwarteschlange und dem Austausch. Die Implementierung dieser benutzerdefinierten Nachrichtenkomponente basierend auf der Konfigurationsklasse ist genau die gleiche wie die der API-basierten benutzerdefinierten Nachrichtenkomponente, mit der Ausnahme, dass die Implementierungsmethode unterschiedlich ist.
Gemäß den Implementierungsschritten der Nachrichtendienstintegration müssen nach Abschluss der Anpassung der Nachrichtenkomponente der Nachrichtensender und der Nachrichtenkonsument geschrieben werden. Der Nachrichtensender und der Nachrichtenkonsument wurden in der API-basierten Methode implementiert und angepasst in der Konfigurationsklasse Der Name der Nachrichtenkomponente ist derselbe wie der Name der im vorherigen Test verwendeten Komponenten zum Senden und Empfangen von Nachrichten, sodass wir ihn hier direkt wiederverwenden können.
Führen Sie die Testmethode subPublisher() für den Nachrichtensender erneut aus, und der Nachrichtenkonsument kann die Nachrichten in der Nachrichtenwarteschlange automatisch überwachen und konsumieren. Der Effekt ist der gleiche wie beim API-basierten Test.
Annotationsbasierter Ansatz
Die annotationsbasierte Methode bezieht sich auf die Verwendung der @RabbitListener-Annotation des Spring-Frameworks, um die Nachrichtensendekomponente anzupassen und die Nachricht zu senden.
In der Geschäftsklasse RabbitMQService für den Empfang und die Verarbeitung von Nachrichten wird die Nachrichtenkonsumentenmethode für die Verarbeitung von E-Mail-Diensten und SMS-Diensten mit Anmerkungen versehen, und die Annotation @RabbitListener und die zugehörigen Attribute werden zum Anpassen der Nachrichtensendekomponente verwendet.
package com.ytx.chapter08.service;
import com.ytx.chapter08.domain.User;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;
/** RabbitMQ消息接收处理的业务类 */
@Service
public class RabbitMQService {
/** Publish/Subscribe工作模式接收，处理邮件业务 */
/*
@RabbitListener(queues = "fanout_queue_email")
public void subConsumerEmail(Message message) {
byte[] body = message.getBody();
String msg = new String(body);
System.out.println("邮件业务接收到消息：" + msg);
}
*/
/** Publish/Subscribe工作模式接收，处理短信业务 */
/*
@RabbitListener(queues = "fanout_queue_sms")
public void subConsumerSms(Message message) {
byte[] body = message.getBody();
String msg = new String(body);
System.out.println("短信业务接收到消息：" + msg);
}
*/
/** 使用基于注解的方式实现消息服务 */
// 1.1 Publish/Subscribe工作模式接收，处理邮件业务
@RabbitListener(bindings = @QueueBinding(
value = @Queue("fanout_queue_email"),
exchange = @Exchange(value = "fanout_exchange", type = "fanout")))
public void subConsumerEmailAno(User user) {
System.out.println("邮件业务接收到消息：" + user);
}
// 1.2 Publish/Subscribe工作模式接收，处理短信业务
@RabbitListener(bindings = @QueueBinding(
value = @Queue("fanout_queue_sms"),
exchange = @Exchange(value = "fanout_exchange", type = "fanout")))
public void subConsumerSmsAno(User user) {
System.out.println("短信业务接收到消息：" + user);
}
}Im obigen Code werden die Verbraucher der beiden Nachrichtenkomponenten mithilfe der Annotation @RabbitListener und der zugehörigen Attribute angepasst. Beide Verbraucher empfangen und konsumieren die Entitätsklasse User. In der Annotation @RabbitListener wird das Bindungsattribut zum Erstellen und Binden der Austausch- und Nachrichtenwarteschlangenkomponenten verwendet. Es ist zu beachten, dass wir Folgendes anpassen müssen, damit die Verbraucher der beiden Nachrichtenkomponenten den Entitätsklassenbenutzer empfangen können Der Switch-Typ ist auf Fanout eingestellt. Darüber hinaus entfernt die @QueueBinding-Annotation des Bindungsattributs die Wert- und Austauschattribute, und das Schlüsselattribut wird zum Anpassen des Routing-Schlüssels „routingKey“ verwendet (im aktuellen Publish-Subscribe-Modus nicht erforderlich).
Starten Sie die Testmethode subPublisher () neu. Der Nachrichtenkonsument kann die Nachrichten in der Nachrichtenwarteschlange automatisch überwachen und konsumieren. Der Effekt ist der gleiche wie beim API-basierten Test.
Bisher haben wir die API-basierten, konfigurationsbasierten und annotationsbasierten Methoden in SpringBoot abgeschlossen, um die integrierte Erklärung des Publish/Subscribe-Arbeitsmodus zu realisieren. Unter den drei Möglichkeiten zur Implementierung von Nachrichtendiensten ist die API-basierte Methode relativ einfach und intuitiv, lässt sich jedoch leicht mit Geschäftscode koppeln. Die konfigurationsbasierte Methode ist relativ isoliert, lässt sich leicht einheitlich verwalten und ist konform die Idee des Spring Boot-Frameworks; die annotationsbasierte Methode Es ist klar und einfach separat zu verwalten, lässt sich aber auch leicht mit Geschäftscode koppeln.
In der tatsächlichen Entwicklung werden häufiger konfigurationsbasierte Methoden und annotationsbasierte Methoden verwendet, während gelegentlich API-basierte Methoden verwendet werden. Natürlich müssen Sie entsprechend der tatsächlichen Situation spezifische Entscheidungen treffen.
Zusammenfassen
Heute hat Herr Yuan drei Nachrichtenwarteschlangen basierend auf API, Konfiguration und Annotation vorgestellt und Ihnen die Integration und Code-Implementierung des Publish/Subscribe-Modus beigebracht. Sie müssen sich auf die annotationsbasierte Implementierung konzentrieren. . In Bezug auf andere Inhalte von RabbitMQ wird Herr Yuan in den folgenden Artikeln weiterhin Aktualisierungen vornehmen, und Sie können gerne weiterhin darauf achten.