SpringCloud----RabbitMQ高级消息队列

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

文章目录

概述

RabbitMQ是一种消息中间件，用于处理来自客户端的异步消息。服务端将要发送的消息放入到队列池中。接收端可以根据RabbitMQ配置的转发机制接收服务端发来的消息。

RabbitMQ依据指定的转发规则进行消息的转发、缓冲和持久化操作，主要用在多服务器间或单服务器的子系统间进行通信，是分布式系统标准的配置。

使用场景

虚拟机配置

image-20211213152010280

  1. 解压出来
  2. 通过VMware打开
  3. 内容
    1. yun 安装源, 扩展源使用了阿里服务器
    2. 安装了Python, pip, ansible
    3. 添加了两个脚本文件, 方便配置IP地址
      1. IP-static- 配置固定IP
      2. IP-dhcp: 自动获取IP
  4. 使用./ip-dhcp命令自动获取IP
  5. 关机克隆设置名字为 Docker-base 用来安装docker
  6. ifconfig查看IP地址
  7. 使用MobaXterm连接虚拟机

Docker

下载docker离线包

https://download.docker.com/linux/static/stable/x86_64/docker-20.10.6.tgz

这个地址可以选择自己需要的版本进行下载：
https://download.docker.com/linux/static/stable/

离线安装工具

https://github.com/Jrohy/docker-install/

image-20211213204324420

安装

  1. 将前面下载的以下文件放入服务器的 /root/docker-install 文件夹下：

    - [docker-install]
	- docker-20.10.6.tgz
	- install.sh
	- docker.bash

  2. 执行安装：

    # 进入 docker-install 文件夹
cd docker-install

# 为 docker-install 添加执行权限
chmod +x install.sh

# 安装
./install.sh -f docker-20.10.6.tgz

镜像加速

由于国内网络问题，需要配置加速器来加速。
修改配置文件 /etc/docker/daemon.json

下面命令直接生成文件 daemon.json

cat <<EOF > /etc/docker/daemon.json
{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "http://hub-mirror.c.163.com"
  ],
  "max-concurrent-downloads": 10,
  "log-driver": "json-file",
  "log-level": "warn",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
    },
  "data-root": "/var/lib/docker"
}
EOF

​ 重启服务

# 重新加载docker配置
sudo systemctl daemon-reload

#重启docker服务
sudo systemctl restart docker

测试

docker info

docker run hello-world

Docker运行RabbitMQ

  1. 克隆Docker虚拟机: RabbitMQ
  2. 设置IP地址
  3. MobaX连接虚拟机

RabbitMQ配置

  1. Rabbit镜像拖入root目录

​ image-20211213204334418

  1. 导入镜像docker load < rabbit-image.gz

  2. 关闭防火墙

    systemctl stop firewalld
systemctl disable firewalld
 
# 重启 docker 系统服务
systemctl restart docker

  3. 配置管理员账号密码

    mkdir /etc/rabbitmq
vim /etc/rabbitmq/rabbitmq.conf

# 添加两行配置：
default_user = admin
default_pass = admin

  4. 启动Rabbitmq

    docker run -d --name rabbit \
-p 5672:5672 \
-p 15672:15672 \
-v /etc/rabbitmq/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf \
-e RABBITMQ_CONFIG_FILE=/etc/rabbitmq/rabbitmq.conf \
--restart=always \
rabbitmq:management

  5. 访问测试

访问管理控制台 http://192.168.64.4:15672
用户名密码是 admin

image-20211213204341508

rabbitmq六种工作模式

简单模式

准备工作

image-20211213204349127

  1. 新建空项目

  2. 添加依赖

        <dependencies>
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.4.3</version>
        </dependency>
    </dependencies>

生产者发送信息

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        /*连接*/
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.4");
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");

        Connection con = f.newConnection();   // 创建连接
        Channel c = con.createChannel();  // 通信的通道

        /*在服务器上创建 helloworld 队列
        * 队列如果存在, 不会重复创建*/
        c.queueDeclare("helloworld",false,false,false,null); //队列定义/声明

        /*向队列发送消息*/
        c.basicPublish("","helloworld",null,"Hello World".getBytes());  // 2. 队列名

    }
}
  • setHost : 为 Rabbitmq服务虚拟机IP
  • setPort : Rabbitmq端口号
  • setUsername/setPassword : Rabbitmq配置的用户名密码
参数说明

image-20211213204356740

  1. 队列名

  2. 布尔值(是否是持久队列)持久: 重启服务器队列存在 (在磁盘储存队列信息)

  3. 是否是排他队列 (独占队列) (是否可以共享队列)

  4. 队列能不能被服务器自动删除, (没有消费者时服务器是否自动删除)

  5. 队列的其他参数属性

  6. 交换机，空串是默认交换机

  7. 队列名

  8. 消息的其他参数属性 (用键值对设置参数属性, 如果没有就用 null )

测试
image-20211213152059618

消费者接受消息

public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        /*建立连接*/
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.4");
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");

        Connection con = f.newConnection();   // 创建连接
        Channel c = con.createChannel();  // 通信的通道

        /*创建队列*/
        c.queueDeclare("helloworld",false,false,false,null); //队列定义/声明

        /*创建回调对象*/
        DeliverCallback deliverCallback = new DeliverCallback() {
            public void handle(String s, Delivery delivery) throws IOException {
                byte[] a = delivery.getBody();
                String string = new String(a);
                System.out.println("收到："+ string);
            }
        };  // 处理消息的回调
        CancelCallback cancelCallback = new CancelCallback() {
            public void handle(String s) throws IOException {

            }
        };  // 取消消息的回调

        /*从队列接收消息, 把消息传递到回调对象处理*/
//        c.basicConsume("helloworld", true, 处理消息的回调对象, 取消消息的回调对象);
        c.basicConsume("helloworld", true, deliverCallback, cancelCallback);
    }
}
参数说明

image-20211213152129190

  1. 确认方式 ACK – Acknowledgment

    • true 自动确认
    • false 手动确认

工作模式

多个消费者接收消息

生产者发送消息

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        /*创建连接*/
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.4");
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");

        Connection con = f.newConnection();   // 创建连接
        Channel c = con.createChannel();  // 通信的通道

        /*创建队列*/
        c.queueDeclare("helloworld",false,false,false,null); //队列定义/声明

        /*循环输入消息发送*/
        while (true) {
            System.out.println("请输入消息：");
            String s = new Scanner(System.in).nextLine();
            c.basicPublish("","helloworld",null,s.getBytes());
        }

    }
}

消费者接收消息

  • 遍历每一个数据
  • 当遇到" . " 时就暂停1秒
public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.4");
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");

        Connection con = f.newConnection();   // 创建连接
        Channel c = con.createChannel();  // 通信的通道

        /*创建队列*/
        c.queueDeclare("helloworld",false,false,false,null); //队列定义/声明

        /* 回调对象*/
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            String s = new String(message.getBody());
            System.out.println(s);
            // 遍历所有字符，遇到 '.' 暂停1秒
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == '.') {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                    }
                }
            }
            System.out.println("-------------------------------消息处理完成");
        };
        CancelCallback cancelCallback = consumerTag -> {};

        // 接收消息
        c.basicConsume("helloworld",true,deliverCallback,cancelCallback);
    }
}

测试一

  1. Producer发送消息

    image-20211213152139544

  2. Consumer接收消息

    image-20211213152146236

  3. 查看服务器

    image-20211213152153093

​ image-20211213152204310

测试二

  • 启动多个消费者

    image-20211213152221646

  1. Producer 发送消息

    image-20211213152233501

  2. 查看两个Consumer接收

image-20211213152244947 image-20211213152255042
  1. 通过" . " 测试, 先发送一堆 " . "
image-20211213152307027
  1. Consumer接收到 “…” 接着发送 1-9测试

image-20211213152320614

  • 接收到"…"的Consumer-2 进入等待

    image-20211213152328759

  • 另一个 Consumer 打印出一部分信息

    image-20211213152336251

  • Consumer-2 等待结束后, 打印出剩下的消息

    image-20211213152350559

测试三(手动确认回执)

修改成手动确认回执

  1. 修改Consumer 手动确认

image-20211213152358163

  1. 添加回执

    image-20211213152405668

  2. 添加Qos

    image-20211213152412220

测试

  1. produce 发送 “…” 和 1-9

    image-20211213152421860

  2. Consumer2接收后进入等待

  3. Consumer2接收后进入等待

    image-20211213152432297

  4. Consumer接收到所有信息

image-20211213152444964

队列持久化

  1. 将Producer 持久化改成 true, 队列名改成"task_queue"

image-20211213152454325

  1. basicPublish其他参数属性改为 持久化属性

    image-20211213152502966

  2. 修改Consumer 创建队列参数

  3. 修改Consumer 接收信息队列名 (task_queue)

  4. 添加队列信息测试, 打开RabbitMQ 服务器查看队列信息, 会发现有helloworld 和 task_queue 两个队列

  5. 重启 RabbitMQ 服务, 再打开RabbitMQ 服务器查看, 没有持久化的helloworld就没有了, 做了持久化的task_queue 还存在

发布订阅模式

生产者

package m3;

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

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

/**
 * 生产商
 *
 * @author 刘杰
 * @date 2021/11/22 10:48:59
 */
public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.4"); // wht6.cn
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        Channel c = f.newConnection().createChannel();
        // 创建 Fanout 类型的交换机： logs
        // c.exchangeDeclare("logs", "fanout");
        c.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);
        // 向 logs 交换机发送消息
        while (true) {
            System.out.print("输入消息：");
            String s = new Scanner(System.in).nextLine();
            // 第二个参数，对于fanout类型交换机无效
            c.basicPublish("logs", "", null, s.getBytes());
        }
    }
}

消费者

package m3;

import com.rabbitmq.client.*;

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

/**
 * 消费者
 *
 * @author 刘杰
 * @date 2021/11/22 10:08:32
 */
public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 连接
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.4"); // wht6.cn
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        Channel c = f.newConnection().createChannel();


        // 1.创建随机队列 2.创建交换机 3.绑定  手动命名
        String queue = UUID.randomUUID().toString();
        c.queueDeclare(queue,false,true,true,null);  //手动提供参数
        c.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);
        // 第三个参数对 fanout 交换机无效
        c.queueBind(queue, "logs", "");

        // 正常的从随机队列接收处理消息
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            String s = new String(message.getBody());
            System.out.println("收到："+s);
        };
        CancelCallback cancelCallback = consumerTag -> {};
        c.basicConsume(queue,true,deliverCallback,cancelCallback);
    }
}

测试

主题模式

生产者

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.4"); // wht6.cn
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        f.setVirtualHost("/");  //默认空间
        Channel c = f.newConnection().createChannel();

        c.exchangeDeclare("direct_logs", BuiltinExchangeType.DIRECT);

        while (true) {
            System.out.println("输入消息: ");
            String s = new Scanner(System.in).nextLine();
            System.out.println("输入路由键: ");
            String k = new Scanner(System.in).nextLine();
            /*2: 路由键关键词
            * 如果用默认交换机, 路由键就是队列名*/
            c.basicPublish("direct_logs", k,null, s.getBytes(StandardCharsets.UTF_8));

        }
    }
}

消费者

public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory f = new ConnectionFactory();
        f.setHost("192.168.64.4"); // wht6.cn
        f.setPort(5672);
        f.setUsername("admin");
        f.setPassword("admin");
        Channel c = f.newConnection().createChannel();

        String queue = c.queueDeclare().getQueue();//服务器自动提供参数: 随机名,false,true,true  .getQueue(): 得到随机名(因为后面要用)
        c.exchangeDeclare("direct_logs", BuiltinExchangeType.DIRECT);
        System.out.println("输入绑定键, 用空格隔开: ");   // "aa  bb  cc"
        String s = new Scanner(System.in).nextLine();
        String[] a = s.split("\\s+");// \s是空白字符, +表示一到多个 (一个或多个都可以)
        for (String k : a) {
            c.queueBind(queue, "direct_logs", k);
        }
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            java.lang.String ss = new java.lang.String(message.getBody());
            System.out.println("收到：" + ss);
        };
        CancelCallback cancelCallback = consumerTag -> {};
        c.basicConsume(queue,true, deliverCallback, cancelCallback);

    }
}

测试一

  • 消费者输入绑定键

    image-20211213152516247

  • 生产者输入消息 + 路由键

    image-20211213152528362

  • 消费者收到消息

    image-20211213152535631

测试二

  • 生产者随便输入

    image-20211213152542597

  • 消费者不会受到

    image-20211213152549932

virtual host 设置空间

在RabbitMQ中叫做虚拟消息服务器VirtualHost，每个VirtualHost相当于一个相对独立的RabbitMQ服务器，每个VirtualHost之间是相互隔离的。exchange、queue、message不能互通

image-20211213152602598
  • 默认空间名为: " / "

查看结果

image-20211213152614778

使用:

image-20211213152625613

​

Sleuth + Zipkin 链路跟踪

随着系统规模越来越大，微服务之间调用关系变得错综复杂，一条调用链路中可能调用多个微服务，任何一个微服务不可用都可能造整个调用过程失败

spring cloud sleuth 可以跟踪调用链路，分析链路中每个节点的执行情况

添加依赖

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-sleuth</artifactId>
        </dependency>

Zipkin

https://github.com/openzipkin/zipkin

下载

image-20211213152636075

启动服务器

在根目录打开终端控制器

java -jar zipkin-server-2.23.5-exec.jar --zipkin.collector.rabbitmq.uri=amqp://admin:admin@192.168.64.4:5672

如用自己的空间

java -jar zipkin-server-2.12.9-exec.jar --zipkin.collector.rabbitmq.uri=amqp://admin:admin@192.168.64.4:5672 / 空间名

Zipkin访问地址

http://localhost:9411/zipkin

添加依赖

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>

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

配置yml

添加06网关, 三个消费服务

rabbitmq:
    port: 5672
    host: 192.168.64.4
    username: admin
    password: admin
    virtual-host: /
  zipkin:
    sender:
      type: rabbit   # zipkin 向 Rabbit 转发日志

导入商城项目

  1. 课前资料/elasticsearch/pd-商城项目案例.zip 里面的 pd-web 文件夹，解压到 rabbitmq 工程目录

  2. pom文件 SpringBoot版本改为2.3.2.RELEASE

  3. 配置连接数据库

  4. 执行启动类后配置启动类

  5. 在 working directory 中配置 pd-web 模块目录路径 然后重新启动

    image-20211213152721576

  6. 访问 http://localhost

订单发送到 RabbitMQ

添加依赖

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

配置yml

  rabbitmq:
    host: 192.168.64.4
    port: 5672
    username: amdin
    password: admin
    virtual-host: /

配置启动类

  1. 新建 spring 的 Queue 实例
  2. 封装队列的参数
  3. rabbitmq的自动配置类会自动发现这个Queue 实例
  4. 根据其中的参数自动在服务器上创建队列
	@Bean
	public Queue orderQueue() {
		return new Queue("orderQueue", true, false, false);
	}

队列参数解析

  1. 持久队列
  2. 独占队列
  3. 不自动删除

修改 orderServiceImpl

  1. 注释 64-89行

    image-20211213152745426

  2. 添加 代码

    • 注入对象: AmqpTemplate (用来封装发送消息代码的工具)

    image-20211213152804733

订单消费者

  1. 复制 pd-web 项目起名为 pd-web-consumer
  2. 修改pom文件

新建消费者类: OrderConsumer

  1. 添加注解

    • @RabbitListener 通过注解配置就可以接受消息
    • queues = “orderQueue” 队列名

  2. 创建方法

    image-20211213204604428

用注解配置接收消息
收到的订单通过原来的业务方法代码, 存储到数据库

偶尔也吹晚风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SpringCloud项目整合RabbitMQ
weixin_43028393的博客
03-28 4129
在应用程序中，我们可以使用publishMessage()方法来发布消息，并使用handleMessage()方法来处理接收到的消息。在上面的示例中，我们注入了名为“myOutputChannel”的输出通道，并在publishMessage()方法中使用它来发布消息。在我们的示例中，我们已经定义了一个名为“myInputChannel”的输入通道，并在MyMessageChannels接口中定义了它。在需要发送消息的地方，我们可以通过注入MessageChannel并使用send()方法来发送消息。
关于SpringCloud整合RabbitMQ踩坑记录
RZYuen的博客
08-31 234
我是在做尚硅谷的谷粒商城遇到这个问题的，困扰了我一天。查了很多资料。一度怀疑是我代码的问题。简单明了如果你报了以下异常。并且还无限循环抛出这个异常。。。 org.springframework.amqp.AmqpException: No method found for class [B SimpleMessageConverter only supports String, byte[] and Serializable payload 又反复找不到问题那可以试试这个方法 在MQconfig里.
SpringCloud（6）— RabbitMQ(消息队列)
shaopengjie的博客
12-13 1491
MQ（MessageQueue）,中文含义为消息队列，用来存放消息，也就是事件驱动模式中的 BrokerRabbitMQ：现阶段使用最多的MQ技术，优点在于消息的低延迟和可靠性ActiveMQ：开发语言基于Java,可以进行深度定制RocketMQ：开发语言基于Java,可以进行深度定制，阿里巴巴开发Kafka：单机吞吐量很高，但消息可靠性不高。RabbitMQ通过 VirtualHost 进行隔离，相互不可见。RabbitMQ中的相关概念channel：操作MQ的工具。
spring cloud基于rabbitmq发布订阅的websocket集群
qq_35140572的博客
05-18 492
*** 站内信(websocket)交换机，发布订阅* @return} }
Spring Cloud 集成 RabbitMQ
最新发布
程序员们必读的博客，涵盖IT技术、编程经验等领域。
04-09 1069
在当今的微服务架构盛行的时代，消息队列作为一种重要的通信机制，在分布式系统中扮演着不可或缺的角色。RabbitMQ，作为一款开源的消息代理和队列服务器，以其高可用性、易扩展性、灵活的路由机制以及多协议支持等特点，深受开发者们的青睐。而Spring Cloud，作为Spring生态中针对微服务架构的一套集成解决方案，也提供了与RabbitMQ的集成支持，使得在Spring Cloud环境下使用RabbitMQ变得更加简单高效。
Springboot+RabbitMQ + WebSocket 给前端推送消息 + 定时队列
丶Melody
07-22 7403
环境 : JDK : 1.8 Springboot : 2.1.6.RELEASE ErLang : otp_win64_22.0.exe RabbitMQ : 3.7.16 下载地址 开启RabbitMQ的stomp插件 . 在RabbitMQ安装目录sbin文件夹里执行命令 : rabbitmq-plugins enable rabbitmq_stomp Springboot pom.xm...
rabbitmq-advanced-spring-boot-starter：一个通用库，用于通过spring boot amqp上的扩展名与rabbit mq进行消息传递
01-30
Rabbitmq高级 用于通过RabbitMq（Spring Boot amqp的扩展）进行消息传递的通用库。 注意：如果您已经在使用Spring Cloud Stream，则可能不需要此启动程序。 但是，如果由于其抽象级别而需要Spring Cloud无法提供的...
详解Spring Cloud微服务架构下的WebSocket解决方案
08-26
RabbitMQ 是一个高级消息队列，可以实现消息广播。Spring Cloud Stream 是一个用于构建高度可扩展事件驱动型微服务的框架，并且它可以跟 RabbitMQ、Kafka 以及其他多种消息服务集成。 使用方法 首先，我们需要引入...
otp_win64_21.0.1+rabbitmq-server-3.7.9.rar
02-03
rabbitmq是实现了高级消息队列协议（AMQP）的开源消息代理软件，RabbitMQ服务器是用Erlang语言编写的，安装rabbitmq需要安装Erlang开发环境，rabbitmq-server-3.7.9和erlang21.0.1，21.0.1版本的erlang能支持3.7.9...
1000道 互联网大厂Java工程师面试题-基础 全部有
10-18
1. RabbitMQ 介绍：RabbitMQ 是一个基于 AMQP 协议的消息队列服务器，提供了消息队列、消息路由等功能。 2. RabbitMQ 的应用场景：包括消息队列、异步处理、微服务架构等。 Kafka 知识点 1. Kafka 介绍：Kafka 是...
springCloudStream集成rabbitmq
admin522043032的博客
06-06 3945
springCloudStream集成rabbitmq SpringCloudStream框架封装出了三个最基础的概念来对各种消息中间件提供统一的抽象： Destination Binders:负责集成外部消息系统的组件。 Destination Binding:由Binders创建的，负责沟通外部消息系统、消息发送者和消息消费者的桥梁。 Message:消息发送者与消息消费者沟通的简单数据结构。 简单使用案例 引入依赖 RabbitMQ的SpringCloudStream支持是由Spring社区官网提
springcloud部署rabbitMQ
09-20
这里两个项目，一个发送mq消息列队，另一个介绍mq消息，你需要配置安装rabbitmq
SpringCloud一:提供者架构Eureka+Sleuth+RabbitMQ
lhc0512的博客
08-25 976
SpringCloud真是微服务的集大成者,与springBoot的一样,都是基于一些开源框架之上,这几天都在搞springcloud,网上资料很多,但都是基于一些零散的知识点,没有串起来一些组件,本次写的博客会总结springcloud的实战场景,分几个微服务将springcloud串起来,我会连载几篇博客供读者参考 本次写基于springcloud的消费者如何架构, 我们使用Eureka来...
Spring cloud sleuth rabbitmq zipkin mysql分布式服务跟踪分析
泽佑兄弟 ZYbros
06-17 4654
基于zipkin搭了一个分布式跟踪分析应用，在查看服务链间的调用过程、耗时时间、服务依赖时可以用它。 尤其是后期分析性能时可以作为参考依据，根据个人需要选择使用。 介绍： Twitter的zipkin是一个致力于收集Twitter所有的分布式服务的时间数据的分布式跟踪系统。它提供了收集数据，和查询数据两大服务。系统的理论模型来自于Google Dapper 论文。通过采集跟踪数据可以帮助
【学习】AMQP（高级消息队列协议）
Lisong_jack的博客
10-27 316
1、AMQP架构及基本概念 Borker：接收和分发消息的应用，RabbitMQ Server就是Message Broker。 Vritual Host：虚拟主机，出于多租户和安全因素设计的，在逻辑上把AMQP的基本组件划分到一个分组中，类似于Namespace概念。当多个不同的用户使用同一个AMQP Server时，可以划分出多个vhost，每个用户在自己的vhost创建exchange/queue等，彼此隔离不影响。 Connection：Publisher、Comsumer和Borker之
拼多多面试官没想到RabbitMQ我早就入门了，人直接傻掉
沉默王二
06-19 3799
拼多多面试官没想到RabbitMQ我早就入门了，人直接傻掉
SpringCloud学习之路（四）： SpringCloud 整合 RabbitMq（一）----RabbitMq基本原理及自动创建并监听队列
stuild stuil 的博客
12-24 2267
前言 什么是RabbitMq rabbitMq是消息队列的一种； 那么问题来了，什么是消息队列呢？戳这里 消息队列中间件是大型系统中的重要组件，它具有松耦合、异步消息、流量削峰、可靠投递、广播、流量控制、最终一致性等一系列功能，已经成为异步RPC的主要手段之一。 目前常见的消息中间件有ActiveMQ、RabbitMQ、ZeroMQ等。 我也想写的详细，写得多，写得好，但是实力不允许 ...
SpringCloud-实现基于RabbitMQ的消息队列
踏雨歌青春，诗酒趁年华
03-09 3632
本文详细介绍了在Spring Cloud框架中集成RabbitMQ消息队列的步骤。首先，通过添加必要的依赖，配置RabbitMQ连接信息。接着，创建消息生产者和消费者，利用Spring Cloud Stream简化消息绑定过程。生产者负责发送消息到RabbitMQ队列，而消费者通过监听队列接收并处理消息。通过这种异步通信机制，实现了分布式系统中微服务之间的松耦合，提高了系统的可伸缩性和可维护性。最后，通过一个简单的控制器示例展示了如何在实际应用中使用消息生产者发送消息。
实战：Spring Cloud Stream消息驱动框架整合rabbitMq
勤于笔记，成于点滴。
06-05 3412
Spring Cloud Stream消息驱动框架整合rabbitMq
springcloud stream rabbitmq
03-16
Spring Cloud Stream是一个用于构建消息驱动微服务的框架，而RabbitMQ是一个开源的消息队列系统。Spring Cloud Stream集成了RabbitMQ，使得开发者可以更加方便地使用RabbitMQ来实现消息驱动的微服务架构。通过Spring Cloud Stream，开发者可以轻松地创建和管理消息通道，以及定义消息的生产者和消费者。同时，Spring Cloud Stream还提供了一些高级功能，如消息分区、消息转换和消息路由等，使得开发者可以更加灵活地处理消息。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

偶尔也吹晚风

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值