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);
}
}