RabbitMQ实战

RabbitMQ 作为目前应用相当广泛的消息中间件，在企业级应用、微服务应用中充当着重要的角色。特别是在一些典型的应用场景以及业务模块中具有重要的作用，比如业务服务模块解耦、异步通信、高并发限流、超时业务、数据延迟处理等。

其中课程的学习链接地址：RabbitMQ实战教程-@rabbitlistener,rabbitlistener-Java视频教程-编程语言-CSDN程序员研修院 

RabbitMQ 官网拜读

首先，让我们先拜读 RabbitMQ 官网的技术开发手册以及相关的 Features，感兴趣的朋友可以耐心的阅读其中的相关介绍，相信会有一定的收获，地址可见：

RabbitMQ Tutorials — RabbitMQ

阅读该手册过程中，我们可以得知 RabbitMQ 其实核心就是围绕 “消息模型” 来展开的，其中就包括了组成消息模型的相关组件：生产者，消费者，队列，交换机，路由，消息等！而我们在实战应用中，实际上也是紧紧围绕着 “消息模型” 来展开撸码的！

下面，我就介绍一下这一消息模型的演变历程，当然，这一历程在 RabbitMQ 官网也是可以窥览得到的！

上面几个图就已经概述了几个要点，而且，这几个要点的含义可以说是字如其名！

1. 生产者：发送消息的程序
2. 消费者：监听接收消费消息的程序
3. 消息：一串二进制数据流
4. 队列：消息的暂存区/存储区
5. 交换机：消息的中转站，用于接收分发消息。其中有 fanout、direct、topic、headers 四种
6. 路由：相当于密钥/第三者，与交换机绑定即可路由消息到指定的队列！

正如上图所展示的消息模型的演变，接下来我们将以代码的形式实战各种典型的业务场景！

SpringBoot 整合 RabbitMQ 实战

工欲善其事，必先利其器。我们首先需要借助 IDEA 的 Spring Initializr 用 Maven 构建一个 SpringBoot 的项目，并引入 RabbitMQ、Mybatis、Log4j 等第三方框架的依赖。搭建完成之后，可以简单的写个 RabbitMQController 测试一下项目是否搭建是否成功（可以暂时用单模块方式构建）

紧接着，我们进入实战的核心阶段，在项目或者服务中使用 RabbitMQ，其实无非是有几个核心要点要牢牢把握住，这几个核心要点在撸码过程中需要“时刻的游荡在自己的脑海里”，其中包括：

1. 我要发送的消息是什么
2. 我应该需要创建什么样的消息模型：DirectExchange+RoutingKey？TopicExchange+RoutingKey？等
3. 我要处理的消息是实时的还是需要延时/延迟的？
4. 消息的生产者需要在哪里写，消息的监听消费者需要在哪里写，各自的处理逻辑是啥

基于这样的几个要点，我们先小试牛刀一番，采用 RabbitMQ 实战异步写日志与异步发邮件。当然啦，在进行实战前，我们需要安装好 RabbitMQ 及其后端控制台应用，并在项目中配置一下 RabbitMQ 的相关参数以及相关 Bean 组件。

RabbitMQ 安装完成后，打开后端控制台应用：http://localhost:15672  输入guest guest 登录，看到下图即表示安装成功

然后是项目配置文件层面的配置 application.properties

1. spring.rabbitmq.host=127.0.0.1

2. spring.rabbitmq.port=5672

3. spring.rabbitmq.username=guest

4. spring.rabbitmq.password=guest

5. spring.rabbitmq.listener.concurrency=10

6. spring.rabbitmq.listener.max-concurrency=20

7. spring.rabbitmq.listener.prefetch=5

其中，后面三个参数主要是用于“并发量的配置”，表示：并发消费者的初始化值，并发消费者的最大值，每个消费者每次监听时可拉取处理的消息数量。

接下来，我们需要以 Configuration 的方式配置 RabbitMQ 并以 Bean 的方式显示注入 RabbitMQ 在发送接收处理消息时相关 Bean 组件配置其中典型的配置是 RabbitTemplate 以及 SimpleRabbitListenerContainerFactory，前者是充当消息的发送组件，后者是用于管理  RabbitMQ监听器listener 的容器工厂，其代码如下：

1. @Configuration

2. public class RabbitmqConfig {

3. private static final Logger log= LoggerFactory.getLogger(RabbitmqConfig.class);

5. @Autowired

6. private Environment env;

8. @Autowired

9. private CachingConnectionFactory connectionFactory;

11. @Autowired

12. private SimpleRabbitListenerContainerFactoryConfigurer factoryConfigurer;

14. /**

15. * 单一消费者

16. * @return

17. */

18. @Bean(name = "singleListenerContainer")

19. public SimpleRabbitListenerContainerFactory listenerContainer(){

20. SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();

21. factory.setConnectionFactory(connectionFactory);

22. factory.setMessageConverter(new Jackson2JsonMessageConverter());

23. factory.setConcurrentConsumers(1);

24. factory.setMaxConcurrentConsumers(1);

25. factory.setPrefetchCount(1);

26. factory.setTxSize(1);

27. factory.setAcknowledgeMode(AcknowledgeMode.AUTO);

28. return factory;

29. }

31. /**

32. * 多个消费者

33. * @return

34. */

35. @Bean(name = "multiListenerContainer")

36. public SimpleRabbitListenerContainerFactory multiListenerContainer(){

37. SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();

38. factoryConfigurer.configure(factory,connectionFactory);

39. factory.setMessageConverter(new Jackson2JsonMessageConverter());

40. factory.setAcknowledgeMode(AcknowledgeMode.NONE);

41. factory.setConcurrentConsumers(env.getProperty("spring.rabbitmq.listener.concurrency",int.class));

42. factory.setMaxConcurrentConsumers(env.getProperty("spring.rabbitmq.listener.max-concurrency",int.class));

43. factory.setPrefetchCount(env.getProperty("spring.rabbitmq.listener.prefetch",int.class));

44. return factory;

45. }

47. @Bean

48. public RabbitTemplate rabbitTemplate(){

49. connectionFactory.setPublisherConfirms(true);

50. connectionFactory.setPublisherReturns(true);

51. RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);

52. rabbitTemplate.setMandatory(true);

53. rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {

54. @Override

55. public void confirm(CorrelationData correlationData, boolean ack, String cause) {

56. log.info("消息发送成功:correlationData({}),ack({}),cause({})",correlationData,ack,cause);

57. }

58. });

59. rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {

60. @Override

61. public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {

62. log.info("消息丢失:exchange({}),route({}),replyCode({}),replyText({}),message:{}",exchange,routingKey,replyCode,replyText,message);

63. }

64. });

65. return rabbitTemplate;

66. }}

RabbitMQ 实战：业务模块解耦以及异步通信

在一些企业级系统中，我们经常可以见到一个执行 function 通常是由许多子模块组成的，这个 function 在执行过程中，需要 同步的将其代码从头开始执行到尾，即执行流程是 module_A -> module_B -> module_C -> module_D，典型的案例可以参见汇编或者 C 语言等面向过程语言开发的应用，现在的一些 JavaWeb 应用也存在着这样的写法。

而我们知道，这个执行流程其实对于整个 function 来讲是有一定的弊端的，主要有几点：

1. 整个 function 的执行响应时间将很久；
2. 如果某个 module 发生异常而没有处理得当，可能会影响其他 module 甚至整个 function 的执行流程与结果；
3. 整个 function 中代码可能会很冗长，模块与模块之间可能需要进行强通信以及数据的交互，出现问题时难以定位与维护，甚至会陷入 “改一处代码而动全身”的尴尬境地！

故而，我们需要想办法进行优化，我们需要将强关联的业务模块解耦以及某些模块之间实行异步通信！下面就以两个场景来实战我们的优化措施！

场景一：异步记录用户操作日志

对于企业级应用系统或者微服务应用中，我们经常需要追溯跟踪记录用户的操作日志，而这部分的业务在某种程度上是不应该跟主业务模块耦合在一起的，故而我们需要将其单独抽出并以异步的方式与主模块进行异步通信交互数据。

下面我们就用 RabbitMQ 的 DirectExchange+RoutingKey 消息模型也实现“用户登录成功记录日志”的场景。如前面所言，我们需要在脑海里回荡着几个要点：

• 消息模型：DirectExchange+RoutingKey 消息模型
• 消息：用户登录的实体信息，包括用户名，登录事件，来源的IP，所属日志模块等信息
• 发送接收：在登录的 Controller 中实现发送，在某个 listener 中实现接收并将监听消费到的消息入数据表；实时发送接收

首先我们需要在上面的 RabbitmqConfig 类中创建消息模型：包括 Queue、Exchange、RoutingKey 等的建立，代码如下：

上图中 env 获取的信息，我们需要在 application.properties 进行配置，其中 mq.env=local

此时，我们将整个项目/服务跑起来，并打开 RabbitMQ 后端控制台应用，即可看到队列以及交换机及其绑定已经建立好了，如下所示：

接下来，我们需要在 Controller 中执行用户登录逻辑，记录用户登录日志，查询获取用户角色视野资源信息等，由于篇幅关系，在这里我们重点要实现的是用MQ实现 “异步记录用户登录日志” 的逻辑，即在这里 Controller 将充当“生产者”的角色，核心代码如下：

1. @RestController

2. public class UserController {

4. private static final Logger log= LoggerFactory.getLogger(HelloWorldController.class);

6. private static final String Prefix="user";

8. @Autowired

9. private ObjectMapper objectMapper;

11. @Autowired

12. private UserMapper userMapper;

14. @Autowired

15. private UserLogMapper userLogMapper;

17. @Autowired

18. private RabbitTemplate rabbitTemplate;

20. @Autowired

21. private Environment env;

23. @RequestMapping(value = Prefix+"/login",method = RequestMethod.POST,consumes = MediaType.MULTIPART_FORM_DATA_VALUE)

24. public BaseResponse login(@RequestParam("userName") String userName,@RequestParam("password") String password){

25. BaseResponse response=new BaseResponse(StatusCode.Success);

26. try {

27. //TODO：执行登录逻辑

28. User user=userMapper.selectByUserNamePassword(userName,password);

29. if (user!=null){

30. //TODO：异步写用户日志

31. try {

32. UserLog userLog=new UserLog(userName,"Login","login",objectMapper.writeValueAsString(user));

33. userLog.setCreateTime(new Date());

34. rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());

35. rabbitTemplate.setExchange(env.getProperty("log.user.exchange.name"));

36. rabbitTemplate.setRoutingKey(env.getProperty("log.user.routing.key.name"));

38. Message message=MessageBuilder.withBody(objectMapper.writeValueAsBytes(userLog)).setDeliveryMode(MessageDeliveryMode.PERSISTENT).build();

39. message.getMessageProperties().setHeader(AbstractJavaTypeMapper.DEFAULT_CONTENT_CLASSID_FIELD_NAME, MessageProperties.CONTENT_TYPE_JSON);

40. rabbitTemplate.convertAndSend(message);

41. }catch (Exception e){

42. e.printStackTrace();

43. }

45. //TODO：塞权限数据-资源数据-视野数据

46. }else{

47. response=new BaseResponse(StatusCode.Fail);

48. }

49. }catch (Exception e){

50. e.printStackTrace();

51. }

52. return response;

53. }}

在上面的“发送逻辑”代码中，其实也体现了我们最开始介绍的演进中的几种消息模型，比如我们是将消息发送到 Exchange 的而不是 Queue，消息是以二进制流的形式进行传输等等。当用 postman 请求到这个 controller 的方法时，我们可以在 RabbitMQ 的后端控制台应用看到一条未确认的消息，通过 GetMessage 即可看到其中的详情，如下：

最后，我们将开发消费端的业务代码，如下：

1. @Component

2. public class CommonMqListener {

4. private static final Logger log= LoggerFactory.getLogger(CommonMqListener.class);

6. @Autowired

7. private ObjectMapper objectMapper;

9. @Autowired

10. private UserLogMapper userLogMapper;

12. @Autowired

13. private MailService mailService;

15. /**

16. * 监听消费用户日志

17. * @param message

18. */

19. @RabbitListener(queues = "${log.user.queue.name}",containerFactory = "singleListenerContainer")

20. public void consumeUserLogQueue(@Payload byte[] message){

21. try {

22. UserLog userLog=objectMapper.readValue(message, UserLog.class);

23. log.info("监听消费用户日志 监听到消息： {} ",userLog);

24. //TODO：记录日志入数据表

25. userLogMapper.insertSelective(userLog);

26. }catch (Exception e){

27. e.printStackTrace();

28. }

29. }

将服务跑起来之后，我们即可监听消费到上面 Queue 中的消息，即当前用户登录的信息，而且，我们也可以看到“记录用户登录日志”的逻辑是由一条异于主业务线程的异步线程去执行的：

“异步记录用户操作日志”的案例我想足以用于诠释上面所讲的相关理论知识点了，在后续篇章中，由于篇幅限制，我将重点介绍其核心的业务逻辑！

场景二：异步发送邮件

发送邮件的场景，其实也是比较常见的，比如用户注册需要邮箱验证，用户异地登录发送邮件通知等等，在这里我以 RabbitMQ 实现异步发送邮件。实现的步骤跟场景一几乎一致！

1. 消息模型的创建

2. 配置信息的创建

3. 生产端

4. 消费端

RabbitMQ 实战：并发量配置与消息确认机制

实战背景

对于消息模型中的 listener 而言，默认情况下是“单消费实例”的配置，即“一个 listener 对应一个消费者”，这种配置对于上面所讲的“异步记录用户操作日志”、“异步发送邮件”等并发量不高的场景下是适用的。但是在对于秒杀系统、商城抢单等场景下可能会显得很吃力！

我们都知道，秒杀系统跟商城抢单均有一个共同的明显的特征，即在某个时刻会有成百上千万的请求到达我们的接口，即瞬间这股巨大的流量将涌入我们的系统，我们可以采用下面一图来大致体现这一现象：

当到了“开始秒杀”、“开始抢单”的时刻，此时系统可能会出现这样的几种现象：

• 应用系统配置承载不了这股瞬间流量，导致系统直接挂掉，即传说中的“宕机”现象；
• 接口逻辑没有考虑并发情况，数据库读写锁发生冲突，导致最终处理结果跟理论上的结果数据不一致（如商品存库量只有 100，但是高并发情况下，实际表记录的抢到的用户记录数据量却远远大于 100）；
• 应用占据服务器的资源直接飙高，如 CPU、内存、宽带等瞬间直接飙升，导致同库同表甚至可能同 host 的其他服务或者系统出现卡顿或者挂掉的现象；

于是乎，我们需要寻找解决方案！对于目前来讲，网上均有诸多比较不错的解决方案，在此我顺便提一下我们的应用系统采用的常用解决方案，包括：

• 我们会将处理抢单的整体业务逻辑独立、服务化并做集群部署；
• 我们会将那股巨大的流量拒在系统的上层，即将其转移至 MQ 而不直接涌入我们的接口，从而减少数据库读写锁冲突的发生以及由于接口逻辑的复杂出现线程堵塞而导致应用占据服务器资源飙升；
• 我们会将抢单业务所在系统的其他同数据源甚至同表的业务拆分独立出去服务化，并基于某种 RPC 协议走 HTTP 通信进行数据交互、服务通信等等；
• 采用分布式锁解决同一时间同个手机号、同一时间同个 IP 刷单的现象；

下面，我们用 RabbitMQ 来实战上述的第二点！即我们会在“请求” -> "处理抢单业务的接口" 中间架一层消息中间件做“缓冲”、“缓压”处理，如下图所示：

并发量配置与消息确认机制

正如上面所讲的，对于抢单、秒杀等高并发系统而言，如果我们需要用 RabbitMQ 在 “请求” - “接口” 之间充当限流缓压的角色，那便需要我们对 RabbitMQ 提出更高的要求，即支持高并发的配置，在这里我们需要明确一点，“并发消费者”的配置其实是针对 listener 而言，当配置成功后，我们可以在 MQ 的后端控制台应用看到 consumers 的数量，如下所示：

其中，这个 listener 在这里有 10 个 consumer 实例的配置，每个 consumer 可以预监听消费拉取的消息数量为 5 个（如果同一时间处理不完，会将其缓存在 mq 的客户端等待处理！）

另外，对于某些消息而言，我们有时候需要严格的知道消息是否已经被 consumer 监听消费处理了，即我们有一种消息确认机制来保证我们的消息是否已经真正的被消费处理。在 RabbitMQ 中，消息确认处理机制有三种：Auto - 自动、Manual - 手动、None - 无需确认，而确认机制需要 listener 实现 ChannelAwareMessageListener 接口，并重写其中的确认消费逻辑。在这里我们将用 “手动确认” 的机制来实战用户商城抢单场景。

1.在 RabbitMQConfig 中配置确认消费机制以及并发量的配置

2.消息模型的配置信息

3.RabbitMQ 后端控制台应用查看此队列的并发量配置

4.listener 确认消费处理逻辑：在这里我们需要开发抢单的业务逻辑，即“只有当该商品的库存 >0 时，抢单成功，扣减库存量，并将该抢单的用户信息记录入表，异步通知用户抢单成功！”

紧接着我们采用 CountDownLatch 模拟产生高并发时的多线程请求（或者采用 jmeter 实施压测也可以！），每个请求将携带产生的随机数：充当手机号 -> 充当消息，最终入抢单队列！在这里，我模拟了 50000 个请求，相当于 50000 手机号同一时间发生抢单的请求，而设置的产品库存量为 100，这在 product 数据库表即可设置

6.将抢单请求的手机号信息压入队列，等待排队处理

7.在最后我们写个 Junit 或者写个 Controller，进行 initService.generateMultiThread(); 调用模拟产生高并发的抢单请求即可

1. @RestController

2. public class ConcurrencyController {

4. private static final Logger log= LoggerFactory.getLogger(HelloWorldController.class);

6. private static final String Prefix="concurrency";

8. @Autowired

9. private InitService initService;

11. @RequestMapping(value = Prefix+"/robbing/thread",method = RequestMethod.GET)

12. public BaseResponse robbingThread(){

13. BaseResponse response=new BaseResponse(StatusCode.Success);

14. initService.generateMultiThread();

15. return response;

16. }}

8.最后，我们当然是跑起来，在控制台我们可以观察到系统不断的在产生新的请求（线程）– 相当于不断的有抢单的手机号涌入我们的系统，然后入队列，listener 监听到请求之后消费处理抢单逻辑！最后我们可以观察两张数据库表：商品库存表、商品成功抢单的用户记录表 - 只有当库存表中商品对应的库存量为 0、商品成功抢单的用户记录刚好 100 时 即表示我们的实战目的以及效果已经达到了！！

总结：如此一来，我们便将 request 转移到我们的 mq，在一定程度缓解了我们的应用以及接口的压力！当然，实际情况下，我们的配置可能远远不只代码层次上的配置，比如我们的 mq 可能会做集群配置、负载均衡、商品库存的更新可能会考虑分库分表、库存更新可能会考虑独立为库存 Dubbo 服务并通过 Rest Api 异步通信交互并独立部署等等。这些优化以及改进的目的其实无非是为了能限流、缓压、保证系统稳定、数据的一致等！而我们的 MQ，在其中可以起到不可磨灭的作用，其字如其名：“消息队列”，而队列具有 “先进先出” 的特点，故而所有进入 MQ 的消息都将 “乖巧” 的在 MQ 上排好队，先来先排队，先来先被处理消费，由此一来至少可以避免 “瞬间时刻一窝蜂的 request 涌入我们的接口” 的情况！