springboot项目中整合RabbitMQ高级消息队列（技术篇）

注：此篇只是简单整合使用，不涉及RabbitMQ高级消息队列概念

1.在pom中导入rabbitMQ整合启动场景依赖

<!--       引入rabbitMQ高级消息队列依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

2.此时容器中自动配置了RabbitAutoConfiguration类，其给容器放四个重要的的对象

@Bean
		public CachingConnectionFactory rabbitConnectionFactory(RabbitProperties properties,
				ObjectProvider<ConnectionNameStrategy> connectionNameStrategy) 


@Bean
		@ConditionalOnSingleCandidate(ConnectionFactory.class)
		@ConditionalOnMissingBean(RabbitOperations.class)
		public RabbitTemplate rabbitTemplate(RabbitProperties properties,
				ObjectProvider<MessageConverter> messageConverter,
				ObjectProvider<RabbitRetryTemplateCustomizer> retryTemplateCustomizers,
				ConnectionFactory connectionFactory)

@Bean
		@ConditionalOnSingleCandidate(ConnectionFactory.class)
		@ConditionalOnProperty(prefix = "spring.rabbitmq", name = "dynamic", matchIfMissing = true)
		@ConditionalOnMissingBean
		public AmqpAdmin amqpAdmin(ConnectionFactory connectionFactory)

@Bean
		@ConditionalOnSingleCandidate(RabbitTemplate.class)
		public RabbitMessagingTemplate rabbitMessagingTemplate(RabbitTemplate rabbitTemplate) 

3.主启动类上添加开启Rabbit注解

@EnableRabbit

4.编写配置文件

#配置rabbitMq的配置
#指定虚拟机的地址
spring.rabbitmq.host=145.85.127.158
#指定链接端口
spring.rabbitmq.port=5672
#哪个虚拟地址
spring.rabbitmq.virtual-host=/

5.使用AmqpAdmin进行创建Exchange，Queue，Binding等

@Autowired
    private AmqpAdmin amqpAdmin;

    /**
     * 如何创建Exchange，Queue，Binding
     * 1.使用AmqpAdmin进行创建
     */

    //创建交换机
    @Test
    public void createExchange() {
        //创建交换机-交换机名字,是否持久化，是否自动删除
        DirectExchange directExchange = new DirectExchange("java-exchange", true, false);
        amqpAdmin.declareExchange(directExchange);
        log.info("Exchange创建成功：[{}]", "java-exchange");
    }

    //创建队列
    @Test
    public void createQueue() {
        //创建一个队列-队列名字，是否持久，是否排他，是否自动删除
        Queue queue = new Queue("java-queue", true, false, false);
        amqpAdmin.declareQueue(queue);
        log.info("Queue创建成功：[{}]", "java-queue");
    }

    //创建一个绑定关系
    @Test
    public void createBinding() {
//        String destination,目的地
//        DestinationType destinationType,目的地类型
//        String exchange,交换机
//        String routingKey,路由键（重要）(通过路由键判断交换机把消息给到哪个队列 )
//        Map<String, Object> arguments自定义参数
        Binding binding = new Binding("java-queue"
                , Binding.DestinationType.QUEUE
                , "java-exchange"
                , "hello.java", null);
        amqpAdmin.declareBinding(binding);
        log.info("binding创建成功：[{}]", "java-binding");
    }

6.如何通过RabbitTemplate收发消息

@Autowired
    private RabbitTemplate rabbitTemplate;
    /**
     * 如何创建Exchange，Queue，Binding
     * 1.使用AmqpAdmin进行创建
     * 2.如何收发消息
     */
    //发送消息
//    @Test
//    public void sendMessage(){
//        String msg = "hello world";
//        //转换和发送消息，交换机名字，路由键，消息(这里还可以传递对象)
//        rabbitTemplate.convertAndSend("java-exchange","hello.java",msg);
//        log.info("消息发送成功：[{}]",msg);
//    }
    //发送消息
    @Test
    public void sendMessage(){
        String msg = "hello world";
        //这个要传递的类必须实现序列化
        OrderReturnReasonEntity orderReturnReasonEntity = new OrderReturnReasonEntity();
        orderReturnReasonEntity.setId(1L);
        orderReturnReasonEntity.setName("哈哈");
        orderReturnReasonEntity.setCreateTime(new Date());

        //发送对象消息可以是一个json
        //转换和发送消息，交换机名字，路由键，消息(这里还可以传递对象)
        rabbitTemplate.convertAndSend("java-exchange","hello.java",orderReturnReasonEntity);
        log.info("消息发送成功：[{}]",orderReturnReasonEntity);
    }

7.监听消息：使用@RabbitListener和@RabbitHandler

@RabbitListener(queues = {"java-queue"})//标识监听这个队列
@Service("orderItemService")
public class OrderItemServiceImpl extends ServiceImpl<OrderItemDao, OrderItemEntity> implements OrderItemService {


    /**
     * queues:声明需要监听的所有队列
     * Message:原生消息对象，头+体
     * OrderReturnReasonEntity:发送消息时候的封装对象
     * Channel：客户端连接通道对象
     * queue：可以很多人都来监听，只要有收到消息，队列就进行删除消息，而且只能有一个收到消息
     * @RabbitListener(queues = {"java-queue"})类+方法
     * @RabbitHandler 方法
     */
    @RabbitHandler //真正的消息队列处理在这里执行，根据这个参数OrderReturnReasonEntity的类型进行接收
    public void recieveMessage1(Message message, OrderReturnReasonEntity content,
                               Channel channel) {
        //获取消息体
        System.out.println("接收到的消息：" + message + "===>类型：" + content);
        byte[] body = message.getBody();
        //获取消息头
        MessageProperties messageProperties = message.getMessageProperties();
        //进行线程休眠
//        try {
//            Thread.sleep(1000);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        System.out.println("消息处理完成："+content.getName());
//        System.out.println("接收到的消息："+message+"===>类型："+message.getClass());
    }

    @RabbitHandler //真正的消息队列处理在这里执行，根据这个参数OrderReturnReasonEntity的类型进行接收
    public void recieveMessage2(Message message, OrderEntity content,
                               Channel channel) {
        //获取消息体
        System.out.println("接收到的消息：" + message + "===>类型：" + content);
        byte[] body = message.getBody();
        //获取消息头
        MessageProperties messageProperties = message.getMessageProperties();
        //进行线程休眠
//        try {
//            Thread.sleep(1000);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        System.out.println("消息处理完成："+content.getOrderSn());
//        System.out.println("接收到的消息："+message+"===>类型："+message.getClass());
    }

}

8.保证可靠抵达配置文件：

#开启确认消息已发送到交换机，选择确认类型为交互,ConfirmCallback调用这个函数
spring.rabbitmq.publisher-confirm-type=correlated
#开启发送端消息抵达队列的确认
spring.rabbitmq.publisher-returns=true
#只要抵达就以异步方式优先回调这个returncallback函数
spring.rabbitmq.template.mandatory=true

#手动ack消息回复
spring.rabbitmq.listener.simple.acknowledge-mode=manual

9.保证可靠抵达服务端配置：

@Configuration
public class MyRabbitConfig {

    @Autowired
    private RabbitTemplate rabbitTemplate;//为实现可靠抵达，服务端需要进行定制化setConfirmCallback，setReturnCallback

    //如果容器中有消息转化对象，就用容器中的
    @Bean
    public MessageConverter getMessageConverter(){
        return new Jackson2JsonMessageConverter();
    }

    //定制化消息队列模板
    @PostConstruct//MyRabbitConfig对象创建完成后，执行这个方法
    public void initRabbitTemplate(){
        //设置确认回调
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            /**
             * Confirmation callback.
             * @param correlationData correlation data for the callback.当前消息唯一关联数据
             * @param ack true for ack, false for nack  消息是否成功
             * @param cause An optional cause, for nack, when available, otherwise null.失败原因
             */
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                System.out.println("comfirm....correlationData["+correlationData+"]==>ack["+ack+"]==>cause["+cause+"]");
            }
        });
        //设置消息抵达队列的确认回调
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            /**
             * 只要消息没有投递给指定的队列，就触发这个失败的回调
             * Returned message callback.
             * @param message the returned message. 投递失败的消息详情信息
             * @param replyCode the reply code.回复的状态码
             * @param replyText the reply text.回复的文本内容
             * @param exchange the exchange.当前消息发送给哪个交换机
             * @param routingKey the routing key.当时这个消息用哪个路由健
             */
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println("return....message["+message+"]==>replyCode["+replyCode+"]==>replyText["+replyText+"]==>exchange["+exchange+"]==>routingKey["+routingKey+"]");
            }
        });
    }
}

10.保证可靠抵达ack（修改监听处理方法）：

@RabbitHandler //真正的消息队列处理在这里执行，根据这个参数OrderReturnReasonEntity的类型进行接收
    public void recieveMessage1(Message message, OrderReturnReasonEntity content,
                               Channel channel) throws IOException {
        //获取消息体
        System.out.println("接收到的消息：" + message + "===>类型：" + content);
        byte[] body = message.getBody();
        //获取消息头
        MessageProperties messageProperties = message.getMessageProperties();
        //进行线程休眠
//        try {
//            Thread.sleep(1000);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        System.out.println("消息处理完成："+content.getName());
        /**
         * 为实现可靠抵达，消费端确认（保证每个消息被正确消费，此时才可以broker删除消息）
         *  1.默认是自动确认的，只要消息接收到，客户端会自动确认，服务端就会移除掉这个消息
         *         问题：我们收到很多消息，自动回复ack，只要有一个消息成功，发生的其他消息就会丢失
         *           我们要修改成手动确认：rabbit会自动把数据从Unacked中放入到Ready中下次服务器启动就会执行
         */
        //这个在channel通道中是自增的
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
//        System.out.println("接收到的消息："+message+"===>类型："+message.getClass());

        try {
            /**
             * 派发的标签
             * * @param deliveryTag the tag from the received {@link com.rabbitmq.client.AMQP.Basic.GetOk} or {@link com.rabbitmq.client.AMQP.Basic.Deliver}
             * * @param multiple true to acknowledge all messages up to and
             * 签收消息，非批量处理
             */
            //签收模式 进行判断签收
            if (deliveryTag%2==0){

                channel.basicAck(deliveryTag,false);
                System.out.println("签收了消息："+deliveryTag);
            }else {
                System.out.println("没有签收消息："+deliveryTag);
            }
        } catch (IOException e) {
            //网络中断
            e.printStackTrace();
            //退货模式
            /**
             * requeue true if the rejected message(s) should be requeued rather
             * 是否批量拒收，是否重新入队
             */
            channel.basicNack(deliveryTag,false,false);
            /**
             * requeue true if the rejected message should be requeued rather than discarded/dead-lettered
             */
            //channel.basicReject();
            System.out.println("拒绝签收消息："+deliveryTag);
        }
    }