SpringBoot集成Rabbitmq [交换机消息确认，路有消息确认，原型（多例）引用]

最新推荐文章于 2023-03-16 16:12:02 发布

帅是一辈子的事

最新推荐文章于 2023-03-16 16:12:02 发布

阅读量256

点赞数

分类专栏： MQ RabbitMQ 文章标签： java

本文链接：https://blog.csdn.net/CSDN_WXQ/article/details/111246796

版权

RabbitMQ 同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

1 篇文章 0 订阅

订阅专栏

SpringBoot集成Rabbitmq入门使用

Rabbitmq是什么
入门使用
总结

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 "发送成功";
    }
}

总结

帅是一辈子的事

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot集成Rabbitmq [交换机消息确认，路有消息确认，原型（多例）引用]

SpringBoot集成Rabbitmq入门使用Rabbitmq是什么MQ：AMQP协议：JMS：总结：入门使用创建工程导入依赖启动类创建配置文件消息确认总结Rabbitmq是什么MQ：即消息队列，Rabbitmq是erlang语言开发，基于AMQP协议实现消息队列，高并发性能好，任务异步处理，程序解耦。AMQP协议：高级消息队列协议，应用层协议开放标准，基于协议的客户端和消息中间件消息传递，不限制开发语言，跨语言使用。与JMS不同，JMS是java语言专属的消息服务标准，在api层定义标准，只
复制链接

扫一扫