RabbitMQ消息实现方案

已于 2024-01-25 11:32:50 修改
阅读量869 收藏 1
点赞数
文章标签： java-rabbitmq rabbitmq java
于 2022-08-01 18:19:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Boy_Martin/article/details/126104042
版权

目录

MQ消息的可靠投递

在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。官网描述几种模式地址：https://www.rabbitmq.com/getstarted.html

confirm 确认模式
return 退回模式

1、rabbitmq 整个消息投递的路径为：
producer—>rabbitmq broker—>exchange—>queue—>consumer
2、消息从 producer 到 exchange 则会返回一个 confirmCallback 。
3、消息从 exchange–>queue 投递失败则会返回一个 returnCallback 。

生产者的实现

public class Producer{
    @Autowired
    RabbitTemplate rabbitTemplate;
    @Autowired
    ConfirmCallback confirmCallback;
    @Autowired
    ReturnCallback returnCallback;
    @Autowired
    private CommonFeignClient commonFeignClient;

	/**
	* 推送MQ消息（第一种）不需要创建队列的MQ，可以队列创建在bean工厂里
	*/
    public void sendMail(String ex, String message) {
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setConfirmCallback(confirmCallback);
        rabbitTemplate.setReturnCallback(returnCallback);
        //第一个是参数交换机(exchange)的名字,第二个是路由键(routing-key)**的名字，第三个则为消息的内容
        rabbitTemplate.convertAndSend(ex, SysCode.BUSINESS.GROUP_KEY, message);
    }

	/**
     * 推送MQ消息（第二种）
     *
     * @param message
     * @return
     */
    public String sendMessage(MessageData message) {
        Connection connection = null;
        //创建信道
        Channel channel = null;
        try {
	        /**
		     * Mandatory为true时,消息通过交换器无法匹配到队列会返回给生产者
		     *          为false时,匹配不到会直接被丢弃
		     */
            rabbitTemplate.setMandatory(true);
            /**
             * 消费者确认收到消息后，手动ack回执回调处理
             */
            rabbitTemplate.setConfirmCallback(confirmCallback);
            /**
             * 消息投递到队列失败回调处理
             */
            rabbitTemplate.setReturnCallback(returnCallback);
            ConnectionFactory connectionFactory = rabbitTemplate.getConnectionFactory();
			//日志对象
            CommonInterfaceLog commonInterfaceLog = new CommonInterfaceLog();

            //创建连接
            connection = connectionFactory.createConnection();
            // 建立信道 构造参数 true代表该信道开启 Transactional 事务模式
 			// 此处传入true，就不需要再显示编码 channel.txSelect()了
 			// 内部已经调用了channle.txSelect();
            //创建信道
            channel = connection.createChannel(false);
            //在信道中设置交换器
            channel.exchangeDeclare(message.getEx(), ExchangeTypes.TOPIC, true);
            
            commonInterfaceLog.setCreateTime(new Date());
            commonInterfaceLog.setMqKey(message.getKey());
            commonInterfaceLog.setMqExchange(message  .getEx());
            commonInterfaceLog.setMqQueue(message.getQueue());
            commonInterfaceLog.setBusinessCode(message.getBusinessNumber());
            commonInterfaceLog.setSource(message.getSource());
            commonInterfaceLog.setMqReqType(ExchangeTypes.TOPIC);
            commonInterfaceLog.setRequestMessage(JSONObject.toJSONString(message.getMessageJsonStr()));
            commonInterfaceLog.setInterfaceType("MQ");
            //进行日志的写入
            commonFeignClient.commonInterfaceLogService(commonInterfaceLog);
            //发送消息
            log.info("------------pushMessageInfo[" + JSONObject.toJSONString(message.getMessageJsonStr()).getBytes().toString() + "]");
            channel.basicPublish(message.getEx(), message.getKey(),null, JSONObject.toJSONString(message.getMessageJsonStr()).getBytes());
            channel.close();
            connection.close();
        

            if(channel!=null||connection!=null){
                channel.clearConfirmListeners();
                channel.clearReturnListeners();
                connection.close();
            }
            return "------------pushMessageInfo[" + JSONObject.toJSONString(message.getMessageJsonStr()).getBytes().toString() + "]";
        } catch (Exception e) {
            log.info("MQ消息队列异常：" + message.getQueue() + ":" + message.getKey() + ":" + e.getMessage());
            e.printStackTrace();
            throw new RuntimeException("MQ消息队列异常：" + message.getQueue() + ":" + message.getKey() + ":" + e.getMessage());
        }
    }
}

ConfirmCallback 类的实现

//ConfirmCallback确认模式
@Slf4j
@Component
public class ConfirmCallback implements RabbitTemplate.ConfirmCallback {

    @Autowired
    RabbitTemplate rabbitTemplate;
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        if (ack && null != correlationData) {
            try{
                Message returnedMessage = correlationData.getReturnedMessage();
//                returnedMessage.getMessageProperties().getMessageId();
                log.info("消息发送成功:correlationData({}),ack({}),cause({})", new String(returnedMessage.getBody()), ack, cause);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            String uuid = rabbitTemplate.getUUID();
            log.info("消息发送失败:correlationData({}),ack({}),cause({}),uuid({})",correlationData.getReturnedMessage().getBody(),ack, cause,uuid);

        }
    }
}

ReturnCallback 类的实现

//ReturnCallback 退回模式
@Slf4j
@Component
public class ReturnCallback implements RabbitTemplate.ReturnCallback {


    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        log.info("消息退回 ===> replyCode={} ,replyText={} ,exchange={} ,routingKey={}", replyCode, replyText, exchange, routingKey);
    }
}

CommonfaceLog 日志表，根据自己的需求进行编写

@Data
@TableName("common_log")
public class CommonfaceLog implements Serializable {
    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    @TableId(value = "id", type = IdType.INPUT)
    private Integer id;
    /**
     * 业务编码
     */
    @TableField(value = "business_code")
    private String businessCode;
    /**
     * 接口名称
     */
    @TableField(value = "interface_name")
    private String interfaceName;
    /**
     * 接口类型
     */
    @TableField(value = "interface_type")
    private String interfaceType;
    /**
     * mq交换机
     */
    @TableField(value = "mq_exchange")
    private String mqExchange;
    /**
     * mq队列
     */
    @TableField(value = "mq_queue")
    private String mqQueue;
    /**
     * mq方式
     */
    @TableField(value = "mq_req_type")
    private String mqReqType;
    /**
     * topic_KEY
     */
    @TableField(value = "mq_key")
    private String mqKey;
    /**
     * 接口地址
     */
    @TableField(value = "interface_address")
    private String interfaceAddress;
    /**
     * 上次调用时间
     */
    @TableField(value = "last_call_time")
    private Date lastCallTime;
    /**
     * 请求报文
     */
    @TableField(value = "request_message")
    private String requestMessage;
    /**
     * 响应报文
     */
    @TableField(value = "response_message")
    private String responseMessage;
    /**
     * 失败次数
     */
    @TableField(value = "failures_number")
    private Integer failuresNumber;
    /**
     * 本次失败原因
     */
    @TableField(value = "this_failure_reasons")
    private String thisFailureReasons;
    /**
     * 创建时间
     */
    @TableField(value = "create_time")
    private Date createTime;
    /**
     * 请求状态
     */
    @TableField(value = "request_status")
    private Integer requestStatus;
    /**
     * 业务条线
     */
    @TableField(value = "source")
    private String source;
}

消费者的实现

@Log4j2
@Component("CarPolicysDirectListener")
public class CarPolicysDirectListener {
    @Autowired
    CoreSalesPolicysService coreSalesPolicysService;

    @Autowired
    CommonFeignClient commonFeignClient;

    @RabbitHandler
    @Qualifier("carPolicyListenerContainer") //指定消费的bean来控制消费者
    @RabbitListener( containerFactory = "carPolicysFactory", //bean名称，根据业务起
    		bindings = {@QueueBinding(
            value = @Queue(name = SysCode.CAR_POLICY.QUEUES, durable = "true"),//队列
            exchange = @Exchange(name = SysCode.CAR_POLICY.EX,//交换机
                    type = ExchangeTypes.DIRECT,//模式
                    ignoreDeclarationExceptions = "true"),
            key = SysCode.CAR_POLICY.KEY,//路由规则key
            ignoreDeclarationExceptions = "true")})
    public void getCarPolicysTopic(@Payload String message, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag, Channel channel){
        CommonInterfaceLog commonInterfaceLog =new CommonInterfaceLog();
        int length=255;
        try {
			//那个消息开始消费
            log.info("["+SysCode.SOURCE.CAR+"]getCarPolicysTopic监听到消息："+message);
            //判断是否为空
            if(StringUtils.isNotBlank(message)){
				//把消息json串转换成你所需要的对象
                CoreSalesPolicysModel coreSalesPolicysModel = JSONObject.parseObject(message, CoreSalesPolicysModel.class);
                //执行相关的业务
                if (SysCode.CERTITYPE.POLICY.equals(coreSalesPolicysModel.getCertiType())){
                    commonInterfaceLog.setBusinessCode(coreSalesPolicysModel.getPolicyNo());
                }else if (SysCode.CERTITYPE.ENDORSE.equals(coreSalesPolicysModel.getCertiType())){
                    commonInterfaceLog.setBusinessCode(coreSalesPolicysModel.getCertiNo());
                }
                R r=coreSalesPolicysService.savePolicys(coreSalesPolicysModel);

				//异常处理
                if(500==r.getCode()){
                    log.info(""+r.getMsg());
                    commonInterfaceLog.setThisFailureReasons(r.getMsg());

                    //出现异常,告诉mq抛弃该消息
                    channel.basicNack(deliveryTag,false,false);
                }else {
                    //消费消息
                    channel.basicAck(deliveryTag, false);
                }

                commonInterfaceLog.setResponseMessage(r.toString());
                log.info("["+SysCode.SOURCE.CAR+"]getCarPolicysTopic执行完毕**************");

            }else {
                channel.basicReject(deliveryTag,false);
                //出现异常,告诉mq抛弃该消息
                channel.basicNack(deliveryTag,false,false);
            }

        } catch (Exception e) {
            commonInterfaceLog.setThisFailureReasons(null != e.getMessage() ? e.getMessage().substring(0, e.getMessage().length() > length ? length : e.getMessage().length()) : null);
            try {
                //出现异常,告诉mq抛弃该消息
                channel.basicNack(deliveryTag,false,false);
                e.printStackTrace();
            }catch (IOException e1) {
                e1.printStackTrace();
            }
        }finally {
        	//进行日志表的写入，记录MQ日志，建议存储到非关系数据库
            commonInterfaceLog.setInterfaceName("savePolicys");
            commonInterfaceLog.setInterfaceType("MQ");
            commonInterfaceLog.setMqExchange(SysCode.CAR_POLICY.EX);
            commonInterfaceLog.setMqQueue(SysCode.CAR_POLICY.QUEUES);
            commonInterfaceLog.setMqKey(SysCode.CAR_POLICY.KEY);
            commonInterfaceLog.setMqReqType(ExchangeTypes.DIRECT);
            commonInterfaceLog.setRequestMessage(message);
            commonInterfaceLog.setCreateTime(new Date());
            commonInterfaceLog.setSource(SysCode.SOURCE.CAR);
            commonFeignClient.saveInterfaceLog(commonInterfaceLog);
        }
    }
}

1、创建bean来控制MQ的消费者

    @Bean(name = "carPolicyListenerContainer")
    public SimpleRabbitListenerContainerFactory baseMultiListenerContainer(@Qualifier("carPolicyConnectionFactory") ConnectionFactory secondConnectionFactory){
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(secondConnectionFactory);
        //手动确认消息，默认自动确认消息
        factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        //初始化消费者数量
        factory.setConcurrentConsumers(5);
        //最大消费者数量
        factory.setMaxConcurrentConsumers(5);
		//一次处理的消息数量
        factory.setPrefetchCount(2);
        factory.setDefaultRequeueRejected(true);
        return factory;
    }

2、定义MQ的连接
其中Integer.parseInt(SysCode.RABBITMQPORT)是MQ的端口号，可以写活

    @Bean(name = "carPolicyConnectionFactory")
    public ConnectionFactory groupPolicyConnectionFactory(
            @Value("${spring.rabbitmq.group.addresses}") String addresses,//地址
            @Value("${spring.rabbitmq.group.virtualhost}") String virtualHost,//端口和指定位置组合，例如 /car，5672/car等
            @Value("${spring.rabbitmq.group.username}") String username,//用户名
            @Value("${spring.rabbitmq.group.password}") String password//密码
    ) {
        return connectionFactory1(addresses, Integer.parseInt(SysCode.RABBITMQPORT), username, password,virtualHost);
    }

    public CachingConnectionFactory connectionFactory1(String host, int port, String username, String password,String virtualHost) {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses(host);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);
        log.info("MQ配置：{}",connectionFactory);
        return connectionFactory;
    }

版权声明：转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Boy_Martin/article/details/126104042

佳德_Boy
关注
RabbitMQ实现Demo
01-22
RabbitMQ实现发布消息队列和接收消息。
RabbitMQ延时消息实现方案
12-24
在RabbitMQ中实现延时消息功能是许多企业级消息系统中的常见需求。延时消息指的是消息发送后，消费者并不会立即接收到消息，而是需要等待一段时间之后，消费者才能获得并处理消息。这种机制可以应用于订单状态检查、...
RabbitMQ 实践及使用
weixin_30633405的博客
01-05 174
目录 - 1. RabbitMQ的安装- 1.1 配置好 epel- 1.2 安装 RPM包- 1.3 创建用户设置权限- 2. RabbitMQ组件- 3. RabbitMQ-Server 六种消息类型- 3.1 "Hello World"- 3.1.1 代码整合- 3.2 Work queues （工作队列模式）- 3....
RabbitMQ 使用教程
最新发布
白白白鲤鱼的博客
08-11 3165
RabbitMQ使用教程
RabbitMQ介绍及工作原理
m0_67402026的博客
03-28 2684
RabbitMQ介绍及工作原理 一，什么是RabbitMQ RabbitMQ是一种称为消息代理或队列管理器的消息队列软件。它是一个可以定义队列的软件，应用程序可以连接到队列并将消息传输到它们。消息队列的基本体系结构很简单：存在称为生产者的客户端应用程序，它们可以创建消息并将其传递到代理（消息队列）。称为使用者的其他应用程序连接到队列并订阅要处理的消息。 RabbitMQ实现高级消息队列协议（AMQP）。它提供了主要编程语言的客户端库。 二，RabbitMQ基本概念 生产者（Producer）：发送消息的应
Rabbitmq的实现方式
qq_52166656的博客
09-23 1438
Rabbitmq的实现方式
rabbitMQ的简单实现
荼蘼_的博客
04-12 2428
java中，实现rabbitMQ的【生产者→队列→消费者】的一个过程。 直接上代码 一、配置 创建一个项目（本次我没有创建新的项目。在原来的项目中写的案例） 配置pom.xml <!-- RabbitMQ --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spr
使用RabbitMQ+延迟队列实现分布式事务的最终一致性方案
04-13
在本方案中，我们将利用RabbitMQ的延迟队列特性来实现在订单和库存系统中的分布式事务最终一致性。 RabbitMQ是基于AMQP（Advanced Message Queuing Protocol）的消息中间件，它提供了一种可靠的消息传递机制，使得...
开源 RabbitMQ 消息队列解决方案部署手册
02-13
【开源 RabbitMQ 消息队列解决方案部署手册】 在当今的分布式系统中，消息队列作为重要的组件，用于处理异步任务、解耦系统以及负载均衡。RabbitMQ 是一个广泛应用的消息中间件，它遵循 AMQP（Advanced Message ...
rabbitmq 消息100%可靠性投递的解决方案实现 ack手动确认方式.zip
01-15
通过明智的资源分配，方案可以在有限的资源条件下实现最大的效益，提高效率并减少浪费。 风险管理： 方案通常会对潜在的风险进行评估，并制定相应的风险管理策略。这有助于减轻潜在问题的影响，提高方案的可行性和...
精选_基于Springboot+Redis+RabbitMQ消息队列实现的秒杀方案_源码打包
03-10
本方案将探讨如何利用Spring Boot、Redis和RabbitMQ构建一个高效的秒杀系统。 首先，Spring Boot作为Java开发的微服务框架，以其简洁的配置和快速的启动特性，被广泛用于构建现代化的应用。在秒杀场景中，Spring ...
rabbitmq 实现消息插队
10-29
rabbitmq 实现消息插队，以多人投资为例子，手动投资优先于自动投资都进入消息队列，进行消息插队处理
RabbitMQ的简单实现
luking的博客
09-11 381
1.简单实现，不使用交换机 引入依赖 <!--依赖都一样--> <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <ve...
RabbitMQ的六种工作模式以及代码实现。
u010797364的博客
09-18 1020
一、什么是RabbitMQ rabbitmq是基于amqp协议实现一套高效的数据传输组件，MQ（消息队列）。 常见的MQ：ActiveMQ、Kafka、RocketMQ、RabbitMQ 参考网址： RabbitMQ的应用场景以及基本原理介绍 RabbitMQ使用详解 RabbitMQ的Java应用(1) – Rabbit Java Client使用 二、MQ的应用场景 1、消息异步通知(注册时邮箱认证、添加商品生成详情页和将商品添加到搜索库等) 2、消息顺序处理 3、消息延迟处理 4、请求削峰 三，Rab
RabbitMQ原理及实现
渣渣
08-02 3631
一、RabbitMQ核心概念以及工作原理 我们来看看流行的RabbitMQ消息系统以及它是如何让你的系统之间进行解耦的。 英文原文 二、RabbitMQ特点及应用 RabbitMQ除了像兔子一样跑的很快以外，还有这些特点： 开源、性能优秀，稳定性保障 提供可靠性消息投递模式、返回模式 与Spring AMQP完美整合，API丰富 集群模式丰富，表达式配置，HA模式，镜像队列模型 保证数据不丢失的前提做到高可靠性、可用性 MQ典型应用场景： 异步处理。把消息放入消息中间件中，.
RabbitMQ的几种典型使用场景
weixin_33895695的博客
08-17 2994
RabbitMQ主页：https://www.rabbitmq.com/ AMQP AMQP协议是一个高级抽象层消息通信协议，RabbitMQ是AMQP协议的实现。它主要包括以下组件： 1.Server(broker): 接受客户端连接，实现AMQP消息队列和路由功能的进程。 2.Virtual Host:其实是一个虚拟概念，类似于权限控制组，一个Virtual Host里面可以有若干...
RabbitMQ详解与Java实现
qq_45110186的博客
01-17 4267
两个服务调用时，我们可以通过传统的HTTP方式，让服务A直接去调用服务B的接口，但是这种方式是同步的方式，虽然可以采用SpringBoot提供的@Async注解实现异步调用，但是这种方式无法确保请求一定回访问到服务B的接口。那如何保证服务A的请求信息一定能送达到服务B去完成一些业务操作呢？
使用RabbitMQ实现简单消息队列
make_progress的博客
02-23 483
实现消息队列有多种框架，例如ActiveMQ、RabbitMQ、RocketMQ和Kafka，本文选择使用RabbitMQ实现简单的消息队列。 1 安装RabbitMQ 1.1 安装Erlang 下载Erlang，下载地址 https://www.erlang.org/downloads 默认安装即可（安装目录可自己选择） 1.2 安装RabbitMQ （1）下载RabbitMQ，下载地址 https://www.rabbitmq.com/download.html 默认安装即可.
RabbitMQ理论与实现
恋志传奇的博客
08-28 257
MQ(Message Quene) : 翻译为消息队列,通过典型的生产者和消费者模型,生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入,轻松的实现系统间解耦。别名为消息中间件通过利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。connections：无论生产者还是消费者，都需要与RabbitMQ建立连接后才可以完成消息的生产和消费，在这里可以查看连接情况。
RabbitMQ消息中间件解决方案
RabbitMQ 消息中间件解决方案 RabbitMQ 是一个流行的开源消息中间件，广泛应用于分布式系统中。下面是基于给定文件信息，总结的相关知识点： **1. 解决消息积压问题** 在 RabbitMQ 中，如果消息积压了几个小时还...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值