Wie SpringBoot RabbitMQ integriert

1. Einführung in RabbitMQ

RabbitMQ ist eine Art Nachrichten-Middleware, die AMQP (Advanced Message Queuing Protocol) implementiert und zum Speichern und Weiterleiten von Nachrichten in verteilten Systemen verwendet wird Verwendung, Skalierbarkeit, gute Leistung in Aspekten wie Hochverfügbarkeit. RabbitMQ wird hauptsächlich implementiert, um eine bidirektionale Entkopplung zwischen Systemen zu erreichen. Wenn der Produzent eine große Datenmenge generiert und der Verbraucher diese nicht schnell nutzen kann, ist eine Zwischenschicht erforderlich. Speichern Sie diese Daten.

AMQP, Advanced Message Queuing Protocol, ist ein offener Standard für Protokolle der Anwendungsschicht und wurde für nachrichtenorientierte Middleware entwickelt. Der Hauptzweck der Nachrichten-Middleware besteht darin, Komponenten zu entkoppeln, sodass Nachrichtensender und -empfänger sich nicht gegenseitig stören und unabhängig voneinander sind. Daher muss der Absender die Existenz des Benutzers nicht kennen und umgekehrt. Zu den herausragenden Merkmalen von AMQP gehören Nachrichtenorientierung, Warteschlangen, Routing (einschließlich Punkt-zu-Punkt und Publish/Subscribe), Zuverlässigkeit und Sicherheit.

RabbitMQ ist eine Open-Source-AMQP-Implementierung. Der Server ist in Erlang-Sprache geschrieben und unterstützt eine Vielzahl von Clients, wie zum Beispiel: Python, Ruby, .NET, Java, JMS, C, PHP, ActionScript, XMPP, STOMP usw. und unterstützt AJAX. Diese Technologie zeichnet sich durch gute Benutzerfreundlichkeit, Skalierbarkeit und hohe Verfügbarkeit bei der Speicherung und Weiterleitung von Nachrichten in verteilten Systemen aus.

2. Verwandte Konzepte

Wenn wir über Warteschlangendienste sprechen, gibt es normalerweise drei Konzepte: Nachrichtensender, Warteschlange und Nachrichtenempfänger. Zusätzlich zu diesem Grundkonzept fügt RabbitMQ eine zusätzliche Abstraktionsebene hinzu Zwischen dem Nachrichtensender und der Warteschlange wird keine direkte Verbindung zwischen dem Nachrichtensender und der Warteschlange hergestellt. Stattdessen sendet der Nachrichtensender die Nachricht an die Warteschlange Planungsrichtlinie.

• Das P auf der linken Seite stellt den Produzenten dar, also das Programm, das Nachrichten an RabbitMQ sendet.

• In der Mitte befindet sich RabbitMQ, das Schalter und Warteschlangen umfasst.

• Das C auf der rechten Seite stellt den Verbraucher dar, das Programm, das Nachrichten von RabbitMQ erhält.

Es gibt 4 wichtige Konzepte , nämlich: virtueller Host, Switch, Warteschlange und Bindung.

• Virtueller Host: Ein virtueller Host enthält eine Reihe von Switches, Warteschlangen und Bindungen. Warum benötigen Sie mehrere virtuelle Hosts? Es ist ganz einfach. In RabbitMQ können Benutzer Berechtigungen nur auf der Granularität des virtuellen Hosts steuern. Wenn Sie der Gruppe A den Zugriff auf die Switches/Warteschlangen/Bindungen der Gruppe B verbieten möchten, müssen Sie daher jeweils einen virtuellen Host für A und B erstellen. Jeder RabbitMQ-Server verfügt über einen standardmäßigen virtuellen Host „/“.

• Switch: Exchange wird zum Weiterleiten von Nachrichten verwendet, speichert diese jedoch nicht. Wenn keine Warteschlangenbindung an Exchange besteht, werden die vom Produzenten gesendeten Nachrichten direkt verworfen.

• Bindung: Das heißt, der Schalter muss an die Warteschlange gebunden sein. Wie in der Abbildung oben gezeigt, handelt es sich um eine Viele-zu-Viele-Beziehung.

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

Konfigurieren Sie die Installationsadresse und den Port von Rabbitmq Und Kontoinformationen.

spring.application.name=spirng-boot-rabbitmq
spring.rabbitmq.host=192.168.0.86
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=123456

@Configuration
public class RabbitConfig {
@Bean
public Queue Queue() {
return new Queue("hello");
}
}

Nach dem Login kopieren

einen Sender, N Empfänger oder N Sender und N Empfänger verwenden?

Eins-zu-viele-Senden

Am obigen Code wurde eine kleine Änderung vorgenommen. Die empfangende Seite hat zwei Empfänger registriert, Empfänger1 und Empfänger2, und die empfangende Seite hat die empfangenen Parameter ausgedruckt. Das Folgende ist der Testcode: Senden Sie einhundert Nachrichten, um den Ausführungseffekt der beiden Empfangsenden zu beobachten. Die Ergebnisse sind wie folgt: Empfänger 1: Start der Neo-Warteschlange ****** 11 Empfänger 2: Start-Neo-Warteschlange ** **** 12Empfänger 2: Start-Neo-Warteschlange ****** 14

Empfänger 2: Start Boot-Neo-Warteschlange ****** 15

Empfänger 1: Boot-Neo-Warteschlange ****** 18Empfänger 2: Boot-Neo-Warteschlange ** **** 17Empfänger 2: Start-Boot-Neo-Warteschlange ****** 19

根据返回结果得到以下结论

一个发送者，N个接受者,经过测试会均匀的将消息发送到N个接收者中

多对多发送

复制了一份发送者，加入标记，在一百个循环中相互交替发送

@Test
public void manyToMany() throws Exception {
for (int i=0;i<100;i++){
neoSender.send(i);
neoSender2.send(i);
}
}

结果如下：

Receiver 1: spirng boot neo queue ****** 20
Receiver 2: spirng boot neo queue ****** 20
Receiver 1: spirng boot neo queue ****** 21
Receiver 2: spirng boot neo queue ****** 21
Receiver 1: spirng boot neo queue ****** 22
Receiver 2: spirng boot neo queue ****** 22
Receiver 1: spirng boot neo queue ****** 23
Receiver 2: spirng boot neo queue ****** 23
Receiver 1: spirng boot neo queue ****** 24
Receiver 2: spirng boot neo queue ****** 24
Receiver 1: spirng boot neo queue ****** 25
Receiver 2: spirng boot neo queue ****** 25

结论：和一对多一样，接收端仍然会均匀接收到消息.

四、高级使用

//对象的支持
//springboot以及完美的支持对象的发送和接收，不需要格外的配置。
//发送者
public void send(User user) {
System.out.println("Sender object: " + user.toString());
this.rabbitTemplate.convertAndSend("object", user);
}
...
//接受者
@RabbitHandler
public void process(User user) {
System.out.println("Receiver object : " + user);
}

结果如下：

Sender object: User{name='neo', pass='123456'}
Receiver object : User{name='neo', pass='123456'}

1.Topic Exchange

在RabbitMQ中，Topic是最灵活的一种方式，它允许根据routing_key随意绑定到不同的队列

首先对topic规则配置，这里使用两个队列来测试

@Configuration
public class TopicRabbitConfig {

final static String message = "topic.message";
final static String messages = "topic.messages";

@Bean
public Queue queueMessage() {
return new Queue(TopicRabbitConfig.message);
}

@Bean
public Queue queueMessages() {
return new Queue(TopicRabbitConfig.messages);
}

@Bean
TopicExchange exchange() {
return new TopicExchange("exchange");
}

@Bean
Binding bindingExchangeMessage(Queue queueMessage, TopicExchange exchange) {
return BindingBuilder.bind(queueMessage).to(exchange).with("topic.message");
}

@Bean
Binding bindingExchangeMessages(Queue queueMessages, TopicExchange exchange) {
return BindingBuilder.bind(queueMessages).to(exchange).with("topic.#");
}
}

使用queueMessages同时匹配两个队列，queueMessage只匹配"topic.message"队列

public void send1() {
String context = "hi, i am message 1";
System.out.println("Sender : " + context);
this.rabbitTemplate.convertAndSend("exchange", "topic.message", context);
}

public void send2() {
String context = "hi, i am messages 2";
System.out.println("Sender : " + context);
this.rabbitTemplate.convertAndSend("exchange", "topic.messages", context);
}

发送send1会匹配到topic.#和topic.message 两个Receiver都可以收到消息，发送send2只有topic.#可以匹配所有只有Receiver2监听到消息

2.Fanout Exchange

Fanout 就是我们熟悉的广播模式或者订阅模式，给Fanout交换机发送消息，绑定了这个交换机的所有队列都收到这个消息。

Fanout 相关配置：

@Configuration
public class FanoutRabbitConfig {

@Bean
public Queue AMessage() {
return new Queue("fanout.A");
}

@Bean
public Queue BMessage() {
return new Queue("fanout.B");
}

@Bean
public Queue CMessage() {
return new Queue("fanout.C");
}
@Bean
FanoutExchange fanoutExchange() {
return new FanoutExchange("fanoutExchange");
}
@Bean
Binding bindingExchangeA(Queue AMessage,FanoutExchange fanoutExchange) {
return BindingBuilder.bind(AMessage).to(fanoutExchange);
}
@Bean
Binding bindingExchangeB(Queue BMessage, FanoutExchange fanoutExchange) {
return BindingBuilder.bind(BMessage).to(fanoutExchange);
}
@Bean
Binding bindingExchangeC(Queue CMessage, FanoutExchange fanoutExchange) {
return BindingBuilder.bind(CMessage).to(fanoutExchange);
}
}

这里使用了A、B、C三个队列绑定到Fanout交换机上面，发送端的routing_key写任何字符都会被忽略：

public void send() {
String context = "hi, fanout msg ";
System.out.println("Sender : " + context);
this.rabbitTemplate.convertAndSend("fanoutExchange","", context);
}

结果如下：

Sender : hi, fanout msg
...
fanout Receiver B: hi, fanout msg
fanout Receiver A : hi, fanout msg
fanout Receiver C: hi, fanout msg

结果说明，绑定到fanout交换机上面的队列都收到了消息.

Das obige ist der detaillierte Inhalt vonWie SpringBoot RabbitMQ integriert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!