RabbitMQ實戰篇：消息確認之生產者確認

生產者把消息發送到exchange 確認。通過實現 ConfirmCallback 接口，消息發送到 Broker 後觸發回調，確認消息是否到達 Broker 服務器，也就是隻確認是否正確到達 Exchange 中 implements RabbitTemplate.ConfirmCallback

看一下代碼實現：

配置類：

package com.lwl.rabbitmq.config;

import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;

public class RabbitConfig {
    
    @Value("${spring.rabbitmq.host}")
    private String addresses;
    
    @Value("${spring.rabbitmq.port}")
    private String port;

    @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.publisher-confirms}")
    private boolean publisherConfirms;
    
    @Value("${spring.rabbitmq.publisher-returns}")
    private boolean publisherReturns;
    
    @Bean
    public ConnectionFactory connectionFactory() {

        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses(addresses+":"+port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);
        /** 如果要進行消息回調，則這裏必須要設置爲true */
        connectionFactory.setPublisherConfirms(publisherConfirms);
        connectionFactory.setPublisherReturns(publisherReturns);
        return connectionFactory;
    }
    
    @Bean
    /** 因爲要設置回調類，所以應是prototype類型，如果是singleton類型，則回調類爲最後一次設置 */
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public RabbitTemplate rabbitTemplatenew() {
        RabbitTemplate template = new RabbitTemplate(connectionFactory());
        return template;
    }

}

package com.lwl.rabbitmq.config;


import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.lwl.rabbitmq.constant.Constants;

/**
 * 發送消息 配置發送消息的隊列queue
 * @author lwl
 * @create 2018年8月10日 下午2:37:38
 * @version 1.0
 */
@Configuration
public class SendMessageConfig {

    @Bean
    public Queue topicQueue() {
    	return new Queue(Constants.TOPIC_QUEUE);
    }
    
    @Bean
    TopicExchange exchange() {
        return new TopicExchange(Constants.TOPIC_NAME);
    }
    
    /**
     * 使用主題交換機， 
     *  	將隊列Constants.TOPIC_QUEUE與exchange綁定，binding_key爲topic.queue.key,就是完全匹配
     * @param topicQueue
     * @param exchange
     * @return
     * @author lwl
     * @create 2019年6月14日 上午10:51:21
     */
    @Bean
    Binding bindingExchangeMessage(Queue topicQueue, TopicExchange  exchange) {
        return BindingBuilder.bind(topicQueue).to(exchange).with(Constants.ROUTING_KEY);
    }
    
    
    
}

配置文件：

# 配置rabbitmq
spring: 
      rabbitmq:
        host: 192.168.3.66
        port: 5672
        username: lwl
        password: 123456
        publisher-confirms: true
        publisher-returns: true
        virtual-host: /

生產者：

package com.lwl.rabbitmq.producer;

import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;

import com.lwl.rabbitmq.constant.Constants;

/**
 * 生成者
 * @author lwl
 * @create 2019年6月14日 上午10:56:41
 * @version 1.0
 */
@Component
public class AckProducer implements RabbitTemplate.ConfirmCallback , RabbitTemplate.ReturnCallback{

	@Autowired
    private RabbitTemplate rabbitTemplatenew;

    /**
     * 使用主題交換機
     * @param message
     * @author lwl
     * @create 2019年6月14日 上午10:54:54
     */
    public void send(Object message){
    	rabbitTemplatenew.setConfirmCallback(this);
        CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());  
        System.out.println();
        System.out.println("callbackSender UUID: " + correlationData.getId());  
        System.out.println();
        this.rabbitTemplatenew.convertAndSend(Constants.TOPIC_NAME,Constants.ROUTING_KEY, message, correlationData);  
    }
    /**
     * 
     * 通過實現 ConfirmCallback 接口，消息發送到 Broker 後觸發回調，確認消息是否到達 Broker 服務器，也就是隻確認是否正確到達 Exchange 中
     * @param correlationData
     * @param ack
     * @param cause
     * @author lwl
     * @create 2019年6月17日 上午9:46:59
     */
	@Override
	public void confirm(CorrelationData correlationData, boolean ack, String cause) {
		//
		System.out.println();
		System.out.println();
		 System.out.println("callbakck confirm: " + correlationData.getId());
		 System.out.println();
		 System.out.println();
	}
	
	/**
	 * 通過實現 ReturnCallback 接口，啓動消息失敗返回，比如路由不到隊列時觸發回調
	 * @param message
	 * @param replyCode
	 * @param replyText
	 * @param exchange
	 * @param routingKey
	 * @author lwl
	 * @create 2019年6月17日 上午10:01:47
	 */
	@Override
	public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
		System.out.println("消息主體 message : "+message);
        System.out.println("消息主體 message : "+replyCode);
        System.out.println("描述："+replyText);
        System.out.println("消息使用的交換器 exchange : "+exchange);
        System.out.println("消息使用的路由鍵 routing : "+routingKey);		
	}
    
    
}

消費者：

package com.lwl.rabbitmq.consumer;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import com.lwl.rabbitmq.constant.Constants;

/**
 * 消費者
 * @author lwl
 * @create 2019年6月14日 上午10:57:11
 * @version 1.0
 */
@Component
@RabbitListener(queues = Constants.TOPIC_QUEUE)
public class TopicAckConsumer {

	@RabbitHandler
    public void process(String hello) {
		
		System.out.println();
		System.out.println("-----------------------客戶端  3  收到數據 -----------------------");
        System.out.println(Constants.TOPIC_QUEUE+ " --> Receiver3  : " + hello);
        System.out.println();
    }
	
}

測試用例：

package com.lwl.rabbitmq;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;

import com.lwl.rabbitmq.producer.AckProducer;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes={RabbitmqAckApplication.class})
@WebAppConfiguration
public class RabbitmqAckApplicationTests {

	@Resource
	private AckProducer ackProducer;
	
	@Test
	public void send() {
		String message = " message with ack ";
		ackProducer.send(message );
		
	}

}

結果分析：

callbackSender UUID: 2c3a2573-fd21-4160-bb5d-f8f6cbe97cc3

 
callbakck confirm: 2c3a2573-fd21-4160-bb5d-f8f6cbe97cc3

消息發送到exchange之後，返回的uuid 和發送的uuid 是一樣的