【无标题】

订单取消和支付

RabbitConfig

package com.lagou.rabbitmq.ttlorder.config;

import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.listener.DirectMessageListenerContainer;
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 org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.HashMap;
import java.util.Map;

/**
 * 配置消息队列。
 * 包含订单队列
 * 支付死信队列
 */
@Configuration
public class RabbitConfig {

    /**
     * 使用DirectMessageListenerContainer，您需要确保ConnectionFactory配置了一个任务执行器，
     * 该执行器在使用该ConnectionFactory的所有侦听器容器中具有足够的线程来支持所需的并发性。
     * 默认连接池大小仅为5。
     *
     * 并发性基于配置的队列和consumersPerQueue。每个队列的每个使用者使用一个单独的通道，
     * 并发性由rabbit客户端库控制;默认情况下，它使用5个线程池;
     * 可以配置taskExecutor来提供所需的最大并发性。
     *
     * @param connectionFactory
     * @return
     */
    @Bean(name = "rabbitMessageListenerContainer")
    public DirectMessageListenerContainer listenerContainer(ConnectionFactory connectionFactory){
        // 写的时候，默认使用DEFAULT_NUM_THREADS = Runtime.getRuntime().availableProcessors() * 2个线程
        DirectMessageListenerContainer container = new DirectMessageListenerContainer(connectionFactory);
        // 设置确认消息的模式
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        container.setPrefetchCount(5);

        // 并发由setQueues和setConsumersPerQueue控制
        // 从哪些队列消费消息，就设置哪些队列
//        container.setQueues(orderQueue(), ttlQueue(), dlxQueue());
//        container.setQueueNames("", "", "", "");
        // 设置每个队列由几个消费者消费。
        // 如果容器已经在运行，该值可以动态设置。
        // 每个消费者使用一个Channel
        container.setConsumersPerQueue(5);
        //一次确认几个消息
        container.setMessagesPerAck(1);

        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(10);
        taskExecutor.setMaxPoolSize(20);
        //设置该属性，灵活设置并发 ,多线程运行。
        container.setTaskExecutor(taskExecutor);

        return container;
    }

    /**
     * 设置消息转换器，用于将对象转换成JSON数据
     * 可以通过converterAndSend将对象发送消息队列
     * 监听器也可以通过该工具将接受对象反序列化成java对象
     *
     * @return Jackson转换器
     */
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }

    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
        return new RabbitAdmin(connectionFactory);
    }

    /**
     * 订单消息队列
     * @return
     */
    @Bean
    public Queue orderQueue(){
        return QueueBuilder.durable("q.order").build();
    }

    /**
     * 延迟消息队列
     * @return
     */
    @Bean
    public Queue ttlQueue(){
        Map<String,Object> args = new HashMap<>();
        // 该队列的消息10s到期
        args.put("x-message-ttl", 10_000);
        // 设置死信队列交换器,（当队列消息TTL到期后依然没有消费，则加
        //入死信队列）
        args.put("x-dead-letter-exchange","x.dlx");
        // 设置私信队列路由键,设置该队列所关联的死信交换器的routingKey，如果没有特殊指定，使用原
        //队列的routingKey
        args.put("x-dead-letter-routing-key","k.dlx");
        Queue queue = new Queue("q.ttl",true,false,false,args);
        return queue;
    }

    /**
     * 死信队列，用于取消用户订单
     * 当10s还没有付款的订单则进入死信队列，消费死信队列，取消用户订单
     *
     * @return
     */
    @Bean
    public Queue dlxQueue(){
        Map<String,Object> args = new HashMap<>();
        Queue dlq = new Queue("q.dlx",true,false,false, args);

        return dlq;
    }

    /**
     * 订单交换器
     * @return
     */
    @Bean
    public Exchange orderExchange(){
        Map<String, Object> args = new HashMap<>();
        DirectExchange exchange = new DirectExchange("x.order", true, false, args);

        return exchange;
    }

    /**
     * 延迟队列交换器
     * @return
     */
    @Bean
    public Exchange ttlExchange(){
        Map<String, Object> args = new HashMap<>();
        return new DirectExchange("x.ttl", true, false, args);
    }

    /**
     * 死信队列交换器
     * @return
     */
    @Bean
    public Exchange dlxExchange(){
        Map<String, Object> args = new HashMap<>();
        DirectExchange exchange = new DirectExchange("x.dlx", true, false, args);
        return exchange;
    }

    /**
     * 用于发送下单，做分布式事务的MQ
     * @return
     */
    @Bean
    public Binding orderBinding(){
        return BindingBuilder.bind(orderQueue())
                .to(orderExchange())
                .with("k.order")
                .noargs();
    }

    /**
     * 用于等待用户支付的延迟队列绑定
     * @return
     */
    @Bean
    public Binding ttlBinding(){
        return BindingBuilder.bind(ttlQueue())
                .to(ttlExchange())
                .with("k.ttl")
                .noargs();
    }

    /**
     * 用于支付超时取消用户订单的死信队列绑定
     * @return
     */
    @Bean
    public Binding dlxBinding(){
        return BindingBuilder.bind(dlxQueue())
                .to(dlxExchange())
                .with("k.dlx")
                .noargs();
    }




}

OrderController

package com.lagou.rabbitmq.ttlorder.controller;

import com.lagou.rabbitmq.ttlorder.entity.Order;
import com.lagou.rabbitmq.ttlorder.entity.OrderDetail;
import com.lagou.rabbitmq.ttlorder.entity.OrderStatus;
import com.lagou.rabbitmq.ttlorder.utils.Utils;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;

/**
 * 订单控制
 */
@Controller
public class OrderController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 发起一个订单
     * @param model
     * @return
     */
    @RequestMapping("/order")
    public String order(Model model) throws ExecutionException, InterruptedException {
        List<OrderDetail> details = new ArrayList<>();
        OrderDetail od = new OrderDetail();
        od.setItemId(Utils.generateItemId());
        od.setItemName("苹果");
        od.setItemPrice(125);
        od.setNum(5);
        details.add(od);

        Order order = new Order();
        order.setUserId(Utils.generateUserId());
        order.setOrderId(Utils.generateOrderId());
        // 设置状态为待支付
        order.setStatus(OrderStatus.TO_BE_PAYED.toString());
        order.setDetails(details);

        CorrelationData correlationData = new CorrelationData();
        rabbitTemplate.convertAndSend("x.order","k.order",order,correlationData);
        // 同步等待，可以设置为异步回调
        CorrelationData.Confirm confirm = correlationData.getFuture().get();
        // 判断发送的消息是否得到broker的确认
        boolean confirmAck = confirm.isAck();
        if (!confirmAck){
            return "failorder";
        }

        // 发送延迟等待消息
        rabbitTemplate.convertAndSend("x.ttl","k.ttl" , order.getOrderId());

        model.addAttribute("orderId" , order.getOrderId());

        return "order";
    }

    @RequestMapping("/failorder/{orderId}")
    public String failOrder(@PathVariable String orderId , Model model){
        model.addAttribute("orderId",orderId);
        return "fail";
    }

}

PayController

package com.lagou.rabbitmq.ttlorder.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class PayController {

    @RequestMapping("/pay/{orderId}")
    public String pay(@PathVariable String orderId, Model model) {

        // 写数据库

        model.addAttribute("orderId", orderId);
        return "success";
    }


}

MyCancelListener

package com.lagou.rabbitmq.ttlorder.listener;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;

@Component
public class MyCancelListener implements ChannelAwareMessageListener {


    @Override
    @RabbitListener(queues = "q.dlx" , ackMode = "MANUAL")
    public void onMessage(Message message, Channel channel) throws Exception {
        String orderId = new String(message.getBody());
        System.out.println("取消订单：" + orderId);
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }



}

MyOrderListener

package com.lagou.rabbitmq.ttlorder.listener;

import com.lagou.rabbitmq.ttlorder.entity.Order;
import com.lagou.rabbitmq.ttlorder.entity.OrderDetail;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
public class MyOrderListener {

    @RabbitListener(queues = "q.order",ackMode = "MANUAL")
    public void onMessage(Order order , Channel channel , Message message) throws IOException {
        System.out.println("写入数据库");
        System.out.println(order);

        for (OrderDetail detail : order.getDetails()){
            System.out.println(detail);
        }

        channel.basicAck(message.getMessageProperties().getDeliveryTag() , false);
    }

}

Utils

package com.lagou.rabbitmq.ttlorder.utils;

import java.util.Random;

public class Utils {
    private static final Random RANDOM = new Random();

    public static String generateUserId() {
        int i = RANDOM.nextInt(1000000);
        String format = String.format("%06d", i);
        return "u00001-" + format;
    }

    public static String generateOrderId() {
        int i = RANDOM.nextInt(1000000);
        String format = String.format("%06d", i);
        return "oid00001-" + format;
    }

     public static String generateItemId() {
         int i = RANDOM.nextInt(1000000);
         String format = String.format("%06d", i);
         return "item00001-" + format;
     }

}

TTLOrderApplication

package com.lagou.rabbitmq.ttlorder;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class TTLOrderApplication {

    public static void main(String[] args) {
        SpringApplication.run(TTLOrderApplication.class,args);
    }

}

application.properties

server.port=8080

# 设计rabbitmq连接
spring.rabbitmq.host=192.168.25.128

spring.rabbitmq.username=admin
spring.rabbitmq.password=123
# 设置虚拟主机
spring.rabbitmq.virtual-host=/

# 设置发布者确认机制,correlated发布消息成功到交换器后会触发回调方法
# NONE值是禁用发布确认模式，是默认值
spring.rabbitmq.publisher-confirm-type=correlated
spring.rabbitmq.publisher-returns=true

# 消息确认模式为手动确认
spring.rabbitmq.listener.direct.acknowledge-mode=manual