RabbitMQ (入门 工作模式 原生RabbitMQ Spring整合 SpringBoot整合)

最新推荐文章于 2024-04-30 12:51:41 发布
最新推荐文章于 2024-04-30 12:51:41 发布
阅读量387 收藏 1
点赞数
分类专栏： RocketMQ RabbitMQ RocketMQ 文章标签： 队列 交换机 中间件 rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46690280/article/details/108685245
版权

RabbitMQ

RabbitMQ

一、MQ基本概念

1.1 MQ概述

MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。
在这里插入图片描述

  1. MQ，消息队列，存储消息的中间件

  2. 分布式系统通信两种方式：直接远程调用 和 借助第三方 完成间接通信

  3. 发送方称为生产者，接收方称为消费者

1.2 MQ的优劣势

优势：

  1. 应用解耦
  2. 异步提速
  3. 削峰填谷

劣势

  1. 系统可用性降低
  2. 系统复杂度提高
  3. 一致性问题
优势
应用解耦

在这里插入图片描述
在这里插入图片描述
如有要添加功能或者删除功能不需要动原先的系统，只需要在MQ上加入一个内容即可

异步提速

在这里插入图片描述
在这里插入图片描述
原来需要整个同步请求执行完后才能拿到响应结果，现在只需要把消息发给MQ，MQ做出反应后放入数据库即可得到响应。

削峰填谷

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
使用了 MQ 之后，限制消费消息的速度为1000，这样一来，高峰期产生的数据势必会被积压在 MQ 中，高峰
就被“削”掉了，但是因为消息积压，在高峰期过后的一段时间内，消费消息的速度还是会维持在1000，直
到消费完积压的消息，这就叫做“填谷”。
使用MQ后，可以提高系统稳定性。

劣势

在这里插入图片描述
1、 系统可用性降低
系统引入的外部依赖越多，系统稳定性越差。一旦 MQ 宕机，就会对业务造成影响。如何保证MQ的高可用？
2、 系统复杂度提高
MQ 的加入大大增加了系统的复杂度，以前系统间是同步的远程调用，现在是通过 MQ 进行异步调用。如何
保证消息没有被重复消费？怎么处理消息丢失情况？那么保证消息传递的顺序性？
3、 一致性问题
A 系统处理完业务，通过 MQ 给B、C、D三个系统发消息数据，如果 B 系统、C 系统处理成功，D 系统处理
失败。如何保证消息数据处理的一致性？

1.3 常见的MQ产品

目前业界有很多的 MQ 产品，例如 RabbitMQ、RocketMQ、ActiveMQ、Kafka、ZeroMQ、MetaMq等，也有直接使用 Redis 充当消息队列的案例，而这些消息队列产品，各有侧重，在实际选型时，需要结合自身需求及 MQ 产品特征，综合考虑。

在这里插入图片描述

1.4 RabbitMQ简介

AMQP，即 Advanced Message Queuing Protocol（高级消息队列协议），是一个网络协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。2006年，AMQP 规范发布。类比HTTP

2007年，Rabbit 技术公司基于 AMQP 标准开发的 RabbitMQ 1.0 发布。RabbitMQ 采用 Erlang 语言开发。
Erlang 语言由 Ericson 设计，专门为开发高并发和分布式系统的一种语言，在电信领域使用广泛。
在这里插入图片描述
RabbitMQ 中的相关概念：
Broker：接收和分发消息的应用，RabbitMQ Server就是 Message Broker
Virtual host：出于多租户和安全因素设计的，把 AMQP 的基本组件划分到一个虚拟的分组中，类似于网
络中的 namespace 概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务时，可以划分出多个vhost，每个用户在自己的 vhost 创建 exchange／queue 等
Connection：publisher／consumer 和 broker 之间的 TCP 连接
Channel：如果每一次访问 RabbitMQ 都建立一个 Connection，在消息量大的时候建立 TCP Connection的开销将是巨大的，效率也较低。Channel 是在 connection 内部建立的逻辑连接，如果应用程序支持多线程，通常每个thread创建单独的 channel 进行通讯，AMQP method 包含了channel id 帮助客户端和message broker 识别 channel，所以 channel 之间是完全隔离的。Channel 作为轻量级的 Connection 极大减少了操作系统建立 TCP connection 的开销

执行流程
⚫ Exchange：message 到达 broker 的第一站，根据分发规则，匹配查询表中的 routing key，分发消息到
queue 中去。常用的类型有：direct (point-to-point), topic (publish-subscribe) and fanout (multicast)
⚫ Queue：消息最终被送到这里等待 consumer 取走
⚫ Binding：exchange 和 queue 之间的虚拟连接，binding 中可以包含 routing key。Binding 信息被保存
到 exchange 中的查询表中，用于 message 的分发依据

1.5工作模式

简单模式、work queues、Publish/Subscribe 发布与订阅模式、Routing
路由模式、Topics 主题模式、RPC 远程调用模式

简单模式

在这里插入图片描述
消息产生者将消息放入队列
消息的消费者(consumer) 监听(while) 消息队列,如果队列中有消息,就消费掉,消息被拿走后,自动从队列中删除(隐患 消息可能没有被消费者正确处理,已经从队列中消失了,造成消息的丢失)应用场景:聊天(中间有一个过度的服务器;p端,c端)

work queues(资源的竞争)

在这里插入图片描述
work queues与入门程序相比，多了一个消费端，两个消费端共同消费同一个队列中的消息。
应用场景：对于人物过重或人物较多情况使用工作队列可以提高任务处理的速度。
测试：
1、使用helloworld入门程序，启动多个消费者。
2、生产者发送多个消息。
结果：
1、一条消息只会被一个消费者接收；
2、rabbit采用轮询的方式将消息是平均发送给消费者的；
3、消费者在处理完某条消息后，才会收到下一条消息

Publish/Subscribe 发布与订阅模式(共享资源)

在这里插入图片描述
1、每个消费者监听自己的队列。
2、生产者将消息发给broker,由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息。

Routing路由模式

在这里插入图片描述
1、每个消费者监听自己的队列，并且设置routingkey.
2、生产者将消息发给交换机，由交换机根据routingkey来转发消息到指定的队列。
Routing模式和Publish/subcribe模式的区别？
Routing模式要求队列在绑定交换机时要指定routingkey,消息会转发到符合routingkey的队列。

Topics 主题模式(路由模式的一种)

在这里插入图片描述
1、一个交换机可以绑定多个队列，每个队列可以设置一个或多个带通配符的routingkey。
2、生产者将消息发给交换机，交换机根据routingkey的值来匹配队列，匹配时采用通配符方式，匹配成功的将消息转发到指定的队列。
Topics与Routing的区别？
Topics和Routing的基本原理相同，即：生产者将消息发给交换机，交换机根据routingKey将消息转发给与routingKey匹配的队列。
不同之处是：routingKey的匹配方式，Routing模式是相等匹配，topics模式是通配符匹配。
符号#：匹配一个或者多个词，比如inform.#可以匹配inform.sms、inform.email、inform.email.sms
符号*：只能匹配一个词，比如inform.*,可以匹配inform.sms,inform.email

RPC 远程调用模式

在这里插入图片描述
RPC即客户端远程调用服务端的方法，使用MQ可以实现RPC的异步调用，基于Direct交换机实现，流程如下：
1、客户既是生产者又是消费者，向RPC请求队列发送RPC调用消息，同时监听RPC响应队列。
2、服务端监听RPC请求队列的消息，收到消息后执行服务端的方法，得到方法返回的结果
3、服务端将RPC方法的结果发送到RPC响应队列
4、客户端（RPC调用方）监听RPC响应队列，接收到RPC调用结果。

二、 原生RabbitMQ实现

这里以Topic为例子

依赖

    <dependencies>
        <!--rabbitmq java 客户端-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.6.0</version>
        </dependency>
    </dependencies>


    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

producer

package com.itheima.producer;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 发送消息
 */
public class Producer_Topics {
    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("192.168.23.11");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/");//虚拟机 默认值/
        factory.setUsername("xxx");//用户名 默认 guest
        factory.setPassword("xx");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();
       /*

       exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
       参数：
        1. exchange:交换机名称
        2. type:交换机类型
            DIRECT("direct"),：定向
            FANOUT("fanout"),：扇形（广播），发送消息到每一个与之绑定队列。
            TOPIC("topic"),通配符的方式
            HEADERS("headers");参数匹配

        3. durable:是否持久化
        4. autoDelete:自动删除
        5. internal：内部使用。 一般false
        6. arguments：参数
        */

       String exchangeName = "test_topic";
        //5. 创建交换机
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC,true,false,false,null);
        //6. 创建队列
        String queue1Name = "test_topic_queue1";
        String queue2Name = "test_topic_queue2";
        channel.queueDeclare(queue1Name,true,false,false,null);
        channel.queueDeclare(queue2Name,true,false,false,null);
        //7. 绑定队列和交换机
        /*
        queueBind(String queue, String exchange, String routingKey)
        参数：
            1. queue：队列名称
            2. exchange：交换机名称
            3. routingKey：路由键，绑定规则
                如果交换机的类型为fanout ，routingKey设置为""
         */

        // routing key  系统的名称.日志的级别。
        //=需求： 所有error级别的日志存入数据库，所有order系统的日志存入数据库
        channel.queueBind(queue1Name,exchangeName,"#.error");
        channel.queueBind(queue1Name,exchangeName,"order.*");
        channel.queueBind(queue2Name,exchangeName,"*.*");

        String body = "";
        //8. 发送消息
        channel.basicPublish(exchangeName,"1",null,body.getBytes());

        //9. 释放资源
        channel.close();
        connection.close();

    }
}

consumer

Consumer_topic 这里可写多个，只需要绑定不同的队列名字就可以了

package com.itheima.consumer;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer_Topic1 {
    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("192.168.23.129");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/");//虚拟机 默认值/
        factory.setUsername("xxx");//用户名 默认 guest
        factory.setPassword("xxx");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();


        String queue1Name = "test_topic_queue1";
        String queue2Name = "test_topic_queue2";


        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        参数：
            1. queue：队列名称
            2. autoAck：是否自动确认
            3. callback：回调对象

         */
        // 接收消息
        Consumer consumer = new DefaultConsumer(channel){
            /*
                回调方法，当收到消息后，会自动执行该方法

                1. consumerTag：标识
                2. envelope：获取一些信息，交换机，路由key...
                3. properties:配置信息
                4. body：数据

             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
              /*  System.out.println("consumerTag："+consumerTag);
                System.out.println("Exchange："+envelope.getExchange());
                System.out.println("RoutingKey："+envelope.getRoutingKey());
                System.out.println("properties："+properties);*/
                System.out.println("body："+new String(body));
                System.out.println("111111111111");
            }
        };
        channel.basicConsume(queue1Name,true,consumer);


        //关闭资源？不要

    }
}

三、 Spring整合RabbitMQ

producer

在这里插入图片描述

依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit</artifactId>
            <version>2.1.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

rabbitmq.properties

rabbitmq.host=192.168.23.129
rabbitmq.port=5672
rabbitmq.username=xx
rabbitmq.password=xx
rabbitmq.virtual-host=/

spring-rabbitmq-producer.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:rabbitmq.properties"/>

    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"/>
    <!--定义管理交换机、队列-->
    <rabbit:admin connection-factory="connectionFactory"/>

    <!--定义持久化队列，不存在则自动创建；不绑定到交换机则绑定到默认交换机
    默认交换机类型为direct，名字为：""，路由键为队列的名称
    -->
    <!--
        id：bean的名称
        name：queue的名称
        auto-declare:自动创建
        auto-delete:自动删除。 最后一个消费者和该队列断开连接后，自动删除队列
        exclusive:是否独占
        durable：是否持久化
    -->

    <rabbit:queue id="spring_queue" name="spring_queue"    auto-declare="true"/>

    <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~广播；所有队列都能收到消息~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_fanout_queue_1" name="spring_fanout_queue_1" auto-declare="true"/>

    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_fanout_queue_2" name="spring_fanout_queue_2" auto-declare="true"/>

    <!--定义广播类型交换机；并绑定上述两个队列-->
    <rabbit:fanout-exchange id="spring_fanout_exchange" name="spring_fanout_exchange"  auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding  queue="spring_fanout_queue_1"  />
            <rabbit:binding queue="spring_fanout_queue_2"/>
        </rabbit:bindings>
    </rabbit:fanout-exchange>

    <!--<rabbit:direct-exchange name="aa" >
        <rabbit:bindings>
            &lt;!&ndash;direct 类型的交换机绑定队列  key ：路由key  queue：队列名称&ndash;&gt;
            <rabbit:binding queue="spring_queue" key="xxx"></rabbit:binding>
        </rabbit:bindings>

    </rabbit:direct-exchange>-->

    <!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~通配符；*匹配一个单词，#匹配多个单词 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -->
    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_topic_queue_star" name="spring_topic_queue_star"  auto-declare="true"/>
    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_topic_queue_well" name="spring_topic_queue_well" auto-declare="true"/>
    <!--定义广播交换机中的持久化队列，不存在则自动创建-->
    <rabbit:queue id="spring_topic_queue_well2" name="spring_topic_queue_well2" auto-declare="true"/>

    <rabbit:topic-exchange id="spring_topic_exchange"  name="spring_topic_exchange" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding pattern="heima.*"  queue="spring_topic_queue_star"/>
            <rabbit:binding pattern="heima.#" queue="spring_topic_queue_well"/>
            <rabbit:binding pattern="itcast.#" queue="spring_topic_queue_well2"/>
        </rabbit:bindings>
    </rabbit:topic-exchange>

    <!--定义rabbitTemplate对象操作可以在代码中方便发送消息-->
    <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>
</beans>

test

package com.itheima;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-rabbitmq-producer.xml")
public class ProducerTest {

    //1.注入 RabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;


    @Test
    public void testHelloWorld(){
        //2.发送消息

        rabbitTemplate.convertAndSend("spring_queue","hello world spring....");
    }


    /**
     * 发送fanout消息
     */
    @Test
    public void testFanout(){
        //2.发送消息

        rabbitTemplate.convertAndSend("spring_fanout_exchange","","spring fanout....");
    }


    /**
     * 发送topic消息
     */
    @Test
    public void testTopics(){
        //2.发送消息

        rabbitTemplate.convertAndSend("spring_topic_exchange","heima.hehe.haha","spring topic....");
    }
}

consumers

在这里插入图片描述

rabbitmq.properties

rabbitmq.host=192.168.23.129
rabbitmq.port=5672
rabbitmq.username=xx
rabbitmq.password=xx
rabbitmq.virtual-host=/

spring-rabbitmq-consumer.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:rabbitmq.properties"/>

    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"/>

    <bean id="springQueueListener" class="com.itheima.rabbitmq.listener.SpringQueueListener"/>
    <!--<bean id="fanoutListener1" class="com.itheima.rabbitmq.listener.FanoutListener1"/>
    <bean id="fanoutListener2" class="com.itheima.rabbitmq.listener.FanoutListener2"/>
    <bean id="topicListenerStar" class="com.itheima.rabbitmq.listener.TopicListenerStar"/>
    <bean id="topicListenerWell" class="com.itheima.rabbitmq.listener.TopicListenerWell"/>
    <bean id="topicListenerWell2" class="com.itheima.rabbitmq.listener.TopicListenerWell2"/>
-->
    <rabbit:listener-container connection-factory="connectionFactory" auto-declare="true">
        <rabbit:listener ref="springQueueListener" queue-names="spring_queue"/>
       <!-- <rabbit:listener ref="fanoutListener1" queue-names="spring_fanout_queue_1"/>
        <rabbit:listener ref="fanoutListener2" queue-names="spring_fanout_queue_2"/>
        <rabbit:listener ref="topicListenerStar" queue-names="spring_topic_queue_star"/>
        <rabbit:listener ref="topicListenerWell" queue-names="spring_topic_queue_well"/>
        <rabbit:listener ref="topicListenerWell2" queue-names="spring_topic_queue_well2"/>-->
    </rabbit:listener-container>
</beans>

SpringQueueListener

package com.itheima.rabbitmq.listener;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;

public class SpringQueueListener implements MessageListener {
    @Override
    public void onMessage(Message message) {
        //打印消息
        System.out.println(new String(message.getBody()));
    }
}

ConsumerTest

package com.itheima;


import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.io.IOException;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-rabbitmq-consumer.xml")
public class ConsumerTest {

    @Test
    public void test1(){
        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

四、 Spring Boot整合RabbitMQ

provider

在这里插入图片描述
依赖

   <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
    </parent>

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

application.yml

spring:
  rabbitmq:
    host: 192.168.23.129
    username: ybb
    password: ybb
    virtual-host: /
    port: 5672

RabbitMQConfig

package com.ybb.Rabbitmq;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Description :
 * Version :1.0
 */
@Configuration
public class RabbitMQConfig {

    //交换机
    @Bean("topic_Exchange")
    public Exchange topicExchange(){
        return ExchangeBuilder.topicExchange("topic_Exchange").durable(true).build();
    }
    //Queue
    @Bean("topic_Queue")
    public Queue topicQueue(){
        return QueueBuilder.durable("topic_Queue").build();
    }
    //绑定
    @Bean()
    public Binding bindTopic(@Qualifier("topic_Exchange")Exchange exchange,@Qualifier("topic_Queue")Queue queue){
        return BindingBuilder.bind(queue).to(exchange).with("bbb.#").noargs();
    }


    @Bean("direct_Exchange")
    public Exchange directExchange(){
        return ExchangeBuilder.directExchange("direct_Exchange").durable(true).build();
    }
    //Queue
    @Bean("direct_Queue")
    public Queue directQueue(){
        return QueueBuilder.durable("direct_Queue").build();
    }
    @Bean()
    public Binding binddirect(@Qualifier("direct_Exchange")Exchange exchange,@Qualifier("direct_Queue")Queue queue){
        return BindingBuilder.bind(queue).to(exchange).with("abc").noargs();
    }

}

Test

package com.ybb;

import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * Description :
 * Version :1.0
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class Test {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @org.junit.Test
    public void sendtopic(){
        rabbitTemplate.convertAndSend("topic_Exchange","bbb.123","topic_nihao");
    }

    @org.junit.Test
    public void senddirect(){
        rabbitTemplate.convertAndSend("direct_Exchange","abc","direct_nihao");
    }


}

consumer

在这里插入图片描述
application.yml

spring:
  rabbitmq:
    host: 192.168.23.129
    username: ybb
    password: ybb
    virtual-host: /
    port: 5672

RabbitMQConfig

package com.ybb.RabbitMQ;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * Description :
 * Version :1.0
 */
@Component
public class RabbitMQConfig {

    @RabbitListener(queues = "topic_Queue")
    public void topic(Message message){
        System.out.println(new String(message.getBody()));
    }

    @RabbitListener(queues = "direct_Queue")
    public void direct(Message message){
        System.out.println(new String(message.getBody()));
    }
}
Ybb_studyRecord
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
RabbitMQ - Spring boot 整合
wanght笔记
03-12 2万+
文章目录新建项目pom.xmlapplication.yml主程序简单模式创建主类生产者消费者测试类工作模式主类生产者生产者消费者ack模式设置 ack 模式手动执行确认操作抓取数量 新建项目 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4...
springboot使用rabbitmq工具类
03-29
springboot使用rabbitmq工具类,里面包含比较原生的方法,还有一套是我结合springboot框架写的一套方法,里面有两个方法,看情况使用,一般使用框架的方法比较好,因为框架方法时前辈们封装好经过检验的没有问题的方法,...
RabbitMq 的概念及应用（原生api、springboot、Springcloud Stream整合篇）
m0_49982368的博客
03-24 330
RabbitMq 的概念及应用（原生api、springboot、Springcloud Stream整合篇）
一文理解RabbitMQ原生版
Mr_aaao的博客
07-18 336
什么是RabbitMQ RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue 高级消息队列协议 ）的开源实现， 能够实现异步消息处理。RabbitMQ是支持持久化消息队列的消息中间件，应用在上下游的层次级业务逻辑中，上级业务逻辑相当于生产者发布消息，下级业务逻辑相当于消费者接受到消息并且消费消息。主流的MQ产品有很多，如ActiveMQ（基于JMS）、RabbitMQ（基于AMQP协议）、RocketMQ（基于JMS）和Kafka。 核心基础概念 Server:
Spring Boot整合RabbitMQ详细教程
最新发布
2401_84103936的博客
04-30 1239
笔者已经把面试题和答案整理成了面试专题文档//假如想一个消费者处理多个队列里面的信息可以如下设置：//设置最大的并发的消费者数量笔者已经把面试题和答案整理成了面试专题文档[外链图片转存中…(img-YrVM3PMb-1714452690743)][外链图片转存中…(img-HzjoMwqG-1714452690743)][外链图片转存中…(img-NwQsbI6W-1714452690744)][外链图片转存中…(img-1vfHO6gi-1714452690744)]
Springboot整合RabbitMQ
Rk的博客
10-11 1674
在Spring启动时，利用Spring Bean管理工厂BeanFactory接口，这里使用的是扇形交换机，交换机会把消息路由到绑定到它的所有队列。这里直接发送的user对象，实现能者多劳和手动确认。访问注册接口，会立即响应。
springBoot集成rabbitmq 之工作模式（Work queues）
weixin_45730866的博客
02-13 391
springBoot集成rabbitmq 之工作模式（Work queues）
WebSocket整合SpringBoot、SockJS、Stomp、Rabbitmq分布式消息推送
06-20
（2）SockJS、Stomp、RabbitMQ Stomp消息代理； （3）分别用Nginx和Spring Cloud Gateway实现多实例负载均衡； （4）可靠消息推送（Stomp持久化队列、客户端ACK确认机制）； （5）Java原生、Stomp客户端实现（非...
SpringBoot整合SpringCloud实战开发系列教程
06-18
《SpringBoot整合SpringCloud实战开发系列教程》是一个深入讲解如何使用SpringBoot与SpringCloud进行集成开发的教程。这个课程旨在帮助Java开发者掌握这两者结合的实际应用，以应对现代微服务架构的需求。 首先，...
RabbitMQ 的消息持久化与 Spring AMQP 的实现详解
08-25
RabbitMQ 消息持久化与 Spring AMQP 实现详解 RabbitMQ 的消息持久化是指在 RabbitMQ Server 中保留消息的机制，以便在...无论使用原生 RabbitMQ 客户端还是 Spring AMQP，消息持久化都是 RabbitMQ 中的一种基本机制。
Java Springboot入门自学笔记
09-08
Spring Boot 基于 Spring Framework，但通过预设的默认配置，减少了大量繁琐的配置工作，使得开发者可以更快地专注于业务逻辑。本入门自学笔记将带你一步步了解并掌握Spring Boot的核心概念和实践技巧。 ### 01 ...
SpringBoot2.x整合RabbitMQ（完整版）
热门推荐
孔明的博客
03-18 4万+
本篇文章实现了 SpringBoot整合RabbitMQ，实现了 work模型，发布订阅模型，topic模型，confirm消息确认机制，return消息机制，TTL队列，死信队列等。整合方式有很多，比如使用 RabbitAdmin进行整合，本文介绍一个最简单的整合方式，只需要在 RabbitmqConfig.java 配置文件中进行简单配置，便可以方便的使用。相信你会喜欢这种方式的
springboot集成RabbitMQ原生教程系列
胃病的不良少彦
05-31 428
文章目录1. 我们这篇博客要做什么2 、消息中间件(消息队列)3、Rabbit初步介绍3.1 生产者、消费者模型3.2 交换器、路由键、绑定3.2.1 交换器类型3.2.2 topic交换器，作用：把多个队列根据模糊规则，最后只让一个队列去接收 1. 我们这篇博客要做什么 我们用Java原生的代码来模拟RabbitMQ的各种实现，参考官方网站，目的是为了让我们了解rabbitmq的细节 而不是集...
rabbitmq介绍
k393393的博客
01-22 3648
1.rabbitmq简单介绍 rabbitmq是一种跨进程、异步的通信机制，用于上下游传递消息。由消息系统来确保消息的可靠传递。      1).rabbitmq的作用： 消峰、异步、解耦      2).rabbitmq的特点：           可靠性：通过持久化、传输确认、发布确认等操作保证可靠性 &n
SpringBoot集成原生RabbitMQ中遇到的问题
qq314499182的博客
06-14 3620
由于项目与其他系统集成,数据交互采用MQ队列形式.在帮助老系统编写MQ工具类时发现,接收方出现异常后,接收方会与MQ服务器断开连接.必须重新连接.在生产环境很不稳定.使用守护线程思想实现异常断电重连. 代码如下:(一) MQ工具类代码public class MQUtils { private static ExecutorService service = Executors.newFi...
（二）RabbitMQ工作模式之直接模式（Direct | Work queues）图文教学通俗易懂，SpringBoot集成，超级简单！！
天道酬勤
07-27 768
1.直接模式（Direct） 直接模式（Direct）也叫 Work queues。 我们需要将消息发给唯一一个节点时使用这种模式，这是最简单的一种形式。 直接模式是不需要配置交换机的，使用系统默认的交换机，默认交换机什么都不干，只是“走个形式” 多个消费者可以监听同一个队列，采用轮询的方式将消息平均分发给消费者，也就是负载均衡 消息传递时需要一个“RouteKey”，可以简单的理解为要发送到...
springboot几种开发模式_springboot整合rabbitmq的五种模式
weixin_39682301的博客
12-20 397
SpringBoot-RabbitMQ本案例为springboot整合rabbitmq的五种工作模式。springboot不需要在启动类前加@EnableRabbit和新建ConnectionFactory(),因为可以在yml里配置rabbitmq的选项。本案例开启的消息确认机制,持久化了交换机,队列以及消息,消费者端开启了手动ACK,保证非极端情况下消息的可靠性。配置简单,doem中有详细的注...
SpringBoot+RabbitMQ
一名系统架构师的征途
08-08 3631
RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。消息中间件在互联网公司的使用中越来越多，刚才还看到新闻阿里将RocketMQ捐献给了apache，当然了今天的主角还是讲RabbitMQ。消息中间件最主要的作用是解耦，中间件最标准的用法是生产者生产消息传送到队列，消费者从队列中拿取消息并处理，生产者不用关心是谁来消费，消费者不用关心谁在生产...
spring整合rabbitmq的实现
飞翔的鸡肉
04-27 8549
RabbittMq的五种队列：简单队列 ：P：消息的生产者C：消息的消费者红色：队列生产者将消息发送到队列，消费者从队列中获取消息。WORK模式：一个生产者、2个消费者。一个消息只能被一个消费者获取。订阅模式：解读：1、1个生产者，多个消费者2、每一个消费者都有自己的一个队列3、生产者没有将消息直接发送到队列，而是发送到了交换机4、每个队列都要绑定到交换机5、生产者发送的消息，经过交换机，到达队列...
Springboot入门到精通.pdf
08-14
"Springboot入门到精通.pdf" Spring Boot 是一个由 Pivotal 团队创建的 Java 开发框架，它的目标是简化 Spring 应用的初始搭建以及开发过程。Spring Boot 不是为替换 Spring 而生，而是作为增强 Spring 开发者体验...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值