RabbitMQ的安装和使用

圆咕噜咕噜  金牌会员 | 2024-10-9 14:16:55 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 909|帖子 909|积分 2727

RabbitMQ

MQ根本概念

1.MQ概述

MQ全称 Message Queue（[kjuː]）（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式体系之间进行通信。
（队列是一种容器，用于存放数据的都是容器，存放消息的就是消息队列）
分布式体系的调用：
方式一：直接调用
order
product
account

方式二：间接调用
A将数据存放到中心一个体系，通过中心的体系发送到B
中心体系可以成为中心件MQ

生产者-》中心件《--消费者

MQ是用于存放消息的中心件
被调用者叫生产者 调用者是消费者（微服务中说过）
2.MQ的优势和劣势

2.1 优势

应用解耦：提高体系容错性和可维护性。
异步提速：提升用户体验和体系吞吐量。
削峰填谷：提高体系稳定性。
应用解耦

体系的耦合性越高，容错性就越低，可维护性就越低。
例：订单体系 的时候 依赖于库存体系 付出体系 物流体系 当库存体系发生异常，就有可能导致订单体系发生异常 下单失败
追加体系 x 就只能修改订单体系更改代码 导致维护性比较低

使用 MQ 使得应用间解耦，提升容错性和可维护性
库存体系宕机订单体系影响不大，因为消息已经发送到mq了当库存体系恢复的时候就可以正常使用了。
追加体系的时候跟订单体系无关
已将数据发送到MQ了，直接从MQ中拿就行了，无需更改订单中的代码，可维护性提高

异步提速


一个下单操作耗时：20 + 300 + 300 + 300 = 920ms
用户点击完下单按钮后，需要等候920ms才气得到下单响应，太慢！

用户点击完下单按钮后，只需等候25ms就能得到下单响应 (20 + 5 = 25ms)。
提升用户体验和体系吞吐量（单位时间内处置处罚请求的数目）。
以前920ms处置处罚一个请求，现在25ms处置处罚一个请求，体系的吞吐量(单位时间内访问量)增长
削峰




使用了 MQ 之后，限定消费消息的速度为1000，如许一来，高峰期产生的数据势必会被积压在 MQ 中，高峰就被“削”掉了，但是因为消息积压，在高峰期事后的一段时间内，消费消息的速度还是会维持在1000，直到消费完积压的消息，这就叫做“填谷”。
使用MQ后，可以提高体系稳定性。
2.2 劣势


体系可用性降低
体系引入的外部依赖越多，体系稳定性越差。一旦 MQ 宕机，就会对业务造成影响。怎样保证MQ的高可用？
体系复杂度提高
MQ 的参加大大增长了体系的复杂度，以前体系间是同步的长途调用，现在是通过 MQ 进行异步调用。怎样保证消息没有被重复消费？怎么处置处罚消息丢失环境？那么保证消息传递的序次性？
同等性标题
A 体系处置处罚完业务，通过 MQ 给B、C、D三个体系发消息数据，如果 B 体系、C 体系处置处罚成功，D 体系处置处罚失败。怎样保证消息数据处置处罚的同等性？
2.3 既然 MQ 有优势也有劣势，那么使用 MQ 需要满意什么条件呢？




  • 生产者不需要从消费者处获得反馈。引入消息队列之前的直接调用，其接口的返回值应该为空，这才让明显下层的动作还没做，上层却当成动作做完了继承往后走，即所谓异步成为了可能。
订单->库存

  • 容许短暂的不同等性。
  • 确实是用了有结果。即解耦、提速、削峰这些方面的收益，超过参加MQ，管理MQ这些本钱。

3. 常见的MQ产品

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

RabbitMQ根本介绍

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

消息队列中心件
exchange 互换机 分发消息 分发到不同的容器 queue 通过路由来处置处罚
queue 容器
routes 路由
生产者 发布消息到exchange exchange 通过不同的路由规则发布/路由 给不同的queue 进行存储 cunsumer通过队列去监听拿到消息进行消费

2007年，Rabbit 技能公司基于 AMQP 标准开发的 RabbitMQ 1.0 发布。RabbitMQ 采用 Erlang 语言开发。Erlang 语言由 Ericson 设计，专门为开发高并发和分布式体系的一种语言，在电信领域使用广泛。
1. RabbitMQ 基础架构

Broker 中心者 服务
procedure 和consumer都是客户端
客户端通过链接和服务端进行通信 所以需要建立起来毗连 然后进行通信a
使用channel（管道）节省资源
一个rabbitmq里面有许多的假造机 相称于mysql里面有许多数据库，数据库里面有许多表，都是独立的。
每个假造机里面有许多的exchange和queue 独立分区的作用

2. 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)
fanout (multicast)
Queue：消息终极被送到这里等候 consumer 取走
Binding：exchange 和 queue 之间的假造毗连，binding 中可以包罗 routing key。Binding 信息被保存到 exchange 中的查询表中，用于 message 的分发依据
3. RabbitMQ的6 种工作模式

RabbitMQ 提供了 6 种工作模式：
简单模式、work queues、Publish/Subscribe 发布与订阅模式、Routing 路由模式、Topics 主题模式、RPC 长途调用模式（长途调用，不太算 MQ；暂不作介绍）。==
官网对应模式介绍：https://www.rabbitmq.com/getstarted.html


4. AMQP 和 JMS

MQ是消息通信的模型；实现MQ的大致有两种主流方式：AMQP、JMS。
4.1 AMQP

AMQP是一种协议，更准确的说是一种binary wire-level protocol（链接协议）。这是其和JMS的本质差别，AMQP不从API层进行限定，而是直接界说网络互换的数据格式。
4.2 JMS

JMS即Java消息服务（Java Message Service）应用步调接口，是一个Java平台中关于面向消息中心件（MOM）的API，用于在两个应用步调之间，或分布式体系中发送消息，进行异步通信。
（规定了消息客户端的一套api的东西，rabbitmq没有遵循规则）
JMS 是 JavaEE 规范中的一种，类比JDBC。
4.3 AMQP与 JMS 区别

JMS是界说了统一的接口，来对消息操作进行统一；AMQP是通过规定协议来统一数据交互的格式。
JMS限定了必须使用Java语言；AMQP只是协议，不规定实现方式，因此是跨语言的。
JMS规定了两种消息模式；而AMQP的消息模式更加丰富
4.4 再谈市场上常见的消息队列

ActiveMQ：基于JMS
ZeroMQ：基于C语言开发
RabbitMQ：基于AMQP协议，erlang语言开发，稳定性好
RocketMQ：基于JMS，阿里巴巴产品
Kafka：类似MQ的产品；分布式消息体系，高吞吐量。
安装rabbitmq

安装erlang

  1. yum install -y erlang
  2. ​
复制代码
验证是否安装成功
  1. erl -version
  2. ​
复制代码
安装rabbitmq

  1. yum install -y rabbitmq-server
复制代码
安装成功后启用web管理插件

  1. rabbitmq-plugins enable rabbitmq_management
  3. ​
复制代码
启动mq

  1. systemctl enable rabbitmq-server.service # 设置开机自启动
  2. systemctl start rabbitmq-server.service # 启动
  3. ​
  4. ​
复制代码
访问rabbitmq的页面

rabbitmq-server的端口号是5672 对应的web管理端是15672
访问的页面是ip地址:页面端口号
http://192.168.174.66:15672/
默认的用户是 guest/guest
添加用户以及对应的脚色


Spring Boot整合RabbitMQ

1. 简介

在Spring项目中，可以使用Spring-Rabbit去操作RabbitMQ
尤其是在spring boot项目中只需要引入对应的amqp启动器依赖即可，方便的使用RabbitTemplate发送消息，使用注解接收消息。
一样平常在开发过程中：
  1. 生产者工程：
复制代码

  • application.yml文件配置相干信息；
  • 在生产者工程中编写配置类，用于创建互换机和队列，并进行绑定
  • 注入RabbitTemplate对象，通过RabbitTemplate对象发送消息到互换机
  1. 消费者工程：
复制代码

  • application.yml文件配置相干信息
  • 创建消息处置处罚类，用于接收队列中的消息并进行处置处罚
2.搭建生产者工程

2.1 创建工程

创建生产者工程 springboot-rabbitmq-producer
2.2 添加依赖

修改pom.xml文件内容为如下：
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.    <modelVersion>4.0.0</modelVersion>
  6. ​
  7.    <groupId>com.yyl</groupId>
  8.    <artifactId>producer-springboot</artifactId>
  9.    <version>1.0-SNAPSHOT</version>
  10. ​
  11.    <!--1. 父工程依赖 -->
  12.    <parent>
  13.        <groupId>org.springframework.boot</groupId>
  14.        <artifactId>spring-boot-starter-parent</artifactId>
  15.        <version>2.17.4</version>
  16.    </parent>
  17. ​
  18.    <dependencies>
  19.        <!--2. rabbitmq-->
  20.        <dependency>
  21.            <groupId>org.springframework.boot</groupId>
  22.            <artifactId>spring-boot-starter-amqp</artifactId>
  23.        </dependency>
  24.        <dependency>
  25.            <groupId>org.springframework.boot</groupId>
  26.            <artifactId>spring-boot-starter-test</artifactId>
  27.        </dependency>
  28.    </dependencies>
  29. ​
  30. </project>
复制代码
2.3 启动类

  1. package com.yyl;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  8. @SpringBootApplication
  9. public class ProducerApplication {
  12.     public static void main(String[] args) {
  13.         SpringApplication.run(ProducerApplication.class);
  14.     }
  15. }
复制代码
2.4 配置RabbitMQ

配置文件

创建application.yml，内容如下：

  1. # 配置RabbitMQ的基本信息  ip 端口 username  password..
  2. spring:
  3.   rabbitmq:
  4.     host: 192.168.159.35 # ip
  5.     port: 5672
  6.     username: yuyongli
  7.     password: yuyongli
  8.     virtual-host: /yyl
复制代码
绑定互换机和队列

创建RabbitMQ队列与互换机绑定的配置类com.yyl.rabbitmq.config.RabbitMQConfig
  1. package yyl.config;
  2. import org.springframework.amqp.core.*;
  3. import org.springframework.beans.factory.annotation.Qualifier;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  7. @Configuration
  8. public class RabbitMqConfig {
  9.     //设置交换机的名字  和 队列的名字
  10.     public static  final String EXCHANGE_NAME="exchange_topic_name";
  11.     public static  final String QUEUE_NAME="queue_topic_name1";
  12.     public static  final String QUEUE_NAME_2="queue_topic_name2";
  13.     //将交换机这只成为一个bean注入到Springboot里面
  14.     @Bean("topicExchange")
  15.     public Exchange topicExchange(){
  16.         //可以持久化的一个交换机
  17.         return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
  18.     }
  19.     /**
  20.      * 队列
  21.      */
  22.     @Bean("topicQueue")
  23.     public Queue topicQueue(){
  24.         return QueueBuilder.durable(QUEUE_NAME).build();
  25.     }
  26.     @Bean("topicQueue2")
  27.     public Queue topicQueue2(){
  28.         return QueueBuilder.durable(QUEUE_NAME_2).build();
  29.     }
  30.     /**
  31.      * 将队列和交换机绑定到一起
  32.      */
  33.     @Bean
  34.     public Binding exchangeWithQueue(@Qualifier("topicExchange") Exchange exchage, @Qualifier("topicQueue") Queue queue){
  35.         //保存到数据库中
  36.         //将交换机和队列绑定在一起
  37.         return BindingBuilder.bind(queue).to(exchage).with("*.error").noargs();
  38.     }
  39.     @Bean
  40.     public Binding exchangeWithQueue2(@Qualifier("topicExchange") Exchange exchage, @Qualifier("topicQueue2") Queue queue){
  41.         //输出到控制台中
  42.         //将交换机和队列绑定在一起
  43.         return BindingBuilder.bind(queue).to(exchage).with("*.*").noargs();
  44.     }
  45. }
复制代码
3. 搭建消费者工程

3.1 创建工程

创建消费者工程springboot-rabbitmq-consumer

修改pom.xml文件内容为如下：
  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-amqp</artifactId>
  5.         </dependency>
  6.     </dependencies>
复制代码
3.3 启动类


  1. package com.yyl.rabbitmq;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class ConsumerApplication {
  8.     public static void main(String[] args) {
  9.         SpringApplication.run(ConsumerApplication.class);
  10.     }
  11. }
复制代码
3.4 配置RabbitMQ

  1. 创建application.yml，内容如下：
  3. # 配置RabbitMQ的基本信息  ip 端口 username  password..
  4. spring:
  5.   rabbitmq:
  6.     host 192.168.159.35# ip
  7.     port: 5672
  8.     username: yuyongli
  9.     password: yuyongli
  10.     virtual-host: /yyl
复制代码
*3.5 消息监听处置处罚类*

编写消息监听器com.yyl.rabbitmq.listener.RabbimtMQListener
  1. package com.yyl.listen;
  2. import org.springframework.amqp.core.Message;
  3. import org.springframework.amqp.rabbit.annotation.RabbitListener;
  4. import org.springframework.stereotype.Component;
  6. @Component
  7. public class RabbitMqListener {
  8.     //监听队列的消息
  9.     @RabbitListener(queues = "queue_topic_name1")
  10.     public void listenQueue(Message message){
  11.         System.out.println("监听的error级别的日志，需要保存到数据库中======="+new String(message.getBody()));//message.getBody()
  12.     }
  13. }
复制代码
4.搭建消费者工程2

启动类，配置文件跟消费者1是一样的，仅需要配置监听类即可
4.1 消息监听处置处罚类

  1. package yyl.listen;
  4. import org.springframework.amqp.core.Message;
  5. import org.springframework.amqp.rabbit.annotation.RabbitListener;
  6. import org.springframework.stereotype.Component;
  9. /**
  10. * @author yuyongli
  11. */
  12. @Component
  13. public class RabbitMqListener {
  16.     //监听队列的xiaoxi
  17.     @RabbitListener(queues = "queue_topic_name2")
  18.     public void listenQueue(Message message){
  19.         System.out.println("监听的是所有模块的日志，需要输出到控制台上面，日子的信息是======="+new String(message.getBody()));//message.getBody()
  20.     }
  21. }
复制代码


5. 测试

在生产者工程springboot-rabbitmq-producer中创建测试类，发送消息：
  1. package test;
  4. import org.junit.Test;
  5. import org.junit.runner.RunWith;
  6. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.boot.test.context.SpringBootTest;
  9. import org.springframework.test.context.ContextConfiguration;
  10. import org.springframework.test.context.junit4.SpringRunner;
  11. import yyl.ProducerApplication;
  12. import yyl.config.RabbitMqConfig;
  15. import javax.annotation.Resource;
  18. @SpringBootTest
  19. @RunWith(SpringRunner.class)
  20. @ContextConfiguration(classes = ProducerApplication.class)
  21. public class ProcedureTest {
  24.     @Resource
  25.     private RabbitTemplate rabbitTemplate;
  28.     @Test
  29.     public void  testSendMesssage(){
  30.         //将消息发送到队列里面
  31.         rabbitTemplate.convertAndSend(RabbitMqConfig.EXCHANGE_NAME,"test.error","我是test模块中，日志级别为error的信息");
  32.     }
  35. }
复制代码

测试：

先运行上述测试步调（互换机和队列才气先被声明和绑定），然后启动消费者；在消费者工程springboot-rabbitmq-consumer中控制台查看是否接收到对应消息。











附：

docker安装rabbitmq

使用docker 安装 RabbitMq
1.拉取镜像

搜索rabbitmq 镜像
  1. docker search rabbitmq
复制代码
拉取rabbitmq
  1. docker pull rabbitmq:3.9-management
复制代码

2.创建挂载目录

2.创建挂载目录
  1. mkdir -p /data/rabbitmq/
复制代码

3.创建容器

  1. docker run -d --name rabbitmq --restart=always -p 5672:5672 -p 15672:15672 -v /data/rabbitmq/:/var/lib/rabbitmq rabbitmq:3.9-management
复制代码
  -name 镜像名 -d 背景运行 –rm 停止服务就删除文件（根据本身环境选择） -v /宿主机目录:/容器目录 –restart=always 自动重启
  4.碰到的标题

无法web访问RabbitMq管理页面 我这边在centos体系中运行容器后是可以通过web访问的，但是有时候有些版本的体系出现了无法通过web访问，我去查看了端口是否开放和防火墙是否开放端口，结果是都开放的，最后查抄到的标题是启用web管理插件，下面介绍一下怎样在容器内启用web管理插件：
方法一 直接通过docker下令启用
  1. docker exec -it rabbitmq rabbitmq-plugins enable rabbitmq_management
  4. 查看插件是否启用
  5. docker exec -it rabbitmq rabbitmq-plugins list
复制代码
  有 E* 或* e 标志的则为启用的插件 E 显式启用 e 隐式启用
  
方法二 进入Rabbitmq容器内
  1. docker exec -it rabbitmq  /bin/bash
复制代码
进入容器后需要执行下令启用web管理插件。
5. 启用web管理插件

  1. rabbitmq-plugins enable rabbitmq_management
复制代码
6. 查看插件是否启用成功

  1. rabbitmq-plugins list
复制代码






卸载：


卸载erlang

查看erlang安装的相干列表
  1. yum list|grep erlang
复制代码
卸载erlang所有内容
  1. yum -y remove erlang-*
复制代码
删除erlang目录
  1. rm -rf /usr/lib64/erlang
  2. ​
复制代码
卸载rabbitmq

查看rabbitmq安装的相干列表
  1. yum list|grep rabbitmq
复制代码
卸载rabbitmq所有内容
  1. yum -y remove rabbitmq-server.noarch
复制代码
查找并删除rabbitmq相干目录
  1. find / -name rabbit*
复制代码
依次删除对应目录：rm -rf 路径 比方：
  1. rm -rf /var/lib/rabbitmq
  2. rm -rf /usr/lib/rabbitmq
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

圆咕噜咕噜

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表