rabbitMQ入门

1、安装

如果你是使用docker安装的rabbitmq，那简直不要太轻松愉快。

docker run -d --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:management

其中

• management是带有管理页面的版本
• 5672是AMQP端口
• 15672是web管理后台端口

安装成功后，访问ip:15672查看管理页面：

如果出现这个页面则表示安装成功，初始用户名和密码都是guest。

2、rabbitmq是什么，能解决什么问题

是什么

RabbitMQ是一个由Erlang语言编写的，实现了高级消息队列协议（AMQP）的消息中间件。

使用消息中间件解决什么问题？

消息中间件一般可以起到异步处理、应用解耦、流量控制的作用。

异步处理

假设有这么一个场景，用户注册成功后，需要给用户发送注册邮件和注册短信，如下：

这时我们可能会想到使用多线程异步编程来提升速度：

在异步编程中，异步任务的响应时间取决去处理时间最长的任务，因此响应时间为50ms+60ms=110ms。

使用消息队列异步处理

其实对于我们来说，只有将注册信息写入数据库这是必须的，而邮件和发短信迟一会也没事，因此可以这么做：

在这种方案中，我们只需要将注册消息写入到消息队列中即可，不必等待发送邮件和发送短信的执行，从而提高响应速度。

应用解耦

以订单系统为例，订单系统下完单后需要扣减库存，如果直接调用库存系统的接口，那么就会出现强耦合。

而如果直接将消息发给消息队列，让库存系统自己去订阅消息队列，这样就可以起到解耦的作用。

流量削峰

在秒杀活动中，有大量的请求过来，如果服务器照单全收，直接处理可能使系统压力过大，导致宕机，因此我们可以将请求先写入消息队列中，然后再由秒杀服务按照一定的速率处理消息队列中的消息。

3、rabbitmq的概念

消息模型

所有的MQ产品从模型抽象来说过程都是一样的：消费者（consumer）订阅某个队列，生产者（producer）创建消息，并发布到队列（queue）中，最后将消息发送给监听的消费者。

RabbitMQ基本概念

上面只是最简单抽象的描述，具体到 RabbitMQ 则有更详细的概念需要解释。上面介绍过 RabbitMQ 是 AMQP 协议的一个开源实现，所以其内部实际上也是 AMQP 中的基本概念：

• Message
  消息，消息是不具名的，它由消息头和消息体组成。消息体是不透明的，而消息头则由一系列的可选属性组成，这些属性包括routing-key（路由键）、priority（相对于其他消息的优先权）、delivery-mode（指出该消息可能需要持久性存储）等。
• Publisher
  消息的生产者，也是一个向交换器发布消息的客户端应用程序。
• Exchange
  交换器，用来接收生产者发送的消息并将这些消息路由给服务器中的队列。
• Binding
  绑定，用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则，所以可以将交换器理解成一个由绑定构成的路由表。
• Queue
  消息队列，用来保存消息直到发送给消费者。它是消息的容器，也是消息的终点。一个消息可投入一个或多个队列。消息一直在队列里面，等待消费者连接到这个队列将其取走。
• Connection
  网络连接，比如一个TCP连接。
• Channel
  信道，多路复用连接中的一条独立的双向数据流通道。信道是建立在真实的TCP连接内地虚拟连接，AMQP 命令都是通过信道发出去的，不管是发布消息、订阅队列还是接收消息，这些动作都是通过信道完成。因为对于操作系统来说建立和销毁 TCP 都是非常昂贵的开销，所以引入了信道的概念，以复用一条 TCP 连接。
• Consumer
  消息的消费者，表示一个从消息队列中取得消息的客户端应用程序。
• Virtual Host
  虚拟主机，表示一批交换器、消息队列和相关对象。虚拟主机是共享相同的身份认证和加密环境的独立服务器域。每个 vhost 本质上就是一个 mini 版的 RabbitMQ 服务器，拥有自己的队列、交换器、绑定和权限机制。vhost 是 AMQP 概念的基础，必须在连接时指定，RabbitMQ 默认的 vhost 是 / 。
• Broker
  表示消息队列服务器实体。

这些概念很多，但我认为没有必要死记，只要你能做到心中有图,消息在RabbitMQ内部结构图中是如何运转，这些概念自然也就记住了。

其中Channel如果你没有了解过NIO的话，可能不太容易了解。Virtual Host一般是每个应用对应一个，也可以用来分区开发环境和生产环境，即开发环境用一个Virtual Host，生产环境用一个Virtual Host。

4、springboot整合rabbitmq

整合rabbitmq

1、加入依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

2、编写配置文件

spring:
  rabbitmq:
    host: 192.168.243.136
    username: guest
    password: guest
    virtual-host: /

3、@EnableRabbit启动RabbitMQ功能

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

至此，我们已经整合完毕。接下来我们看看SpringBoot为我们自动配置了哪些内容。

@ConditionalOnClass({RabbitTemplate.class, Channel.class})
//RabbitProperties: rabbitmq的配置信息,可在配置文件中配置
@EnableConfigurationProperties({RabbitProperties.class})
@Import({RabbitAnnotationDrivenConfiguration.class})
public class RabbitAutoConfiguration {
	...
	@Configuration(
        proxyBeanMethods = false
    )
    @Import({RabbitAutoConfiguration.RabbitConnectionFactoryCreator.class})
    protected static class RabbitTemplateConfiguration {
        @Bean
        @ConditionalOnSingleCandidate(ConnectionFactory.class)
        @ConditionalOnMissingBean({RabbitOperations.class})
        public RabbitTemplate rabbitTemplate(RabbitProperties properties, ObjectProvider<MessageConverter> messageConverter, ObjectProvider<RabbitRetryTemplateCustomizer> retryTemplateCustomizers, ConnectionFactory connectionFactory) {
            PropertyMapper map = PropertyMapper.get();
            RabbitTemplate template = new RabbitTemplate(connectionFactory);
            messageConverter.ifUnique(template::setMessageConverter);
            template.setMandatory(this.determineMandatoryFlag(properties));
            Template templateProperties = properties.getTemplate();
            if (templateProperties.getRetry().isEnabled()) {
                template.setRetryTemplate((new RetryTemplateFactory((List)retryTemplateCustomizers.orderedStream().collect(Collectors.toList()))).createRetryTemplate(templateProperties.getRetry(), Target.SENDER));
            }

            templateProperties.getClass();
            map.from(templateProperties::getReceiveTimeout).whenNonNull().as(Duration::toMillis).to(template::setReceiveTimeout);
            templateProperties.getClass();
            map.from(templateProperties::getReplyTimeout).whenNonNull().as(Duration::toMillis).to(template::setReplyTimeout);
            templateProperties.getClass();
            map.from(templateProperties::getExchange).to(template::setExchange);
            templateProperties.getClass();
            map.from(templateProperties::getRoutingKey).to(template::setRoutingKey);
            templateProperties.getClass();
            map.from(templateProperties::getDefaultReceiveQueue).whenNonNull().to(template::setDefaultReceiveQueue);
            return template;
        }

        private boolean determineMandatoryFlag(RabbitProperties properties) {
            Boolean mandatory = properties.getTemplate().getMandatory();
            return mandatory != null ? mandatory : properties.isPublisherReturns();
        }

        @Bean
        @ConditionalOnSingleCandidate(ConnectionFactory.class)
        @ConditionalOnProperty(
            prefix = "spring.rabbitmq",
            name = {"dynamic"},
            matchIfMissing = true
        )
        @ConditionalOnMissingBean
        public AmqpAdmin amqpAdmin(ConnectionFactory connectionFactory) {
            return new RabbitAdmin(connectionFactory);
        }
    }
	....
}

我们可以看到Springboot为我们配置了RabbitTemplate 、AmqpAdmin(看有@Bean注解的方法) 因此我们可以直接使用。

@ConfigurationProperties(
    prefix = "spring.rabbitmq"
)
public class RabbitProperties {
    private String host = "localhost";
    private int port = 5672;
    private String username = "guest";
    private String password = "guest";
    ...

这是Springboot为我们配置的默认信息，我们可以通过配置文件进行修改，比如spring. rabbitmq.host=xxx就可以修改rabbitmq的连接地址。

操作rabbitmq

1、声明交换机、队列、绑定

前面我们知道SpringBoot已经为我们配置了AmqpAdmin，该类可以用来创建交换机、队列和绑定

    @Autowired
    AmqpAdmin amqpAdmin;
    
	//创建交换机
    @Test
    public void createExchange(){
         /**
         * 参数说明
         * String name: 交换机名称
         * boolean durable: 是否持久化。false交换机会在rabbitmq重启后丢失
         * boolean autoDelete: 是否自动删除。ture当交换机不再使用的时候会被删除
         * Map<String, Object> arguments: 额外参数
         */
        DirectExchange exchange = new DirectExchange("hello-java-exchange", true, false, null);
        amqpAdmin.declareExchange(exchange);
    }

	//创建队列
    @Test
    public void createQueue(){
   		 /**
         * 参数说明
         * String name: 队列名称
         * boolean durable: 是否持久化,队列声明默认是放在内存中的,如果rabbitmq重启就会丢失,如果想要重启之后还存在就要使队列持久化
         * boolean exclusive: 是否排他,排他指一个队列只能由一个消费者消费
         * boolean autoDelete: 是否自动删除,当最后一个消费者断开连接后是否自动删除
         * Map<String, Object> arguments: 额外参数
         */
        Queue queue = new Queue("hello-java-queue",true,false,false,null);
        amqpAdmin.declareQueue(queue);
    }

	//创建绑定
    @Test
    public void createBinding(){
        /**
         * String destination: 目的的名称
         * Binding.DestinationType destinationType: 目的地类型。交换机可以与交换机或队列进行绑定
         * String exchange: 交换机名称
         * String routingKey: 路由键
         * Map<String, Object> arguments: 额外参数
         */
        Binding binding = new Binding("hello-java-queue", Binding.DestinationType.QUEUE,"hello-java-exchange","hello-java",null);
        amqpAdmin.declareBinding(binding);
    }

2、发送消息

使用rabbitTemplate向rabbitmq发送消息

    @Autowired
    RabbitTemplate rabbitTemplate;
    
 	@Test
    public void sendMsg(){
        for (int i = 0;i < 10;i++){
            OrderItemEntity orderItemEntity = new OrderItemEntity();
            orderItemEntity.setOrderSn(i+"");
            //String exchange, String routingKey, Message message, @Nullable CorrelationData correlationData
            /**
             * 参数说明
             * String exchange: 交换机名称
             * String routingKey: 路由键
             * Message message: 交换机
             * CorrelationData correlationData: 消息的唯一标识(消息的ID)
             */
            rabbitTemplate.convertAndSend("hello-java-exchange","hello-java",orderItemEntity);
            log.info("发送{}消息成功",orderItemEntity);
        }
    }

使用JSON序列化机制进行消息转换
RabbitTemplate默认使用的是java序列化机制。

使用java序列化一方面是我们看不懂，另一方面是消费者可能不是java写的，那它就不能处理java序列化后的消息，因此我们应该使用JSON序列化机制进行消息转换。

进行如下配置即可。

 @Bean
 public Jackson2JsonMessageConverter jackson2JsonMessageConverter(){
     return new Jackson2JsonMessageConverter();
 }

3、监听队列

在@EnableRabbit的前提下，使用@RabbitListener和@RabbitHadnler注解可以实现对队列的监听。

区别：

• @RabbitListener：可以标记在类或方法上，指定监听哪些队列
• @RabbitHandler：标在方法上，可以重载区分不同的消息

接下来用例子来说明：

例1：

 	@RabbitListener(queues = "hello-java-queue")
    public void receiveMessage(Message message, OrderItemEntity orderItemEntity, Channel channel){
        //消息体：发送的消息
        byte[] body = message.getBody();
        //消息头属性
        MessageProperties properties = message.getMessageProperties();
        System.out.println("OrderItemEntity==> 接收的消息内容:"+orderItemEntity.getOrderSn()+",消息头:"+properties);
    }

@RabbitListener用在方法级别上，表示该方法消费hello-java-queue队列中的消息。

例2：

@Service
@RabbitListener(queues = "hello-java-queue")
public class OrderItemServiceImpl {
	@RabbitHandler
    public void receiveMessage(Message message, OrderItemEntity orderItemEntity, Channel channel){
        //消息体：发送的消息
        byte[] body = message.getBody();
        //消息头属性
        MessageProperties properties = message.getMessageProperties();
        System.out.println("OrderItemEntity==> 接收的消息内容:"+orderItemEntity.getOrderSn()+",消息头:"+properties);
}

    @RabbitHandler
    public void receiveMessage(Message message, OrderEntity orderEntity, Channel channel){
        //消息头属性
        MessageProperties properties = message.getMessageProperties();
        System.out.println("orderEntity==>  接收的消息内容:"+orderEntity.getOrderSn()+",消息头:"+properties);
    }
}

该案例中，@RabbitListener用在类级别上表示该类监听消费hello-java-queue队列中的消息。但是一个队列中可能有多个不同的类型的消息。在这种场景下，我们可以在方法参数中指明要消费的消息类型，并在方法上使用@RabbitHandler注解实现重载区分不同的方法。

文中部分内容摘抄自消息队列之 RabbitMQ