定时关闭订单
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.Exchange;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class DemoMqConfig {
// 监听队列消息
@RabbitListener(queues = "order.release.order.queue")
public void listener(OrderEntity entity, Channel channel, Message message) throws IOException {
System.out.println("收到过期的订单信息:准备关闭订单" + entity.getOrderSn());
// 可以通过 Message.getBody() 获取消息
System.out.println("收到过期的订单信息:准备关闭订单:" + message.getBody());
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
}
/**
* 容器中的Binding,Queue,Exchange 都会自动创建(RabbitMq没有的情况)
* RabbitMQ 只要有。@Bean声明属性发生变化也不会覆盖
*/
@Bean
public Queue orderDelayQueue() {
Map<String, Object> arguments = new HashMap<>();
arguments.put("x-dead-letter-exchange", "order-event-exchange");
arguments.put("x-dead-letter-routing-key", "order.release.order");
arguments.put("x-message-ttl", 60000);
Queue queue = new Queue("order.delay.queue", true, false, false, arguments);
return queue;
}
@Bean
public Queue orderReleaseOrderQueue() {
Queue queue = new Queue("order.release.order.queue", true, false, false);
return queue;
}
@Bean
public Exchange orderEventExchange() {
TopicExchange exchange = new TopicExchange("order-event-exchange", true, false);
return exchange;
}
@Bean
public Binding orderCreateOrder() {
Binding binding = new Binding("order.delay.queue", Binding.DestinationType.QUEUE,
"order-event-exchange", "order.create.order", null);
return binding;
}
@Bean
public Binding orderReleaseOrder() {
Binding binding = new Binding("order.release.order.queue", Binding.DestinationType.QUEUE,
"order-event-exchange", "order.release.order", null);
return binding;
}
}
创建订单,发送消息:
@Autowired
RabbitTemplate rabbitTemplate;
@ResponseBody
@GetMapping("test/createOrder")
public String createOrderTest() {
// 订单下单成功
OrderEntity orderEntity = new OrderEntity();
orderEntity.setOrderSn(UUID.randomUUID().toString());
// 给MQ发送消息
rabbitTemplate.convertAndSend("order-event-exchange", "order.create.order", orderEntity);
return "ok";
}
定时解锁库存
1、下订单成功,订单过期没有支付,被系统自动取消,被用户手动取消,都要解锁库存。
2、下订单成功,库存锁定成功,接下来的业务调用失败,导致订单回滚,之前锁定的库存就要指定解锁。
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.Exchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class MyRabbitConfig {
/**
* 使用JSON序列化机制,进行消息转换
*/
@Bean
public MessageConverter messageConverter() {
return new Jackson2JsonMessageConverter();
}
@Bean
public Exchange stockDemoEventExchange() {
return new TopicExchange("stock-demo-event-exchange", true, false);
}
@Bean
public Exchange orderDemoEventExchange() {
return new TopicExchange("order-demo-event-exchange", true, false);
}
@Bean
public Queue stockDemoReleaseStockQueue() {
return new Queue("stock.demo.release.stock.queue", true, false, false);
}
@Bean
public Queue stockDemoDelayQueue() {
Map<String, Object> arguments = new HashMap<>();
arguments.put("x-dead-letter-exchange", "stock-demo-event-exchange");
arguments.put("x-dead-letter-routing-key", "stock.release");
arguments.put("x-message-ttl", 20000);
return new Queue("stock.demo.delay.queue", true, false, false, arguments);
}
@Bean
public Binding stockReleaseBinding() {
return new Binding("stock.demo.release.stock.queue", Binding.DestinationType.QUEUE,
"stock-demo-event-exchange", "stock.release.#", null);
}
@Bean
public Binding stockLockedBinding() {
return new Binding("stock.demo.delay.queue", Binding.DestinationType.QUEUE,
"stock-demo-event-exchange", "stock.locked", null);
}
@Bean
public Binding orderReleaseOtherBinding() {
return new Binding("stock.demo.release.stock.queue", Binding.DestinationType.QUEUE,
"order-demo-event-exchange", "order.release.other.#", null);
}
}
监听消息:
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;
import java.io.IOException;
@Service
@RabbitListener(queues = "stock.demo.release.stock.queue")
public class StockReleaseListener {
@RabbitHandler
public void handleStockLockedRelease(Stock stock, Message message, Channel channel) throws IOException {
System.out.println("收到锁定库存的消息...to:" + stock);
try {
System.out.println("判断是否需要解锁库存");
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
} catch (Exception e) {
channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
}
}
@RabbitHandler
public void handleStockLockedRelease(Order order, Message message, Channel channel) throws IOException {
System.out.println("收到释放订单的消息...to:" + order);
try {
System.out.println("判断是否需要解锁库存");
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
} catch (Exception e) {
channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
}
}
}
发送消息:
@Autowired
RabbitTemplate rabbitTemplate;
@GetMapping("/sendStock")
public String sendStock() {
rabbitTemplate.convertAndSend("stock-demo-event-exchange", "stock.locked", new Stock("锁定库存成功,看看是否需要解锁呢"));
return "ok";
}
@GetMapping("/sendOrder")
public String sendOrder() {
rabbitTemplate.convertAndSend("order-demo-event-exchange", "order.release.other", new Order("释放订单成功,看看是否需要解锁呢"));
return "ok";
}