springcloud使用rabbitmq消息队列中间件

1.在配置服务config或者直接在需要发送和接收消息的服务中向pom.xml中添加依赖

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

2.在配置服务config或者直接在需要发送和接收消息的服务中配置.yml配置文件，配置rabbitmq的ip，端口，账号，密码

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: root
    password: 123456

3.接下来就是需要用到各个类，我都放到一个package（包）下

常量类配置你的队列名，exhange名和route_key名

/**
 * 常量类 需要用到的exhange,队列名,ROUTE_KEY
 * @author my
 *
 */
public class Constants {

	public static final String EXCHANGE_NAME = "queue_exchange";
	
	public static final String QUEUE_NAME = "queue";
	
	public static final String ROUTE_KEY = "queue_route_key";
	
	
}

 获取配置文件实体类

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "spring.rabbitmq")
public class RabbitYmlConfig {
	private String host;
	private String port;
	private String username;
	private String password;
	private String virtualhost;
	public String getHost() {
		return host;
	}
	public void setHost(String host) {
		this.host = host;
	}
	public String getPort() {
		return port;
	}
	public void setPort(String port) {
		this.port = port;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getVirtualhost() {
		return virtualhost;
	}
	public void setVirtualhost(String virtualhost) {
		this.virtualhost = virtualhost;
	}


}

 配置消息队列连接工厂，配置回调方法作回调操作

import java.text.MessageFormat;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.fastech.monitor_controller.rabbitmq.SendAlarmQueue;

@Configuration
public class RabbitMqConfig {
	Logger logger = LoggerFactory.getLogger("RabbitMqConfig");
	@Autowired
	RabbitYmlConfig rabbitYmlConfig;
	@Autowired
	SendAlarmQueue sendAlarmQueue;
	
	@Bean
	public ConnectionFactory connectionFactory() {
		CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
		connectionFactory.setAddresses(rabbitYmlConfig.getHost() + ":" + rabbitYmlConfig.getPort());
		connectionFactory.setUsername(rabbitYmlConfig.getUsername());
		connectionFactory.setPassword(rabbitYmlConfig.getPassword());
		connectionFactory.setVirtualHost("/");
		connectionFactory.setPublisherConfirms(true);// 消息确认
		connectionFactory.setPublisherReturns(true);
		return connectionFactory;
	}

	// 回调发送失败方法，如果失败放入rabbitmq.log日志中
	@Bean
	public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
		RabbitTemplate template = new RabbitTemplate(connectionFactory);
		template.setMessageConverter(new Jackson2JsonMessageConverter());
		template.setConfirmCallback((data, ack, cause) -> {
			if (!ack) {

				logger.info("消息发送到exchange失败!" + cause + data.getId().toString());
			}

		});
		template.setMandatory(true);//开启强制委托模式

		template.setReturnCallback((message, replyCode, replyText,exchange, routingKey) ->{
			logger.info(MessageFormat.format("消息发送到queue失败! ReturnCallback:{0},{1},{2},{3},{4},{5}", message.getBody().toString(), replyCode, replyText, exchange, routingKey));
		});
		return template;
	}

	@Bean
	public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory) {
		SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
		factory.setConnectionFactory(connectionFactory);
		factory.setMessageConverter(new Jackson2JsonMessageConverter());
		return factory;
	}

}

 发送队列方法类

import java.util.UUID;

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

import com.fastech.monitor_controller.rabbitmq.config.Constants;
@Component
public class SendAlarmQueue {
	Logger logger = LoggerFactory.getLogger(this.getClass());
	
    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 通过exchange和routingKey的方式,传入实体类
     * rabbitTemplate.convertAndSend(String exchange, String routingKey, Object object)
     * @param i
     */
    public void sendAlarmQueue(Object obj) {
    	
        this.rabbitTemplate.convertAndSend(Constants.EXCHANGE_NAME,Constants.ROUTE_KEY, obj,new CorrelationData(UUID.randomUUID().toString() ));
//      消息从exchange到queue发送失败测试
//        this.rabbitTemplate.convertAndSend(Constants.EXCHANGE_NAME,"1234", obj, new CorrelationData(UUID.randomUUID().toString()));
//      消息发送到exchange发送失败测试
//        this.rabbitTemplate.convertAndSend("1234","1234", obj ,new CorrelationData(UUID.randomUUID().toString()));        
    }
    
}

接收队列方法类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.stereotype.Component;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;

import com.fastech.monitor_consume.controller.ThreadPool;
import com.fastech.monitor_consume.rabbitmq.config.Constants;

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

	@Autowired
	ThreadPool threadPool;

	@RabbitListener(containerFactory = "rabbitListenerContainerFactory", bindings = @QueueBinding(value = @Queue(value = Constants.QUEUE_NAME, durable = "true"), exchange = @Exchange(value = Constants.EXCHANGE_NAME, type = ExchangeTypes.TOPIC,durable="true"), key = Constants.ROUTE_KEY))
	public void receive(@Payload Object obj) {
		logger.info("consume success...  " + (String) obj);
	}

}