springboot集成rabbitMQ

最近公司两个项目master（主）和affiliate（从）间需要异步通信，主管选用了rabbitMQ，让我去搭建了下。

rabbitMQ服务搭建参考链接：

https://www.cnblogs.com/5ishare/p/6716142.html

下面是affiliate（从）项目接收端，springboot集成rabbit的代码：

一、pom.xml

<!-- 添加springboot对amqp的支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

二、application.properties，配置文件开启了发送、接收确认

#Rabbitmq配置
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
# 开启发送确认
spring.rabbitmq.publisher-confirms=true
# 开启发送失败退回
spring.rabbitmq.publisher-returns=true
# 开启ACK
spring.rabbitmq.listener.direct.acknowledge-mode=manual
spring.rabbitmq.listener.simple.acknowledge-mode=manual

三、编写配置类RabbitConfig.java，发送和接收队列不能试同一个，系统启动后队列就会自动创建并接收消息。

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

/**
 * @description rabbitmq配置类
 */
@Configuration
public class RabbitConfig {

	/**
	 * 接收队列名
	 */
	public final static String RECEIVE_QUEUE_NAME = "master_queue_name";
	/**
	 * 发送队列名
	 */
	public final static String SEND_QUEUE_NAME = "affiliate_queue_name";


    /**
     * 定义接收队列
     * @return
     */
    @Bean
    public Queue receive() {
        return new Queue(RECEIVE_QUEUE_NAME);
    }
    
    
    /**
     * 定义发送队列
     * @return
     */
    @Bean
    public Queue send() {
        return new Queue(SEND_QUEUE_NAME);
    }
}

四、消息接收类，重点提下@RabbitListener这个注解，我原先是放在类上面的，然后主系统发的消息怎么都收不到，百度了下说要放在方法上面，我点进去看这个注解说明是可以放在类上的，不知道是什么原因，具体还要去查下。

import java.io.IOException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.amqp.config.RabbitConfig;
import com.rabbitmq.client.Channel;

/**
 * @date 2019/1/2
 */
@Component
public class RabbitReceive {

    @Autowired
    private AmqpTemplate rabbitmqTemplate;

    private static final Logger logger = LoggerFactory.getLogger(RabbitReceive.class);

    /**
     * 消息消费
     * @RabbitHandler 代表此方法为接受到消息后的处理方法
     **/
    @RabbitHandler
    @RabbitListener(queues = RabbitConfig.RECEIVE_MEMBER_QUEUE_NAME)//@RabbitListener放在类上与master对接有问题，必须放在方法上
    public void recieved(Message message, Channel channel) throws IOException {
        System.out.println("RabbitReceive 收到  : " + new String(message.getBody(),"utf-8") );
        try {
            //告诉服务器收到这条消息 已经被我消费了 可以在队列删掉 这样以后就不会再发了 否则消息服务器以为这条消息没处理掉 后续还会在发
            channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
            System.out.println("RabbitReceive receiver success");
        } catch (IOException e) {
        	logger.error("RabbitReceive receiver fail!");
            e.printStackTrace();
            //异常处理
            //业务逻辑
            /** 分割线 **/
            //或者丢弃这条消息
            //channel.basicNack(message.getMessageProperties().getDeliveryTag(), false,false);
        }
    }
}

到这里接收端就写好了，接着写master（主）发送端。

一、pom.xml，同上

二、application.properties，同上

三、编写配置类RabbitConfig.java，和上面差不多，就是接收和发送的队列名调换了下。

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

/**
 * @description rabbitmq配置类
 */
@Configuration
public class RabbitConfig {

	/**
	 * 接收队列名
	 */
	public final static String RECEIVE_QUEUE_NAME = "affiliate_queue_name";
	/**
	 * 发送队列名
	 */
	public final static String SEND_QUEUE_NAME = "master_queue_name";


    /**
     * 定义接收队列
     * @return
     */
    @Bean
    public Queue receive() {
        return new Queue(RECEIVE_QUEUE_NAME);
    }
    
    
    /**
     * 定义发送队列
     * @return
     */
    @Bean
    public Queue send() {
        return new Queue(SEND_QUEUE_NAME);
    }
}

四、消息发送类。

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

import com.amqp.config.RabbitConfig;

/**
 * @description rabbit消息生产者
 */
@Component
public class RabbitSend implements RabbitTemplate.ReturnCallback{

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendMsg(Object message) {
    	this.rabbitTemplate.setReturnCallback(this);
        this.rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
            if (!ack) {
                System.out.println("RabbitSend 消息发送失败" + cause + correlationData.toString());
            } else {
                System.out.println("RabbitSend 消息发送成功 ");
            }
        });
    	// 第一个参数为定义的队列名称
        this.rabbitTemplate.convertAndSend(RabbitConfig.SEND_QUEUE_NAME, message);
    }
    
	@Override
	public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
		System.out.println("sender return success" + message.toString()+"==="+replyCode+"==="+replyText+"==="+exchange+"==="+routingKey);
	}

}

五、测试用例

import java.util.Date;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import com.amqp.send.RabbitSend;


@RunWith(SpringRunner.class)
@SpringBootTest
public class WebApplicationTests {

	@Autowired
	private RabbitSend rabbitSend;
	@Test
	public void contextLoads() {
		rabbitSend.sendMsg("massage from master");
	}

}

六、启动接收端服务，affiliate（从）

七、运行测试用例，master（主），打印ack：true表示发送成功了

接收端，affiliate（从）控制台打印：

反过来affiliate（从）发送master（主）接收也是一样的