springboot整合RabbitMq简单使用

依赖

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

配置yml

消息发送

spring:
  # rabbitmq配置
  rabbitmq:
    # 用户名
    username: 账号
    # 密码
    password: 密码
    # 服务器地址
    host: ip
    # 端口
    port: 断开
    # 消息失败回调
    publisher-returns: true
    # 消息确认回调
    publisher-confirm-type: correlated

消息接收

  #rabbitmq配置
  rabbitmq:
    # 用户名
    username: shop
    # 密码
    password: shop
    # 服务器地址
    host: 192.168.85.131
    # 端口
    port: 5672
    listener:
      simple:
        # 手动确认
        acknowledge-mode: manual

配置config

package com.yc.server.config;

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.yc.server.pojo.MailConstants;
import com.yc.server.pojo.MailLog;
import com.yc.server.service.IMailLogService;
import 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.connection.CachingConnectionFactory;
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 xx
 * @Package com.yc.server.config
 */
@Configuration
public class RabbitMqConfig {

    public static final Logger Logger = LoggerFactory.getLogger(RabbitMqConfig.class);
    @Autowired
    private CachingConnectionFactory cachingConnectionFactory;


    @Bean
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(cachingConnectionFactory);
        /**
         * 消息确认回调，确认消息是否到达broker
         * data:消息唯一标识
         * ack: 确认结果
         * cause:失败原因
         */
        rabbitTemplate.setConfirmCallback((data, ack, cause) -> {
            String msgId = data.getId();
            if (ack) {
                //消息确认成功
                Logger.info("{}====>消息发送成功", msgId);
                //业务处理
                {
					//业务代码块
				}
            } else {
                Logger.info("{}====>消息发送失败", msgId);
            }
        });
        /**
         * 消息失败回调，比如router不到queue时回调
         * msg：消息主题
         * repCode：响应码
         * repText：响应描述
         * exchange:交换机
         * routingKey:路由键
         *
         */
        rabbitTemplate.setReturnCallback((msg, repCode, reText, exchange, routingKey) -> {
            Logger.info("{}======>消息发送到queue时失败", msg.getBody());
        });
        return rabbitTemplate;
    }

    @Bean
    public Queue queue() {
        return new Queue(MailConstants.MAIL_QUEUE_NAME, true);
    }

    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange(MailConstants.MAIl_EXCHANGE_NAEM);
    }

    @Bean
    public Binding binding() {
        return BindingBuilder.bind(queue()).to(directExchange()).with(MailConstants.MAIL_ROUTING_KEY_NAME);
    }
}

package com.yc.server.pojo;

/**
 * 消息状态
 *
 * @Author xx
 * @Package com.yc.server.pojo
 */
public class MailConstants {

    //消息投递中
    public static final Integer DELIVERING = 0;
    //消息投递成功
    public static final Integer SUCCESS = 1;
    //消息投递失败
    public static final Integer FAILURE = 2;
    //最大重试次数
    public static final Integer MAC_TRY_COUNT = 3;
    //消息超时时间
    public static final Integer MSG_TIMEOUT = 1;
    //队列
    public static final String MAIL_QUEUE_NAME = "mail.queue";
    //交换机
    public static final String MAIl_EXCHANGE_NAEM = "mail_exchange";
    //路由键
    public static final String MAIL_ROUTING_KEY_NAME = "mail.routing.key";

}

发送消息

class mq{
	@Autowired
    private RabbitTemplate rabbitTemplate;

	public void test(){
		/**
		* 发送消息
		* 1：交换机 
		* 2：路由key
		* 3：内容
		* 4：序号
		* /
		rabbitTemplate.convertAndSend(MailConstants.MAIl_EXCHANGE_NAEM, MailConstants.MAIL_ROUTING_KEY_NAME, emp, new CorrelationData("序号"));
	}
}

消息接收

class mq{
	@Autowired
    private RabbitTemplate rabbitTemplate;

 	 /**
     *
     *
     * @param message  消息体
     * @param channel  消息
     * queues = 队列名
     */
	@RabbitListener(queues = MailConstants.MAIL_QUEUE_NAME)
	public void test(Message message, Channel channel){
		//获取对接的消息体
		T t = message.getPayload();		
		//获取消息头
		MessageHeaders headers = message.getHeaders();
		 //消息序号
        long tag = (long) headers.get(AmqpHeaders.DELIVERY_TAG);
        //redis中hash 的key
        String msgId = (String) headers.get("key");
        HashOperations hashOperations = redisTemplate.opsForHash();
        try {
            if (hashOperations.entries("key").containsKey(msgId)) {
                // redis中包含key,说明消息已经被消费
                logger.info("消息已经被消费======>{}",msgId);
                /**
                 * 手动确认消息
                 * tag:消息序号
                 * multiple:是否多条
                 */
                channel.basicAck(tag,false);
            }		
            {业务代码块}
             //手动确认消息
            channel.basicAck(tag,false);
          } catch (Exception e) {
            try {
                /**
                 * 手动确认消息
                 * tag:消息序号
                 * multiple:是否多条
                 * requeue:是否回退到队列
                 */
                channel.basicNack(tag,false,true);
            } catch (Exception ex) {
              e.printStackTrace();
                logger.error("消息确认失败======>{}", ex.getMessage());
            }
            e.printStackTrace();
            logger.error("邮件发送失败======>{}", e.getMessage());
        }	
	}
}