SpringBoot整合消息中间件 RabbitMQ 第 5 篇 —— Publish/Subscribe 发布订阅模式（重点掌握，可模拟发邮件）

最新推荐文章于 2023-10-08 18:20:48 发布
最新推荐文章于 2023-10-08 18:20:48 发布
阅读量624 收藏
点赞数
分类专栏： 学习消息中间件 文章标签： rabbitmq 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BiandanLoveyou/article/details/115442014
版权

这个可能是消息队列中最重要的队列了，其他的都是在它的基础上进行了扩展。

RabbitMQ消息传递模型的核心思想是生产者从不将任何消息直接发送到队列。实际上，生产者通常甚至根本不知道是否将消息传递到任何队列。

相反，生产者只能将消息发送到交换机。交换机一方面它接收来自生产者的消息，另一方面，将消息推入队列。交换机必须确切知道如何处理收到的消息。是否应将其附加到特定队列？是否应该将其附加到许多队列中？还是应该将其丢弃。规则由交换类型定义 。

有几种交换类型可用：

Direct exchange（直连交换机）：是根据消息携带的路由键（routing key）将消息投递给对应队列的。

Fanout exchange（扇型交换机）：将消息路由给绑定到它身上的所有队列。

Topic exchange（主题交换机）：队列通过路由键绑定到交换机上，然后，交换机根据消息里的路由值，将消息路由给一个或多个绑定队列。

Headers exchange（头交换机）：类似主题交换机，但是头交换机使用多个消息属性来代替路由键建立路由规则。通过判断消息头的值能否与指定的绑定相匹配来确立路由规则。

这里讲解 Fanout exchange（扇型交换机）

功能实现：

一个生产者发送消息，多个消费者获取消息（同样的消息），包括一个生产者，一个交换机，多个队列，多个消费者。

思路解读（重点理解）：

（1）一个生产者，多个消费者

（2）每一个消费者都有自己的一个队列

（3）生产者没有直接发消息到队列中，而是发送到交换机

（4）每个消费者的队列都绑定到交换机上

（5）消息通过交换机到达每个消费者的队列，该模式就是Fanout Exchange（扇型交换机）将消息路由给绑定到它身上的所有队列。

注意：交换机没有存储消息功能，如果消息发送到没有绑定消费队列的交换机，消息则丢失。

 

本篇博客的示意图：

我们的代码结构如图：

需要在 pom.xml 文件增加Java发送邮件功能的依赖，pom.xml 完整配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.study</groupId>
    <artifactId>RabbitMQStudy</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>Rabbit_P2P</module>
        <module>Rabbit_Work</module>
        <module>Rabbit_Publish</module>
        <module>Rabbit_Routing</module>
        <module>Rabbit_Topic</module>
    </modules>


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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <!--Spring boot 集成包-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!-- 阿里巴巴 fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>
        <!--增加邮件的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Finchley.SR4</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>


</project>

bootstrap.yml 配置文件如下：

spring:
  rabbitmq:
    #主机名
    host: 127.0.0.1
    #端口号
    port: 5672
    #账号
    username: guest
    #密码
    password: guest
    #虚拟主机，这里配置的是我们的测试主机
    virtual-host: /test_host

  mail:
    # host是163邮箱的服务器地址
    host: smtp.163.com
    # 邮箱账号
    username: 请替换成你的邮箱地址
    # 授权码，不是登录密码
    password: 你的邮箱授权码，可以查看往期 ActiveMQ 的博客
    enable: true
    smtp:
      auth: true
    starttls:
      enable: true
      required: true

# 自定义配置信息
queueConfig:
  # 邮件队列名
  emailQueue: emailQueue
  # 短信队列名
  SMSQueue: SMSQueue
  # 交换机名称
  fanoutExchangeName: fanoutExchangeName



server:
  port: 8080

# 将SpringBoot项目作为单实例部署调试时，不需要注册到注册中心
eureka:
  client:
    fetch-registry: false
    register-with-eureka: false

配置类 QueueConfig，这里动态生成2个队列和1个交换机：

package com.study.config;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.Connection;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import sun.net.www.protocol.http.HttpURLConnection;

/**
 * @author biandan
 * @description
 * @signature 让天下没有难写的代码
 * @create 2021-04-05 上午 12:39
 */
@Configuration
public class QueueConfig {

    @Value("${spring.rabbitmq.host}")
    private String host;

    @Value("${spring.rabbitmq.port}")
    private Integer port;

    @Value("${spring.rabbitmq.username}")
    private String username;

    @Value("${spring.rabbitmq.password}")
    private String password;

    @Value("${spring.rabbitmq.virtual-host}")
    private String virtualHost;


    //邮件队列名
    @Value("${queueConfig.emailQueue}")
    private String emailQueue;

    //短信队列名
    @Value("${queueConfig.SMSQueue}")
    private String SMSQueue;

    //扇形交换机名称
    @Value("${queueConfig.fanoutExchangeName}")
    private String fanoutExchangeName;

    /**
     * 封装连接类
     *
     * @return
     */
    @Bean
    public CachingConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(host);
        connectionFactory.setPort(port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);
        return connectionFactory;
    }


    /**
     * 动态的创建队列（这里仅创建配置文件里的一个）
     *
     * @return
     * @throws Exception
     */
    @Bean
    public String getQueueName() throws Exception {
        //获取连接
        Connection connection = connectionFactory().createConnection();

        //创建通道。true表示有事务功能
        Channel channel = connection.createChannel(true);

         /*
        创建队列声明，参数说明：
        1.队列名queue

        2.是否持久化durable。是否持久化, 队列的声明默认是存放到内存中的，
        如果rabbitmq重启会丢失，如果想重启之后还存在就要使队列持久化，
        保存到Erlang自带的Mnesia数据库中，当rabbitmq重启之后会读取该数据库

        3.是否排外exclusive。有两个作用，一：当连接关闭时connection.close()该队列是否会自动删除；二：该队列是否是私有的private，
        如果不是排外的，可以使用两个消费者都访问同一个队列，没有任何问题，
        如果是排外的，会对当前队列加锁，其他通道channel是不能访问的，如果强制访问会报异常。
        一般等于true的话用于一个队列只能有一个消费者来消费的场景

        4.是否自动删除autoDelete。当最后一个消费者断开连接之后队列是否自动被删除，
        可以通过RabbitMQ Management，查看某个队列的消费者数量，当consumers = 0时队列就会自动删除

        5.其它参数 Map<String, Object> arguments
        */
        channel.queueDeclare(emailQueue, true, false, false, null);//创建邮件队列
        channel.queueDeclare(SMSQueue, true, false, false, null);//创建短信队列

        //创建扇形的交换机
        channel.exchangeDeclare(fanoutExchangeName, BuiltinExchangeType.FANOUT, true, false, null);

        //可以在这里直接绑定队列到交换机上，也可以使用代码绑定
        //channel.queueBind(emailQueue, fanoutExchangeName, "");
        //channel.queueBind(SMSQueue, fanoutExchangeName, "");

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

        return "";
    }
}

 如果遇到启动报错如下，则需要去 RabbitMQ 管理后台把旧的交换机删除。

Caused by: com.rabbitmq.client.ShutdownSignalException: channel error; protocol method: #method<channel.close>(reply-code=406, reply-text=PRECONDITION_FAILED - inequivalent arg 'auto_delete' for exchange 'fanoutExchangeName' in vhost '/test_host': received 'false' but current is 'true', class-id=40, method-id=10)
	at com.rabbitmq.utility.ValueOrException.getValue(ValueOrException.java:66) ~[amqp-client-5.4.3.jar:5.4.3]
	at com.rabbitmq.utility.BlockingValueOrException.uninterruptibleGetValue(BlockingValueOrException.java:36) ~[amqp-client-5.4.3.jar:5.4.3]
	at com.rabbitmq.client.impl.AMQChannel$BlockingRpcContinuation.getReply(AMQChannel.java:494) ~[amqp-client-5.4.3.jar:5.4.3]
	at com.rabbitmq.client.impl.AMQChannel.privateRpc(AMQChannel.java:288) ~[amqp-client-5.4.3.jar:5.4.3]
	at com.rabbitmq.client.impl.AMQChannel.exnWrappingRpc(AMQChannel.java:138) ~[amqp-client-5.4.3.jar:5.4.3]
	... 39 common frames omitted
Caused by: com.rabbitmq.client.ShutdownSignalException: channel error; protocol method: #method<channel.close>(reply-code=406, reply-text=PRECONDITION_FAILED - inequivalent arg 'auto_delete' for exchange 'fanoutExchangeName' in vhost '/test_host': received 'false' but current is 'true', class-id=40, method-id=10)
	at com.rabbitmq.client.impl.ChannelN.asyncShutdown(ChannelN.java:516) ~[amqp-client-5.4.3.jar:5.4.3]
	at com.rabbitmq.client.impl.ChannelN.processAsync(ChannelN.java:346) ~[amqp-client-5.4.3.jar:5.4.3]
	at com.rabbitmq.client.impl.AMQChannel.handleCompleteInboundCommand(AMQChannel.java:178) ~[amqp-client-5.4.3.jar:5.4.3]
	at com.rabbitmq.client.impl.AMQChannel.handleFrame(AMQChannel.java:111) ~[amqp-client-5.4.3.jar:5.4.3]
	at com.rabbitmq.client.impl.AMQConnection.readFrame(AMQConnection.java:670) ~[amqp-client-5.4.3.jar:5.4.3]
	at com.rabbitmq.client.impl.AMQConnection.access$300(AMQConnection.java:48) ~[amqp-client-5.4.3.jar:5.4.3]
	at com.rabbitmq.client.impl.AMQConnection$MainLoop.run(AMQConnection.java:597) ~[amqp-client-5.4.3.jar:5.4.3]
	at java.lang.Thread.run(Thread.java:745) ~[na:1.8.0_91]

删除的方式如下：

 

队列绑定交换机配置如下：FanoutConfig。需要注意的是绑定队列到交换机，入参是获取队列的函数名。

package com.study.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.swing.text.rtf.RTFEditorKit;

/**
 * @author biandan
 * @description 扇形交换机绑定队列的配置
 * @signature 让天下没有难写的代码
 * @create 2021-04-04 下午 6:11
 */
@Configuration
public class FanoutConfig {
    //邮件队列名称
    @Value("${queueConfig.emailQueue}")
    private String emailQueue;

    //短信队列名称
    @Value("${queueConfig.SMSQueue}")
    private String SMSQueue;

    //扇形交换机名称
    @Value("${queueConfig.fanoutExchangeName}")
    private String fanoutExchangeName;


    /**
     * 定义邮件队列
     *
     * @return
     */
    @Bean
    public Queue getEmailQueue() {
        return new Queue(emailQueue);
    }

    /**
     * 定义短信队列
     *
     * @return
     */
    @Bean
    public Queue getSMSQueue() {
        return new Queue(SMSQueue);
    }

    /**
     * 定义扇形交换机
     *
     * @return
     */
    @Bean
    public FanoutExchange getFanoutExchange() {
        return new FanoutExchange(fanoutExchangeName);
    }


    /**
     * 绑定邮件队列到交换机
     *
     * @param getEmailQueue     获取邮件队列的函数
     * @param getFanoutExchange 获取扇形交换机的函数
     * @return
     */
    @Bean
    public Binding bindEmailQueueToExchange(Queue getEmailQueue, FanoutExchange getFanoutExchange) {
        return BindingBuilder.bind(getEmailQueue).to(getFanoutExchange);
    }

    /**
     * 绑定短信队列到交换机
     *
     * @param getSMSQueue       获取短信队列的函数
     * @param getFanoutExchange 获取扇形交换机的函数
     * @return
     */
    @Bean
    public Binding bindSMSQueueToExchange(Queue getSMSQueue, FanoutExchange getFanoutExchange) {
        return BindingBuilder.bind(getSMSQueue).to(getFanoutExchange);
    }

}

 

消息生产者 FanoutProducer 代码如下：

package com.study.producer;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author biandan
 * @description 消息生产者（扇形交换机）
 * @signature 让天下没有难写的代码
 * @create 2021-04-04 下午 10:49
 */
@Component
public class FanoutProducer {

    private SimpleDateFormat SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    //邮件队列名称
    @Value("${queueConfig.emailQueue}")
    private String emailQueue;

    //短信队列名称
    @Value("${queueConfig.SMSQueue}")
    private String SMSQueue;

    //扇形交换机名称
    @Value("${queueConfig.fanoutExchangeName}")
    private String fanoutExchangeName;

    /**
     * 注入 AMQP 消息模板
     */
    @Autowired
    private AmqpTemplate template;

    /**
     * 每隔5秒产生一条消息
     */
    @Scheduled(fixedRate = 1000 * 5)
    public void sendMsg() {
        String msg = "扇形交换机消息生产者：" + SDF.format(new Date());
        System.out.println(msg);
        //发送消息
        template.convertAndSend(fanoutExchangeName, emailQueue, msg);
        template.convertAndSend(fanoutExchangeName, SMSQueue, msg);
    }

}

启动类 RabbitMQPublishApplication：

package com.study;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling //启用任务调度
@EnableEurekaClient
public class RabbitMQPublishApplication {
    public static void main(String[] args) {
        SpringApplication.run(RabbitMQPublishApplication.class, args);
    }
}

OK，我们启动项目。看下控制台输出，每隔5秒生产一条消息，并推送到2个队列：

我们到 RabbitMQ 后台查看：

①队列里已经有了2个队列名称，并且有待消费的消息。

②交换机里也有扇形交换机的名称了

 

点进进入交换机管理页面，看到2个队列已经绑定到了交换机上（可手动解绑）：

 

然后我们编写消费者代码。

短信消费者代码如下：

package com.study.consumer;

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

/**
 * @author biandan
 * @description 短信消费者
 * @signature 让天下没有难写的代码
 * @create 2021-04-04 下午 11:39
 */
@Component
@RabbitListener(queues = "${queueConfig.SMSQueue}")
public class Consumer_SMS {

    @RabbitHandler
    public void receiveMsg(String msg) {
        System.out.println("短信消费者_消费掉的消息：" + msg);
    }

}

邮件消费者代码如下（可以真实发送邮件，需要配置对应的邮箱号码和授权码）：

package com.study.consumer;

import com.alibaba.fastjson.JSONObject;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Component;

/**
 * @author biandan
 * @description 邮件消费者
 * @signature 让天下没有难写的代码
 * @create 2021-04-04 下午 11:39
 */
@Component
@RabbitListener(queues = "${queueConfig.emailQueue}")
public class Consumer_Email {

    @Value("${spring.mail.username}")
    private String emailName;

    @Autowired
    JavaMailSender javaMailSender;

    @RabbitHandler
    public void receiveMsg(String msg) {
        System.out.println("邮件消费者_消费掉的消息：" + msg);
        SimpleMailMessage message = new SimpleMailMessage();
        //发送者邮箱号
        message.setFrom(emailName);
        //接收者邮箱账号
        message.setTo(emailName);
        //主题
        message.setSubject("RabbitMQ发送邮件学习");
        //文本内容
        message.setText(msg);
        javaMailSender.send(message);
        System.out.println("邮件发送完成," + JSONObject.toJSONString(message));
    }

}

 

OK，我们启动项目，看到控制台输出。

然后登陆我们 163 邮箱，看到邮件过来了。

 

代码在百度网盘连接：https://pan.baidu.com/s/1Izb0WbsuLCJJXlm445xjrw   提取码：xnjd

流放深圳
关注
专栏目录
深入详解高性能消息队列中间件 RabbitMQ
dvlinker的技术专栏
11-06 1万+
深入详解高性能消息队列中间件 RabbitMQ
Rabbitmq消息中间件初步学习——第二节SpringBoot集成Rabbitmq
Burnup_110的博客
02-14 490
前言 本节主要涉及到Rabbitmq在SpringBoot的API使用，基本是上一节的一个扩展，也会简单的介绍一下七种模型和Header Exchange的使用，不过使用场景从原生变成了SpringBoot封装。 对于七种模型和Header Exchange的介绍会很简单提及，如果想详细了解，可以看一下上一节内容。 一 Hello Word Hello Word 模型采用默认Exchange，以Queue Name作为RoutingKey的方式进行消息发布。 ...
SpringBoot的RabbitMQ消息队列: 四、第三模式"Publish/Subscribe"
lxhjh的专栏
04-04 8822
Publish/Subscribe 发布/订阅模式，官方定义是每次把消息发送给多个消费者（Sending messages to many consumers at once）。 它的结构式 一、相关概念 1、RabbitMQ结构 通常我们谈到队列服务, 会有三个概念： 发消息者、队列、收消息者，RabbitMQ 在这个基本概念之上, 多做了一层抽象, 在发消息者和 队列之间, 加
SpringBoot RabbitMQ 集成 三 "Publish/Subscribe"
weixin_34112181的博客
04-30 272
为什么80%的码农都做不了架构师？>>> ...
SpringBoot使用RabbitMQ消息队列
热门推荐
lizc_lizc的博客
06-18 1万+
RabbitMQ简介RabbitMQ基本概念SpringBoot整合RabbitMQ在 pom.xml 中添加 spring-boot-starter-amqp的依赖        &lt;dependencies&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;a...
java publish_Java Spring boot 整合RabbitMQ（三）：（Publish/Subscribe）-B2B2C小程序电子商务...
weixin_39603537的博客
02-24 75
在本篇教程中，我们要做的跟之前完全不一样 —— 分发一个消息给多个消费者(consumers)。这种模式被称为” 发布 / 订阅”。交换器(Exchanges)在本教程的前面部分，我们发送和接收到队列中的消息，现在是时候在 RabbitMQ 中引入完整的消息传递模式了。让我们快速回顾一下之前了解的内容：生产者(producer)：发送消息的程序队列(queue)：存储消息的缓冲器消费者(consu...
消息队列 — RabbitMQ_02(workqueue_工作队列、publish/subscribe_发布订阅、routing_路由、topics_通配符、springboot整合RabbitMQ)
文泽路小男孩的博客
02-06 1155
文章目录3 工作模式3.1 Work queues3.1.1 特点3.2 Publish/Subscribe 发布订阅（不需要指定routingKey）3.2.1 特点3.2.2 代码3.2.2.1 生产者3.2.2.2 消费者3.2.3 publish/subscribe与work queues的区异同3.3 Routing 路由 (设置routingKey)3.3.1 特点3.3.2 代码3....
RabbitMQ的Publish/Subscribe发布订阅模式详解
关注我！带你一路 "狂飙" 到底！
08-24 6491
需要说明的是，使用@RabbitListener注解监听队列消息后，一旦服务启动且监听到指定的队列中有消息存在(目前两个队列中各有一条相同的消息)，对应注解的方法就会立即接收并消费队列中的消息。而测试类中发送的是User实体类对象消息，所以发生异常。按照消息服务整合实现步骤，完成消息组件的定制后，还需要编写消息发送者和消息消费者，而在基于API的方式中已经实现了消息发送者和消息消费者，并且基于配置类方式定制的消息组件名称，和之前测试用的消息发送和消息消费组件名称都是一致的，所以这里我们可以直接重复使用。
RabbitMQDemo_RabbitMQ发布与订阅Demo_rabbitmq_JSON_中间件_
10-04
总结来说，"RabbitMQDemo_RabbitMQ发布与订阅Demo_rabbitmq_JSON_中间件_"是一个演示项目，其核心在于利用RabbitMQ作为中间件，通过发布者发送JSON格式的消息到队列，由订阅者从队列中接收并处理这些消息。...
SpringBoot中消息中间件(RabbitMQ)的概述
w1316022737的博客
11-07 958
一,Spring Boot与消息服务概述: 做消息中间件的主要有:JMS,AMQP,RabbitMQ 大多应用中,可通过消息服务中间件来提升系统异步通信,扩展解耦能力 消息服务中两个重要概念: 消息代理(message broker)和目的地(destination) 当消息发送者发送消息以后,将由消息代理接管,消息代理保证消息传递到指定目的地 消息队列主要有两种形式的目的地 1).队列(que...
RabbitMQ消息队列(四)：SpringBoot整合之发布订阅模式
fatestranger的博客
08-11 941
P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给 X（交换机）C：消费者，消息的接受者，会一直等待消息到来。Queue：消息队列，接收消息、缓存消息。Exchange：交换机，图中的 X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于 Exchange 的类型。.........
SpringBoot + RabbitMQ 实现"订阅模式"
Felix
03-01 3084
RabbitMQ官网提供了七种队列模型，分别是：简单队列、工作队列、发布订阅、路由模式、主题模式、RPC模式、发布者确认模式。 本文在SpringBoot+RabbitMQ环境实现"订阅模式"。 一、订阅模式 特点： 1、X代表交换机，生产者没有将消息直接发送到队列，而是先发送到了交换机。 2、订阅模式的交换机类型为fanout。 3、一个队列可以有多个消费者，但发送到队...
springboot 发布订阅
悟世君子的博客
10-10 2444
springboot 发布订阅，可以实现基于事件驱动对业务进行解耦 这里模拟下订单发消息业务，实现如下 1、定义 Order 实体类 package com.tdemo.learn.bean; import lombok.Data; @Data public class Order { private String orderNo; private String content; } 2、定义 OrderService 发布事件使用ApplicationConte..
消息队列 RabbitMQ[四] RabbitMQ的Publish/Subscribe(发布/订阅)工作模式(SpringBoot方式与amqp-client方式)
qq_43623492的博客
04-23 1814
Publish/Subscribe工作模式架构图: 如图所示我们需要一个交换机以及两个队列，生产者发布消息到交换机，交换机会将消息发送到这两个与它绑定的队列 一、amqp-client操作RabbitMQ 1. 引入依赖： <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>4
Spring中的发布订阅
weixin_44971379的博客
01-04 945
模型构成 事件类 ApplicationEvent 继承 java.util.EventObject， 我们需要继承ApplicationEvent，必要时候为事件添加一些属性 事件发布类 ApplicationContext 继承了org.springframework.context.ApplicationEventPublisher， 我们需要通过ApplicationContext.publisEvent(event)发布事件 事件处理类 ApplicationListener 继
spring中的发布订阅
pipi蛋
06-19 2085
发布订阅模式可能大家都熟悉，消息队列、redis等很多中间件都有发布订阅模式，但你知道我们平时用的spring也有发布订阅模式吗？ 在我们系统中，可能会遇到处理完一个流程以后，接下来要同时处理多个流程，比如用户支付成功以后，接下来会同时减少库存、发送下单成功短信等，这种情况就可以用到发布订阅。减少库存和发送下单成功短信服务监听支付成功事件，当用户支付成功以后，发布这个消息，另外两个服务则会监听到，接着执行对应的逻辑。 可能在真实情况下，我们应用都是分布式的，处理这种情况可能都是使用消息队列等中间件来处理.
Redis学习（九）SpringBoot实现（Pub/Sub）发布订阅
最新发布
ACGkaka的博客
10-08 1648
Redis学习（九）SpringBoot实现（Pub/Sub）发布订阅
spring 订阅发布实现
xj15010735572的博客
12-30 951
这里我们学习一下Spring的订阅发布功能 参考资料： https://www.jianshu.com/p/e2d257ce410d?from=timeline&isappinstalled=0 https://www.iteye.com/blog/butteryrose-2283056 整个功能分为三部分：事件，发布 ，订阅 事件必须继承ApplicationEvent...
SpringBoot——消息
长不大的大灰狼
01-22 876
SpringBoot——消息中间件（ActiveMQ）一、消息服务的基本概念二、JMS规范 一、消息服务的基本概念 1、消息服务中两个重要概念： 消息代理（message broker，消息服务器）和目的地（destination）当消息发送者发送消息以后，将由消息代理接管，消息代理保证消息传递到指定目的地。 2、消息队列主要有两种形式的目的地： （1） 队列（queue）：点对点消息通信（point-to-point）。 发送者发送消息，消息代理将其放入一个队列中，在合适的时候，消息接收者从队列中获取消
RabbitMQ消息发布订阅机制深入解析
本文档共7页，主要讲解了RabbitMQ中的发布和订阅（Publish/Subscribe）模型。发布和订阅模型是消息队列系统中一种常见的消息分发方式，它允许发布者（Publisher）发送消息到交换机（Exchange），由交换机将消息推送...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值