springboot集成rabbitmq

最新推荐文章于 2022-11-08 09:48:30 发布

优秀的佐同学

最新推荐文章于 2022-11-08 09:48:30 发布

阅读量534

点赞数

分类专栏： springboot springboot2 mq 文章标签： rabbitmq

本文链接：https://blog.csdn.net/weixin_41843757/article/details/100990776

版权

springboot 同时被 3 个专栏收录

5 篇文章 0 订阅

订阅专栏

springboot2

5 篇文章 0 订阅

订阅专栏

1 篇文章 0 订阅

订阅专栏

application.properties:

#RabbitMQ配置
spring.rabbitmq.host=154.8.231.85
#spring.rabbitmq.host=169.254.210.241
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=admin
#  消息发送到交换机确认机制,是否确认回调
spring.rabbitmq.publisher-confirms=true  
#  消息发送到交换机确认机制,是否返回回馈
spring.rabbitmq.publisher-returns=true

pom.xml

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

mq配置


import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * RabbitMq配置
 * @author zhuzhe
 * @date 2018/5/25 13:37
 * @email 1529949535@qq.com
 */
@Configuration
public class RabbitMqConfig {

    /**
     * key: queue在该direct-exchange中的key值，当消息发送给direct-exchange中指定key为设置值时，
     * 消息将会转发给queue参数指定的消息队列
     */
    /** 队列key1*/
    public static final String ROUTING_KEY_1 = "queue_one_key1";
    public static final String ROUTING_KEY_2 = "queue_one_key2";
    public static final String ROUTING_KEY_4 = "queue_one_key4";

    @Autowired
    private QueueConfig queueConfig;

    @Autowired
    private ExchangeConfig exchangeConfig;

    @Autowired
    private ConnectionFactory connectionFactory;

    /**
     * 将消息队列1和交换机1进行绑定,指定队列key1
     */
    @Bean
    public Binding binding_one() {
        return BindingBuilder.bind(queueConfig.firstQueue()).to(exchangeConfig.directExchange()).with(RabbitMqConfig.ROUTING_KEY_1);
    }

    /**
     * 将消息队列2和交换机1进行绑定,指定队列key2
     */
    @Bean
    public Binding binding_two() {
        return BindingBuilder.bind(queueConfig.secondQueue()).to(exchangeConfig.directExchange()).with(RabbitMqConfig.ROUTING_KEY_2);
    }
    /**
     * 将消息队列4和交换机4进行绑定,指定队列key4
     */
    @Bean
    public Binding binding_three() {
        return BindingBuilder.bind(queueConfig.fourthQueue()).to(exchangeConfig.directExchange()).with(RabbitMqConfig.ROUTING_KEY_4);
    }

    /**
     * 定义rabbit template用于数据的接收和发送
     * 可以设置消息确认机制和回调
     * @return
     */
    @Bean
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate template = new RabbitTemplate(connectionFactory);
        // template.setMessageConverter(); 可以自定义消息转换器  默认使用的JDK的，所以消息对象需要实现Serializable
        // template.setMessageConverter(new Jackson2JsonMessageConverter());

        /**若使用confirm-callback或return-callback，
         * 必须要配置publisherConfirms或publisherReturns为true
         * 每个rabbitTemplate只能有一个confirm-callback和return-callback
         */
        template.setConfirmCallback(msgSendConfirmCallBack());

        /**
         * 使用return-callback时必须设置mandatory为true，或者在配置中设置mandatory-expression的值为true，
         * 可针对每次请求的消息去确定’mandatory’的boolean值，
         * 只能在提供’return -callback’时使用，与mandatory互斥
         */
        template.setReturnCallback(msgSendReturnCallback());
        template.setMandatory(true);
        return template;
    }

    /**
     * 关于 msgSendConfirmCallBack 和 msgSendReturnCallback 的回调说明：
     * 1.如果消息没有到exchange,则confirm回调,ack=false
     * 2.如果消息到达exchange,则confirm回调,ack=true
     * 3.exchange到queue成功,则不回调return
     * 4.exchange到queue失败,则回调return(需设置mandatory=true,否则不回调,消息就丢了)
     */

    /**
     * 消息确认机制
     * Confirms给客户端一种轻量级的方式，能够跟踪哪些消息被broker处理，
     * 哪些可能因为broker宕掉或者网络失败的情况而重新发布。
     * 确认并且保证消息被送达，提供了两种方式：发布确认和事务。(两者不可同时使用)
     * 在channel为事务时，不可引入确认模式；同样channel为确认模式下，不可使用事务。
     * @return
     */
    @Bean
    public MsgSendConfirmCallBack msgSendConfirmCallBack(){
        return new MsgSendConfirmCallBack();
    }

    @Bean
    public MsgSendReturnCallback msgSendReturnCallback(){
        return new MsgSendReturnCallback();
    }

}


import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;
/**
 * 创建队列
 *
 */
@Configuration
public class QueueConfig {

    /*对列名称*/
    public static final String QUEUE_NAME1 = "first_queue";
    public static final String QUEUE_NAME2 = "second-queue";
    public static final String QUEUE_NAME3 = "third-queue";
    public static final String QUEUE_NAME4 = "messageQueue";
    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
        //设置忽略声明异常
        rabbitAdmin.setIgnoreDeclarationExceptions(true);
        return rabbitAdmin;
    }
    /**
     * 短信发送
     * @return
     */
    @Bean
    public Queue firstQueue() {
        /**
         durable="true" 持久化消息队列 ， rabbitmq重启的时候不需要创建新的队列
         auto-delete 表示消息队列没有在使用时将被自动删除 默认是false
         exclusive  表示该消息队列是否只在当前connection生效,默认是false
         */
        return new Queue(QUEUE_NAME1,true,false,false);
    }

    @Bean
    public Queue secondQueue() {
        return new Queue(QUEUE_NAME2,true,false,false);
    }

    @Bean
    public Queue thirdQueue() {
        // 配置 自动删除
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-message-ttl", 60000);//60秒自动删除
        return new Queue(QUEUE_NAME3,true,false,true,arguments);
    }
    
    
    @Bean
    public Queue fourthQueue() {
        return new Queue(QUEUE_NAME4,true,false,false);
    }
}

package cn.com.sinosoft.common;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import com.rabbitmq.client.Channel;

import cn.com.sinosoft.pojo.ShortMessage;
import cn.com.sinosoft.util.SMS.SendSMSUtil;

@Component
public class OrderConsumer {
	private Logger logger = LoggerFactory.getLogger(this.getClass());

	/* 对列名称 */
	public final String QUEUE_NAME1 = "first_queue";//注意在linux中可能不识别  “-”，起名时尽量用“_”代替
 	public final String QUEUE_NAME4 = "message-queue";
	/**
	 * queues 指定从哪个队列（queue）订阅消息
	 * 
	 * @param message
	 * @param channel
	 */
	@RabbitListener(queues = {QueueConfig.QUEUE_NAME1})
    public void handleMessage(String message,Channel channel) throws IOException {
        try {
            // 处理消息
        	logger.info("OrderConsumer  handleMessage :"+message);
            // 页面提示
           /**
            * 第一个参数 deliveryTag：就是接受的消息的deliveryTag,可以通过msg.getMessageProperties().getDeliveryTag()获得
            * 第二个参数 multiple：如果为true，确认之前接受到的消息；如果为false，只确认当前消息。
            * 如果为true就表示连续取得多条消息才发会确认，和计算机网络的中tcp协议接受分组的累积确认十分相似，
            * 能够提高效率。
            *
            * 同样的，如果要nack或者拒绝消息（reject）的时候，
            * 也是调用channel里面的basicXXX方法就可以了（要指定tagId）。
            *
            * 注意：如果抛异常或nack（并且requeue为true），消息会重新入队列，
            * 并且会造成消费者不断从队列中读取同一条消息的假象。
            */
            // 确认消息
            // 如果 channel.basicAck   channel.basicNack  channel.basicReject 这三个方法都不执行，消息也会被确认 【这个其实并没有在官方看到，不过自己测试的确是这样哈】
            // 所以，正常情况下一般不需要执行 channel.basicAck
            // channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
            /**
             * 调用短信发送方法
             */
           if(!StringUtils.isBlank(message)) {
        	   SendSMSUtil ssu = new SendSMSUtil();
               String code = message.substring(message.length()-6, message.length());
               String mobile = message.substring(message.length()-17, message.length()-6);
               String address = message.substring(0, message.length()-17);
               logger.info("code"+code);
               logger.info("mobile"+mobile);
               logger.info("address"+address);
       		ssu.sendTemplateSingleSMS(address, mobile,code);
           }else{
        	   logger.info("模板消息内容为空");
           }
        }catch (Exception e){
            logger.error("OrderConsumer  handleMessage {} , error:{}",message,e);
            // 处理消息失败，将消息重新放回队列
        }
    }
	/**
	 * queues 指定从哪个队列（queue）订阅消息
	 * 
	 * @param message
	 * @param channel
	 */
	@RabbitListener(queues = {QueueConfig.QUEUE_NAME4})
    public void handleMessageFore(String message,Channel channel) throws IOException {
        try {
            // 处理消息
        	logger.info("OrderConsumer  handleMessage :"+message);
            // 页面提示
           /**
            * 第一个参数 deliveryTag：就是接受的消息的deliveryTag,可以通过msg.getMessageProperties().getDeliveryTag()获得
            * 第二个参数 multiple：如果为true，确认之前接受到的消息；如果为false，只确认当前消息。
            * 如果为true就表示连续取得多条消息才发会确认，和计算机网络的中tcp协议接受分组的累积确认十分相似，
            * 能够提高效率。
            *
            * 同样的，如果要nack或者拒绝消息（reject）的时候，
            * 也是调用channel里面的basicXXX方法就可以了（要指定tagId）。
            *
            * 注意：如果抛异常或nack（并且requeue为true），消息会重新入队列，
            * 并且会造成消费者不断从队列中读取同一条消息的假象。
            */
            // 确认消息
            // 如果 channel.basicAck   channel.basicNack  channel.basicReject 这三个方法都不执行，消息也会被确认 【这个其实并没有在官方看到，不过自己测试的确是这样哈】
            // 所以，正常情况下一般不需要执行 channel.basicAck
            // channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
           
        }catch (Exception e){
            logger.error("OrderConsumer  handleMessage {} , error:{}",message,e);
            // 处理消息失败，将消息重新放回队列
        }
    }
	public void doGet()throws ServletException,IOException {
			HttpServletRequest req;
			HttpServletResponse res = null;
    		PrintWriter out = res.getWriter();
    		out.println("Hello world!");
//    		res.sendRedirect("test.do"); // servlet实现跳转（客户端跳转）
    		}
}
/*
 * 消息的标识，false只确认当前一个消息收到，true确认consumer获得的所有消息
 * channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
 *
 * ack返回false，并重新回到队列
 * channel.basicNack(message.getMessageProperties().getDeliveryTag(), false,
 * true);
 *
 * 拒绝消息 channel.basicReject(message.getMessageProperties().getDeliveryTag(),
 * true);
 *
 */

package cn.com.sinosoft.common;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.RabbitTemplate;

/**
 *  交换机异常处理
 */
public class MsgSendReturnCallback implements RabbitTemplate.ReturnCallback {

    /**
     * 当消息从交换机到队列失败时，该方法被调用。（若成功，则不调用）
     * 需要注意的是：该方法调用后，{@link MsgSendConfirmCallBack}中的confirm方法也会被调用，且ack = true
     * @param message
     * @param replyCode
     * @param replyText
     * @param exchange
     * @param routingKey
     */
    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        System.out.println("MsgSendReturnCallback [消息从交换机到队列失败]  message："+message);

        // TODO 消息从交换机到队列失败，重新发送

    }
}

package cn.com.sinosoft.common;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;

/**
 * 消息发送到交换机确认机制
 * 交换机
 */
public class MsgSendConfirmCallBack implements RabbitTemplate.ConfirmCallback {

    /**
     * 当消息发送到交换机（exchange）时，该方法被调用.
     * 1.如果消息没有到exchange,则 ack=false
     * 2.如果消息到达exchange,则 ack=true
     * @param correlationData
     * @param ack
     * @param cause
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        System.out.println("MsgSendConfirmCallBack  , 回调correlationData:" + correlationData);
        if (ack) {
            System.out.println("消息发送到exchange成功");
            // TODO 删除 msgId 与 Message 的关系
        } else {
            System.err.println("消息发送到exchange失败");
            // TODO 消息发送到exchange失败 ， 重新发送
        }
    }
}