YanZhaoHanWei_555
YanZhaoHanWei_555

学习笔记：RabbitMQ快速入门

本文最后更新于 2022-04-30，若内容或图片失效，请留言反馈。部分素材来自网络，若不小心影响到您的利益，请联系博主删除。

文章目录

  • 前言
  • 1.MQ的基本概念
    • 1.1.MQ概述
    • 1.2.MQ的优势
    • 1.3.MQ的劣势
    • 1.4.使用MQ需要满足的条件
    • 1.5.常见的MQ产品
    • 1.6.RabbitMQ的基本概念
    • 1.7.JMS
    • 1.8.RabbitMQ小结
  • 2.RabbitMQ 的安装和配置
    • 2.1.安装RabbitMQ
    • 2.2.开启管理界面及配置
    • 2.3.配置虚拟主机及用户
  • 3.RabbitMQ 快速入门
    • 3.1.RabbitMQ管理界面介绍
      • 3.1.1.Overview
      • 3.1.2.Connetions
      • 3.1.3.Channels
      • 3.1.4.Exchanges
      • 3.1.5.Queues
      • 3.1.6.Admin
    • 3.2.RabbitMQ快速入门
      • 3.2.1.需求和步骤
      • 3.2.2.代码部分（生产者）
      • 3.2.3.解析（生产者）
      • 3.2.4.代码部分（消费者）
      • 3.2.5.小结
  • 4.RabbitMQ 的工作模式
    • 4.1.Work queues 工作队列模式
    • 4.2.Pub/Sub 订阅模式
    • 4.3.Routing 路由模式
    • 4.4.Topics 通配符模式
    • 4.5.工作模式总结
  • 5.Spring 整合 RabbitMQ
    • 5.1.1.生产端
    • 5.1.2.消费端
  • 6.SpringBoot 整合 RabbitMQ
    • 6.1.生产端
    • 6.2.消费端
    • 6.3.小结
  • 7.RabbitMQ 高级特性
    • 7.0.项目准备
      • 7.0.1.生产端
      • 7.0.2.消费端
    • 7.1.消息的可靠投递
    • 7.2.Consumer Ack
    • 7.3.消费端限流
    • 7.4.TTL
    • 7.5.死信队列
    • 7.6.延迟队列
    • 7.7.日志与监控
      • 7.7.1.RabbitMQ 日志
      • 7.7.2.web 管控台监控
      • 7.7.3.rabbitmqctl 管理和监控
    • 7.8.消息追踪
  • 8.RabbitMQ 应用问题
  • 9.RabbitMQ 集群搭建
    • 9.1 集群方案的原理
    • 9.2.单机多实例部署
    • 9.3.集群管理
    • 9.4.RabbitMQ镜像集群配置
    • 9.5.负载均衡-HAProxy
      • 9.5.1. 安装HAProxy
      • 9.5.2.配置HAProxy

前言

  • 学习资料：黑马程序员 公众号提供的文档资料链接 | 提取码：dor4）
  • 学习视频：黑马程序员 《RabbitMQ全套教程，RabbitMQ消息中间件到实战》
  • 写博客的原因：写写笔记，做做记录，巩固知识，方便自己在线阅读。
  • 大体上是照搬了公众号提供的资料的。同时对内容进行了一些删减和补充，记录了自己在操作过程中的遇到的问题和解决办法。

1.MQ的基本概念

1.1.MQ概述

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

学习笔记：RabbitMQ快速入门_第1张图片

  • MQ，消息队列，存储消息的中间件
  • 分布式系统通信两种方式：直接远程调用和借助第三方完成间接通信
  • 发送方称为生产者，接收方称为消费

1.2.MQ的优势

  • 优势：应用解耦、异步提速、削峰填谷

1.应用解耦

学习笔记：RabbitMQ快速入门_第2张图片

系统的耦合性越高，容错性就越低，可维护性就越低。

学习笔记：RabbitMQ快速入门_第3张图片

使用 MQ 使得应用间解耦，提升容错性和可维护性。

2.异步提速

在这里插入图片描述

模拟：一个下单操作耗时：20 + 300 + 300 + 300 = 920ms

用户点击完下单按钮后，需要等待920ms才能得到下单响应，太慢！

学习笔记：RabbitMQ快速入门_第4张图片

模拟：用户点击完下单按钮后，只需等待25ms就能得到下单响应 (20 + 5 = 25ms)。

提升用户体验和系统吞吐量（单位时间内处理请求的数目）。

3.削峰填谷

学习笔记：RabbitMQ快速入门_第5张图片

学习笔记：RabbitMQ快速入门_第6张图片

学习笔记：RabbitMQ快速入门_第7张图片

使用了 MQ 之后，限制消费消息的速度为1000，这样一来，高峰期产生的数据势必会被积压在 MQ 中，高峰就被“削”掉了。

但是因为消息积压，在高峰期过后的一段时间内，消费消息的速度还是会维持在1000，直到消费完积压的消息，这就叫做“填谷”。

使用MQ后，可以提高系统稳定性。

4.小结（MQ的优势）

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

1.3.MQ的劣势

  • 劣势：系统可用性降低、系统复杂度提高、一致性问题

在这里插入图片描述

系统可用性降低

系统引入的外部依赖越多，系统稳定性越差。一旦 MQ 宕机，就会对业务造成影响。如何保证MQ的高可用？

系统复杂度提高

MQ 的加入大大增加了系统的复杂度，以前系统间是同步的远程调用，现在是通过 MQ 进行异步调用。

如何保证消息没有被重复消费？怎么处理消息丢失情况？那么保证消息传递的顺序性？

一致性问题

A 系统处理完业务，通过 MQ 给B、C、D三个系统发消息数据，如果 B 系统、C 系统处理成功，D 系统处理失败。

如何保证消息数据处理的一致性？

1.4.使用MQ需要满足的条件

既然 MQ 有优势也有劣势，那么使用 MQ 需要满足什么条件呢？

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

② 容许短暂的不一致性。

③ 确实是用了有效果。即解耦、提速、削峰这些方面的收益，超过加入MQ，管理MQ这些成本。

1.5.常见的MQ产品

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

RabbitMQ ActiveMQ RocketMQ Kafka
公司/社区 Rabbit Apache 阿里 Apache
开发语言 Erlang Java Java Scala&Java
协议支持 AMQP，XMPP，SMTP，STOMP OpenWire,STOMP，REST,XMPP,AMQP 自定义 自定义协议，社区封装了http协议支持
客户端支持语言 官方支持Erlang，Java，Ruby等，社区产出多种API，几乎支持所有语言 Java，C，C++，Python，PHP，Perl，.net等 Java，C++（不成熟） 官方支持Java,社区产出多种API，如PHP，Python等
单机吞吐量 万级（其次） 万级（最差） 十万级（最好） 十万级（次之）
消息延迟 微秒级 毫秒级 毫秒级 毫秒以内
功能特性 并发能力强，性能极其好，延时低，社区活跃，管理界面丰富 老牌产品，成熟度高，文档较多 MQ功能比较完备，扩展性佳 只支持主要的MQ功能，毕竟是为大数据领域准备的。

1.6.RabbitMQ的基本概念

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

学习笔记：RabbitMQ快速入门_第8张图片

2007年，Rabbit 技术公司基于 AMQP 标准开发的 RabbitMQ 1.0 发布。RabbitMQ 采用 Erlang 语言开发。

Erlang 语言由 Ericson 设计，专门为开发高并发和分布式系统的一种语言，在电信领域使用广泛。

RabbitMQ 基础架构 如下图

学习笔记：RabbitMQ快速入门_第9张图片

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 的分发依据

RabbitMQ 提供了 6 种工作模式：简单模式、work queues、Publish/Subscribe 发布与订阅模式、Routing路由模式、Topics 主题模式、RPC 远程调用模式（远程调用，不太算 MQ；暂不作介绍）。

官网对应模式介绍：https://www.rabbitmq.com/getstarted.html

学习笔记：RabbitMQ快速入门_第10张图片

1.7.JMS

  • JMS 即 Java 消息服务（JavaMessage Service）应用程序接口，是一个 Java 平台中关于面向消息中间件的 API
  • JMS 是 JavaEE 规范中的一种，类比 JDBC
  • 很多消息中间件都实现了JMS规范，例如：ActiveMQ。RabbitMQ 官方没有提供 JMS 的实现包，但是开源社区有实现包。

1.8.RabbitMQ小结

RabbitMQ 是基于 AMQP 协议使用 Erlang 语言开发的一款消息队列产品。

RabbitMQ 提供了6种工作模式，我们学习 5 种。这是今天的重点。

AMQP 是协议，类比 HTTP。

JMS 是 API 规范接口，类比 JDBC。

2.RabbitMQ 的安装和配置

RabbitMQ 官方网址：http://www.rabbitmq.com

2.1.安装RabbitMQ

前置操作：关闭防火墙

systemctl disable firewalld.service

另外，此处我使用的虚拟机是 CentOS7

1.在线安装依赖环境

yum install build-essential openssl openssl-devel unixODBC unixODBC-devel make gcc gcc-c++ kernel-devel m4 ncurses-devel tk tc xz

2.安装 Erlang

上传资料中给的erlang-18.3-1.el7.centos.x86_64.rpm、socat-1.7.3.2-5.el7.x86_64.rpm、rabbitmq-server-3.6.5-1.noarch.rpm。

其中涉及到的 sftp 操作，可以参考我之前写的博客：《CentOS7的下载安装以及之后的基本操作》的 putty 部分

之后再安装 Erlang

rpm -ivh erlang-18.3-1.el7.centos.x86_64.rpm
  • 如果出现以下错误，则是说明 gblic 的版本太低。

可以使用strings /lib64/libc.so.6 | grep GLIBC这个命令来查看当前版本号

在这里插入图片描述

  • 升级 glibc 的操作

使用 yum 更新

sudo yum install zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gcc make -y 安装依赖

下载rpm包

wget http://copr-be.cloud.fedoraproject.org/results/mosquito/myrepo-el6/epel-6-x86_64/glibc-2.17-55.fc20/glibc-utils-2.17-55.el6.x86_64.rpm &
wget http://copr-be.cloud.fedoraproject.org/results/mosquito/myrepo-el6/epel-6-x86_64/glibc-2.17-55.fc20/glibc-static-2.17-55.el6.x86_64.rpm &
wget http://copr-be.cloud.fedoraproject.org/results/mosquito/myrepo-el6/epel-6-x86_64/glibc-2.17-55.fc20/glibc-2.17-55.el6.x86_64.rpm &
wget http://copr-be.cloud.fedoraproject.org/results/mosquito/myrepo-el6/epel-6-x86_64/glibc-2.17-55.fc20/glibc-common-2.17-55.el6.x86_64.rpm &
wget http://copr-be.cloud.fedoraproject.org/results/mosquito/myrepo-el6/epel-6-x86_64/glibc-2.17-55.fc20/glibc-devel-2.17-55.el6.x86_64.rpm &
wget http://copr-be.cloud.fedoraproject.org/results/mosquito/myrepo-el6/epel-6-x86_64/glibc-2.17-55.fc20/glibc-headers-2.17-55.el6.x86_64.rpm &
wget http://copr-be.cloud.fedoraproject.org/results/mosquito/myrepo-el6/epel-6-x86_64/glibc-2.17-55.fc20/nscd-2.17-55.el6.x86_64.rpm &

sudo rpm -Uvh *-2.17-55.el6.x86_64.rpm --force --nodeps # 安装 rpm 包

此时我们可以通过命令 glibc 的版本

strings /lib64/libc.so.6 | grep GLIBC

3.安装 socat

socat 支持多协议，用于协议处理，端口转发，rabbitmq 依赖于 socat，因此在安装 rabbitmq 前要安装 socat。

rpm -ivh socat-1.7.3.2-5.el7.x86_64.rpm

4.安装 RabbitMQ

rpm -ivh rabbitmq-server-3.6.5-1.noarch.rpm

5.启动、停止、重启

service rabbitmq-server start # 启动服务

service rabbitmq-server stop # 停止服务

service rabbitmq-server restart # 重启服务
  • 如果出现如下错误
Job for rabbitmq-server.service failed because the control process exited with error code.
See "systemctl status rabbitmq-server.service" and "journalctl -xe" for details.

可以先通过systemctl status rabbitmq-server.service命令查看情况

学习笔记：RabbitMQ快速入门_第11张图片

显然问题出在这里：Failed to start LSB: Enable AMQP service provided by RabbitMQ broker

使用如下指令： vim /etc/hosts，在下图位置添加自己的 CentOS7 的 IP 地址 hostname，使用hostname就可以看到自己的主机名

在这里插入图片描述

之后再使用vi /etc/rabbitmq/rabbitmq-env.conf，在文件中添加NODENAME=rabbit@localhost即可。

之后再使用service rabbitmq-server start命令来启动 RabbitMQ 就没有问题了。

在这里插入图片描述

2.2.开启管理界面及配置

1.开启管理界面

rabbitmq-plugins enable rabbitmq_management # 开启管理界面

2.修改默认配置信息

比如修改密码、配置等等，例如：loopback_users 中的 <<"guest">>，只保留 guest

vim /usr/lib/rabbitmq/lib/rabbitmq_server-3.6.5/ebin/rabbit.app

学习笔记：RabbitMQ快速入门_第12张图片

将图中画框一行改为 {loopback_users, [guest]},

之后我们需要重启一下 RabbitMQ ：service rabbitmq-server restart

在自己的本机中输入：虚拟机的IP地址:默认端口号（一般都是15672）。

可以使用vim /usr/lib/rabbitmq/lib/rabbitmq_server-3.6.5/ebin/rabbit.app 命令查看

学习笔记：RabbitMQ快速入门_第13张图片

RabbitMQ 在安装好后，可以访问 http://ip 地址:15672 。其自带了 guest/guest 的用户名和密码。

学习笔记：RabbitMQ快速入门_第14张图片

如下图的情况，则是进入成功

学习笔记：RabbitMQ快速入门_第15张图片

在上图中我们发现Config file /etc/rabbitmq/rabbitmq.config(not found)，所以此时我们需要设置rabbitmq.config配置文件

3.设置配置文件 rabbitmq.config

cd /usr/share/doc/rabbitmq-server-3.6.5/

cp rabbitmq.config.example /etc/rabbitmq/rabbitmq.config

学习笔记：RabbitMQ快速入门_第16张图片

操作完成后就不再出现 not found 的字眼了

学习笔记：RabbitMQ快速入门_第17张图片

2.3.配置虚拟主机及用户

RabbitMQ 在安装好后，可以访问 http://ip地址:15672 。其自带了 guest/guest 的用户名和密码。

1.设置用户角色

如果需要创建自定义用户；那么也可以登录管理界面后，进行如下操作：

点击Add a user，输入username和password，并在set下选择角色类型（选择后会自动添加到tag中）

学习笔记：RabbitMQ快速入门_第18张图片

2.角色说明

  • 超级管理员(administrator)
    • 可登陆管理控制台，可查看所有的信息，并且可以对用户，策略(policy)进行操作。
  • 监控者(monitoring)
    • 可登陆管理控制台，同时可以查看rabbitmq节点的相关信息(进程数，内存使用情况，磁盘使用情况等)
  • 策略制定者(policymaker)
    • 可登陆管理控制台, 同时可以对policy进行管理。但无法查看节点的相关信息(上图红框标识的部分)。
  • 普通管理者(management)
    • 仅可登陆管理控制台，无法看到节点信息，也无法对策略进行管理。
  • 其他
    • 无法登陆管理控制台，通常就是普通的生产者和消费者。

3.Virtual Hosts 配置

类似于 MySQL 拥有数据库的概念并且可以指定用户对库和表等操作的权限。

RabbitMQ 也有类似的权限管理，在 RabbitMQ 中可以虚拟消息服务器 Virtual Host，每个 Virtual Hosts 相当于一个相对独立的 RabbitMQ 服务器，每个 VirtualHost 之间是相互离的。exchange、queue、message不能互通。 相当于 MySQL 的 db。Virtual Name 一般以 / 开头。

创建 Virtual Hosts

点击Add a new virtual host即可

学习笔记：RabbitMQ快速入门_第19张图片

4.设置 Virtual Hosts 权限

点击上图的 Virtual Hosts （如 /itcast）

我们可以在如下图所示的界面 选择可以管理这个虚拟机的用户，同时我们也可以在此界面 删除管理这个虚拟机的用户

学习笔记：RabbitMQ快速入门_第20张图片

添加成功

学习笔记：RabbitMQ快速入门_第21张图片

此时我们也可以使用刚才绑定的用户来登录 RabbitMQ 管理界面（rabbitmq_management）

不过在那之前我们需要先 service rabbitmq-server restart 重启一下

学习笔记：RabbitMQ快速入门_第22张图片

如上，登录成功。

3.RabbitMQ 快速入门

3.1.RabbitMQ管理界面介绍

当安装完 RabbitMQ，访问安装主机 Ip:15672 即可进入管理界面，初始密码为 guest/guest

引用的博客原址：

  • https://www.cnblogs.com/Runawayprogrammer/p/15980436.html
  • https://www.csdn.net/tags/NtzaYgzsOTczODctYmxvZwO0O0OO0O0O.html

学习笔记：RabbitMQ快速入门_第23张图片

学习笔记：RabbitMQ快速入门_第24张图片

  • Overview：概览信息
  • Conneticons：连接
  • Channels：通道
  • Exchanges：交换机
  • Queues：队列
  • Admin：管理
  • connections：无论生产者还是消费者，都需要与 RabbitMQ 建立连接后才可以完成消息的生产和消费，在这里可以查看连接情况。
  • channels：通道，建立连接后，会形成通道，消息的投递获取依赖通道。
  • Exchanges：交换机，用来实现消息的路由。
  • Queues：队列，即消息队列，消息存放在队列中，等待消费，消费后被移除队列。

3.1.1.Overview

学习笔记：RabbitMQ快速入门_第25张图片

  • Totals
  • Ready： 待消费的消息总数。
  • Unacked： 待应答的消息总数。
  • Total：总数 Ready + Unacked。
  • Publish： producter pub 消息的速率。
  • Publisher confirm： broker 确认 pub 消息的速率。
  • Deliver(manual ack)： customer 手动确认的速率。
  • Deliver( auto ack)： customer 自动确认的速率。
  • Consumer ack： customer 正在确认的速率。
  • Redelivered： 正在传递 ‘redelivered’ 标志集的消息的速率。
  • Get (manual ack)： 响应 basic.get 而要求确认的消息的传输速率。
  • Get (auto ack)： 响应于 basic.get 而发送不需要确认的消息的速率。
  • Return： 将basic.return发送给producter的速率。
  • Disk read： queue 从磁盘读取消息的速率。
  • Disk write： queue 从磁盘写入消息的速率。
  • Connections：client 的 tcp 连接的总数。
  • Channels：通道的总数。
  • Exchange：交换器的总数。
  • Queues：队列的总数。
  • Consumers：消费者的总数。

学习笔记：RabbitMQ快速入门_第26张图片

  • Node

启动一个 broker 就会产生一个 node（节点）。

Nodes 项，显示的是 RabbitMQ 的服务节点,目前有一个本地节点，可以有多个服务节点（比如集群的时候）

  • Name：broker名称
  • File descriptors：broker 打开的文件描述符和限制。
  • Socket descriptors：broker 管理的网络套接字数量和限制。当限制被耗尽时，RabbitMQ将停止接受新的网络连接。
  • Erlang processes：erlang 启动的进程数。
  • Memory：当前 broker 占用的内存。
  • Disk space：当前 broker 占用的硬盘。
  • Uptime：当前 broker 持续运行的时长。

在这里插入图片描述

  • Ports and contexts
  1. AMQP 协议端口（通过 TCP 连接访问该端口，写代码时就是通过这个端口来连接的）
  2. 集群端口
  3. 管理工具的端口

学习笔记：RabbitMQ快速入门_第27张图片

  • Import / export definitions

导入 / 导出配置文件。比如说将来我们做 RabbitMQ 迁移的时候，我们可以先把配置文件导出去，迁移操作完成之后再导入。

学习笔记：RabbitMQ快速入门_第28张图片

3.1.2.Connetions

当前所有客户端活动的连接。包括生成者和消费者。

在这里可以看客户端连接 RabbitMQ 服务的信息。

  • Virtual host：所属的虚拟主机。
  • Name：名称。
  • User name：使用的用户名。
  • State：当前的状态，running：运行中；idle：空闲。
  • SSL/TLS：是否使用ssl进行连接。
  • Protocol：使用的协议。
  • Channels：创建的channel的总数。
  • From client：每秒发出的数据包。
  • To client：每秒收到的数据包。

学习笔记：RabbitMQ快速入门_第29张图片

3.1.3.Channels

当前连接所有创建的通道。

在这里可以看客户端连接 RabbitMQ 通道的信息。通道是建立在连接之上的。

  • channel：名称。
  • Virtual host：所属的虚拟主机。
  • User name：使用的用户名。
  • Mode：渠道保证模式。 可以是以下之一，也可以不是：C: confirm；T：transactional(事务)。
  • State ：当前的状态。running ：运行中；idle：空闲。
  • Unconfirmed：待 confirm 的消息总数。
  • Prefetch：设置的 prefetch 的个数。
  • Unacker：待 ack 的消息总数。
  • publish：producter pub 消息的速率。
  • confirm：producter confirm 消息的速率。
  • deliver/get：consumer 获取消息的速率。
  • ack：consumer ack 消息的速率。

学习笔记：RabbitMQ快速入门_第30张图片

3.1.4.Exchanges

Exchanges 选项有交换机的信息，并且可以通过 Add a new exchange 来添加交换机。

  • Virtual host：所属的虚拟主机。
  • Name：名称。
  • Type：exchange type
  • Features：功能。 可以是以下之一，或者不是：D: 持久化；T：Internal，存在改功能表示这个 exchange 不可以被 client 用来推送消息，仅用来进行 exchange 和 exchange 之间的绑定，否则可以推送消息也可以绑定。
  • Message rate in：消息进入的速率。
  • Message rate out：消息出去的速率。

学习笔记：RabbitMQ快速入门_第31张图片

页面添加 exchange 交换机

  • virtual host ：选择虚拟机
  • Name ：交换机名子
  • Type ：交换机类型选择，默认 direct 直连模式，fanout 路由模式吗，topic 模式
  • Durability ： 是否需要持久化，true 为持久化
  • Auto Delete ：当最后一个绑定到 Exchange上 的队列删除后，自动删除该 Exchange
  • Internal ：当前Exchange是否用于 RabbitMQ 内部使用，默认为 False
  • Arguments ：扩展参数，用于扩展 AMQP 协议，定制化使用

学习笔记：RabbitMQ快速入门_第32张图片

3.1.5.Queues

Queues 选项有 queue 的信息，并且可以通过 Add a new queue 来添加 queue

  • Virtual host：所属的虚拟主机。
  • Name：名称。
  • Features：功能。 可以是以下之一，或者不是：D: 持久化。
  • State：当前的状态，running：运行中；idle：空闲。
  • Ready：待消费的消息总数。
  • Unacked：待应答的消息总数。
  • Total：总数 Ready+Unacked。
  • incoming：消息进入的速率。
  • deliver/get：消息获取的速率。
  • ack：消息应答的速率。

创建队列 queue

  • type：此 queue 的类型，默认为 classic 主队列，也可以设置为 quorum 从队列\
  • name：此 queue 的名称
  • durability：queue 中的消息是否要持久化到硬盘
  • auto delete：如果此 queue 没有绑定到任何一个 exchange，是否自动删除此 queue
  • arguments：设置一些其它参数

学习笔记：RabbitMQ快速入门_第33张图片

3.1.6.Admin

  • Name：名称。
  • Tags：角色标签，只能选取一个。
  • Can access virtual hosts：允许进入的vhost。
  • Has password：设置了密码

角色说明

  • administrator （超级管理员）
    • 可登录管理控制台（启用 management plugin 的情况下），可查看所有的信息，并且可以对用户，策略（policy）进行操作。
  • monitoring（监控者）
    • 可登录管理控制台（启用 management plugin 的情况下），同时可以查看 rabbitmq 节点的相关信息（进程数，内存使用情况，磁盘使用情况等）
  • policymaker（策略制定者）
    • 可登录管理控制台（启用 management plugin 的情况下）， 同时可以对policy进行管理。
  • management(普通管理者)
    • 仅可登录管理控制台（启用management plugin的情况下），无法看到节点信息，也无法对策略进行管理。
  • none（其他）
    • 无法登录管理控制台，通常就是普通的生产者和消费者。

学习笔记：RabbitMQ快速入门_第34张图片

3.2.RabbitMQ快速入门

3.2.1.需求和步骤

  • 需求：使用简单模式完成消息传递

  • 步骤：
    ① 创建工程（生成者、消费者）
    ② 分别添加依赖
    ③ 编写生产者发送消息
    ④ 编写消费者接收消息

学习笔记：RabbitMQ快速入门_第35张图片

3.2.2.代码部分（生产者）

1.使用 Maven 工具创建如下的项目结构

学习笔记：RabbitMQ快速入门_第36张图片

2.导入依赖：pom.xml


<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.0modelVersion>

    <groupId>com.itheimagroupId>
    <artifactId>spring-rabbitmq-producersartifactId>
    <version>1.0-SNAPSHOTversion>

    <dependencies>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.1.7.RELEASEversion>
        dependency>

        <dependency>
            <groupId>org.springframework.amqpgroupId>
            <artifactId>spring-rabbitartifactId>
            <version>2.1.8.RELEASEversion>
        dependency>

        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
        dependency>

        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-testartifactId>
            <version>5.1.7.RELEASEversion>
        dependency>
    dependencies>

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

project>

3.Producer_HelloWorld.java

  • 步骤：1.创建连接工厂、2.设置参数、3. 创建连接 Connection、4.创建 Channel、5.声明队列 Queue、6.发送消息、7.释放资源
package com.itheima.producer;

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_HelloWorld {
    public static void main(String[] args) throws IOException, TimeoutException {
    
        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        
        //2.设置参数
        factory.setHost("192.168.2.212");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值/
        factory.setUsername("heima");//用户名 默认 guest
        factory.setPassword("heima");//密码 默认值 guest
        
        //3.创建连接 Connection
        Connection connection = factory.newConnection();
        
        //4.创建 Channel
        Channel channel = connection.createChannel();
       
        /*
        queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments)
        参数：
            1. queue：队列名称
            2. durable：是否持久化，(持久化的会把数据写到自带的数据库中)当 mq 重启之后，还在
            3. exclusive：
                * 是否独占。只能有一个消费者监听这队列
                * 当 Connection 关闭时，是否删除队列
            4. autoDelete：是否自动删除。当没有 Consumer 时，自动删除掉
            5. arguments：参数。
        */
        //5.创建队列 Queue
        //如果没有一个名字叫 hello_world 的队列，则会创建该队列；如果有，则不会创建
        channel.queueDeclare("hello_world", true, false, false, null);

        /*
        basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
        参数：
            1. exchange：交换机名称。简单模式下交换机会使用默认的 ""（空字符串）
            2. routingKey：路由名称（简单模式下，routingKey 只要与队列名称相同就可以绑定）
            3. props：配置信息
            4. body：发送消息数据
        */
        String body = "hello RabbitMQ~~~";
        
        //6.发送消息
        channel.basicPublish("", "hello_world", null, body.getBytes());

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

3.2.3.解析（生产者）

运行上面的代码成功后，我们发现一个队列

学习笔记：RabbitMQ快速入门_第37张图片

点击上面的队列，进入到如下的界面

学习笔记：RabbitMQ快速入门_第38张图片

这里使用的是默认的交换机（Exchange）

学习笔记：RabbitMQ快速入门_第39张图片

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

因为释放了资源，所以此时是查询不到Connections和Channel的。我们可以注释掉上述两行代码，再次运行程序。

学习笔记：RabbitMQ快速入门_第40张图片

学习笔记：RabbitMQ快速入门_第41张图片

如上面的两图，此时可以发现Connections和Channels。

如下图所示，此时Queues中已经有两条信息（因为程序又执行了一遍）

学习笔记：RabbitMQ快速入门_第42张图片

3.2.4.代码部分（消费者）

1.使用 Maven 工具创建如下的项目结构

学习笔记：RabbitMQ快速入门_第43张图片

2.导入依赖：pom.xml


<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.0modelVersion>

    <groupId>com.itheimagroupId>
    <artifactId>rabbitmq-consumerartifactId>
    <version>1.0-SNAPSHOTversion>

    <dependencies>
        
        <dependency>
            <groupId>com.rabbitmqgroupId>
            <artifactId>amqp-clientartifactId>
            <version>5.6.0version>
        dependency>
    dependencies>

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

project>

3.Consumer_HelloWorld.java

  • 步骤：1.创建连接工厂、2.设置参数、3. 创建连接 Connection、4.创建 Channel、5.声明队列 Queue、6.接收消息
package com.ithiema.consumer;

import com.rabbitmq.client.*;

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

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

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        
        //2. 设置参数
        factory.setHost("192.168.2.212");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/itcast");//虚拟机 默认值/
        factory.setUsername("heima");//用户名 默认 guest
        factory.setPassword("heima");//密码 默认值 guest
        
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        
        //4. 创建Channel
        Channel channel = connection.createChannel();
        
        /*
        queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map arguments)
        参数：
            1. queue：队列名称
            2. durable:是否持久化，当 MQ 重启之后，还在
            3. exclusive：
                * 是否独占。只能有一个消费者监听这队列
                * 当 Connection 关闭时，是否删除队列
            4. autoDelete:是否自动删除。当没有 Consumer 时，自动删除掉
            5. arguments：参数。
        */
        //5. 创建队列 Queue
        //之前在书写生产者时已经声明过队列，但下行代码放在这里也没有什么问题
        channel.queueDeclare("hello_world", true, false, false, null);

        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));
            }
        };
        
        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        参数：
            1. queue：队列名称
            2. autoAck：是否自动确认
            3. callback：回调对象
        */
        //6. 接收消息
        channel.basicConsume("hello_world", true, consumer);
        
        //关闭资源？不需要
    }
}

以下是控制台上打印的消息

consumerTag：amq.ctag-4x8XsSmEQLu-YIwjDXw0-A
Exchange：
RoutingKey：hello_world
properties：#contentHeader(content-type=null, content-encoding=null, headers=null,
							 delivery-mode=null, priority=null, correlation-id=null, 
							 reply-to=null, expiration=null, message-id=null, 
							 timestamp=null, type=null, user-id=null, app-id=null,
							 cluster-id=null)
body：hello RabbitMQ~~~

3.2.5.小结

上述的入门案例中其实使用的是如下的简单模式

学习笔记：RabbitMQ快速入门_第44张图片

  • 在上图的模型中，有以下概念：
    • P：生产者，也就是要发送消息的程序
    • C：消费者：消息的接收者，会一直等待消息到来
    • queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息

4.RabbitMQ 的工作模式

之前我们已经讲过 “Hello World” 工作模式了，故这里不再赘述。

学习笔记：RabbitMQ快速入门_第45张图片

4.1.Work queues 工作队列模式

模式说明

  • Work Queues：与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。
  • 应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

学习笔记：RabbitMQ快速入门_第46张图片

代码编写

  • Work Queues 与入门程序的简单模式的代码几乎是一样的。可以完全复制，并多复制一个消费者进行多个消费者同时对消费消息的测试。

我们可以模拟一下这个场景

比如在生产者中设置发送五次消息

for (int i = 1; i <= 10; i++) {
    String body = i + "hello rabbitmq~~~";
    //发送消息
    channel.basicPublish("", "work_queues", null, body.getBytes());
}

同时设置两个消费者接收消息，并且打印真实数据到控制台上

System.out.println("body：" + new String(body));

学习笔记：RabbitMQ快速入门_第47张图片

学习笔记：RabbitMQ快速入门_第48张图片

这里是 Queues

学习笔记：RabbitMQ快速入门_第49张图片

小结

  • 在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系。

  • Work Queues 对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

例如：短信服务部署多个，只需要有一个节点成功发送即可

4.2.Pub/Sub 订阅模式

模式说明

在订阅模型中，多了一个 Exchange 角色，而且过程略有变化。

学习笔记：RabbitMQ快速入门_第50张图片

  • P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
  • C：消费者，消息的接收者，会一直等待消息到来
  • Queue：消息队列，接收消息、缓存消息
  • Exchange：交换机（X）。一方面，接收生产者发送的消息。另一方面，知道如何处理消息。
    例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于 Exchange 的类型。
  • Exchange 有常见以下3种类型：
    • Fanout：广播，将消息交给所有绑定到交换机的队列
    • Direct：定向，把消息交给符合指定 routing key 的队列
    • Topic：通配符，把消息交给符合 routing pattern（路由模式） 的队列

Exchange（交换机）只负责转发消息，不具备存储消息的能力。

因此如果没有任何队列与 Exchange 绑定，或者没有符合路由规则的队列，那么消息会丢失！

代码编写（生产者）

  • 步骤：
    • 1.创建连接工厂、2.设置参数、3. 创建连接 Connection、4.创建 Channel（省略）
    • 5.创建交换机、6.创建队列、7.绑定队列和交换机、8.发送消息、9.释放资源

生产者：Producer_PubSub.java

/*
exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable,
		boolean autoDelete, boolean internal, Map 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_fanout";

//5.创建交换机
channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT, true, false, false, null);

//6.创建队列
String queue1Name = "test_fanout_queue1";
String queue2Name = "test_fanout_queue2";
channel.queueDeclare(queue1Name, true, false, false, null);
channel.queueDeclare(queue2Name, true, false, false, null);

/*
queueBind(String queue, String exchange, String routingKey)
参数：
    1. queue：队列名称
    2. exchange：交换机名称
    3. routingKey：路由键，绑定规则
        如果交换机的类型为 fanout ，routingKey 设置为""
*/
//7.绑定队列和交换机
channel.queueBind(queue1Name, exchangeName, "");
channel.queueBind(queue2Name, exchangeName, "");

String body = "日志信息：张三调用了 findAll 方法...日志级别：info ...";

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

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

学习笔记：RabbitMQ快速入门_第51张图片

学习笔记：RabbitMQ快速入门_第52张图片

学习笔记：RabbitMQ快速入门_第53张图片

消费者部分的代码比较简单，与前面没有太大区别（两个消费者分别监听自己的队列），这里就省略掉了。

小结

  • 交换机需要与队列进行绑定，绑定之后；一个消息可以被多个消费者都收到。
  • 发布订阅模式与工作队列模式的区别：
    • 工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机
    • 发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发送消息（底层使用默认交换机）
    • 发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队列绑定到默认的交换机

4.3.Routing 路由模式

模式说明

  • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个 RoutingKey（路由key）
  • 消息的发送方在向 Exchange 发送消息时，也必须指定消息的 RoutingKey
  • Exchange 不再把消息交给每一个绑定的队列，而是根据消息的 Routing Key 进行判断，只有队列的 Routingkey 与消息的 Routing key 完全一致，才会接收到消息

学习笔记：RabbitMQ快速入门_第54张图片

  • P：生产者，向 Exchange 发送消息，发送消息时，会指定一个routing key
  • X：Exchange（交换机），接收生产者的消息，然后把消息递交给与 routing key 完全匹配的队列
  • C1：消费者，其所在队列指定了需要 routing key 为 error 的消息
  • C2：消费者，其所在队列指定了需要 routing key 为 info、error、warning 的消息

代码编写

【生产者】Producer_Routing.java

  • 步骤
    • 1.创建连接工厂、2.设置参数、3. 创建连接 Connection、4.创建 Channel
    • 5.创建交换机、6.创建队列、7.绑定队列和交换机、8.发送消息、9.释放资源
//5.创建交换机
channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT, true, false, false, null);

 //6.创建队列
String queue1Name = "test_direct_queue1";
String queue2Name = "test_direct_queue2";

channel.queueDeclare(queue1Name, true, false, false, null);
channel.queueDeclare(queue2Name, true, false, false, null);

 //7.绑定队列和交换机
 
//队列1 绑定 error
channel.queueBind(queue1Name, exchangeName, "error");
//队列2 绑定 info  error  warning
channel.queueBind(queue2Name, exchangeName, "info");
channel.queueBind(queue2Name, exchangeName, "error");
channel.queueBind(queue2Name, exchangeName, "warning");

 String body = "日志信息：张三调用了delete方法...出错误了。。。日志级别：error...";

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

【消费者】 部分与之前的代码无异，更改队列名即可，此处省略。

小结

Routing 模式要求队列在绑定交换机时要指定 routing key，消息会转发到符合 routing key 的队列。

4.4.Topics 通配符模式

模式说明

  • Topic 类型与 Direct 相比，都是可以根据 RoutingKey 把消息路由到不同的队列。只不过 Topic 类型 Exchange 可以让队列在绑定 Routing key 的时候使用通配符！
  • Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert
  • 通配符规则：# 匹配一个或多个词，* 匹配不多不少恰好1个词。
    • 例如：item.# 能够匹配 item.insert.abc 或者 item.insert
    • 例如：item.* 只能匹配 item.insert

学习笔记：RabbitMQ快速入门_第55张图片

  • 红色 Queue：绑定的是 usa.# ，因此凡是以 usa. 开头的 routing key 都会被匹配到
  • 黄色 Queue：绑定的是 #.news ，因此凡是以 .news 结尾的 routing key 都会被匹配

代码部分

【生产者】 需要注意的代码。

channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC,true,false,false,null);

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

【消费者】 部分的代码与之前无异，改变一下队列名即可，此处省略。

小结

Topic 主题模式可以实现 Pub/Sub 发布与订阅模式和 Routing 路由模式的功能。

只是 Topic 在配置 routing key 的时候可以使用通配符，显得更加灵活。

4.5.工作模式总结

  • 简单模式 HelloWorld
    • 一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）。
  • 工作队列模式 Work Queue
    • 一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）。
  • 发布订阅模式 Publish/subscribe
    • 需要设置类型为 fanout 的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列。
  • 路由模式 Routing
    • 需要设置类型为 direct 的交换机，交换机和队列进行绑定，并且指定 routing key，当发送消息到交换机后，交换机会根据 routing key 将消息发送到对应的队列。
  • 通配符模式 Topic
    • 需要设置类型为 topic 的交换机，交换机和队列进行绑定，并且指定通配符方式的 routing key，当发送消息到交换机后，交换机会根据 routing key 将消息发送到对应的队列。

5.Spring 整合 RabbitMQ

需求：使用 Spring 整合 RabbitMQ

5.1.1.生产端

步骤

  • 创建生产者工程
  • 添加依赖
  • 配置整合
  • 编写代码发送消息

代码部分

1.项目结构

学习笔记：RabbitMQ快速入门_第56张图片

2.导入依赖

pom.xml

生产者和消费者导入的依赖是相同的

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.1.7.RELEASEversion>
    dependency>

    <dependency>
        <groupId>org.springframework.amqpgroupId>
        <artifactId>spring-rabbitartifactId>
        <version>2.1.8.RELEASEversion>
    dependency>

    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
    dependency>

    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-testartifactId>
        <version>5.1.7.RELEASEversion>
    dependency>
dependencies>

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

3.配置文件：rabbitmq.properties

rabbitmq.host=192.168.2.212
rabbitmq.port=5672
rabbitmq.username=heima
rabbitmq.password=heima
rabbitmq.virtual-host=/itcast

4.配置文件：spring-rabbitmq-producer.xml


<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"/>

    
    <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"/>

    
    

    <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: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>

    
    <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>

beans>

测试类：

package org.example;

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 {
    //注入 RabbitTemplate
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testHelloWorld() {
        //发送消息
        rabbitTemplate.convertAndSend("spring_queue", "hello world spring....");
    }

    /**
     * 发送fanout消息
     */
    @Test
    public void testFanout() {
        //发送消息
        rabbitTemplate.convertAndSend("spring_fanout_exchange", "", "spring fanout....");
    }


    /**
     * 发送topic消息
     */
    @Test
    public void testTopics() {
        //发送消息
        rabbitTemplate.convertAndSend("spring_topic_exchange", "heima.hehe.haha", "spring topic....");
    }

}

5.1.2.消费端

  • 创建生产者工程
  • 添加依赖
  • 配置整合
  • 编写消息监听

代码部分

1.项目结构

学习笔记：RabbitMQ快速入门_第57张图片

2.导入依赖

pom.xml

生产者和消费者导入的依赖是相同的

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.1.7.RELEASEversion>
    dependency>

    <dependency>
        <groupId>org.springframework.amqpgroupId>
        <artifactId>spring-rabbitartifactId>
        <version>2.1.8.RELEASEversion>
    dependency>

    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
    dependency>

    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-testartifactId>
        <version>5.1.7.RELEASEversion>
    dependency>
dependencies>

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

3.配置文件：rabbitmq.properties

rabbitmq.host=192.168.2.212
rabbitmq.port=5672
rabbitmq.username=heima
rabbitmq.password=heima
rabbitmq.virtual-host=/itcast

4.配置文件：spring-rabbitmq-consumer.xml


<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"/>

    
    <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="org.example.rabbitmq.listener.SpringQueueListener"/>
    

	
    <rabbit:listener-container connection-factory="connectionFactory" auto-declare="true">
        <rabbit:listener ref="springQueueListener" queue-names="spring_queue"/>
        
    rabbit:listener-container>
beans>

5.SpringQueueListener.class

package org.example.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()));
    }
}

6.测试类：ConsumerTest.class

package org.example;

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

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

    @Test
    public void test1() {
        boolean flag = true;
        while (true) { }
    }
}

此处仅仅测试了 Hello World 简单模式，其余的自己创建相关类即可，这里省略。

6.SpringBoot 整合 RabbitMQ

6.1.生产端

步骤

  1. 创建生产者 SpringBoot 工程
  2. 引入 start，依赖坐标
<dependency>
	<groupId>org.springframework.bootgroupId>
	<artifactId>spring-boot-starter-amqpartifactId>
dependency>
  1. 编写 yml 配置，基本信息配置
  2. 定义交换机，队列以及绑定关系的配置类
  3. 注入 RabbitTemplate ，调用方法，完成消息发送

代码部分

1.创建如下的项目结构

学习笔记：RabbitMQ快速入门_第58张图片

2.导入依赖：pom.xml


<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.0modelVersion>

    <groupId>com.itheimagroupId>
    <artifactId>producer-springbootartifactId>
    <version>0.0.1-SNAPSHOTversion>

    
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.1.4.RELEASEversion>
    parent>

    <name>product-springbootname>
    <description>Demo project for Spring Bootdescription>

    <properties>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <maven.compiler.source>1.8maven.compiler.source>
        <maven.compiler.target>1.8maven.compiler.target>
        <java.version>1.8java.version>
    properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>

        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-amqpartifactId>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>

project>

3.配置文件：application.yml

# 配置 RabbitMQ 的基本信息
spring:
  rabbitmq:
    host: 192.168.2.212
    port: 5672
    username: guest
    password: guest
    virtual-host: /

4.核心类：com/ithiema/ProducerApplication.java

package com.ithiema;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ProducerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProducerApplication.class);
    }
}

5.com/ithiema/rabbitmq/config/RabbitMQConfig.java

package com.ithiema.rabbitmq.config;

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

@Configuration
public class RabbitMQConfig {
    public static final String EXCHANGE_NAME = "boot_topic_exchange";
    public static final String QUEUE_NAME = "boot_queue";

    //1.交换机
    @Bean("bootExchange")
    public Exchange bootExchange() {
        /*
            topicExchange (string name)
            directExchange (string name)
            fanoutExchange (string name)
            headersExchange (string name)
        */
        return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
    }

    //2.Queue 队列
    @Bean("bootQueue")
    public Queue bootQueue() {
        return QueueBuilder.durable(QUEUE_NAME).build();
    }

    //3.队列和交互机绑定关系 Binding
    /*
        1.知道哪个队列
        2.知道哪个交换机
        3.routing key
    */
    @Bean
    public Binding bindQueueExchange(@Qualifier("bootQueue") Queue queue, @Qualifier("bootExchange") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("boot.#").noargs();
    }
}

6.测试类：com/itheima/ProducerTest.java

package com.itheima;


import com.ithiema.ProducerApplication;
import com.ithiema.rabbitmq.config.RabbitMQConfig;
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.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest(classes = ProducerApplication.class)
@RunWith(SpringRunner.class)
public class ProducerTest {

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

    @Test
    public void testSend() {
        //public void convertAndSend(String exchange, String routingKey, Object object)
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME, "boot.haha", "boot mq hello~~~");
    }
}

结果

学习笔记：RabbitMQ快速入门_第59张图片

6.2.消费端

步骤

  1. 创建消费者 SpringBoot 工程
  2. 引入 start，依赖坐标
<dependency>
	<groupId>org.springframework.bootgroupId>
	<artifactId>spring-boot-starter-amqpartifactId>
dependency>
  1. 编写 yml 配置，基本信息配置
  2. 定义监听类，使用 @RabbitListener 注解完成队列监听。

代码部分

1.创建如下的项目结构

学习笔记：RabbitMQ快速入门_第60张图片

2.导入依赖：pom.xml


<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
         https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0modelVersion>

    <groupId>com.itheimagroupId>
    <artifactId>consumer-springbootartifactId>
    <version>0.0.1-SNAPSHOTversion>

    
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.1.4.RELEASEversion>
    parent>

    <name>consumer-springbootname>
    <description>Demo project for Spring Bootdescription>

    <properties>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <maven.compiler.source>1.8maven.compiler.source>
        <maven.compiler.target>1.8maven.compiler.target>
        <java.version>1.8java.version>
    properties>

    <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-amqpartifactId>
        dependency>
    dependencies>

project>

3.配置文件：application.yml

# 配置 RabbitMQ 的基本信息
spring:
  rabbitmq:
    host: 192.168.2.212
    port: 5672
    username: guest
    password: guest
    virtual-host: /

4.主类：com/itheima/ConsumerApplication.java

package com.itheima;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class);
    }
}

5.com/itheima/RabbitMQListener.java

package com.itheima;

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

@Component
public class RabbitMQListener {
    @RabbitListener(queues = "boot_queue")
    public void ListenerQueue(Message message){
        System.out.println(new String(message.getBody()));
    }

}

启动主类后的结果

在这里插入图片描述

6.3.小结

  • SpringBoot 提供了快速整合 RabbitMQ 的方式
  • 基本信息再 yml 中配置，队列交互机以及绑定关系在配置类中使用 Bean 的方式配置
  • 生产端直接注入 RabbitTemplate 完成消息发送
  • 消费端直接使用 @RabbitListener 完成消息接收

7.RabbitMQ 高级特性

消息可靠性投递、Consumer ACK、消费端限流、TTL、死信队列、延迟队列、日志与监控、消息可靠性分析与追踪、管理（角色、权限等）

7.0.项目准备

7.0.1.生产端

1.项目结构

学习笔记：RabbitMQ快速入门_第61张图片

2.依赖 pom.xml


<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.0modelVersion>

    <groupId>com.itheimagroupId>
    <artifactId>rabbitmq-producer-springartifactId>
    <version>1.0-SNAPSHOTversion>

    <properties>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <maven.compiler.source>1.8maven.compiler.source>
        <maven.compiler.target>1.8maven.compiler.target>
        <java.version>1.8java.version>
    properties>

    <dependencies>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.1.7.RELEASEversion>
        dependency>

        <dependency>
            <groupId>org.springframework.amqpgroupId>
            <artifactId>spring-rabbitartifactId>
            <version>2.1.8.RELEASEversion>
        dependency>

        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
        dependency>

        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-testartifactId>
            <version>5.1.7.RELEASEversion>
        dependency>
    dependencies>

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

project>

3.配置文件：rabbitmq.properties

rabbitmq.host=192.168.2.212
rabbitmq.port=5672
rabbitmq.username=guest
rabbitmq.password=guest
rabbitmq.virtual-host=/

4.配置文件：spring-rabbitmq-producer.xml


<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"/>

    
    <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"/>

    
    <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>

beans>

5.测试类：com/itheima/test/ProducerTest.java

package com.itheima.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 {

    @Autowired
    private RabbitTemplate rabbitTemplate;
    
}

7.0.2.消费端

1.项目结构

学习笔记：RabbitMQ快速入门_第62张图片

2.导入依赖 pom.xml


<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.0modelVersion>

    <groupId>com.itheimagroupId>
    <artifactId>rabbitmq-consumer-springartifactId>
    <version>1.0-SNAPSHOTversion>

    <properties>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <maven.compiler.source>1.8maven.compiler.source>
        <maven.compiler.target>1.8maven.compiler.target>
        <java.version>1.8java.version>
    properties>

    <dependencies>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>5.1.7.RELEASEversion>
        dependency>

        <dependency>
            <groupId>org.springframework.amqpgroupId>
            <artifactId>spring-rabbitartifactId>
            <version>2.1.8.RELEASEversion>
        dependency>

        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
        dependency>

        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-testartifactId>
            <version>5.1.7.RELEASEversion>
        dependency>
    dependencies>

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

project>

3.配置文件：rabbitmq.properties

rabbitmq.host=192.168.2.212
rabbitmq.port=5672
rabbitmq.username=guest
rabbitmq.password=guest
rabbitmq.virtual-host=/

4.配置文件：spring-rabbitmq-producer.xml


<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"/>

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


    <context:component-scan base-package="com.itheima.listener"/>

    
    <rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual" prefetch="1">
        
        
        
        
        
        
    rabbit:listener-container>

beans>

5.测试类：com/itheima/test/ConsumerTest.java

package com.itheima.test;

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

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

    @Test
    public void test() {
        while (true) {

        }
    }
}

7.1.消息的可靠投递

在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任
何消息丢失或者投递失败场景。

RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式：confirm 确认模式、return 退回模式

RabbitMQ 整个消息投递的路径为：producer—>rabbitmq broker—>exchange—>queue—>consumer

  • 消息从 producer 到 exchange 则会返回一个 confirmCallback 。
  • 消息从 exchange --> queue 投递失败则会返回一个 returnCallback 。

消息可靠投递：confirm

spring-rabbitmq-producer.xml


<rabbit:connection-factory  publisher-confirms="true"/>


<rabbit:queue id="test_queue_confirm" name="test_queue_confirm"/>

<rabbit:direct-exchange name="test_exchange_confirm">
    <rabbit:bindings>
        <rabbit:binding queue="test_queue_confirm" key="confirm"/>
    rabbit:bindings>
rabbit:direct-exchange>

com/itheima/test/ProducerTest.java

/**
 * 确认模式：
 * 步骤：
 * 1. 确认模式开启：ConnectionFactory 中开启 publisher-confirms="true"
 * 2. 在 rabbitTemplate 定义 ConfirmCallBack 回调函数
 */
@Test
public void testConfirm() {

    //定义回调
    rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
        /**
         *
         * @param correlationData 相关配置信息
         * @param ack   exchange 交换机 是否成功收到了消息。true 代表成功，false 代表失败
         * @param cause 失败原因
         */
        @Override
        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            System.out.println("confirm方法被执行了....");

            if (ack) {
                //接收成功
                System.out.println("接收成功消息" + cause);
            } else {
                //接收失败
                System.out.println("接收失败消息" + cause);
                //做一些处理，让消息再次发送。
            }
        }
    });

    //发送消息
    rabbitTemplate.convertAndSend("test_exchange_confirm", "confirm", "message confirm....");
}

消息可靠投递：return

spring-rabbitmq-producer.xml


<rabbit:connection-factory  publisher-returns="true"/>

com/itheima/test/ProducerTest.java

/**
 * 回退模式： 当消息发送给 Exchange 后，Exchange 路由到 Queue 失败是 才会执行 ReturnCallBack
 * 步骤：
 * 		1. 开启回退模式：publisher-returns="true"
 * 		2. 设置 ReturnCallBack
 * 		3. 设置 Exchange 处理消息的模式：
 * 			1. 如果消息没有路由到 Queue ，则丢弃消息（默认）
 * 			2. 如果消息没有路由到 Queue ，返回给消息发送方 ReturnCallBack
 */

@Test
public void testReturn() {

    //设置交换机处理失败消息的模式
    rabbitTemplate.setMandatory(true);

    //设置 ReturnCallBack
    rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
        /**
         *
         * @param message   消息对象
         * @param replyCode 错误码
         * @param replyText 错误信息
         * @param exchange  交换机
         * @param routingKey 路由键
         */
        @Override
        public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
            System.out.println("return 执行了....");

            System.out.println(message);
            System.out.println(replyCode);
            System.out.println(replyText);
            System.out.println(exchange);
            System.out.println(routingKey);

            //处理（省略）
        }
    });

    //发送消息
    rabbitTemplate.convertAndSend("test_exchange_confirm", "confirm_666", "message confirm....");
}

控制台输出

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.

return 执行了....

(Body:'message confirm....' MessageProperties 
		[headers={}, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, 
		receivedDeliveryMode=PERSISTENT, priority=0, deliveryTag=0])
312
NO_ROUTE
test_exchange_confirm
confirm_666

消息的可靠投递：confirm & return 小结

我们将利用上述两个 callback 控制消息的可靠性投递

  • 设置 ConnectionFactory 的 publisher-confirms=“true” 开启 确认模式。
  • 使用 rabbitTemplate.setConfirmCallback 设置回调函数。当消息发送到 exchange 后回调 confirm 方法。在方法中判断 ack ，如果为 true ，则发送成功，如果为 false ，则发送失败，需要处理。
  • 设置 ConnectionFactory的publisher-returns=“true” 开启 退回模式。
  • 使用 rabbitTemplate.setReturnCallback 设置退回函数，当消息从 exchange 路由到 queue失败后，如果设置了 rabbitTemplate.setMandatory(true) 参数，则会将消息退回给 producer 。并执行回调函数 returnedMessage 。
  • 在 RabbitMQ 中也提供了事务机制，但是性能较差，故不做讲解。
  • 使用channel下列方法，完成事务控制：
    • txSelect(), 用于将当前channel设置成transaction模式
    • txCommit()，用于提交事务
    • txRollback(),用于回滚事务
  • 持久化
    • exchange 要持久化
    • queue 要持久化
    • message 要持久化
  • 生产方确认 Confirm
  • 消费方确认 Ack
  • Broker 高可用

7.2.Consumer Ack

ack（Acknowledge）：表示消费端收到消息后的确认方式。

有三种确认方式：

  • 自动确认：acknowledge=“none”
  • 手动确认：acknowledge=“manual”
  • 根据异常情况确认：acknowledge=“auto”，（这种方式使用麻烦，不作讲解）

其中自动确认是指，当消息一旦被 Consumer 接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的消息缓存中移除。

但是在实际业务处理中，很可能消息接收到，业务处理出现异常，那么该消息就会丢失。

如果设置了手动确认方式，则需要在业务处理成功后，调用channel.basicAck()，手动签收。

如果出现异常，则调用 channel.basicNack() 方法，让其自动重新发送消息。

spring-rabbitmq-consumer.xml


<rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual">
    <rabbit:listener ref="ackListener" queue-names="test_queue_confirm"/>
rabbit:listener-container>

com/itheima/listener/AckListener.java

package com.itheima.listener;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;

/**
 * Consumer ACK 机制：
 *  1. 设置手动签收。acknowledge="manual"
 *  2. 让监听器类实现 ChannelAwareMessageListener 接口
 *  3. 如果消息成功处理，则调用 channel 的 basicAck() 签收
 *  4. 如果消息处理失败，则调用 channel 的 basicNack() 拒绝签收，broker 重新发送给 consumer
 */

@Component
public class AckListener implements ChannelAwareMessageListener {

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
    	//表示当前收到的一个 tag 的标签
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        try {
            //1.接收转换消息
            System.out.println(new String(message.getBody()));

            //2.处理业务逻辑
            System.out.println("处理业务逻辑...");
            
            int i = 3/0;//出现错误
            
            //3. 手动签收
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
            //e.printStackTrace();

            //4.拒绝签收
            /*
            第三个参数：requeue：重回队列。如果设置为 true，则消息重新回到 queue，broker 会重新发送该消息给消费端
             */
            channel.basicNack(deliveryTag, true, true);//多条处理
            //channel.basicReject(deliveryTag,true);//单条处理
        }
    }
}
  • 在 rabbit : listener-container 标签中设置 acknowledge 属性，设置 ack 方式 none：自动确认，manual：手动确认
  • 如果在消费端没有出现异常，则调用 channel.basicAck( deliveryTag , false ) ; 方法确认签收消息
  • 如果出现异常，则在 catch 中调用 basicNack 或 basicReject，拒绝消息，让 MQ 重新发送消息。

7.3.消费端限流

  • 在 中配置 prefetch 属性设置消费端一次拉取多少消息
  • 消费端的确认模式一定为手动确认。acknowledge=“manual”

学习笔记：RabbitMQ快速入门_第63张图片

spring-rabbitmq-consumer.xml


<rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual" prefetch="1">
    <rabbit:listener ref="qosListener" queue-names="test_queue_confirm"/>
rabbit:listener-container>

com/itheima/listener/QosListener.java

package com.itheima.listener;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;

/**
 * Consumer 限流机制
 *  1. 确保 ack 机制为手动确认。
 *  2. listener-container 配置属性
 *      perfetch = 1，表示消费端每次从 MQ 拉去一条消息来消费，直到手动确认消费完毕后，才会继续拉去下一条消息。
 */

@Component
public class QosListener implements ChannelAwareMessageListener {

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {

        Thread.sleep(1000);
        
        //1.获取消息
        System.out.println(new String(message.getBody()));

        //2. 处理业务逻辑（此处省略）

        //3. 签收
        channel.basicAck(message.getMessageProperties().getDeliveryTag(),true);

    }
}

生产端（模拟消息发送）

@Test
public void testSend() {
    for (int i = 0; i < 10; i++) {
        // 发送消息
        rabbitTemplate.convertAndSend("test_exchange_confirm", "confirm", "message confirm....");
    }
}

7.4.TTL

  • TTL 全称 Time To Live（存活时间/过期时间）。
  • 当消息到达存活时间后，还没有被消费，会被自动清除。
  • RabbitMQ 可以对消息设置过期时间，也可以对整个队列（Queue）设置过期时间。

学习笔记：RabbitMQ快速入门_第64张图片

  • 设置队列过期时间使用参数：x-message-ttl，单位：ms(毫秒)，会对整个队列消息统一过期。
  • 设置消息过期时间使用参数：expiration。单位：ms(毫秒)，当该消息在队列头部时（消费时），会单独判断这一消息是否过期。
  • 如果两者都进行了设置，以时间短的为准。

spring-rabbitmq-producer.xml


<rabbit:queue name="test_queue_ttl" id="test_queue_ttl">
    
    <rabbit:queue-arguments>
        
        <entry key="x-message-ttl" value="100000" value-type="java.lang.Integer"/>
    rabbit:queue-arguments>
rabbit:queue>

<rabbit:topic-exchange name="test_exchange_ttl">
    <rabbit:bindings>
        <rabbit:binding pattern="ttl.#" queue="test_queue_ttl"/>
    rabbit:bindings>
rabbit:topic-exchange>

/**
 * TTL:过期时间
 * 1.队列统一过期
 * 2.消息单独过期
 * 
 * 如果设置了消息的过期时间，也设置了队列的过期时间，它以时间短的为准。
 * 队列过期后，会将队列所有消息全部移除。
 * 消息过期后，只有消息在队列顶端，才会判断其是否过期(移除掉)
 */
@Test
public void testTtl() {
    /*  for (int i = 0; i < 10; i++) {
        // 发送消息
        rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.hehe", "message ttl....");
    }*/

    // 消息后处理对象，设置一些消息的参数信息
    MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            //1.设置 message 的信息
            message.getMessageProperties().setExpiration("5000");//消息的过期时间
            //2.返回该消息
            return message;
        }
    };

    //消息单独过期
    //rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.hehe", "message ttl....",messagePostProcessor);

    for (int i = 0; i < 10; i++) {
        if (i == 5) {
        	//过期的消息
            rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.hehe", "message ttl....", messagePostProcessor);
        } else {
            //不过期的消息
            rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.hehe", "message ttl....");
        }
    }

}

7.5.死信队列

死信队列，英文缩写：DLX 。Dead Letter Exchange（死信交换机）。

当消息成为 Dead message 后，可以被重新发送到另一个交换机，这个交换机就是 DLX。

学习笔记：RabbitMQ快速入门_第65张图片

消息成为死信的三种情况：

  1. 队列消息长度到达限制；
  2. 消费者拒接消费消息，basicNack / basicReject，并且不把消息重新放入原目标队列，requeue=false；
  3. 原队列存在消息过期设置，消息到达超时时间未被消费；

队列绑定死信交换机：

  • 给队列设置参数： x-dead-letter-exchange 和 x-dead-letter-routing-key

学习笔记：RabbitMQ快速入门_第66张图片

生产端：spring-rabbitmq-producer.xml





<rabbit:queue name="test_queue_dlx" id="test_queue_dlx">
    
    <rabbit:queue-arguments>
        
        <entry key="x-dead-letter-exchange" value="exchange_dlx"/>

        
        <entry key="x-dead-letter-routing-key" value="dlx.hehe"/>

        
        <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer"/>
        
        
        <entry key="x-max-length" value="10" value-type="java.lang.Integer"/>
    rabbit:queue-arguments>
rabbit:queue>
<rabbit:topic-exchange name="test_exchange_dlx">
    <rabbit:bindings>
        <rabbit:binding pattern="test.dlx.#" queue="test_queue_dlx"/>
    rabbit:bindings>
rabbit:topic-exchange>




<rabbit:queue name="queue_dlx" id="queue_dlx"/>
<rabbit:topic-exchange name="exchange_dlx">
    <rabbit:bindings>
        <rabbit:binding pattern="dlx.#" queue="queue_dlx"/>
    rabbit:bindings>
rabbit:topic-exchange>

生产端：com/itheima/test/ProducerTest.java

/**
 * 发送测试死信消息：
 * 1. 过期时间
 * 2. 长度限制
 * 3. 消息拒收
 */
@Test
public void testDlx() {
    //1. 测试过期时间，死信消息
    //rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.haha","我是一条消息，我会死吗？");

    //2. 测试长度限制后，消息死信
   /* for (int i = 0; i < 20; i++) {
        rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.haha","我是一条消息，我会死吗？");
    }*/

    //3. 测试消息拒收
    rabbitTemplate.convertAndSend("test_exchange_dlx", "test.dlx.haha", "我是一条消息，我会死吗？");

}

消费端：com/itheima/listener/DlxListener.java

package com.itheima.listener;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;

@Component
public class DlxListener implements ChannelAwareMessageListener {

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        try {
            //1.接收转换消息
            System.out.println(new String(message.getBody()));

            //2. 处理业务逻辑
            System.out.println("处理业务逻辑...");
            int i = 3 / 0;//出现错误
            //3. 手动签收
            channel.basicAck(deliveryTag, true);
        } catch (Exception e) {
            //e.printStackTrace();
            System.out.println("出现异常，拒绝接受");
            //4.拒绝签收，不重回队列 requeue=false
            channel.basicNack(deliveryTag, true, false);
        }
    }
}

消费端：spring-rabbitmq-consumer.xml


<rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual" prefetch="1">
    
    <rabbit:listener ref="dlxListener" queue-names="test_queue_dlx"/>
rabbit:listener-container>

小结

  1. 死信交换机和死信队列和普通的没有区别

  2. 当消息成为死信后，如果该队列绑定了死信交换机，则消息会被死信交换机重新路由到死信队列

  3. 消息成为死信的三种情况：

    1. 队列消息长度到达限制；
    2. 消费者拒接消费消息，并且不重回队列；
    3. 原队列存在消息过期设置，消息到达超时时间未被消费；

7.6.延迟队列

延迟队列，即消息进入队列后不会立即被消费，只有到达指定时间后，才会被消费。

需求：

  1. 下单后，30分钟未支付，取消订单，回滚库存。
  2. 新用户注册成功7天后，发送短信问候。

实现方式：

  1. 定时器
  2. 延迟队列

学习笔记：RabbitMQ快速入门_第67张图片

很可惜，在 RabbitMQ 中并未提供延迟队列功能。

但是可以使用：TTL + 死信队列 组合实现延迟队列的效果。

学习笔记：RabbitMQ快速入门_第68张图片

spring-rabbitmq-producer.xml




<rabbit:queue id="order_queue" name="order_queue">
    
    <rabbit:queue-arguments>
        <entry key="x-dead-letter-exchange" value="order_exchange_dlx"/>
        <entry key="x-dead-letter-routing-key" value="dlx.order.cancel"/>
        <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer"/>
    rabbit:queue-arguments>
rabbit:queue>

<rabbit:topic-exchange name="order_exchange">
    <rabbit:bindings>
        <rabbit:binding pattern="order.#" queue="order_queue"/>
    rabbit:bindings>
rabbit:topic-exchange>


<rabbit:queue id="order_queue_dlx" name="order_queue_dlx"/>
<rabbit:topic-exchange name="order_exchange_dlx">
    <rabbit:bindings>
        <rabbit:binding pattern="dlx.order.#" queue="order_queue_dlx"/>
    rabbit:bindings>
rabbit:topic-exchange>

生产者：com/itheima/test/ProducerTest.java

@Test
public void testDelay() throws InterruptedException {
    //1.发送订单消息。 将来是在订单系统中，下单成功后，发送消息
    rabbitTemplate.convertAndSend("order_exchange", "order.msg", "订单信息：id=1,time=2019年8月17日16:41:47");
    
    /*//2.打印倒计时10秒
    for (int i = 10; i > 0 ; i--) {
        System.out.println(i+"...");
        Thread.sleep(1000);
    }*/
}

消费者：com/itheima/listener/OrderListener.java

package com.itheima.listener;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;

@Component
public class OrderListener implements ChannelAwareMessageListener {
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        try {
            //1.接收转换消息
            System.out.println(new String(message.getBody()));

            //2. 处理业务逻辑
            System.out.println("处理业务逻辑...");
            System.out.println("根据订单id查询其状态...");
            System.out.println("判断状态是否为支付成功");
            System.out.println("取消订单，回滚库存....");
            //3. 手动签收
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
            //e.printStackTrace();
            System.out.println("出现异常，拒绝接受");
            //4.拒绝签收，不重回队列 requeue=false
            channel.basicNack(deliveryTag,true,false);
        }
    }
}

spring-rabbitmq-consumer.xml


<rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual" prefetch="1">
    
    <rabbit:listener ref="orderListener" queue-names="order_queue_dlx"/>
rabbit:listener-container>

小结

  1. 延迟队列 指消息进入队列后，可以被延迟一定时间，再进行消费。
  2. RabbitMQ 没有提供延迟队列功能，但是可以使用 ： TTL + DLX 来实现延迟队列效果。

7.7.日志与监控

7.7.1.RabbitMQ 日志

RabbitMQ 默认日志存放路径： /var/log/rabbitmq/[email protected]

日志包含了 RabbitMQ 的版本号、Erlang 的版本号、RabbitMQ 服务节点名称、cookie 的 hash 值、RabbitMQ 配置文件地址、内存限制、磁盘限制、默认账户 guest 的创建以及权限配置等等。

7.7.2.web 管控台监控

此处信息在 3.1.RabbitMQ管理界面介绍 处已介绍的很详细了，故这里不再赘述。

7.7.3.rabbitmqctl 管理和监控

查看队列

rabbitmqctl list_queues

查看exchanges

rabbitmqctl list_exchanges

查看用户

rabbitmqctl list_users

查看连接

rabbitmqctl list_connections

查看消费者信息

rabbitmqctl list_consumers

查看环境变量

rabbitmqctl environment

查看未被确认的队列

rabbitmqctl list_queues name messages_unacknowledged

查看单个队列的内存使用

rabbitmqctl list_queues name memory

查看准备就绪的队列

rabbitmqctl list_queues name messages_ready

7.8.消息追踪

在使用任何消息中间件的过程中，难免会出现某条消息异常丢失的情况。对于 RabbitMQ 而言，可能是因为生产者或消费者与 RabbitMQ 断开了连接，而它们与 RabbitMQ 又采用了不同的确认机制；也有可能是因为交换器与队列之间不同的转发策略；甚至是交换器并没有与任何队列进行绑定，生产者又不感知或者没有采取相应的措施；另外 RabbitMQ 本身的集群策略也可能导致消息的丢失。这个时候就需要有一个较好的机制跟踪记录消息的投递过程，以此协助开发和运维人员进行问题的定位。

在 RabbitMQ 中可以使用 Firehose 和 rabbitmq_tracing 插件功能来实现消息追踪。

消息追踪-Firehose

firehose 的机制是将生产者投递给 rabbitmq 的消息，rabbitmq 投递给消费者的消息按照指定的格式发送到默认的 exchange 上。

这个默认的exchange的名称为 amq.rabbitmq.trace，它是一个 topic 类型的 exchange。

发送到这个 exchange 上的消息的 routing key 为 publish.exchangename 和 deliver.queuename。

其中 exchangename 和 queuename 为实际 exchange 和 queue 的名称，

分别对应生产者投递到 exchange 的消息，和消费者从 queue 上获取的消息。

注意：打开 trace 会影响消息写入功能，适当打开后请关闭。

  • rabbitmqctl trace_on：开启 Firehose 命令

  • rabbitmqctl trace_off：关闭 Firehose 命令

消息追踪-rabbitmq_tracing

rabbitmq_tracing 和 Firehose 在实现上如出一辙，只不过 rabbitmq_tracing 的方式比 Firehose 多了一层 GUI 的包装，更容易使用和管理。

  • 启用插件：rabbitmq-plugins enable rabbitmq_tracing

8.RabbitMQ 应用问题

  • 消息可靠性保障

    • 消息补偿机制

  • 消息幂等性保障

    • 乐观锁解决方案

消息可靠性保障–消息补偿

需求：100%确保消息发送成功

学习笔记：RabbitMQ快速入门_第69张图片

消息幂等性保障

幂等性指一次和多次请求某一个资源，对于资源本身应该具有同样的结果。也就是说，其任意多次执行对资源本身所产生的影响均与一次执行的影响相同。

在MQ中指，消费多条相同的消息，得到与消费该消息一次相同的结果。

  • 乐观锁机制

学习笔记：RabbitMQ快速入门_第70张图片

9.RabbitMQ 集群搭建

RabbitMQ 高可用集群

摘要：实际生产应用中都会采用消息队列的集群方案，如果选择RabbitMQ那么有必要了解下它的集群方案原理

一般来说，如果只是为了学习RabbitMQ或者验证业务工程的正确性那么在本地环境或者测试环境上使用其单实例部署就可以了，但是出于MQ中间件本身的可靠性、并发性、吞吐量和消息堆积能力等问题的考虑，在生产环境上一般都会考虑使用RabbitMQ的集群方案。

9.1 集群方案的原理

RabbitMQ 这款消息队列中间件产品本身是基于 Erlang 编写，Erlang 语言天生具备分布式特性（通过同步 Erlang 集群各节点的 magic cookie 来实现）。因此，RabbitMQ 天然支持 Clustering。这使得 RabbitMQ 本身不需要像 ActiveMQ、Kafka 那样通过 ZooKeeper 分别来实现 HA 方案和保存集群的元数据。集群是保证可靠性的一种方式，同时可以通过水平扩展以达到增加消息吞吐量能力的目的。

学习笔记：RabbitMQ快速入门_第71张图片

9.2.单机多实例部署

由于某些因素的限制，有时候你不得不在一台机器上去搭建一个 rabbitmq 集群，这个有点类似 zookeeper 的单机版。真实生成环境还是要成多机集群的。有关怎么配置多机集群的可以参考其他的资料，这里主要论述如何在单机中配置多个 rabbitmq 实例。

主要参考官方文档：https://www.rabbitmq.com/clustering.html

首先确保 RabbitMQ 运行没有问题

查看 RabbitMQ 状态

rabbitmqctl status

停止 RabbitMQ 服务

service rabbitmq-server stop

启动第一个节点

RABBITMQ_NODE_PORT=5673 RABBITMQ_NODENAME=rabbit1 rabbitmq-server start

注意

若执行上条命令出现了这样的错误，且在 /etc/rabbitmq/rabbitmq-env.conf文件中添加NODENAME=rabbit@localhost也于事无补的话

ERROR: epmd error for host 192: badarg (unknown POSIX error)

那么这个错误则是因为 hostname 是数字的原因导致的

此时我们需要重新设置 hostname 为英文

hostnamectl set-hostname *随便输入一个英文名称*

另外我们还需要在/etc/hosts中添加了 IP 地址 hostname

在这里插入图片描述

重启后，hostname 更改成功，在执行上述命令就没有问题了。

学习笔记：RabbitMQ快速入门_第72张图片

启动第二个节点

web 管理插件端口占用，所以还要指定其 web 插件占用的端口号

RABBITMQ_NODE_PORT=5674 RABBITMQ_SERVER_START_ARGS="-rabbitmq_management listener [{port,15674}]" RABBITMQ_NODENAME=rabbit2 rabbitmq-server start

结束命令

rabbitmqctl -n rabbit1 stop

rabbitmqctl -n rabbit2 stop

rabbit1 操作作为主节点

rabbitmqctl -n rabbit1 stop_app # 停止

rabbitmqctl -n rabbit1 reset # 重置	 

rabbitmqctl -n rabbit1 start_app

rabbit2 操作为从节点

rabbitmqctl -n rabbit2 stop_app

rabbitmqctl -n rabbit2 reset

rabbitmqctl -n rabbit2 join_cluster rabbit1@'centos7' #''内是主机名换成自己的

rabbitmqctl -n rabbit2 start_app

查看集群状态

rabbitmqctl cluster_status -n rabbit1

web监控

学习笔记：RabbitMQ快速入门_第73张图片

9.3.集群管理

rabbitmqctl join_cluster {cluster_node} [–ram]

将节点加入指定集群中。在这个命令执行前需要停止 RabbitMQ 应用并重置节点。

rabbitmqctl cluster_status

显示集群的状态。

rabbitmqctl change_cluster_node_type {disc|ram}

修改集群节点的类型。在这个命令执行前需要停止 RabbitMQ 应用。

rabbitmqctl forget_cluster_node [–offline]

将节点从集群中删除，允许离线执行。

rabbitmqctl update_cluster_nodes {clusternode}

在集群中的节点应用启动前咨询 clusternode 节点的最新信息，并更新相应的集群信息。这个和 join_cluster 不同，它不加入集群。

考虑这样一种情况，节点A和节点B都在集群中，当节点A离线了，节点C又和节点B组成了一个集群，然后节点B又离开了集群，当A醒来的时候，它会尝试联系节点B，但是这样会失败，因为节点B已经不在集群中了。

rabbitmqctl cancel_sync_queue [-p vhost] {queue}

取消队列 queue 同步镜像的操作。

rabbitmqctl set_cluster_name {name}

设置集群名称。集群名称在客户端连接时会通报给客户端。

Federation 和 Shovel 插件也会有用到集群名称的地方。

集群名称默认是集群中第一个节点的名称，通过这个命令可以重新设置。

9.4.RabbitMQ镜像集群配置

上面已经完成 RabbitMQ 默认集群模式，但并不保证队列的高可用性，尽管交换机、绑定这些可以复制到集群里的任何一个节点，但是队列内容不会复制。虽然该模式解决一项目组节点压力，但队列节点宕机直接导致该队列无法应用，只能等待重启，所以要想在队列节点宕机或故障也能正常应用，就要复制队列内容到集群里的每个节点，必须要创建镜像队列。

镜像队列是基于普通的集群模式的，然后再添加一些策略，所以你还是得先配置普通集群，然后才能设置镜像队列，我们就以上面的集群接着做。

设置的镜像队列可以通过开启的网页的管理端 Admin->Policies，也可以通过命令

rabbitmqctl set_policy my_ha "^" '{"ha-mode":"all"}'

学习笔记：RabbitMQ快速入门_第74张图片

  • Name：策略名称
  • Pattern：匹配的规则，如果是匹配所有的队列，是 ^.
  • Definition：使用 ha-mode 模式中的 all，也就是同步所有匹配的队列。问号链接帮助文档。

9.5.负载均衡-HAProxy

HAProxy 提供高可用性、负载均衡以及基于 TCP 和 HTTP 应用的代理，支持虚拟主机，它是免费、快速并且可靠的一种解决方案。

包括 Twitter，Reddit，StackOverflow，GitHub 在内的多家知名互联网公司在使用。

HAProxy 实现了一种事件驱动、单一进程模型，此模型支持非常大的并发连接数。

9.5.1. 安装HAProxy

下载依赖包

yum install gcc vim wget

上传资料中提供的 haproxy 源码包，并且解压

tar -zxvf haproxy-1.6.5.tar.gz -C /usr/local

进入目录、进行编译、安装

cd /usr/local/haproxy-1.6.5

make TARGET=linux31 PREFIX=/usr/local/haproxy

make install PREFIX=/usr/local/haproxy

mkdir /etc/haproxy

赋权

groupadd -r -g 149 haproxy

useradd -g haproxy -r -s /sbin/nologin -u 149 haproxy

创建 haproxy 配置文件

vim /etc/haproxy/haproxy.cfg

9.5.2.配置HAProxy

配置文件路径：/etc/haproxy/haproxy.cfg

#logging options
global
	log 127.0.0.1 local0 info
	maxconn 5120
	chroot /usr/local/haproxy
	uid 99
	gid 99
	daemon
	quiet
	nbproc 20
	pidfile /var/run/haproxy.pid

defaults
	log global
	
	mode tcp

	option tcplog
	option dontlognull
	retries 3
	option redispatch
	maxconn 2000
	contimeout 5s
   
     clitimeout 60s

     srvtimeout 15s	
#front-end IP for consumers and producters

listen rabbitmq_cluster
	bind 0.0.0.0:5672
	
	mode tcp
	#balance url_param userid
	#balance url_param session_id check_post 64
	#balance hdr(User-Agent)
	#balance hdr(host)
	#balance hdr(Host) use_domain_only
	#balance rdp-cookie
	#balance leastconn
	#balance source //ip
	
	balance roundrobin
	
        server node1 127.0.0.1:5673 check inter 5000 rise 2 fall 2
        server node2 127.0.0.1:5674 check inter 5000 rise 2 fall 2

listen stats
	bind 192.168.2.13:8100
	mode http
	option httplog
	stats enable
	stats uri /rabbitmq-stats
	stats refresh 5s

启动 HAproxy 负载

/usr/local/haproxy/sbin/haproxy -f /etc/haproxy/haproxy.cfg

查看 haproxy 进程状态

ps -ef | grep haproxy

访问如下地址对 MQ 节点进行监控

http://192.168.2.13:8100/rabbitmq-stats

代码中访问 MQ 集群地址，则变为访问 haproxy 地址：5672

学习笔记：RabbitMQ快速入门_第75张图片

com/itheima/test/HelloWorld.java

package com.itheima.test;

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 HelloWorld {
    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("192.168.2.13");//ip  HaProxy的ip
        factory.setPort(5672); //端口 HaProxy的监听的端口
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();
        //5. 创建队列Queue
        channel.queueDeclare("hello_world", true, false, false, null);
        String body = "hello rabbitmq~~~";
        //6. 发送消息
        channel.basicPublish("", "hello_world", null, body.getBytes());
        //7.释放资源
        channel.close();
        connection.close();

        System.out.println("send success....");

    }
}

你可能感兴趣的:(微服务,rabbitmq,微服务)

  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • 腾讯云技术深度探索：构建高效云原生微服务架构 我的运维人生 云原生架构腾讯云运维开发技术共享
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
  • 06选课支付模块之基于消息队列发送支付通知消息 echo 云清 学成在线javarabbitmq消息队列支付通知学成在线
    消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
  • 在RabbitMQ中四种常见的消息路由模式 Xwzzz_ rabbitmq分布式
    1.Fanout模式Fanout模式的交换机是扇出交换机（FanoutExchange），它会将消息广播给所有绑定到它的队列，而不考虑消息的内容或路由键。工作原理：生产者发送消息到FanoutExchange。FanoutExchange会将消息广播给所有绑定到它的队列，所有绑定的队列都会收到这条消息。消费者监听绑定的队列，处理收到的消息。特点：没有路由键：消息不需要路由键，所有绑定的队列都会接收
  • 【RabbitMQ 项目】服务端：数据管理模块之绑定管理 月夜星辉雪 rabbitmq分布式
    文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
  • RabbitMQ生产者重复机制与确认机制 java炒饭小能手 java-rabbitmqrabbitmqjava
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
  • 网关gateway学习总结 猪猪365 学习总结学习总结
    一微服务概述:微服务网关就是一个系统!通过暴露该微服务的网关系统,方便我们进行相关的鉴权,安全控制,日志的统一处理,易于监控的相关功能!实现微服务网关技术都有哪些呢?1nginx:nginx是一个高性能的http和反向代理web的服务器,同事也提供了IMAP/POP3/SMTP服务.他可以支撑5万并发链接,并且cpu,内存等资源消耗非常的低,运行非常的稳定!2Zuul:Zuul是Netflix公司
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架 叶准鑫Natalie
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
  • 从单体到微服务：FastAPI ‘挂载’子应用程序的转变 黑金IT fastapi微服务fastapi架构
    在现代Web应用开发中，模块化架构是一种常见的设计模式，它有助于将大型应用程序分解为更小、更易于管理的部分。FastAPI，作为一个高性能的PythonWeb框架，提供了强大的支持来实现这种模块化设计。通过“挂载”子应用程序，我们可以为不同的功能区域（如前端接口、管理员接口和用户中心）创建独立的应用程序，并将它们整合到一个主应用程序中。本文将详细介绍如何在FastAPI中使用“挂载”子应用程序的方
  • Sentinel 眼泪落在琴弦 springcloudjavajava
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
  • Kafka 基础与架构理解 StaticKing KAFKAkafka
    目录前言Kafka基础概念消息队列简介：Kafka与传统消息队列（如RabbitMQ、ActiveMQ）的对比Kafka的组件Kafka的工作原理：消息的生产、分发、消费流程Kafka系统架构Kafka的分布式架构设计Leader-Follower机制与数据复制Log-basedStorage和持久化Broker间通信协议Zookeeper在Kafka中的角色总结前言Kafka是一个分布式的消息系
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算 码踏云端 springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
  • 软件测试/测试开发/全日制 |利用Django REST framework构建微服务 霍格沃兹-慕漓 django微服务sqlite
    霍格沃兹测试开发学社推出了《Python全栈开发与自动化测试班》。本课程面向开发人员、测试人员与运维人员，课程内容涵盖Python编程语言、人工智能应用、数据分析、自动化办公、平台开发、UI自动化测试、接口测试、性能测试等方向。为大家提供更全面、更深入、更系统化的学习体验，课程还增加了名企私教服务内容，不仅有名企经理为你1v1辅导，还有行业专家进行技术指导，针对性地解决学习、工作中遇到的难题。让找
  • Dubbo架构概览：服务注册与发现、远程调用、监控与管理 木南曌 dubbo架构
    Dubbo是一个成熟的、高性能的、基于Java的微服务开发框架，它主要用于解决分布式系统中的服务治理问题，包括服务的注册与发现、远程过程调用（RPC）、服务监控与管理等多个关键环节。以下是Dubbo架构概览的详细介绍：服务注册与发现Dubbo的服务注册与发现机制是其核心功能之一，它依赖于注册中心来管理服务的生命周期和定位服务提供者。1.服务提供者（Provider）服务提供者是实际提供服务的节点，
  • 【RabbitMQ 项目】服务端数据管理模块之交换机管理 月夜星辉雪 rabbitmqoracle数据库
    文章目录一.编写思路二.代码实践一.编写思路定义交换机类型直接交换广播交换主题交换定义交换机名字类型是否持久化定义交换机持久化类(持久化到sqlite3)构造函数(只能成功，不能失败)如果数据库(文件)不存在则创建打开数据库打开exchange_table数据库表插入交换机移除交换机将数据库中的交换机恢复到内存中传入一个哈希表，key为名字，value为交换机的智能指针，填充该哈希表定义交换机管理
  • 【仿RabbitMQ消息队列项目day2】使用muduo库中基于protobuf的应用层协议进行通信 月夜星辉雪 rabbitmq网络分布式c++后端服务器linux
    一.什么是muduo?muduo库是⼀个基于非阻塞IO和事件驱动的C++高并发TCP网络编程库。简单来理解，它就是对原生的TCP套接字的封装，是一个比socket编程接口更好用的编程库。二.使用muduo库完成一个英译汉翻译服务TranslateServer.hpp:#pragmaonce#include#include#include#include#include"muduo/net/TcpC
  • rabbitmq 楚楚ccc Java系列rabbitmq分布式
    1.消息服务概述、rabbitmq核心概念消息服务概述：大多数应用中，可通过消息服务中间件来提升系统异步通信，扩展解耦能力两个重要概念：消息代理(messagebroker)和目的地(destination)。当消息发送者者发出消息后，将由消息代理接管，消息代理保证将消息传递至目的地两种形式的目的地：队列(queue):点对点的消息通信(point-to-point)主题(topic):发布(pu
  • 使用 RabbitMQ 实现秒杀订单系统的异步消息处理 c137范特西 rabbitmq分布式
    使用RabbitMQ实现秒杀订单系统的异步消息处理在秒杀系统中，如何确保高并发环境下的订单处理稳定高效是个很大的挑战。为了解决这个问题，我们通常会引入消息队列，通过异步处理来削峰填谷。这篇文章将详细讲解如何使用RabbitMQ来设计一个秒杀订单系统的异步消息处理流程，重点是如何使用交换机（Exchange）、队列（Queue）、路由键（RoutingKey）以及死信队列（DeadLetterQue
  • 面试常见题之Spring Cloud 拾光编程 java面试面试springcloud职场和发展
    在Java软件工程师的面试中，关于SpringCloud的题目旨在考察候选人对微服务架构的理解、SpringCloud各组件的掌握程度、以及如何在实际项目中应用这些技术来构建可扩展、可靠和高效的服务。本文将概括性地列出20个关于SpringCloud的面试题目，并为每个题目提供一个简要的回答框架或关键点，以便你根据需要进行扩展。1.SpringCloud是什么？它解决了什么问题？回答框架：Spri
  • springcloud — 微服务鉴权管理Spring Security原理解析(二) RachelHwang springcloudspringjavaspringsecurityoauth2springcloud
    引言：回顾之前介绍的OAuth2简单分析与介绍，微服务鉴权管理之OAuth2原理解析(一)，前面的部分，我们关注了SpringSecurity是如何完成认证工作的，但是另外一部分核心的内容：过滤器，一直没有提到，我们已经知道SpringSecurity使用了springSecurityFilterChain作为了安全过滤的入口，这一节主要分析一下这个过滤器链都包含了哪些关键的过滤器，并且各自的使命
  • 微服务架构 | nacos - [自动刷新配置方式 & 失效排查] 问仙长何方蓬莱 微服务java技术SpringCloud微服务javanacos
    INDEX§1配置方式§1.1springboot配置§1.2springcloud配置§2失效排查§2.1常见失效场景§2.1.1配置不配套§2.1.2自动刷新未开启§2.1.3依赖冲突§2.1.4改错了配置文件§2.2未知情况关键排查点§1配置方式nacos的配置中心主要有两套配置方式，配置方式不互相共通，需要配套配置springbootspringcloud§1.1springboot配置依
  • Spring Cloud: Hystrix请求队列线程不足 MeazZa
    在SpringCloud中，Feign可以实现本地化的微服务API调用，Hystrix可以实现调用失败时的fallback处理。问题描述：在实际生产环境中使用时，我们遇到了这样一个错误："...,stacktrace:[com.netflix.hystrix.exception.HystrixRuntimeException:QueryNodeImpalaBdService#getQueryRes
  • 当前最流行的架构设计模式 turingbooks
    《微服务设计（第2版）》最可贵的地方在于，不光具备理论性与系统性，更为注重实践性与可操作性。全书勾勒出一幅从宏观到细节，再到组织落地的微服务架构整体实施蓝图。无论是对关注微服务领域的工程师与架构师，还是对寻求架构升级的管理者与决策者来说，本书都可以作为指导手册。——沈剑，快狗打车CTO《微服务设计（第2版）》萨姆·纽曼|著钟健鑫张沙沙智伟|译软件开发大神MartinFowler如此推荐本书：“微服
  • 等保测评中的关键技术挑战与应对策略 亿林数据 网络安全等保测评
    在信息安全领域，等保测评（信息安全等级保护测评）作为确保信息系统安全性的重要手段，其过程中不可避免地会遇到一系列技术挑战。这些挑战不仅考验着企业的技术实力，也对其安全管理水平提出了更高要求。本文将深入探讨等保测评中的关键技术挑战，并提出相应的应对策略。一、等保测评中的关键技术挑战1.复杂系统架构的评估难度随着信息技术的快速发展，企业信息系统的架构日益复杂，包括分布式系统、微服务架构、云计算环境等。
  • Nacos 与 Eureka 的区别 litGrey 微服务eureka
    随着微服务架构的流行，服务发现成为了构建分布式系统的关键技术之一。在众多服务发现工具中，Nacos和Eureka是两个非常受欢迎的选择。本文将深入探讨这两者的区别，帮助你在选择适合自己的服务发现解决方案时做出明智的决策。如果你不懂得怎么选择，请记得看最后一点小建议！1.基础对比1.1.架构设计：集中式vs分布式Eureka采用的是客户端-服务器（Client-Server,CS）架构。Eureka
  • 微服务治理：Nacos, Zookeeper, consul, etcd, Eureka等 5 个常用微服务注册工具对比 surfirst 架构微服务zookeeperconsul
    当然！下面是Nacos、Zookeeper、Consul、etcd和Eureka这五个常用的注册中心的详细对比：Nacos：Nacos是由HashiCorp开发的高度可扩展和可靠的服务发现、配置管理和服务网格解决方案。它的架构基于一组服务器代理形成的共识组和与服务器交互的许多客户端代理。主要特点包括：服务发现：服务在Nacos中注册，客户端可以通过DNS或HTTPAPI发现服务及其位置。健康检查：
  • docker镜像的批量备份和加载 小卡车555 docker
    随着微服务的不断发展，docker在微服务的部署中也占着不可缺少的角色，有这样一种场景，需要将服务器上的若干个最新的镜像打成tar.gz做一个备份或者异地部署。针对此问题尝试写了如下shell脚本#vimsaveImages.sh脚本内容如下：#当前需要打包的版本号version=xxx.0.0.1-RELEASE#仓库rep=defaultRep#名称name=defaultNameforiin
  • 论微服务架构及应用 凋零的老树 架构微服务云原生
    2021年初，我所在的公司承担了某能源集团化工产业部的化工生产运营综合管控系统，简称运营管控系统。我有幸担任了该项目的系统架构师，主要负责系统的体系架构、架构评估和研发管理工作。随着国内外化工行业日新月异的繁荣与发展，化工产业部在数字化、网络化、信息化方面要求不提提高。传统管理方式和技术手段也越来越难以适用瞬息万变的市场情况了。加上原来化工产业部原来建设的信息系统大多部署困难，升级麻烦，扩展性差等
  • 微服务之服务注册与发现：Etcd、Zookeeper、Consul 与 Nacos 比较 陌北v1 微服务etcdzookeeperConsulNacos
    在微服务架构中，服务注册与发现是实现服务动态管理和负载均衡的关键。本文将对四款主流的服务注册与发现工具——Etcd、Zookeeper、Consul、Nacos进行深入对比，从功能、性能、一致性、生态集成、应用场景等多个维度展开分析，帮助您选择最适合的工具。核心概念服务注册：服务实例启动时将自身信息（IP地址、端口、健康状态等）注册到注册中心。服务发现：服务消费者通过注册中心查询所需服务的地址列表
  • Spring的注解积累 yijiesuifeng spring注解
    用注解来向Spring容器注册Bean。   需要在applicationContext.xml中注册： <context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。 如：在base-package指明一个包    <context:component-sc
  • 传感器 百合不是茶 android传感器
    android传感器的作用主要就是来获取数据,根据得到的数据来触发某种事件   下面就以重力传感器为例;   1,在onCreate中获得传感器服务   private SensorManager sm;// 获得系统的服务 private Sensor sensor;// 创建传感器实例 @Override protected void
  • [光磁与探测]金吕玉衣的意义 comsci
          这是一个古代人的秘密:现在告诉大家       信不信由你们:       穿上金律玉衣的人,如果处于灵魂出窍的状态,可以飞到宇宙中去看星星       这就是为什么古代
  • 精简的反序打印某个数 沐刃青蛟 打印
    以前看到一些让求反序打印某个数的程序。 比如：输入123，输出321。   记得以前是告诉你是几位数的，当时就抓耳挠腮，完全没有思路。   似乎最后是用到%和/方法解决的。   而今突然想到一个简短的方法，就可以实现任意位数的反序打印（但是如果是首位数或者尾位数为0时就没有打印出来了）   代码如下： long num, num1=0;
  • PHP：6种方法获取文件的扩展名 IT独行者 PHP扩展名
      PHP：6种方法获取文件的扩展名   1、字符串查找和截取的方法   1 $extension = substr ( strrchr ( $file ,  '.' ), 1); 2、字符串查找和截取的方法二   1 $extension = substr
  • 面试111 文强chu 面试
    1事务隔离级别有那些 ，事务特性是什么（问到一次） 2 spring aop 如何管理事务的，如何实现的。动态代理如何实现，jdk怎么实现动态代理的，ioc是怎么实现的，spring是单例还是多例，有那些初始化bean的方式，各有什么区别（经常问） 3 struts默认提供了那些拦截器 （一次） 4 过滤器和拦截器的区别 （频率也挺高） 5 final，finally final
  • XML的四种解析方式 小桔子 domjdomdom4jsax
    在平时工作中，难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案，哪个最适合我们呢？在这篇文章中，我对这四种主流方案做一个不完全评测，仅仅针对遍历 XML 这块来测试，因为遍历 XML 是工作中使用最多的（至少我认为）。 　　预 备 　　测试环境： 　　AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server
  • wordpress中常见的操作 aichenglong 中文注册wordpress移除菜单
    1 wordpress中使用中文名注册解决办法   1)使用插件   2)修改wp源代码      进入到wp-include/formatting.php文件中找到       function sanitize_user( $username, $strict = false
  • 小飞飞学管理-1 alafqq 管理
    项目管理的下午题，其实就在提出问题（挑刺），分析问题，解决问题。 今天我随意看下10年上半年的第一题。主要就是项目经理的提拨和培养。 结合我自己经历写下心得 对于公司选拔和培养项目经理的制度有什么毛病呢？ 1，公司考察，选拔项目经理，只关注技术能力，而很少或没有关注管理方面的经验，能力。 2，公司对项目经理缺乏必要的项目管理知识和技能方面的培训。 3，公司对项目经理的工作缺乏进行指
  • IO输入输出部分探讨 百合不是茶 IO
     //文件处理  在处理文件输入输出时要引入java.IO这个包； /* 1，运用File类对文件目录和属性进行操作 2，理解流，理解输入输出流的概念 3，使用字节/符流对文件进行读/写操作 4，了解标准的I/O 5，了解对象序列化 */   //1，运用File类对文件目录和属性进行操作   //在工程中线创建一个text.txt
  • getElementById的用法 bijian1013 element
            getElementById是通过Id来设置/返回HTML标签的属性及调用其事件与方法。用这个方法基本上可以控制页面所有标签，条件很简单，就是给每个标签分配一个ID号。        返回具有指定ID属性值的第一个对象的一个引用。        语法： &n
  • 励志经典语录 bijian1013 励志人生
    经典语录1:   哈佛有一个著名的理论：人的差别在于业余时间，而一个人的命运决定于晚上8点到10点之间。每晚抽出2个小时的时间用来阅读、进修、思考或参加有意的演讲、讨论，你会发现，你的人生正在发生改变，坚持数年之后，成功会向你招手。不要每天抱着QQ/MSN/游戏/电影/肥皂剧……奋斗到12点都舍不得休息，看就看一些励志的影视或者文章，不要当作消遣；学会思考人生，学会感悟人生
  • [MongoDB学习笔记三]MongoDB分片 bit1129 mongodb
    MongoDB的副本集(Replica Set)一方面解决了数据的备份和数据的可靠性问题，另一方面也提升了数据的读写性能。MongoDB分片(Sharding)则解决了数据的扩容问题，MongoDB作为云计算时代的分布式数据库，大容量数据存储，高效并发的数据存取，自动容错等是MongoDB的关键指标。 本篇介绍MongoDB的切片(Sharding)   1.何时需要分片 &nbs
  • 【Spark八十三】BlockManager在Spark中的使用场景 bit1129 manager
    1. Broadcast变量的存储，在HttpBroadcast类中可以知道 2. RDD通过CacheManager存储RDD中的数据，CacheManager也是通过BlockManager进行存储的 3. ShuffleMapTask得到的结果数据，是通过FileShuffleBlockManager进行管理的，而FileShuffleBlockManager最终也是使用BlockMan
  • yum方式部署zabbix ronin47 yum方式部署zabbix
    安装网络yum库#rpm -ivh http://repo.zabbix.com/zabbix/2.4/rhel/6/x86_64/zabbix-release-2.4-1.el6.noarch.rpm 通过yum装mysql和zabbix调用的插件还有agent代理#yum install zabbix-server-mysql zabbix-web-mysql mysql-
  • Hibernate4和MySQL5.5自动创建表失败问题解决方法 byalias J2EEHibernate4
    今天初学Hibernate4，了解了使用Hibernate的过程。大体分为4个步骤： ①创建hibernate.cfg.xml文件 ②创建持久化对象 ③创建*.hbm.xml映射文件 ④编写hibernate相应代码 在第四步中，进行了单元测试，测试预期结果是hibernate自动帮助在数据库中创建数据表，结果JUnit单元测试没有问题，在控制台打印了创建数据表的SQL语句，但在数据库中
  • Netty源码学习-FrameDecoder bylijinnan javanetty
    Netty 3.x的user guide里FrameDecoder的例子，有几个疑问： 1.文档说：FrameDecoder calls decode method with an internally maintained cumulative buffer whenever new data is received. 为什么每次有新数据到达时，都会调用decode方法？ 2.Dec
  • SQL行列转换方法 chicony 行列转换
    create table tb(终端名称 varchar(10) , CEI分值 varchar(10) , 终端数量 int) insert into tb values('三星' , '0-5' , 74) insert into tb values('三星' , '10-15' , 83) insert into tb values('苹果' , '0-5' , 93)
  • 中文编码测试 ctrain 编码
    循环打印转换编码 String[] codes = { "iso-8859-1", "utf-8", "gbk", "unicode" }; for (int i = 0; i < codes.length; i++) { for (int j
  • hive 客户端查询报堆内存溢出解决方法 daizj hive堆内存溢出
    hive> select * from t_test where ds=20150323 limit 2; OK Exception in thread "main" java.lang.OutOfMemoryError: Java heap space   问题原因： hive堆内存默认为256M   这个问题的解决方法为： 修改/us
  • 人有多大懒，才有多大闲 (评论『卓有成效的程序员』) dcj3sjt126com 程序员
      卓有成效的程序员给我的震撼很大，程序员作为特殊的群体，有的人可以这么懒，  懒到事情都交给机器去做 ，而有的人又可以那么勤奋，每天都孜孜不倦得做着重复单调的工作。   在看这本书之前，我属于勤奋的人，而看完这本书以后，我要努力变成懒惰的人。 不要在去庞大的开始菜单里面一项一项搜索自己的应用程序，也不要在自己的桌面上放置眼花缭乱的快捷图标
  • Eclipse简单有用的配置 dcj3sjt126com eclipse
    1、显示行号  Window -- Prefences -- General -- Editors -- Text Editors -- show line numbers   2、代码提示字符 Window ->Perferences，并依次展开 Java -> Editor -> Content Assist，最下面一栏 auto-Activation
  • 在tomcat上面安装solr4.8.0全过程 eksliang Solrsolr4.0后的版本安装solr4.8.0安装
    转载请出自出处： http://eksliang.iteye.com/blog/2096478       首先solr是一个基于java的web的应用，所以安装solr之前必须先安装JDK和tomcat，我这里就先省略安装tomcat和jdk了         第一步：当然是下载去官网上下载最新的solr版本，下载地址
  • Android APP通用型拒绝服务、漏洞分析报告 gg163 漏洞androidAPP分析
    点评：记得曾经有段时间很多SRC平台被刷了大量APP本地拒绝服务漏洞，移动安全团队爱内测（ineice.com）发现了一个安卓客户端的通用型拒绝服务漏洞，来看看他们的详细分析吧。  0xr0ot和Xbalien交流所有可能导致应用拒绝服务的异常类型时，发现了一处通用的本地拒绝服务漏洞。该通用型本地拒绝服务可以造成大面积的app拒绝服务。  针对序列化对象而出现的拒绝服务主要
  • HoverTree项目已经实现分层 hvt 编程.netWebC#ASP.ENT
    HoverTree项目已经初步实现分层，源代码已经上传到 http://hovertree.codeplex.com请到SOURCE CODE查看。在本地用SQL Server 2008 数据库测试成功。数据库和表请参考：http://keleyi.com/a/bjae/ue6stb42.htmHoverTree是一个ASP.NET 开源项目，希望对你学习ASP.NET或者C#语言有帮助，如果你对
  • Google Maps API v3: Remove Markers 移除标记 天梯梦 google maps api
    Simply do the following:   I. Declare a global variable: var markersArray = [];   II. Define a function: function clearOverlays() { for (var i = 0; i < markersArray.length; i++ )
  • jQuery选择器总结 lq38366 jquery选择器
      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
  • 基础数据结构和算法六：Quick sort sunwinner AlgorithmQuicksort
    Quick sort is probably used more widely than any other. It is popular because it is not difficult to implement, works well for a variety of different kinds of input data, and is substantially faster t
  • 如何让Flash不遮挡HTML div元素的技巧_HTML/Xhtml_网页制作 刘星宇 htmlWeb
    今天在写一个flash广告代码的时候，因为flash自带的链接，容易被当成弹出广告，所以做了一个div层放到flash上面，这样链接都是a触发的不会被拦截，但发现flash一直处于div层上面，原来flash需要加个参数才可以。 让flash置于DIV层之下的方法，让flash不挡住飘浮层或下拉菜单，让Flash不档住浮动对象或层的关键参数：wmode=opaque。 方法如下：
  • Mybatis实用Mapper SQL汇总示例 wdmcygah sqlmysqlmybatis实用
    Mybatis作为一个非常好用的持久层框架，相关资料真的是少得可怜，所幸的是官方文档还算详细。本博文主要列举一些个人感觉比较常用的场景及相应的Mapper SQL写法，希望能够对大家有所帮助。 不少持久层框架对动态SQL的支持不足，在SQL需要动态拼接时非常苦恼，而Mybatis很好地解决了这个问题，算是框架的一大亮点。对于常见的场景，例如：批量插入/更新/删除，模糊查询，多条件查询，联表查询，
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他