RabbitMQ

最新推荐文章于 2024-07-31 04:02:23 发布
最新推荐文章于 2024-07-31 04:02:23 发布
阅读量208 收藏
点赞数
分类专栏： springcloud 文章标签： rabbitmq 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64702880/article/details/124687606
版权

就是异步调用 feign是同步调用

同步调用就是 回去等待 一次访问一个资源 等待资源的回应才会去访问选一个资源 不仅告诉该工作了还要看着他工作完成 才会开始下一步

同步调用的优点：

  • 时效性较强，可以立即得到结果

同步调用的问题：

  • 耦合度高

  • 性能和吞吐能力下降

  • 有额外的资源消耗

  • 有级联失败问题

异步调用就是 会同时访问多个资源 不会等待他们的回应 就告诉他们一下 该工作了 然后就回去交差 不会去等待 

好处：

  • 吞吐量提升：无需等待订阅者处理完成，响应更快速

  • 故障隔离：服务没有直接调用，不存在级联失败问题

  • 调用间没有阻塞，不会造成无效的资源占用

  • 耦合度极低，每个服务都可以灵活插拔，可替换

  • 流量削峰：不管发布事件的流量波动多大，都由Broker接收，订阅者可以按照自己的速度去处理事件

缺点：

  • 架构复杂了，业务没有明显的流程线，不好管理

  • 需要依赖于Broker的可靠、安全、性能

RabbitMQ中的一些角色：

  • publisher：生产者

  • consumer：消费者

  • exchange个：交换机，负责消息路由

  • queue：队列，存储消息

  • virtualHost：虚拟主机，隔离不同租户的exchange、queue、消息的隔离

五大消息模型：

 

简单消息队列：

 原版实现：

publishe 发送过就不管了 发送到rabbitmq的消息队列里面 

思路：

  • 建立连接

  • 创建Channel

  • 声明队列

  • 发送消息

  • 关闭连接和channel

package cn.itcast.mq.helloworld;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.Test;

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

public class PublisherTest {
    @Test
    public void testSendMessage() throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.150.101");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.发送消息
        String message = "hello, rabbitmq!";
        channel.basicPublish("", queueName, null, message.getBytes());
        System.out.println("发送消息成功：【" + message + "】");

        // 5.关闭通道和连接
        channel.close();
        connection.close();

    }
}

 consumer

代码思路： 从队列中取出信息

  • 建立连接

  • 创建Channel

  • 声明队列

  • 订阅消息

  • package cn.itcast.mq.helloworld;

import com.rabbitmq.client.*;

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

public class ConsumerTest {

    public static void main(String[] args) throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.150.101");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.订阅消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 5.处理消息
                String message = new String(body);
                System.out.println("接收到消息：【" + message + "】");
            }
        });
        System.out.println("等待接收消息。。。。");
    }
}

    SpringAMQP：进行

  • SpringAMQP提供了三个功能：

  • 自动声明队列、交换机及其绑定关系

  • 基于注解的监听器模式，异步接收消息

  • 封装了RabbitTemplate工具，用于发送消息

发送方 接收方 都需要的 

 第一步导依赖：

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

第二步 写配置：

spring:
  rabbitmq:
    host: 192.168.150.101 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 123321 # 密码

发送方的实现：

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
      //从spring容器中注入 rabbitTemplate 
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSimpleQueue() {
        // 队列名称
        String queueName = "simple.queue";
        // 消息
        String message = "hello, spring amqp!";
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message);
    }
}

接收方的实现

package cn.itcast.mq.listener;

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

@Component //声明为bean 让spring容器管理
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue")  //开启监听器 监听队列为。。。的消息
    public void listenSimpleQueueMessage(String msg) throws InterruptedException {
//接受消息 对消息进行处理
        System.out.println("spring 消费者接收到消息：【" + msg + "】");
    }
}

当我们接收方有多个监听者监听一个队列的信息时 会把发送方发送的消息 进行平均分配

但是我们需要根据每个监听者处理消息的能力进行分配才更合理 需要在rabbitMq配置加入

spring:
  rabbitmq:
    host: 192.168.188.100 #主机名
    port: 5672 #端口号
    virtual-host: / #连接的虚拟主机
    username: itcast #用户名
    password: 123321 #密码
    listener:
      simple:# 默认是一人一半不管能不能自己的工作效率 先拿走 这个配置限制一次只能拿一个
        prefetch: 1 # 每次只能获取一条消息，处理完成才能获取下一个消息

这样设置后 监听队列时 就会根据能力进行拿去消息了 不会进行堆积处理不完的现象

发布订阅：

可以看到，在订阅模型中，多了一个exchange角色，而且过程略有变化：

  • Publisher：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）

  • Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有以下3种类型：

    • Fanout：广播，将消息交给所有绑定到交换机的队列

    • Direct：定向，把消息交给符合指定routing key 的队列

    • Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列

  • Consumer：消费者，与以前一样，订阅队列，没有变化

  • Queue：消息队列也与以前一样，接收消息、缓存消息。

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

必须要进行交换机和队列的绑定 然后监听队列 这样才能获取数据

Fanout：

在广播模式下，消息发送流程是这样的：

可以实现简单的一对多发送 把消息发送到交换机 交换机再给你进行群发到绑定的队列中 然后再监听队列 就可以让每个监听者都可以接收到同样的消息 就完成了 一对多完成

  • 1） 可以有多个队列

  • 2） 每个队列都要绑定到Exchange（交换机）

  • 3） 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定

  • 4） 交换机把消息发送给绑定过的所有队列

  • 5） 订阅队列的消费者都能拿到消息

配置的方法绑定交换机和队列：

@Configuration
public class FoundConfig {
//声明交换机
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("itcast.fanout");
    }
    //声明队列
    @Bean
    public Queue queue1(){
        return new Queue("fanout.queue1");
    }
//绑定队列和交换机
    @Bean
    public Binding binding1(){
        //绑定队列1到fanout交换机
        return BindingBuilder.bind(queue1()).to(fanoutExchange());
    }
    @Bean
    public Queue queue2(){
        return new Queue("fanout.queue2");
    }
    @Bean
    public Binding binding2(){
        //绑定队列1到fanout交换机
        return BindingBuilder.bind(queue2()).to(fanoutExchange());
    }

 发送

@RunWith(SpringRunner.class)
@SpringBootTest
public class FoundExchange {
@Autowired
    private RabbitTemplate rabbitTemplate;
@Test
    public void test(){
    String exchangeName="itcast.fanout";
    String message="hellow every one";
    rabbitTemplate.convertAndSend(exchangeName,"",message);
}

 发送的消息就会发送到交换机 斌且我们已经绑定了交换机和队列 那么 spring内部会帮我们 把交换机的信息 发送到绑定该交换机的每一个队列 我们在监听方只需要监听队列就可以了

监听方：

@Component  //接受消息 注册bean 让spring容器扫描 管理
public class FanoutListern {
    @RabbitListener(queues = "fanout.queue1") //开启监听 的队列
    public void listernSimple(String message) throws InterruptedException { //接受消息的具体执行
        System.out.println("接受的消息为====》"+message);
    }
    @RabbitListener(queues = "fanout.queue2") //开启监听 的队列
    public void listernSimple2(String message) throws InterruptedException { //接受消息的具体执行
        System.out.println("22222===接受的消息为====》"+message);
    }
}

交换机的作用是什么？

  • 接收publisher发送的消息

  • 将消息按照规则路由到与之绑定的队列

  • 不能缓存消息，路由失败，消息丢失

  • FanoutExchange的会将消息路由到每个绑定的队列

声明队列、交换机、绑定关系的Bean是什么？

  • Queue

  • FanoutExchange

  • Binding

Direct：

相比于Fanout交换机 可以进行更细致的处理交换机和队列的关系 不仅仅能进行一对多发送 还可以进行选择性的条件性的发送 通过 RoutingKey（路由key） 匹配进行发送

在Direct模型下：

  • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）

  • 消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。

  • Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

发送方：

仅仅指定了交换机的名称 和 RoutingKey为red 然后将消息发送 

@Test
public void testSendDirectExchange() {
    // 交换机名称
    String exchangeName = "itcast.direct";
    // 消息
    String message = "红色警报！日本乱排核废水，导致海洋生物变异，惊现哥斯拉！";
    // 发送消息
    rabbitTemplate.convertAndSend(exchangeName, "red", message);
}

 接收方：

声明监听绑定的交换机和队列 的绑定关系  设置交换机的类型 设置当前监听队列的  RoutingKey

然后根据交换机和队列和RoutingKey进行消息的接受

基于@Bean的方式声明队列和交换机比较麻烦，Spring还提供了基于注解方式来声明。

在consumer的SpringRabbitListener中添加两个消费者，同时基于注解来声明队列和交换机

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "direct.queue1"),
    exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
    key = {"red", "blue"}
))
public void listenDirectQueue1(String msg){
    System.out.println("消费者接收到direct.queue1的消息：【" + msg + "】");
}

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "direct.queue2"),
    exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
    key = {"red", "yellow"}
))
public void listenDirectQueue2(String msg){
    System.out.println("消费者接收到direct.queue2的消息：【" + msg + "】");
}

描述下Direct交换机与Fanout交换机的差异？

  • Fanout交换机将消息路由给每一个与之绑定的队列

  • Direct交换机根据RoutingKey判断路由给哪个队列

  • 如果多个队列具有相同的RoutingKey，则与Fanout功能类似

基于@RabbitListener注解声明队列和交换机有哪些常见注解？

  • @Queue

  • @Exchange

  • @RabbitListener(bindings = @QueueBinding( 
        value = @Queue(name = "direct.queue1"),
        exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
        key = {"red", "blue"}
    ))

  • Topic：

  • Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！

    Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

    通配符规则：

    #：匹配一个或多个词

    *：匹配不多不少恰好1个词

 

解释：

  • Queue1：绑定的是china.# ，因此凡是以 china.开头的routing key 都会被匹配到。包括china.news和china.weather

  • Queue2：绑定的是#.news ，因此凡是以 .news结尾的 routing key 都会被匹配。包括china.news和japan.news

  • 描述下Direct交换机与Topic交换机的差异？

  • Topic交换机接收的消息RoutingKey必须是多个单词，以 **.** 分割

  • Topic交换机与队列绑定时的bindingKey可以指定通配符

  • #：代表0个或多个词

  • *：代表1个词

 

消息转换器：

发送的消息时Object类型的  当是复杂类型如对象等 会进行序列化 默认进行JDK序列化 但是JDK序列化慢 数据大 可读性差 建议将默认的序列化方式改成 JSACSON的 转为json船速快

Spring会把你发送的消息序列化为字节发送给MQ，接收消息的时候，还会把字节反序列化为Java对象。

只不过，默认情况下Spring采用的序列化方式是JDK序列化。众所周知，JDK序列化存在下列问题：

  • 数据体积过大

  • 有安全漏洞

  • 可读性差

 在publisher和consumer两个服务中都引入依赖：

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>

配置消息转换器。

在启动类中添加一个Bean即可：因为spring是自动装配 自己没写的配置会使用默认的 所以我们在这里进行声明 那么 spring就会把我们声明的配置注入进行 这样就会使用我们自己设置的序列化器

发送方和接收方 都需要重新声明这个为 序列化器

@Bean
public MessageConverter jsonMessageConverter(){
    return new Jackson2JsonMessageConverter();
}

无敌无敌就无敌
关注
专栏目录
RabbitMQ的发布/订阅概念以及Exchange三种类型和测试默认转换器
zzll_forever的博客
12-01 661
发布订阅的模型如图： 可以看到，在订阅模型中，多了一个exchange角色，而且过程略有变化： Publisher：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机） Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有以下3种类型： Fanout：广播，将消息交给所有绑定到交换机的队列 Direct：定向，把消息交给符
rabbitMQ入门
王和平的第三个果园
08-31 196
1安装 docker pull rabbitmq:3-management docker run \ -e RABBITMQ_DEFAULT_USER=itcast \ -e RABBITMQ_DEFAULT_PASS=123321 \ --name mq \ --hostname mq1 \ -p 15672:15672 \ -p 5672:5672 \ -d \ rabbitmq:3-management Basic Queue 简单队列模型 在父工程mq-demo中引入依赖 <
【RabbitMQ】三种Exchange模式——订阅、路由、通配符模式
点滴记录，积流成河！
07-29 599
  实际项目应用，请移步：https://github.com/winywork/winy-parent   死信转发实例。   一、订阅模式(Fanout Exchange)：    一个生产者，多个消费者，每一个消费者都有自己的一个队列，生产者没有将消息直接发送到队列，而是发送到了交换机，每个队列绑定交换机，生产者发送的消息经过交换机，到达队列，实现一个消息被多个消费者获取的目的。需要...
RabbitMQ详解
最新发布
weixin_40728084的博客
07-31 1348
一、消息队列技术介绍1.1、 消息队列概述消息队列中间件是分布式系统中重要的组件，主要解决应用耦合、异步消息、流量削锋等问题。实现高性能、高可用、可伸缩和最终一致性架构。是大型分布式系统不可缺少的中间件。目前在生产环境，使用较多的消息队列有ActiveMQ、RabbitMQ、ZeroMQ、Kafka、MetaMQ、Rock...
RabbitMq三种Exchange模式—订阅、路由、通配符
heima201907的博客
04-01 282
三种Exchange模式——订阅、路由、通配符模式 一、订阅模式(Fanout Exchange) 一个生产者绑定一个交换机，每个消费者绑定一个队列。生产者将消息通过交换器分发给所有在线的消费者。交换机没有消息存储的能力，只能向当前在线的消费者发送消息。因此未接收到消息的消费者，即使重新连接rabbitmq也无法获取到已发送的消息 ...
RabbitMQ：Exchange类型之默认类型(分析和使用)
编程学习者的博客
05-13 3112
1.声明 当前内容用于本人学习和使用Exchange的默认类型，主要来源与：RabbitMQ官方文档 当前内容用于描述为什么使用“”作为exchange的时候可以使用，并且默认exchange类型的理解 2.官方文档 从官方文档中发现，默认具有一个"“的交换机，如果向”"的exchange发送消息到指定队列，就可以从队列中获取到数据 3.分析前面的HelloWorld的Demo 消息生产者 private final static String QUEUE_NAME = "hello"; public
RabbitMQ Server3.13.0
04-02
**RabbitMQ Server 3.13.0** RabbitMQ 是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中高效地路由和传递消息。RabbitMQ 3.13.0 版本是其稳定版本之一...
kettle rabbitmq 插件开发
10-26
标题 "kettle rabbitmq 插件开发" 涉及的是如何在 Pentaho Kettle（也称为 Spoon）中创建和使用 RabbitMQ 插件。Kettle 是一个开源的数据集成工具，它允许用户进行数据抽取、转换和加载（ETL）操作。RabbitMQ 是一个...
RabbitMQ实战指南-rabbitmq-action.zip
11-07
**RabbitMQ实战指南** RabbitMQ是一款广泛应用的开源消息队列系统，它基于Advanced Message Queuing Protocol（AMQP）标准，提供高可用性、可靠性和可扩展性。本实战指南将带你深入理解RabbitMQ的核心概念、安装与...
rabbitMQ实战java版-rabbitMQ-demo.zip
11-07
《RabbitMQ实战Java版——基于rabbitMQ-demo.zip的详解》 在当今的分布式系统中，消息队列作为异步处理、解耦组件的关键技术，得到了广泛应用。RabbitMQ作为一款开源的消息代理和队列服务器，以其稳定性和易用性...
Spring AMQP
qq_45578181的博客
08-30 435
文章目录引入使用依赖配置配置消费者@Componet@RabbitListener@QueueBinding模板类AmqpTemplate发送方什么时候发？发送什么内容？接收方接收消息后如何处理？ 引入 Spring-amqp是对AMQP协议的抽象实现，而spring-rabbit 是对协议的具体实现，也是目前的唯一实现。 使用 依赖 添加AMQP的启动器： 配置 在application.yml中添加RabbitMQ地址： 配置消费者 在SpringAmqp中，对消息的消费者进行了封装和抽象，一个普通的J
使用 RabbitMQ 发布和订阅消息
测试
12-28 611
使用 RabbitMQ 发布和订阅消息本指南将指导您如何配置 RabbitMQ AMQP 服务，来发布和订阅消息。 目标您将构建一个应用程序，该应用程序使用 Spring AMQP的 RabbitTemplate 发布消息，并使用 MessageListenerAdapter 订阅 POJO 上的消息。 准备工作 大约15分钟 一个...
spring-amqp学习
crackLu的博客
02-12 989
Spring-AMQP学习Spring-AMQP学习ConnectionFactory连接工厂 Amqp Template模板 消息接收ConnectionFactory(连接工厂) 连接和资源管理CachingConnectionFactory: channelCacheSize：控制缓存的channel数 channelCheckoutTimeout:当这个属性大于0的时候，channel
rabbitmq 测试工具_HTTP API测试工具大全，后端开发必备神器。
weixin_34983902的博客
01-18 709
API测试的主要任务是看被开发的应用程序接口，是否符合期望，能否可靠的服务，能否提供API所预定的功能，然后就是测试性能如何，接口的安全性如何。接下来我们就来看看，目前最流行的测试应用程序接口的工具有哪些。...Soap UISoap UI的功能比较强大,它可以测试REST API，SOAP API和网络服务。该工具有免费版和付费版两种版本。...Katalon StudioKatalon Stu...
Spring注解详解
白开水
03-08 386
Import 导入注解，可以导入 普通类，带有@Configuration的配置类，ImportSelector方式导入的类，通过 ImportBeanDefinitionRegistrar 方式导入的类。@Mapper 用的dao层，在dao层加入此注解，可以在方法上直接进行sql语句的编写，用@Select(""),@Delete(""),@update(""),@insert("") 这四个进行编写。@ComponentScan 用户创建容器时要扫描的包，在扫描位置时，可以制定包名，也可以指定类，
Java分布式微服务4——异步服务通讯（RabbitMQ）中间件
qq_40836168的博客
08-09 831
MQ（MessageQueue）消息队列，就是上文事件驱动架构中的Broker。
rabbitmq多租户环境隔离（虚拟主机）
守护者的CSDN博客
04-16 675
场景：线下测试经常会有多租户配置。数据库通过容器的方式达到隔离；redis通过16个database，也达到了隔离；rabbitmq是否也可以进行隔离，而不是部署多个rabbitmq中间件服务？在此，引入rabbitmq的v_host虚拟主机，一样也可以达到隔离的目的；
Spring Boot + RabbitMQ 简单案例 (exchange的四种类型)
那杯热咖啡
09-18 472
项目已上传至github:https://github.com/astronger/Springboot-rabbitmq 首先Docker一键安装RabbitMQ，然后启动项目，在测试类依次测试，rabbitmq管理页面和控制台均能看到测试结果。 ...
RabbitMQ实战指南
"RabbitMQ Cookbook：由Sigismondo Boschi和Gabriele Santomaggio合著，该书提供了超过70个实用的食谱，旨在帮助读者利用RabbitMQ开发消息传递应用程序，通过大量现实生活中的例子进行教学。" 《RabbitMQ Cookbook...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值