1.背景
RabbitMQ是一个由erlang开发的AMQP(Advanved Message Queue)的开源实现。
2.应用场景
2.1异步处理
场景说明：用户注册后，需要发注册邮件和注册短信,传统的做法有两种1.串行的方式;2.并行的方式
(1)串行方式:将注册信息写入数据库后,发送注册邮件,再发送注册短信,以上三个任务全部完成后才返回给客户端。 这有一个问题是,邮件,短信并不是必须的,它只是一个通知,而这种做法让客户端等待没有必要等待的东西.
(2)并行方式:将注册信息写入数据库后,发送邮件的同时,发送短信,以上三个任务完成后,返回给客户端,并行的方式能提高处理的时间。
假设三个业务节点分别使用50ms,串行方式使用时间150ms,并行使用时间100ms。虽然并性已经提高的处理时间,但是,前面说过,邮件和短信对我正常的使用网站没有任何影响，客户端没有必要等着其发送完成才显示注册成功,应该是写入数据库后就返回.
(3)消息队列
引入消息队列后，把发送邮件,短信不是必须的业务逻辑异步处理
由此可以看出,引入消息队列后，用户的响应时间就等于写入数据库的时间+写入消息队列的时间(可以忽略不计),引入消息队列后处理后,响应时间是串行的3倍,是并行的2倍。
2.2 应用解耦
场景：双11是购物狂节,用户下单后,订单系统需要通知库存系统,传统的做法就是订单系统调用库存系统的接口.
这种做法有一个缺点:
当库存系统出现故障时,订单就会失败。(这样马云将少赚好多好多钱^ ^)
订单系统和库存系统高耦合.
引入消息队列
订单系统:用户下单后,订单系统完成持久化处理,将消息写入消息队列,返回用户订单下单成功。
· 库存系统:订阅下单的消息,获取下单消息,进行库操作。
· 就算库存系统出现故障,消息队列也能保证消息的可靠投递,不会导致消息丢失(马云这下高兴了).
流量削峰：流量削峰一般在秒杀活动中应用广泛
场景:秒杀活动，一般会因为流量过大，导致应用挂掉,为了解决这个问题，一般在应用前端加入消息队列。
作用:
1.可以控制活动人数，超过此一定阀值的订单直接丢弃(我为什么秒杀一次都没有成功过呢^^)
2.可以缓解短时间的高流量压垮应用(应用程序按自己的最大处理能力获取订单)
1.用户的请求,服务器收到之后,首先写入消息队列,加入消息队列长度超过最大值,则直接抛弃用户请求或跳转到错误页面.
2.秒杀业务根据消息队列中的请求信息，再做后续处理.
3.系统架构
几个概念说明:
Broker:它提供一种传输服务,它的角色就是维护一条从生产者到消费者的路线，保证数据能按照指定的方式进行传输,
Exchange：消息交换机,它指定消息按什么规则,路由到哪个队列。
Queue:消息的载体,每个消息都会被投到一个或多个队列。
Binding:绑定，它的作用就是把exchange和queue按照路由规则绑定起来.
Routing Key:路由关键字,exchange根据这个关键字进行消息投递。
vhost:虚拟主机,一个broker里可以有多个vhost，用作不同用户的权限分离。
Producer:消息生产者,就是投递消息的程序.
Consumer:消息消费者,就是接受消息的程序.
Channel:消息通道,在客户端的每个连接里,可建立多个channel.
RabbitMQ提供了三种Exchange：fanout,direct,topic
性能排序：fanout > direct > topic
路由键（routing key）：消息发送给交换器时，消息将拥有一个路由键（默认为空），交换器根据这个路由键将消息发送到匹配的队列中。路由键是偏向生产端的概念。
绑定键（binding key）：队列需要通过绑定键（默认为空）绑定到交换器上，交换器将消息的路由键与所绑定队列的绑定键进行匹配，正确匹配的消息将发送到队列中。绑定键是偏向消费端的概念。
每条消息都有 routing key，当然可能为空，当消息到达 exchange 的时候， rabbitmq 会匹配消息的 routing key 和 binding key，如果匹配，就会转发到对应的 queue，如果不匹配，就会丢弃消息。
任何发送到Direct Exchange的消息都会被转发到RouteKey中指定的Queue。
1.一般情况可以使用rabbitMQ自带的Exchange：”"(该Exchange的名字为空字符串，下文称其为default Exchange)。
2.这种模式下不需要将Exchange进行任何绑定(binding)操作
3.消息传递时需要一个“RouteKey”，可以简单的理解为要发送到的队列名字。
4.如果vhost中不存在RouteKey中指定的队列名，则该消息会被抛弃。
如果路由键（routing key）匹配成功，消息就被投递到对应的各个队列，绑定键（binding key）不支持“*”和“#”。消费者在接受消息的信道上可以给生产者反馈。
当 routing key 和 binding key 相同时，消息就会转发到绑定的 queue。
需要注意的是：如果有两个 queue 绑定到一个 exchange，并且 binding key 一样，那么消息会发到两个 queue。默认情况下，rabbitmq 会有 name 为空的 exchange，类型为 direct，当 declare 一个 queue 的时候，默认会绑定到这个 exchange，binding key 是 queue name。
任何发送到Fanout Exchange的消息都会被转发到与该Exchange绑定(Binding)的所有Queue上。
1.可以理解为路由表的模式
2.这种模式不需要RouteKey
3.这种模式需要提前将Exchange与Queue进行绑定，一个Exchange可以绑定多个Queue，一个Queue可以同多个Exchange进行绑定。
4.如果接受到消息的Exchange没有与任何Queue绑定，则消息会被抛弃。
fanout 当 exchange 类型是 fanout 的时候，并不需要（routing key）路由键，发送到该 exchange 的消息会自动转发给所有绑定的 queues ，也就是说每个 queue 都会收到一份消息。队列不存在绑定键（binding key），消费者在接受消息的当前信道上可以给生产者反馈。
任何发送到Topic Exchange的消息都会被转发到所有关心RouteKey中指定话题的Queue上
1.这种模式较为复杂，简单来说，就是每个队列都有其关心的主题，所有的消息都带有一个“标题”(RouteKey)，Exchange会将消息转发到所有关注主题能与RouteKey模糊匹配的队列。
2.这种模式需要RouteKey，也许要提前绑定Exchange与Queue。
3.在进行绑定时，要提供一个该队列关心的主题，如“#.log.#”表示该队列关心所有涉及log的消息(一个RouteKey为”MQ.log.error”的消息会被转发到该队列)。
4.“#”表示0个或若干个关键字，“*”表示一个关键字。如“log.*”能与“log.warn”匹配，无法与“log.warn.timeout”匹配；但是“log.#”能与上述两者匹配。
5.同样，如果Exchange没有发现能够与RouteKey匹配的Queue，则会抛弃此消息。
存在（routing key）路由键，消息以广播的形式发送到绑定键（bing key）匹配的各个队列，绑定键（binding key）支持“*”和“#”。
routing key 和原来一样，不过 binding key 的名字中可以使用三种特殊的符号：.、*、#。. 把 binding key 分割成不同的单词（word），* 匹配一个单词，# 可以匹配 0 个或者任意多个单词。
1，首先引入配置文件org.springframework.amqp，如下：
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit</artifactId>
<version>1.2.0.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.rabbitmq/amqp-client -->
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>5.2.0</version>
</dependency>
2，准备工作：安装好rabbitmq,并在项目中增加配置文件 rabbit.properties 内容如下：
rmq.ip=192.188.113.114
rmq.port=5672
rmq.producer.num=20
rmq.manager.user=admin
rmq.manager.password=admin
3，配置spring-rabbitmq.xml，内容如下：
<!-- 公共部分 -->
<!-- 创建连接类 连接安装好的 rabbitmq -->
<bean id="connectionFactory" class="org.springframework.amqp.rabbit.connection.CachingConnectionFactory">
<constructor-arg value="localhost" />
<!-- username,访问RabbitMQ服务器的账户,默认是guest -->
<property name="username" value="${rmq.manager.user}" />
<!-- username,访问RabbitMQ服务器的密码,默认是guest -->
<property name="password" value="${rmq.manager.password}" />
<!-- host,RabbitMQ服务器地址，默认值"localhost" -->
<property name="host" value="${rmq.ip}" />
<!-- port，RabbitMQ服务端口，默认值为5672 -->
<property name="port" value="${rmq.port}" />
<!-- channel-cache-size，channel的缓存数量，默认值为25 -->
<property name="channel-cache-size" value="50" />
<!-- cache-mode，缓存连接模式，默认值为CHANNEL(单个connection连接，连接之后关闭，自动销毁) -->
<property name="cache-mode" value="CHANNEL" />
</bean>
<!--或者这样配置，connection-factory元素实际就是注册一个org.springframework.amqp.rabbit.connection.CachingConnectionFactory实例
<rabbit:connection-factory id="connectionFactory" host="${rmq.ip}" port="${rmq.port}"
username="${rmq.manager.user}" password="${rmq.manager.password}" />-->
<rabbit:admin connection-factory="connectionFactory"/>
<!--定义消息队列,durable:是否持久化，如果想在RabbitMQ退出或崩溃的时候，不会失去所有的queue和消息，需要同时标志队列(queue)和交换机(exchange)是持久化的，即rabbit:queue标签和rabbit:direct-exchange中的durable=true,而消息(message)默认是持久化的可以看类org.springframework.amqp.core.MessageProperties中的属性public static final MessageDeliveryMode DEFAULT_DELIVERY_MODE = MessageDeliveryMode.PERSISTENT;exclusive: 仅创建者可以使用的私有队列，断开后自动删除；auto_delete: 当所有消费客户端连接断开后，是否自动删除队列 -->
<rabbit:queue name="spittle.alert.queue.1" id="queue_1" durable="true" auto-delete="false" exclusive="false" />
<rabbit:queue name="spittle.alert.queue.2" id="queue_2" durable="true" auto-delete="false" exclusive="false" />
<rabbit:queue name="spittle.alert.queue.3" id="queue_3" durable="true" auto-delete="false" exclusive="false" />
<!--绑定队列,rabbitmq的exchangeType常用的三种模式：direct，fanout，topic三种,我们用direct模式，即rabbit:direct-exchange标签，Direct交换器很简单，如果是Direct类型，就会将消息中的RoutingKey与该Exchange关联的所有Binding中的BindingKey进行比较，如果相等，则发送到该Binding对应的Queue中。有一个需要注意的地方：如果找不到指定的exchange，就会报错。但routing key找不到的话，不会报错，这条消息会直接丢失，所以此处要小心,auto-delete:自动删除，如果为Yes，则该交换机所有队列queue删除后，自动删除交换机，默认为false -->
<rabbit:direct-exchange id="spittle.fanout" name="spittle.fanout" durable="true" auto-delete="false">
<rabbit:bindings>
<rabbit:binding queue="spittle.alert.queue.1" key="{alert.queue.1}"></rabbit:binding>
<rabbit:binding queue="spittle.alert.queue.2" key="{alert.queue.2}"></rabbit:binding>
<rabbit:binding queue="spittle.alert.queue.3" key="{alert.queue.3}"></rabbit:binding>
</rabbit:bindings>
</rabbit:fanout-exchange>
<!-- 生产者部分 -->
<!-- 发送消息的producer类，也就是生产者 -->
<bean id="msgProducer" class="com.asdf.sdf.ClassA">
<!-- value中的值就是producer中的的routingKey，也就是队列名称，它与上面的rabbit:bindings标签中的key必须相同 -->
<property name="queueName" value="{alert.queue.1}"/>
</bean>
<!-- spring amqp默认的是jackson 的一个插件,目的将生产者生产的数据转换为json存入消息队列，由于fastjson的速度快于jackson,这里替换为fastjson的一个实现 -->
<bean id="jsonMessageConverter" class="com.jy.utils.FastJsonMessageConverter"></bean>
<!-- 或者配置jackson -->
<!--
<bean id="jsonMessageConverter" class="org.springframework.amqp.support.converter.Jackson2JsonMessageConverter" />
-->
<rabbit:template exchange="test-exchange" id="rabbitTemplate" connection-factory="connectionFactory" message-converter="jsonMessageConverter" />
<!-- 消费者部分 -->
<!-- 自定义接口类 -->
<bean id="testHandler" class="com.rabbit.TestHandler"></bean>
<!-- 用于消息的监听的代理类MessageListenerAdapter -->
<bean id="testQueueListenerAdapter" class="org.springframework.amqp.rabbit.listener.adapter.MessageListenerAdapter" >
<!-- 类名 -->
<constructor-arg ref="testHandler" />
<!-- 方法名 -->
<property name="defaultListenerMethod" value="handlerTest"></property>
<property name="messageConverter" ref="jsonMessageConverter"></property>
</bean>
<!-- 配置监听acknowledeg="manual"设置手动应答，它能够保证即使在一个worker处理消息的时候用CTRL+C来杀掉这个worker，或者一个consumer挂了(channel关闭了、connection关闭了或者TCP连接断了)，也不会丢失消息。因为RabbitMQ知道没发送ack确认消息导致这个消息没有被完全处理，将会对这条消息做re-queue处理。如果此时有另一个consumer连接，消息会被重新发送至另一个consumer会一直重发,直到消息处理成功,监听容器acknowledge="auto" concurrency="30"设置发送次数,最多发送30次 -->
<rabbit:listener-container connection-factory="connectionFactory" acknowledge="auto" concurrency="20">
<rabbit:listener queues="spittle.alert.queue.1" ref="testQueueListenerAdapter" />
<rabbit:listener queues="spittle.alert.queue.2" ref="testQueueListenerAdapter" />
<rabbit:listener queues="spittle.alert.queue.2" ref="testQueueListenerAdapter" />
</rabbit:listener-container>
4，生产者（发送端）代码：
@Resource
private RabbitTemplate rabbitTemplate;
private String queueName;
public void sendMessage(CommonMessage msg){
try {
logger.error("发送信息开始");
System.out.println(rabbitTemplate.getConnectionFactory().getHost());
//发送信息 queueName交换机,就是上面的routingKey msg.getSource() 为 test_key
rabbitTemplate.convertAndSend(queueName,msg.getSource(), msg);
//如果是普通字符串消息需要先序列化，再发送消息
//rabbitTemplate.convertAndSend(queueName,msg.getSource(), SerializationUtils.serialize(msg));
logger.error("发送信息结束");
} catch (Exception e) {
e.printStackTrace();
}
}
public void setQueueName(String queueName) {
this.queueName = queueName;
}
5，消费端代码：TestHandler 类
public class TestHandler {
@Override
public void handlerTest(CommonMessage commonMessage) {
System.out.println("DetailQueueConsumer: " + new String(message.getBody()));
}
}
其他exchangeType介绍：
fanOut:
<!-- Fanout 扇出，顾名思义，就是像风扇吹面粉一样，吹得到处都是。如果使用fanout类型的exchange，那么routing key就不重要了。因为凡是绑定到这个exchange的queue，都会受到消息。 -->
<rabbit:fanout-exchange name="delayed_message_exchange" durable="true" auto-delete="false" id="delayed_message_exchange">
<rabbit:bindings>
<rabbit:binding queue="test_delay_queue"/>
</rabbit:bindings>
</rabbit:fanout-exchange>
topic：如果说direct是将消息放到exchange绑定的一个queue里（一对一）；fanout是将消息放到exchange绑定的所有queue里（一对所有）；那么topic类型的exchange就可以实现（一对部分），应用场景就是打印不同级别的错误日志，我们的系统出错后会根据不同的错误级别生成error_levelX.log日志，我们在后台首先要把所有的error保存在一个总的queue（绑定了一个*.error的路由键）里，然后再按level分别存放在不同的queue。
<!-- 发送端不是按固定的routing key发送消息，而是按字符串“匹配”发送，接收端同样如此 -->
<rabbit:topic-exchange name="message-exchange" durable="true" auto-delete="false" id="message-exchange">
<rabbit:bindings>
<rabbit:binding queue="Q1" pattern="error.*.log" />
<rabbit:binding queue="Q2" pattern="error.level1.log" />
<rabbit:binding queue="Q3" pattern="error.level2.log" />
</rabbit:bindings>
</rabbit:topic-exchange>
routing key绑定如下图：
参考大佬博客:
https://blog.csdn.net/nandao158/article/details/81065892
https://www.cnblogs.com/LipeiNet/p/6079427.html
https://www.toutiao.com/a6598154241037042189/?tt_from=mobile_qq&utm_campaign=client_share×tamp=1536277584&app=news_article&utm_source=mobile_qq&iid=43157585039&utm_medium=toutiao_android&group_id=6598154241037042189