Rabbitmq是什么
MQ:
即消息队列,Rabbitmq是erlang语言开发,基于AMQP协议实现消息队列,高并发性能好,任务异步处理,程序解耦。
AMQP协议:
高级消息队列协议,应用层协议开放标准,基于协议的客户端和消息中间件消息传递,不限制开发语言,跨语言使用。与JMS不同,JMS是java语言专属的消息服务标准,在api层定义标准,只能用于Java
JMS:
java提出的一套消息服务API标准,类似JDBC的作用含义,只要遵循JMS标准的应用程序之间,都可以进行消息通讯。
总结:
Rabbitmq是由Erlang语言开发基于AMQP协议的消息中间件
入门使用
创建工程导入依赖
<!--父工程-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.4.RELEASE</version>
</parent>
<dependencies>
<!--Web-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--Rabbitmq-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
</dependencies>
启动类创建
@SpringBootApplication
public class producer {
public static void main(String[] args) {
SpringApplication.run(producer.class,args);
System.out.println("==========结束==========");
}
}
配置文件 消息确认
#Rabbitmq
spring.rabbitmq.addresses=127.0.0.1
spring.rabbitmq.post=15672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.virtual-host=/
#确保生产者到交换器exchange消息有没有发送成功
spring.rabbitmq.publisher-confirm-type=correlated
#消息没有被路由到指定的queue时将消息返回,而不是丢弃
spring.rabbitmq.publisher-returns=true
#使用publisher-returns属性配置时通常会和mandatory属性配合一起使用:指定消息在没有被队列接收时是否强行退回还是直接丢弃
#mandatory属性优先级高于publisher-returns,会返回三种值null、false、true,
#mandatory结果为true、false时会忽略掉publisher-returns属性的值
#结果为null(即不配置)时结果由spring.rabbitmq.publisher-returns确定
spring.rabbitmq.template.mandatory=false
配置类
package com.honghu.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;
/**
* @ClassName RabbitmqConfig
* @Description TODO Rabbitmq配置类
* @Author HongHu
* @Date 2020/12/16 16:28
*/
@Configuration
public class RabbitmqConfig {
@Value("${spring.rabbitmq.addresses}")
private String addresses;
@Value("${spring.rabbitmq.username}")
private String username;
@Value("${spring.rabbitmq.password}")
private String password;
@Value("${spring.rabbitmq.virtual-host}")
private String virtualHost;
@Value("${spring.rabbitmq.port:15672}")
private Integer port;
/**
* 是否确认
*/
@Value("${spring.rabbitmq.publisher-confirm-type:correlated}")
private CachingConnectionFactory.ConfirmType publisherConfirms;
/**
* spring.rabbitmq.template.mandatory
* 消息发送失败,是否回调给发送者
*
* 当其值为true时,交换器无法根据自身的类型和路由键匹配到符合条件的队列,这时rabbitMQ就会通过回调函数将消息返回给生产者。
* 当其值为false时,如果出现上述情形,则消息会丢失
*/
@Value("${spring.rabbitmq.template.mandatory:false}")
private Boolean mandatory;
/**
* 如果mandatorys设置成true,该值也设置成true
*/
@Value("${spring.rabbitmq.publisher-returns:true}")
private Boolean publisherReturns;
private static final String HONGHUCEEXCHANGE = "HONGHUCEEXCHANGE";
private static final String HONGHUROUTING = "HONGHUROUTING";
private static final String HONGHUQUEUE = "HONGHUQUEUE";
@Bean
public ConnectionFactory connectionFactory() {
CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory();
cachingConnectionFactory.setAddresses(this.addresses);
cachingConnectionFactory.setUsername(this.username);
cachingConnectionFactory.setPassword(this.password);
cachingConnectionFactory.setVirtualHost(this.virtualHost);
cachingConnectionFactory.setPort(this.port);
cachingConnectionFactory.setPublisherConfirmType(this.publisherConfirms);
cachingConnectionFactory.setPublisherReturns(this.publisherReturns);
return cachingConnectionFactory;
}
/**
* 以工厂模式设置Rabbitmq为多例模式
* 避免同一个回调函数和其他函数被共用
* 综上所述只是我目前面临的问题,读者可以根据自己的需求灵活利用
* */
@Bean
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public RabbitTemplate rabbitTemplate() {
RabbitTemplate template = new RabbitTemplate(this.connectionFactory());
template.setMandatory(mandatory);
return template;
}
/**
* @return org.springframework.amqp.core.Exchange
* @Author HongHu
* @Description TODO 声明交换机
* @Date 16:52 2020/12/16
* @Param []
*/
@Bean(HONGHUCEEXCHANGE)
public Exchange exchangeDeclare() {
return ExchangeBuilder.directExchange(HONGHUCEEXCHANGE).durable(true).build();
}
/**
* @return org.springframework.amqp.core.Queue
* @Author HongHu
* @Description TODO 声明队列
* @Date 16:52 2020/12/16
* @Param []
*/
@Bean(value = HONGHUQUEUE)
public Queue queueDeclare() {
return QueueBuilder.durable(HONGHUQUEUE).build();
}
/**
* @return org.springframework.amqp.core.Binding
* @Author HongHu
* @Description TODO 交换机路由绑定
* @Date 16:52 2020/12/16
* @Param [queue, exchange]
*/
@Bean
public Binding exchangeToRouting(@Qualifier(HONGHUQUEUE) Queue queue, @Qualifier(HONGHUCEEXCHANGE) Exchange exchange) {
return BindingBuilder.bind(queue).to(exchange).with(HONGHUROUTING).noargs();
}
}
工具类
/**
* 优缺点:
* 因为spring创建默认的都是单例,所以
* 当前项目所有rabbitmqTemplate相关的调用都会共享这一个回调函数
* 如果公用一个回调函数,需要区分具体业务,可以correlationData来区分
* 或者设置rabbitmqTemplate的初始化类型为多例
*
* 目前已经是多例,解决多个rabbitmqTemplate共享回调函数
* 具体需求具体分析,目前我希望每一个业务处理的回调函数不公用,
* 故采用多例方式初始化RebbitmqTemplate
* */
@PostConstruct
public void init() {
// 开启路由失败消息回签
rabbitTemplate.setMandatory(true);
// 指定 ConfirmCallback
rabbitTemplate.setConfirmCallback(this);
//指定 ReturnCallback
rabbitTemplate.setReturnCallback(this);
}
发送工具类
package com.honghu.rabbitmq.thread;
import com.honghu.rabbitmq.config.RabbitmqConfig;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.time.LocalDateTime;
/**
* @ClassName RabbitmqSend
* @Description TODO MQ消息发送
* @Author HongHu
* @Date 2020/12/16 17:17
*/
@Component
public class RabbitmqSend implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnCallback{
@Autowired
private RabbitTemplate rabbitTemplate;
private String msg;
/**
* @Author HongHu
* @Description TODO 类初始化加载这个方法
* @Date 15:52 2020/12/18
* @Param []
* @return void
*/
@PostConstruct
public void init() {
// 开启消息不丢失模式
rabbitTemplate.setMandatory(true);
// 指定 ConfirmCallback
rabbitTemplate.setConfirmCallback(this);
//指定 ReturnCallback
rabbitTemplate.setReturnCallback(this);
}
/**
* @Author HongHu
* @Description TODO 消息发送
* @Date 16:02 2020/12/18
* @Param
* @return
*/
public void send(String msg){
CorrelationData correlationData = new CorrelationData(LocalDateTime.now().toString());
this.msg = msg;
rabbitTemplate.convertAndSend(RabbitmqConfig.HONGHUCEEXCHANGE, RabbitmqConfig.HONGHUROUTING, this.msg,correlationData);
}
/**
* @Author HongHu
* @Description TODO 队列路由消息确认
* @Date 15:47 2020/12/18
* @Param [correlationData, ack, cause]
* @return void
*/
@Override
public void confirm(CorrelationData correlationData, boolean ack, String cause) {
if(ack){
System.out.println("correlationData:"+correlationData+",ack:"+ack);
}else if(!ack){
System.out.println("错误信息:CUSTOMER_RISK消息发送交换机失败,correlationData:"+correlationData+",ack:"+ack+",cause:"+cause);
}
}
/**
* @Author HongHu
* @Description TODO 交换机消息确认
* @Date 15:48 2020/12/18
* @Param [message, replyCode, replyText, exchange, routingKey]
* @return void
*/
@Override
public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
System.out.println("错误信息:CUSTOMER_RISK消息找不到路由,交换机:"+exchange+",路由KEY:"+routingKey+",Rabbitmq错误码:"+replyCode+",Rabbitmq错误信息"+replyText+",=====消息体:"+new String(message.getBody()));
}
}
实际调用
package com.honghu.rabbitmq.controller;
import com.honghu.rabbitmq.thread.RabbitmqSend;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
* @ClassName ProductController
* @Description TODO
* @Author HongHu
* @Date 2020/12/16 15:14
*/
@RestController
@RequestMapping("/product")
public class ProductController {
@Resource
private RabbitmqSend rabbitmqSend;
@RequestMapping("/sendmsg.html/{msg}")
public String sendMsg(@PathVariable("msg")String msg){
try{
rabbitmqSend.send(msg);
}catch(Exception e){
e.printStackTrace();
return "发送失败";
}
return "发送成功";
}
}