本文转载自:https://blog.csdn.net/zl18310999566/article/details/54341057

之前说了集成的ActiveMQ，那就再说说集成另一个很火的MQ，兔子。

本文示例主要参看官方的演示

https://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples/spring-boot-sample-amqp

https://github.com/spring-projects/spring-amqp-samples

的RabbitMQ

介绍

的RabbitMQ是流行的开源消息队列系统，用二郎语言开发.RabbitMQ是AMQP（高级消息队列协议）的标准实现。

概念

经纪人：简单来说就是消息队列服务器实体。
外汇：消息交换机，它指定消息按什么规则，路由到哪个队列。
队列：消息队列载体，每个消息都会被投入到一个或多个队列。
绑定：绑定，它的作用就是把交换和队列按照路由规则绑定起来。
路由密钥：路由关键字，交换根据这个关键字进行消息投递。
虚拟主机：虚拟主机，一个经纪人里可以开设多个虚拟主机，用作不同用户的权限分离。
制片人：消息生产者，就是投递消息的程序。
消费者：消息消费者，就是接受消息的程序。
信道：消息通道，在客户端的每个连接里，可建立多个信道，每个信道代表一个会话任务。

使用过程

客户端连接到消息队列服务器，打开一个信道。
客户端声明一个交换，并设置相关属性。
客户端声明一个队列，并设置相关属性。
客户端使用路由密钥，在交换和队列之间建立好绑定关系。
客户端投递消息到交换。

交换接收到消息后，就根据消息的关键和已经设置的结合，进行消息路由，将消息投递到一个或多个队列里。

exchange也有几个类型，完全根据key进行投递的叫做直接交换机，例如，绑定时设置了routing key为“abc”，那么客户端提交的消息，只有设置了key为“abc”的才会投递到队列。对按键进行模式匹配后进行投递的叫做主题交换机，符号”＃”匹配一个或多个词，符号” *”匹配正好一个词。例如” ABC。＃”匹配” abc.def.ghi” “ABC *”只匹配” abc.def”。还有一种不需要钥匙的，叫做扇出交换机，它采取广播模式，一个消息进来时，投递到与该交换机绑定的所有队列。

。RabbitMQ的支持消息的持久化，也就是数据写在磁盘上，为了数据安全考虑，我想大多数用户都会选择持久化消息队列持久化包括3个部分：

exchange持久化，在声明时指定durable => 1
队列持久化，在声明时指定耐用=> 1
消息持久化，在投递时指定delivery_mode => 2（1是非持久化）

如果交换和队列都是持久化的，那么它们之间的结合也是持久化的。如果交换和队列两者之间有一个持久化，一个非持久化，就不允许建立绑定。

以上内容抄自百岁百科，RabbitMQ百度百科

其它关于RabbitMQ的介绍的看可以 http://www.cnblogs.com/qiyebao/p/4205626.html

Spring-boot集成rabbitmq

添加Maven的依赖

[html] 查看纯文本 
< dependency >  
      < groupId > org.springframework.boot </ groupId >  
      < artifactId > spring-boot-starter-amqp </ artifactId >  
</ dependency >  

简单实现

配置

在application.properties中增加如下配置

[纯] 查看纯文本 
spring.rabbitmq.addresses = 127.0.0.1：5672  
spring.rabbitmq.username =客人  
spring.rabbitmq.password =客人  
spring.rabbitmq.publisher-确认=真  
spring.rabbitmq.virtual主机= /  

RabbitMQ的端口说明：5672-AMQP，25672聚类，61613-蹬地，1883年，MQTT

消息生产者

[java] 查看纯文本 
包 com.rabbitmq.send;  
  
import  org.springframework.amqp.rabbit.core.RabbitTemplate;  
import  org.springframework.beans.factory.annotation.Autowired;  
import  org.springframework.stereotype.Component;  
  
@零件  
公共类 发件人{   
  
    @Autowired  
    私人 兔子模板rabbitTemplate;  
  
    public void  send（String msg）{   
        这个.rabbitTemplate.convertAndSend（“foo” ，msg）;  
    }  
}  

消息监听者

[java] 查看纯文本 
包 com.rabbitmq.listener;  
  
导入 org.slf4j.Logger;  
import  org.slf4j.LoggerFactory;  
import  org.springframework.amqp.core.Queue;  
import  org.springframework.amqp.rabbit.annotation.RabbitHandler;  
import  org.springframework.amqp.rabbit.annotation.RabbitListener;  
import  org.springframework.context.annotation.Bean;  
import  org.springframework.context.annotation.Configuration;  
import  org.springframework.messaging.handler.annotation.Payload;  
  
@组态  
@RabbitListener （queues =  “foo” ）  
公共类 Listener {   
  
    私人静态最终 记录器记录仪= LoggerFactory.getLogger（监听器。类）;    
  
    @豆  
    公共 队列fooQueue（）{  
        返回新的 队列（“foo” ）;   
    }  
  
    @RabbitHandler  
    public void  process（@Payload  String foo）{   
        LOGGER.info（“Listener：”  + foo）;  
    }  
}  

测试控制器

[java] 查看纯文本 
包 com.rabbitmq.controller;  
  
import  com.rabbitmq.send.Sender;  
import  org.springframework.beans.factory.annotation.Autowired;  
import  org.springframework.web.bind.annotation.GetMapping;  
import  org.springframework.web.bind.annotation.RestController;  
  
import  javax.servlet.http.HttpServletRequest;  
  
@RestController  
公共类 RabbitmqController {   
  
    @Autowired  
    私人 发件人发件人;  
  
    @GetMapping （“/ send” ）  
    公共 字符串发送（HttpServletRequest请求，字符串味精）{  
        sender.send（MSG）;  
        返回“发送OK”。;   
    }  
}  

测试

启动服务，在浏览器输入http://127.0.0.1:8080/send?msg=this%20is%20a%20test，点击回车可以在控制台看到如下输出

[纯] 查看纯文本 
INFO 5559 --- [cTaskExecutor-1] c.rabbitmq.listener.Listener：Listener：这是一个测试  
[SimpleAsyncTaskExecutor-1]信息c.rabbitmq.listener.Listener - Listener：这是一个测试  

带ConfirmCallback的使用

增加回调处理，这里不再使用application.properties默认配置的方式，会在程序中显示的使用文件中的配置信息。

配置

[java] 查看纯文本 
包 com.rabbitmq.config;  
  
import  org.springframework.amqp.rabbit.connection.CachingConnectionFactory;  
import  org.springframework.amqp.rabbit.connection.ConnectionFactory;  
import  org.springframework.amqp.rabbit.core.RabbitTemplate;  
import  org.springframework.beans.factory.annotation.Value;  
import  org.springframework.beans.factory.config.ConfigurableBeanFactory;  
import  org.springframework.context.annotation.Bean;  
import  org.springframework.context.annotation.Configuration;  
import  org.springframework.context.annotation.Scope;  
  
@组态  
公共类 AmqpConfig {   
  
    public static final  String FOO_EXCHANGE =  “callback.exchange.foo” ;    
    public static final  String FOO_ROUTINGKEY =  “callback.routingkey.foo” ;    
    public static final  String FOO_QUEUE =  “callback.queue.foo” ;    
  
    @Value （“$ { spring.rabbitmq.addresses }” ）  
    私人 字符串地址;  
    @Value （“$ { spring.rabbitmq.username }” ）  
    私人 字符串用户名  
    @Value （“$ { spring.rabbitmq.password }” ）  
    私人 字符串密码;  
    @Value （“$ { spring.rabbitmq.virtual -host}” ）  
    私人 字符串virtualHost;  
    @Value （“$ { spring.rabbitmq.publisher -confirms}” ）  
    私人布尔 publisherConfirms;   
  
    @豆  
    public  ConnectionFactory connectionFactory（）{  
        CachingConnectionFactory connectionFactory =  new  CachingConnectionFactory（）;  
        connectionFactory.setAddresses（地址）;  
        connectionFactory.setUsername（用户名）;  
        connectionFactory.setPassword（密码）;  
        connectionFactory.setVirtualHost（虚拟主机）;  
        / **如果要进行消息回调，则这里必须要设置为true * /  
        connectionFactory.setPublisherConfirms（publisherConfirms）;  
        返回 connectionFactory;  
    }  
  
    @豆  
    / **因为要设置回调类，所以应该是prototype类型，如果是单例类型，则回调类为最后一次设置* /  
    @Scope （ConfigurableBeanFactory.SCOPE_PROTOTYPE）  
    public  RabbitTemplate rabbitTemplate（）{  
        RabbitTemplate template =  new  RabbitTemplate（connectionFactory（））;  
        返回 模板;  
    }  
  
}  

消息生产者

[java] 查看纯文本 
包 com.rabbitmq.send;  
  
import  com.rabbitmq.config.AmqpConfig;  
导入 org.slf4j.Logger;  
import  org.slf4j.LoggerFactory;  
import  org.springframework.amqp.rabbit.core.RabbitTemplate;  
import  org.springframework.amqp.rabbit.support.CorrelationData;  
import  org.springframework.beans.factory.annotation.Autowired;  
import  org.springframework.stereotype.Component;  
  
import  java.util.UUID;  
  
@零件  
公共类 发件人  实现 RabbitTemplate.ConfirmCallback {   
  
    私人静态最终 记录器记录仪= LoggerFactory.getLogger（发件人。类）;    
  
    私人 兔子模板rabbitTemplate;  
  
    @Autowired  
    公共 发件人（RabbitTemplate rabbitTemplate）{  
        这个.rabbitTemplate = rabbitTemplate;  
        这个.rabbitTemplate.setConfirmCallback（this ）;  
    }  
  
    public void  send（String msg）{   
        CorrelationData correlationData =  new  CorrelationData（UUID.randomUUID（）。toString（））;  
        LOGGER.info（“send：”  + correlationData.getId（））;  
        这个.rabbitTemplate.convertAndSend（AmqpConfig.FOO_EXCHANGE，AmqpConfig.FOO_ROUTINGKEY，msg，correlationData）;  
    }  
  
    / **回调方法* /  
    @覆盖  
    public void  confirm（CorrelationData correlationData，  boolean  ack，String cause）{   
        LOGGER.info（“confirm：”  + correlationData.getId（））;  
    }  
}  

消息监听者

[java] 查看纯文本 
包 com.rabbitmq.listener;  
  
import  com.rabbitmq.config.AmqpConfig;  
导入 org.slf4j.Logger;  
import  org.slf4j.LoggerFactory;  
import  org.springframework.amqp.core.Binding;  
import  org.springframework.amqp.core.BindingBuilder;  
import  org.springframework.amqp.core.DirectExchange;  
import  org.springframework.amqp.core.Queue;  
import  org.springframework.amqp.rabbit.annotation.RabbitHandler;  
import  org.springframework.amqp.rabbit.annotation.RabbitListener;  
import  org.springframework.context.annotation.Bean;  
import  org.springframework.context.annotation.Configuration;  
import  org.springframework.messaging.handler.annotation.Payload;  
  
@组态  
@RabbitListener （队列= AmqpConfig.FOO_QUEUE）  
公共类 Listener {   
  
    私人静态最终 记录器记录仪= LoggerFactory.getLogger（监听器。类）;    
  
    / **设置交换机类型* /  
    @豆  
    public  DirectExchange defaultExchange（）{  
        / ** 
         * DirectExchange：按照路由密钥分发到指定队列 
         * TopicExchange：多关键字匹配 
         * FanoutExchange：将消息分发到所有的绑定队列，无路由密钥的概念 
         * HeadersExchange：通过添加属性键值匹配 
         * /  
        返回新的 DirectExchange（AmqpConfig.FOO_EXCHANGE）;   
    }  
  
    @豆  
    公共 队列fooQueue（）{  
        返回新的 队列（AmqpConfig.FOO_QUEUE）;   
    }  
  
    @豆  
    公共 绑定绑定（）{  
        / **将队列绑定到交换机* /  
         用（AmqpConfig.FOO_ROUTINGKEY）返回BindingBuilder.bind（fooQueue（））。（defaultExchange（））。  
    }  
  
    @RabbitHandler  
    public void  process（@Payload  String foo）{   
        LOGGER.info（“Listener：”  + foo）;  
    }  
}  

或者使用下面的代码来代替@RabbitHandler注解的工艺方法

[java] 查看纯文本 
@豆  
public  SimpleMessageListenerContainer messageContainer（）{  
    SimpleMessageListenerContainer container =  new  SimpleMessageListenerContainer（connectionFactory（））;  
    container.setQueues（fooQueue（））;  
    container.setExposeListenerChannel（true ）;  
    container.setMaxConcurrentConsumers（1 ）;  
    container.setConcurrentConsumers（1 ）;  
    container.setAcknowledgeMode（AcknowledgeMode.MANUAL）; //设置确认模式手工确认  
    container.setMessageListener（new  ChannelAwareMessageListener（）{  
  
        @覆盖  
        public void  onMessage（Message message，Channel channel）  throws  Exception {   
            byte [] body = message.getBody（）;  
            LOGGER.info（“Listener onMessage：”  +  new  String（body））;  
            channel.basicAck（message.getMessageProperties（）。getDeliveryTag（），  false ）; //确认消息成功消费  
        }  
    }）;  
    返回 容器;  
}  

参看这里了这篇博文 http://blog.csdn.net/liaokailin/article/details/49559571

测试

运行服务，刷新上面的测试链接，可以在控制台看到如下输出

[纯] 查看纯文本 
INFO 15122 --- [nio-8080-exec-1] com.jikefriend.rabbitmq.send.Sender：send：c678afb7-af8b-42b2-9370-ea7f9d6004a0  
[http-nio-8080-exec-1] INFO com.jikefriend.rabbitmq.send.Sender - send：c678afb7-af8b-42b2-9370-ea7f9d6004a0  
INFO 15122 --- [127.0.0.1:5672] com.jikefriend.rabbitmq.send.Sender：confirm：c678afb7-af8b-42b2-9370-ea7f9d6004a0  
[AMQP Connection 127.0.0.1:5672] INFO com.jikefriend.rabbitmq.send.Sender - confirm：c678afb7-af8b-42b2-9370-ea7f9d6004a0  
INFO 15122 --- [cTaskExecutor-1] c.jikefriend.rabbitmq.listener.Listener：Listener：这是一个测试  
[SimpleAsyncTaskExecutor-1]信息cjrabbitmq.listener.Listener - Listener：这是一个测试 

spring-boot 集成 rabbitmq

的RabbitMQ

介绍

概念

使用过程

Spring-boot集成rabbitmq

添加Maven的依赖

简单实现

配置

消息生产者

消息监听者

测试控制器

测试

带ConfirmCallback的使用

配置

消息生产者

消息监听者

测试

猜你喜欢