SpringBoot整合RabbitMQ实战案例

1、环境搭建

(1)pom依赖:要使用RabbitMQ,只需要额外如下依赖

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

(2)application.properties文

spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.virtual-host=/

(3)三步走

a、配置队列Queue、交换机Exchange和路由键等

b、发送消息

c、监听接收消息

2、direct:点对点,直接发送和监听

a、配置队列Queue、交换机Exchange和路由键等(由于点对点模式没有交换机,所以此处仅仅定义队列即可,不需要配置交换机和路由键)

@Configuration
public class MQConfig {  
   public static final String QUEUE = "queue";   
   /**
    * Direct模式 交换机Exchange
    * */
   @Bean
   public Queue queue() {
      return new Queue(QUEUE, true);
   }  
}

b、发送消息(直接往队列中发送消息,convertAndSend是个重载方法,第一个参数可以是队列类型比如点对点直接发送,也可以是交换机类型比如fanout模式和topic模式)

@Service
public class MQSender {
   @Autowired
   RabbitTemplate rabbitTemplate ;
   // direct模式
   public void sendDirect(String str) {
      // 往队列MQConfig.QUEUE发送消息str
      rabbitTemplate.convertAndSend(MQConfig.QUEUE, str);
   }
}

c、监听接收消息(注解@RabbitListener

@Service
public class MQReceiver {
      // 监听队列MQConfig.QUEUE,打印接收的消息
      @RabbitListener(queues=MQConfig.QUEUE)
      public void receive(String message) {
         log.info("receive message:"+message);
      }
}

3、topic:按照路由键与发送消息时的匹配关系进行转发

a、配置队列Queue、交换机Exchange和路由键等(此处配置了两个队列和一个topic模式的交换机)

@Configuration 
public class MQConfig {

public static final String TOPIC_QUEUE1 = "topic.queue1";
public static final String TOPIC_QUEUE2 = "topic.queue2";
public static final String TOPIC_EXCHANGE = "topicExchage";

/**
 * Topic模式 此次配置了两个队列和一个交换机Exchange,两个队列以不同的绑定键绑定到了此交换机上
 * */
// 队列1
@Bean
public Queue topicQueue1() {
   return new Queue(TOPIC_QUEUE1, true);
}
// 队列2
@Bean
public Queue topicQueue2() {
   return new Queue(TOPIC_QUEUE2, true);
}
// topic交换机
@Bean
public TopicExchange topicExchage(){
   return new TopicExchange(TOPIC_EXCHANGE);
}
// 绑定1,把队列1与topic交换机绑定,绑定键是topic.key1
@Bean
public Binding topicBinding1() {
   return BindingBuilder.bind(topicQueue1()).to(topicExchage()).with("topic.key1");
}
// 绑定2,把队列2与topic交换机绑定,绑定键是topic.#
@Bean
public Binding topicBinding2() {
   return BindingBuilder.bind(topicQueue2()).to(topicExchage()).with("topic.#");
}
}

b、发送消息(topic和fanout模式中往exchange交换机中发送消息,不是对列)

@Service
public class MQSender {
   @Autowired
   RabbitTemplate rabbitTemplate ;
   // topic模式
   public void sendTopic(String str) {
      log.info("send topic message:"+str);
      rabbitTemplate.convertAndSend(MQConfig.TOPIC_EXCHANGE, "topic.key1", str+"1");
      rabbitTemplate.convertAndSend(MQConfig.TOPIC_EXCHANGE, "topic.key2", str+"2");
      // 可以知道,队列2可以接收到两个消息,但是队列1只能接收到消息1
   }
}

c、监听接收消息(监听的是队列)

@Service
public class MQReceiver {
// 监听队列TOPIC_QUEUE1,打印接收的消息
@RabbitListener(queues=MQConfig.TOPIC_QUEUE1)
public void receiveTopic1(String message) {
   log.info(" topic  queue1 message:"+message);
}
// 监听队列TOPIC_QUEUE2,打印接收的消息
@RabbitListener(queues=MQConfig.TOPIC_QUEUE2)
public void receiveTopic2(String message) {
   log.info(" topic  queue2 message:"+message);
}
}

4、fanout:广播发送

a、配置队列Queue、交换机Exchange和路由键等(此处仍然使用上述的两个对列queue1和queue2

@Configuration
public class MQConfig {  
  public static final String FANOUT_EXCHANGE = "fanoutxchage";  
  public static final String TOPIC_QUEUE1 = "topic.queue1";
  public static final String TOPIC_QUEUE2 = "topic.queue2";
/**
 * Fanout模式 交换机Exchange
 * */
// fanout交换机
@Bean
public FanoutExchange fanoutExchage(){
   return new FanoutExchange(FANOUT_EXCHANGE);
}
// TOPIC_QUEUE1队列绑定到fanout交换机
@Bean
public Binding FanoutBinding1() {
   return BindingBuilder.bind(topicQueue1()).to(fanoutExchage());
}
// TOPIC_QUEUE2队列绑定到fanout交换机
@Bean
public Binding FanoutBinding2() {
   return BindingBuilder.bind(topicQueue2()).to(fanoutExchage());
} 
}

b、发送消息

@Service
public class MQSender {
   @Autowired
   RabbitTemplate rabbitTemplate ;
   // Fanout模式
   public void sendFanout(String str) {
   log.info("send fanout message:"+str);
   rabbitTemplate.convertAndSend(MQConfig.FANOUT_EXCHANGE, "", str);
}
}

c、监听接收消息

@Service
public class MQReceiver {
// 监听队列MQConfig.TOPIC_QUEUE1,打印接收的消息
@RabbitListener(queues=MQConfig.TOPIC_QUEUE1)
public void receiveTopic1(String message) {
   log.info(" topic  queue1 message:"+message);
}
// 监听队列MQConfig.TOPIC_QUEUE2,打印接收的消息
@RabbitListener(queues=MQConfig.TOPIC_QUEUE2)
public void receiveTopic2(String message) {
   log.info(" topic  queue2 message:"+message);
}
}

5、死信队列

a、配置队列Queue、交换机Exchange和路由键等

@Configuration
public class MQConfig {  
	// 死信交换机(在定义产生死信消息的队列时使用此参数),固定写法,不可改变
    // DEAD_LETTER_EXCHANGE: 当此普通队列中存在死信时,把死信消息转发到的死信交换机
	private static final String DEAD_LETTER_EXCHANGE = "x-dead-letter-exchange";

	// 死信交换机绑定(在定义产生死信消息的队列时使用此参数),固定写法,不可改变
    // DEAD_LETTER_EXCHANGE:死信消息被转发到死信交换机后,将按照此路由键转发到死信队列)
	private static final String  DEAD_LETTER_ROUTING_KEY = "x-dead-letter-routing-key";
    
    // 普通队列(由于此队列可能产生死信消息,所以使用DEAD_LETTER_EXCHANGE和DEAD_LETTER_EXCHANGE参数	
	@Bean
	public Queue normalQueue() {
		Map<String, Object> args = new HashMap<String, Object>(2);
		args.put(DEAD_LETTER_EXCHANGE, "DEAD_LETTER_EXCHANGE");
		args.put(DEAD_LETTER_ROUTING_KEY, "REDIRECT_KEY");
		// 当产生死信消息时,把死信消息转发到死信交换机DEAD_LETTER_EXCHANGE中,死信交换机再通过路由REDIRECT_KEY转发到死信队列
		return new Queue("NORMAL_QUEUE", true, false, false, args);
	}


	// 死信队列
	@Bean
	public Queue deadLetterQueue() {
		return new Queue("DEAD_LETTER_QUEUE", true);
	}


	// 普通交换机
	@Bean
	public Exchange normalExchange() {
		//return ExchangeBuilder.directExchange("NORMAL_EXCHANGE").durable(true).build();
		return new DirectExchange("NORMAL_EXCHANGE");
	}


	// 死信交换机
	@Bean
	public TopicExchange deadLetterExchange() {
		return new TopicExchange("DEAD_LETTER_EXCHANGE");
	}


	// 普通队列与普通交换机绑定
	@Bean
	public Binding deadLetterBinding() {
		return new Binding(
				"NORMAL_QUEUE",
				Binding.DestinationType.QUEUE,
				"NORMAL_EXCHANGE",
				"NORMAL_KEY", null);
	}


	// 死信队列与死信交换机绑定
	@Bean
	public Binding redirectBinding() {
		return new Binding(
				"DEAD_LETTER_QUEUE",
				Binding.DestinationType.QUEUE,
				"DEAD_LETTER_EXCHANGE",
				"REDIRECT_KEY", null);
	}
    
}

b、发送消息

@Service
public class MQSender {
   @Autowired
   RabbitTemplate rabbitTemplate ;
   
    	public void sendOrderMessage(final OrderInfo orderInfo){
		String msg = RedisService.beanToString(orderInfo);
		try {
			if (orderInfo!=null){
				// 因为普通交换机是NORMAL_EXCHANGE,且普通交换机和正常队列的绑定键是NORMAL_KEY
				// 所以此处发送的消息会被路由到普通队列
				rabbitTemplate.convertAndSend("NORMAL_EXCHANGE","NORMAL_KEY",msg, new MessagePostProcessor() {
					@Override
					public Message postProcessMessage(Message message) throws AmqpException {
						MessageProperties mp=message.getMessageProperties();
						//TODO:动态设置TTL(为了测试方便,暂且设置10s)
						mp.setExpiration(String.valueOf(1000*20));
						System.out.println("in the sendOrderMessage hs");
						return message;
					}
				});
			}
		}catch (Exception e){
			log.error("秒杀成功后生成抢购订单-发送信息入死信队列,等待着一定时间失效超时未支付的订单-发生异常,消息为:{}",orderInfo.getId(),e.fillInStackTrace());
		}
	}
}

c、监听接收消息

@Service
public class MQReceiver {
	@RabbitListener(queues = "DEAD_LETTER_QUEUE")
	public void consumeExpireOrder(String message){
		OrderInfo orderInfo  = RedisService.stringToBean(message, OrderInfo.class);
		System.out.println("in the 死信监听中");
		try {
			log.info("用户秒杀成功后超时未支付-监听者-接收消息:{}",orderInfo);
			if (orderInfo!=null && orderInfo.getStatus().intValue()==0){
				orderService.updateStatus(orderInfo.getId());
				long goodsId = orderInfo.getGoodsId();
				//修改库存
				long stock = redisService.incr(GoodsKey.getMiaoshaGoodsStock, ""+goodsId);
			}
		}catch (Exception e){
			log.error("用户秒杀成功后超时未支付-监听者-发生异常:",e.fillInStackTrace());
		}
	}
}

 

 

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值