Verteiltes Thema ｜ Fünf Arbeitsmodi von Springboot und RabbitMQ, die für die Eingabe von BAT erforderlich sind

Frühzeitige Anwender

Einführung

RabbitMQ ist eine Nachrichtenwarteschlange, die von der Sprache erlang entwickelt und auf der Grundlage des AMQP-Protokolls (Advanced Message Queue Advanced Message Queue Protocol) implementiert wurde. Es handelt sich um eine Kommunikationsmethode zwischen Anwendungen. Nachrichtenwarteschlangen werden häufig in der Entwicklung verteilter Systeme verwendet.

Offizielle Adresse von RabbitMQ: http://www.rabbitmq.com/

RabbitMQ bietet 6 Modi: einfacher Modus, Arbeitsmodus, Publish / Subscribe-Veröffentlichungs- und Abonnementmodus, Routing-Routing-Modus, Themen-Themenmodus, RPC-Remote-Anrufmodus (Remote-Anruf, nicht viel MQ; keine Einführung);

Installation

Der Einfachheit halber wird empfohlen, die Docker-Installationsmethode zu verwenden. Die Befehle für die Docker-Installation lauten wie folgt:

Spiegel herunterladen

docker pull rabbitmq:3.7.7-management

Erstellen Sie eine Instanz und starten Sie

docker run -d --name rabbitmq -p 5672:5672 -p 15672:15672 -v ~/docker/rabbitmq/data:/var/lib/rabbitmq --hostname myRabbit -e RABBITMQ_DEFAULT_VHOST=my_vhost  -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin rabbitmq:3.7.7-management

Beispiele für fünf Modusaufrufe

Abhängigkeiten einführen

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

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

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

Schreiben Sie die Konfigurationsdatei
application.yml

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    virtual-host: my_vhost #这是我自己创建的主机，请填写你们自己的，注意不要带/
    username: lezai
    password: lezai
    publisher-returns: true
    publisher-confirm-type: simple

Einfacher Nachrichtenmodus

Einfache Nachrichten verwenden den Standardaustausch. Routing_key stimmt mit dem Namen der verbrauchten Warteschlange überein

Der Produzent erstellt eine mq-Konfigurationsdatei

@Configuration
public class RabbitMQConfig {
    
    
    public static final String QUEUE_TEST_SIMPLE_MODE = "queue_test_simple_mode";
//    声明队列
    @Bean("queueTestSimpleMode")
    public Queue queueTestSimpleMode(){
    
    
        return QueueBuilder.durable(QUEUE_TEST_SIMPLE_MODE).build();
    }
}

Schreiben Sie den Code zum Senden einfacher Nachrichten auf der Herstellerseite

@SpringBootTest
class RabbitmqProductApplicationTests {
    
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    public void testSimpleMode() {
    
    
        rabbitTemplate.convertAndSend("",RabbitMQConfig.QUEUE_TEST_SIMPLE_MODE,"测试简单模式");
    }

Überprüfen Sie die Verwaltungskonsole und stellen Sie fest
, dass wir die von uns erstellte Warteschlange gesehen haben und dass bereits eine Nachricht in der Warteschlange zu verbrauchen ist
Verbraucher schaffen

@Component
public class RabbitMQListener {
    
    
    @RabbitListener(queues = "queue_test_simple_mode")
    public void onMessage(Message message, Channel channel) throws Exception {
    
    
        System.out.println("收到消息：" + new String(message.getBody()));
    }
}

Arbeitswarteschlangenmodus

Dies entspricht dem einfachen Modus, außer dass mehrere Konsumenten erstellt werden, um die Warteschlange zu überwachen, und MQ mehrere Listener abfragt, um Nachrichten zu pushen.

@Component
public class RabbitMQListener {
    
    
    @RabbitListener(queues = "queue_test_simple_mode")
    public void onMessage(Message message, Channel channel) throws Exception {
    
    
        System.out.println("收到消息：" + new String(message.getBody()));
    }
        @RabbitListener(queues = "queue_test_simple_mode")
    public void onMessage2(Message message, Channel channel) throws Exception {
    
    
        System.out.println("收到消息：" + new String(message.getBody()));
    }
}

Veröffentlichen / Abonnieren Veröffentlichen und Abonnieren des Modells

Veröffentlichen und Abonnieren verwenden Sie den Broadcast-Modus. Alle an diesen Austauschtyp gebundenen Warteschlangen erhalten Nachrichten. Der
Austauschtyp ist fanoutExchange

Herstellerprofil

@Configuration
public class RabbitMQConfig {
    
    
    public static final String QUEUE_TEST_FANOUT_MODE_1 = "queue_test_fanout_mode_1";
    public static final String QUEUE_TEST_FANOUT_MODE_2 = "queue_test_fanout_mode_2";
    public static final String EXCHANGE_TEST_FANOUT_MODE = "exchange_test_fanout_mode";

    //    声明队列
    @Bean("queueTestFANOUTMode1")
    public Queue queueTestFANOUTMode1() {
    
    
        return QueueBuilder.durable(QUEUE_TEST_FANOUT_MODE_1).build();
    }
    //    声明队列
    @Bean("queueTestFANOUTMode2")
    public Queue queueTestFANOUTMode2() {
    
    
        return QueueBuilder.durable(QUEUE_TEST_FANOUT_MODE_2).build();
    }
    //  声明交换机
    @Bean("exchangeTestFANOUTMode")
    public Exchange exchangeTestFANOUTMode() {
    
    
        return ExchangeBuilder.fanoutExchange(EXCHANGE_TEST_FANOUT_MODE).durable(true).build();
    }

    // 绑定交换机与队列 订阅模式下 routingkey为空
    @Bean
    public Binding itemQueueExchange1(@Qualifier("queueTestFANOUTMode1") Queue queue,
                                     @Qualifier("exchangeTestFANOUTMode") Exchange exchange){
    
    
        return BindingBuilder.bind(queue).to(exchange).with("").noargs();
    }
    @Bean
    public Binding itemQueueExchange2(@Qualifier("queueTestFANOUTMode2") Queue queue,
                                     @Qualifier("exchangeTestFANOUTMode") Exchange exchange){
    
    
        return BindingBuilder.bind(queue).to(exchange).with("").noargs();
    }
}

Schreiben Sie den Code für den Produzenten, um die Nachricht zu senden

    @Test
    public void testFanoutMode() {
    
    
        rabbitTemplate.convertAndSend("exchange_test_fanout_mode","",  "测试发布订阅模式");
    }

Überprüfen Sie die Verwaltungskonsole, es gibt einen zusätzlichen Schalter und eine Warteschlange, und jede Warteschlange enthält eine Nachricht, die wir gerade erstellt haben
Der Consumer-Code wird geschrieben, und der Consumer überwacht immer die Warteschlange, sodass er mit der vorherigen Methode identisch ist

@Component
public class RabbitMQListener {
    
    
    @RabbitListener(queues = "queue_test_fanout_mode_1")
    public void onMessage1(Message message, Channel channel) throws Exception {
    
    
        System.out.println("收到消息来自队列queue_test_fanout_mode_1：" + new String(message.getBody()));
    }
    @RabbitListener(queues = "queue_test_fanout_mode_2")
    public void onMessage2(Message message, Channel channel) throws Exception {
    
    
        System.out.println("收到消息来自队列queue_test_fanout_mode_2：" + new String(message.getBody()));
    }
}

Routing Routing-Modus

Der Routing-Modus besteht darin, Nachrichten mithilfe eines Richtungsschalters weiterzuleiten. Wenn die Warteschlange an den Richtungsschalter gebunden ist, wird ein Routing-Schlüssel bereitgestellt. Wenn der Benutzer beim Senden der Nachricht an den Switch einen Routing-Schlüssel mitbringt, stimmt dieser überein und entspricht gemäß dieser Routingkey-Warteschlange.

Produzentenprofil schreiben

@Configuration
public class RabbitMQConfig {
    
    

    public static final String QUEUE_TEST_ROUTING_MODE_1 = "queue_test_routing_mode_1";
    public static final String QUEUE_TEST_ROUTING_MODE_2 = "queue_test_routing_mode_2";
    public static final String EXCHANGE_TEST_ROUTING_MODE = "exchange_test_routing_mode";
    
    //    声明队列
    @Bean("queueTestROUTINGMode1")
    public Queue queueTestROUTINGMode1() {
    
    
        return QueueBuilder.durable(QUEUE_TEST_ROUTING_MODE_1).build();
    }
    //    声明队列
    @Bean("queueTestROUTINGMode2")
    public Queue queueTestROUTINGMode2() {
    
    
        return QueueBuilder.durable(QUEUE_TEST_ROUTING_MODE_2).build();
    }
    //  声明交换机
    @Bean("exchangeTestROUTINGMode")
    public Exchange exchangeTestROUTINGMode() {
    
    
        return ExchangeBuilder.directExchange(EXCHANGE_TEST_ROUTING_MODE).durable(true).build();
    }

    // 绑定交换机与队列
    // 这里指定了routingkey为order，也就是发消息的时候只能匹配到routingkey为order的消息
    @Bean
    public Binding itemQueueExchange3(@Qualifier("queueTestROUTINGMode1") Queue queue,
 // 这里指定了routingkey为order，也就是发消息的时候只能匹配到routingkey为member的消息                                     @Qualifier("exchangeTestROUTINGMode") Exchange exchange){
    
    
        return BindingBuilder.bind(queue).to(exchange).with("order").noargs();
    }
    
    @Bean
    public Binding itemQueueExchange4(@Qualifier("queueTestROUTINGMode2") Queue queue,
                                      @Qualifier("exchangeTestROUTINGMode") Exchange exchange){
    
    
        return BindingBuilder.bind(queue).to(exchange).with("member").noargs();
    }
}

Schreiben Sie den Code für den Produzenten, um die Nachricht zu senden

Wenn Sie hier eine Nachricht senden, wird der Routingkey als Reihenfolge angegeben. Nur wenn der Routingkey in der an den Switch gebundenen Warteschlange als Reihenfolge festgelegt ist, kann die Nachricht überwacht und die Nachricht an die Warteschlange queue_test_routing_mode_1 gesendet werden.

   @Test
    public void testRoutingMode() {
    
    
        rabbitTemplate.convertAndSend("exchange_test_routing_mode","order",  "测试路由模式");
    }

Überprüfen Sie die Verwaltungskonsole und stellen Sie fest, dass nur eine Nachricht in queue_test_routing_mode_1 auf den Verbrauch wartet
Verbrauchercode

    @RabbitListener(queues = "queue_test_routing_mode_1")
    public void onMessage3(Message message, Channel channel) throws Exception {
    
    
        System.out.println("收到消息来自队列queue_test_routing_mode_1：" + new String(message.getBody()));
    }
    @RabbitListener(queues = "queue_test_routing_mode_2")
    public void onMessage4(Message message, Channel channel) throws Exception {
    
    
        System.out.println("收到消息来自队列queue_test_routing_mode_2：" + new String(message.getBody()));
    }

Themen-Themenmodus

Der Themenmodusschalter ist der gleiche wie der Richtungsschalter. Der einzige Unterschied besteht darin, dass der Richtungsschalter beim Parsen des Routing-Schlüssels die entsprechende Warteschlange gemäß dem Routing-Schlüssel in der Nachricht findet. Dieser Wert wird bestimmt, der Themenmodus jedoch Wird auch als Platzhaltermodus bezeichnet, der gebunden ist. Der angegebene Routing-Schlüssel kann in Form von Platzhaltern vorliegen. Hier gibt es nur zwei Platzhaltersymbole:

# Repräsentiert ein oder mehrere Wörter wie abc. # Stimmt mit abc.d überein oder abc.df
repräsentiert beispielsweise ein Wort. abc. kann nur mit den Nachrichten von abc.a oder abc.f. übereinstimmen. Die Codelogik
entspricht dem Routing-Muster und wird daher nicht demonstriert. Der vollständige Beispielcode wurde in die Git-Bibliothek übertragen. Willkommen auf Anfrage:

Komplette Codesammlung

https://gitee.com/yangleliu/code_learning.git

Wechat Suche nach einer Suche [Le Zai Open Talk] Folgen Sie dem gutaussehenden Ich, antworten Sie [Trockenware erhalten], es werden viele Interviewmaterialien und Bücher, die der Architekt unbedingt lesen muss, auf Sie warten, einschließlich Java-Grundlagen, Java-Parallelität, Microservices, Middleware usw. Weitere Informationen warten auf Sie.