RabbitMQ

最新推荐文章于 2024-03-13 13:28:08 发布

Feng_ZiYou

最新推荐文章于 2024-03-13 13:28:08 发布

阅读量284

点赞数

分类专栏：常用技术点解析文章标签： java

本文链接：https://blog.csdn.net/Feng_ZiYou/article/details/107424844

版权

常用技术点解析专栏收录该内容

10 篇文章 0 订阅

订阅专栏

消息中间件RabbitMQ
RabbitMQ 是一个由 Erlang 语言开发的 AMQP 的开源实现,并不是由java语言开发的.
消息中间件（消息队列）是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量削锋等问题实现高性能，高可用，可伸缩和最终一致性[架构] 使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ
如果不使用消息中间件,服务之间直接交互,则是同步的操作,效率低,如果有了消息中间件,服务之间就是异步通信,并且服务之间解耦合

为什么使用RabbitMQ呢？
1、使得简单，功能强大。
2、基于AMQP协议。
3、社区活跃，文档完善。
4、高并发性能好，这主要得益于Erlang语言。
5、Spring Boot默认已集成RabbitMQ

以下介绍消息队列在实际应用中常用的使用场景：异步处理，应用解耦，流量削锋和消息通讯四个场景
架构图

RabbitMQ安装与启动
1.下载并安装 Erlang
2.下载并安装rabbitmq
注意不要安装在包含中文和空格的目录下！安装后window服务中就存在rabbitMQ了，并且是启动状态。
3.安装管理界面（插件）
通过cmd进入rabbitMQ安装目录的sbin目录，输入命令
rabbitmq‐plugins enable rabbitmq_management
4.重新启动服务
5.打开浏览器，地址栏输入http://127.0.0.1:15672(rubbitMQ服务的端口默认为5672) ,即可看到管理界面的登陆页,输入用户名和密码，都为guest 进入主界面

注意:
当卸载重新安装时会出现RabbitMQ服务注册失败，此时需要进入注册表清理erlang搜索RabbitMQ、ErlSrv，将对应的项全部删除。

RabbitMQ发送与接收消息
直接模式（Direct）
我们需要将消息发给唯一一个节点时使用这种模式，这是最简单的一种形式。
任何发送到Direct Exchange的消息都会被转发到RouteKey中指定的Queue。
1.一般情况可以使用rabbitMQ自带的Exchange：”"(该Exchange的名字为空字符串，下文称其为default Exchange)。
2.这种模式下可以不需要将Exchange进行任何绑定(binding)操作
3.消息传递时需要一个“RouteKey”，可以简单的理解为要发送到的队列名字。(直接模式中的RouteKey就是队列的名称)
4.如果vhost中不存在RouteKey中指定的队列名，则该消息会被抛弃。

代码实现-消息生产者
1.pom.xml添加依赖：

<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring‐rabbit</artifactId>
<version>2.1.4.RELEASE</version>
</dependency>

2.编写配置文件applicationContext-rabbitmq-producer.xml

<beans  .../>
<!‐‐连接工厂‐‐>
<rabbit:connection‐factory id="connectionFactory" host="127.0.0.1" port="5672" username="guest" password="guest" />
<rabbit:template id="rabbitTemplate" connection‐factory="connectionFactory" />
</beans>

3.编写测试代码Test1

ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext‐rabbitmq‐producer.xml");
RabbitTemplate rabbitTemplate=(RabbitTemplate)context.getBean("rabbitTemplate"); //实际工程中不需要通过spring上下文获取,直接注入
rabbitTemplate.convertAndSend("","quest.test","直接模式"); //直接模式可以使用默认的交换器,名字为空字符串
((ClassPathXmlApplicationContext) context).close();

代码实现-消息消费者
1.编写消息监听类

public class MessageConsumer implements MessageListener {
public void onMessage(Message message) {
System.out.println("接收到消息：" +new String(message.getBody()));  //message.getBody())得到的是一个字节数组,需要转为字符串
}
}

2.创建配置文件applicationContext-rabbitmq-consumer.xml

<beans    ...  />
<!‐‐连接工厂‐‐>
<rabbit:connection‐factory id="connectionFactory" host="127.0.0.1" port="5672" username="guest" password="guest"/>
<!‐‐队列‐‐>
<rabbit:queue name="queue.test" />
<!‐‐消费者监听类‐‐>
<bean id="messageConsumer" class="cn.itcast.demo.MessageConsumer">
</bean>
<!‐‐设置监听容器‐‐>
<rabbit:listener‐container connection‐factory="connectionFactory" acknowledge="auto" >
<rabbit:listener queue‐names="queue.test" ref="messageConsumer"/>  //容器一加载,消息监听类就会去监听quest.test队列
</rabbit:listener‐container>
</beans>

3.编写测试代码Test2
启动spring容器, 消息监听类就会去监听quest.test队列

ApplicationContext context=newClassPathXmlApplicationContext("applicationContext‐rabbitmq‐consumer.xml");

分列模式（Fanout）
当我们需要将消息一次发给多个队列时，需要使用这种模式。
比如:
我们的商品即存储在数据库中也存储在ES中,如果数据库中的商品修改了,需要将数据同步到ES中,用来搜索,并且需要重新生成商品详细页,
这时候可以使用分列模式,当商品数据修改时,将数据发送到分列模式的交换器中,该交换器绑定两个队列,这时候数据会发送到两个队列中,
创立两个消费者分别监听这两个队列,一个监听到消息后进行重新导入索引到ES,另一个重新生成商品详细页

一般情况下,消费者监听类在监听到消息后都需要对消息进行逻辑处理

任何发送到Fanout Exchange的消息都会被转发到与该Exchange绑定(Binding)的所有Queue上。
1.这种模式需要提前将Exchange与Queue进行绑定，一个Exchange可以绑定多个Queue，一个Queue可以同多个Exchange进行绑定。
2.这种模式不需要RouteKey(在rabbitMQ中进行绑定队列)
3.如果接受到消息的Exchange没有与任何Queue绑定，则消息会被抛弃。因为交换器不能存储消息

注:交换器是可以和交换机进行绑定的,消息发送到一个交换机,该交换器会把消息发送给绑定的交换器,最后再发送给队列

代码实现-消息生产者
先创建队列queue.test1 和queue.test2
创建交换器exchange.fanout_test，并绑定queue.test1和queue.test2
编写代码

ApplicationContext context=newClassPathXmlApplicationContext("applicationContext‐rabbitmq‐producer.xml");
RabbitTemplate rabbitTemplate=(RabbitTemplate)context.getBean("rabbitTemplate");
rabbitTemplate.convertAndSend("exchange.fanout_test","","分列模式走起");
((ClassPathXmlApplicationContext) context).close();

测试代码，发现队列queue.test1 和queue.test2都收到消息

代码实现-消息消费者
1.将MessageConsumer复制为MessageConsumer1和MessageConsumer2。
2.修改applicationContext-rabbitmq-consumer.xml，增加配置

<rabbit:queue name="queue.test1" />
<rabbit:queue name="queue.test2" />
<bean id="messageConsumer1" class="cn.itcast.demo.MessageConsumer1">
</bean>
<bean id="messageConsumer2" class="cn.itcast.demo.MessageConsumer2">
</bean>

3.修改applicationContext-rabbitmq-consumer.xml的
<!‐‐设置监听容器‐‐>

<rabbit:listener‐container connection‐factory="connectionFactory" >
<rabbit:listener queue‐names="queue.test" ref="messageConsumer"/>
<rabbit:listener queue‐names="queue.test1" ref="messageConsumer1"/>
<rabbit:listener queue‐names="queue.test2" ref="messageConsumer2"/>
</rabbit:listener‐container>

测试：启动Test2测试
结果:两个消费者都监听到了消息

通过配置文件的方式来创建队列与交换器
之前都是需要在rabbitMQ中通过手动的方式来创建队列和交换器,现在通过配置文件来创建
修改配置文件applicationContext-rabbitmq-producer.xml

<!‐‐rabbitAdmin 封装管理操作‐‐>
<rabbit:admin connection‐factory="connectionFactory"></rabbit:admin>
<!‐‐创建队列‐‐>
<rabbit:queue name="queue.test1" />
<!‐‐创建队列‐‐>
<rabbit:queue name="queue.test2" />
<!‐‐创建分发交换器 ‐‐>
<rabbit:fanout‐exchange name="exchange.fanout_test" >
<rabbit:bindings>
<rabbit:binding queue="queue.test1"></rabbit:binding>   绑定队列1
<rabbit:binding queue="queue.test2"></rabbit:binding>   绑定队列2
</rabbit:bindings>
</rabbit:fanout‐exchange>

spingBoot整合RabbitMQ
使用spring-boot-starter-amqp会自动添加spring-rabbit依赖，如下：

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐amqp</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐test</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐logging</artifactId>
</dependency>

1、配置application.yml
配置连接rabbitmq的参数

server:
  port: 44000
spring:
  application:
    name: test‐rabbitmq‐producer
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtualHost: /

2、定义RabbitConfig类，配置Exchange、Queue、及绑定交换机。本例配置Topic交换机。

package com.xuecheng.test.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 QUEUE_INFORM_EMAIL = "queue_inform_email";
public static final String QUEUE_INFORM_SMS = "queue_inform_sms";
public static final String EXCHANGE_TOPICS_INFORM="exchange_topics_inform";
/**
* 交换机配置
* ExchangeBuilder提供了fanout、direct、topic、header交换机类型的配置
* @return the exchange
*/
@Bean(EXCHANGE_TOPICS_INFORM)
public Exchange EXCHANGE_TOPICS_INFORM() {
//durable(true)持久化，消息队列重启后交换机仍然存在
return ExchangeBuilder.topicExchange(EXCHANGE_TOPICS_INFORM).durable(true).build();
}
//声明队列
@Bean(QUEUE_INFORM_SMS)
public Queue QUEUE_INFORM_SMS() {
Queue queue = new Queue(QUEUE_INFORM_SMS);
return queue;
}
//声明队列
@Bean(QUEUE_INFORM_EMAIL)
public Queue QUEUE_INFORM_EMAIL() {
Queue queue = new Queue(QUEUE_INFORM_EMAIL);
return queue;
}
/** channel.queueBind(INFORM_QUEUE_SMS,"inform_exchange_topic","inform.#.sms.#");
* 绑定队列到交换机 .
*
* @param queue the queue
* @param exchange the exchange
* @return the binding
*/
@Bean
public Binding BINDING_QUEUE_INFORM_SMS(@Qualifier(QUEUE_INFORM_SMS) Queue queue, //从spring容器中取出队列和交换机
										@Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange) { //使用名称注入Bean用@Qualifier注解
return BindingBuilder.bind(queue).to(exchange).with("inform.#.sms.#").noargs(); //with后面的参数为routingKey
}
@Bean
public Binding BINDING_QUEUE_INFORM_EMAIL(@Qualifier(QUEUE_INFORM_EMAIL) Queue queue,
@Qualifier(EXCHANGE_TOPICS_INFORM) Exchange exchange) {
return BindingBuilder.bind(queue).to(exchange).with("inform.#.email.#").noargs();
}
}

生产端
使用RarbbitTemplate发送消息生成者只需要配置交换机即可, 具体发到哪个队列由routingKey决定

package com.xuecheng.test.rabbitmq;
import com.xuecheng.test.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
@RunWith(SpringRunner.class)
public class Producer05_topics_springboot {
@Autowired
RabbitTemplate rabbitTemplate;
@Test
public void testSendByTopics(){
for (int i=0;i<5;i++){
String message = "sms email inform to user"+i;
//参数分别为交换机,routingKey,消息,交换机已经在配置类中绑定了队列
rabbitTemplate.convertAndSend(RabbitmqConfig.EXCHANGE_TOPICS_INFORM,"inform.sms.email",message); 
System.out.println("Send Message is:'" + message + "'");
}
}
}

消费端
创建消费端工程，添加依赖：

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐amqp</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐test</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐logging</artifactId>
</dependency>

使用@RabbitListener注解监听队列

package com.xuecheng.test.rabbitmq.mq;
import com.rabbitmq.client.Channel;
import com.xuecheng.test.rabbitmq.config.RabbitmqConfig;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class ReceiveHandler {
//监听email队列
@RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_EMAIL})
public void receive_email(String msg,Message message,Channel channel){
System.out.println(msg);
}
//监听sms队列
@RabbitListener(queues = {RabbitmqConfig.QUEUE_INFORM_SMS})
public void receive_sms(String msg,Message message,Channel channel){
System.out.println(msg);
}
}