RabbitMQ实现分布式的事务处理（基础向）

RabbitMQ实现分布式的事务处理

由于分布式微服务架构是由consumer将请求发到provider去处理mapper的业务，所以无法使用@Transactional注解，这里需要使用消息中间件，也就是RabbitMQ

事务概念：将一个逻辑单元中涉及到的所有数据库实例的操作捆绑成为一个整体进行管理

RabbitMQ概念：主流的消息队列之一,它遵循AMQP协议,由内在高并发的 Erlang语言开发,用在实时的对可靠性要求比较高的消息传递上

​ 生产者 Producer：发送消息

​ 消费者 Consumer：接收消息

​ 队列 Queue：存储消息的缓存

​ 交换机 Exchange：接收到生产者的消息，根据交换机类型，分发到不同队列中

​ 绑定令牌 Routing key：一个队列对应一个交换机，通过Routing key来绑定

​ 绑定 Binding

springboot整合RabbitMQ实现Topic模式：

1.添加依赖

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

2.编写RabbitMQUtils（以下为个人代码，可直接越过）

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.Map;

/**
 * Created by Administrator on 2018-5-13.
 */
@Configuration
public class RabbitMQUtils {

    private Map<String, Object> args = new HashMap<String, Object>();

    @PostConstruct
    public void init(){
        // 设置该Queue的死信的信箱
        args.put("x-dead-letter-exchange", Constants.DEAD_LETTER_EXCHANGE);
        // 设置死信routingKey
        args.put("x-dead-letter-routing-key", Constants.DEAD_LETTER_ROUTINKEY);
    }

    //声明一个死信交换机
    @Bean
    public TopicExchange deadLetterExchange() {
        return new TopicExchange(
                Constants.DEAD_LETTER_EXCHANGE,
                true,
                true);
    }

    //声明一个死信队列用来存放死信消息
    @Bean
    public Queue deadQueue() {
        return new Queue(Constants.DEAD_QUEUE,
                true,
                false,
                true,
                null);
    }

    // 将死信队列和死信的交换机绑定
    @Bean
    public Binding bindingDead() {
        return BindingBuilder.bind(deadQueue()).
                to(deadLetterExchange()).
                with(Constants.DEAD_LETTER_ROUTINKEY);
    }

    @Bean
    public Queue toQgQueue() {
        Map<String, Object> args = new HashMap<String, Object>();
        // 设置该Queue的死信的信箱
        args.put("dead-letter-exchange", Constants.DEAD_LETTER_EXCHANGE);
        // 设置死信routingKey
        args.put("dead-letter-routing-key", Constants.DEAD_LETTER_ROUTINKEY);
        return new Queue(
                Constants.RabbitQueueName.TO_QG_QUEUE,
                true,
                false,
                true, args);
    }

    @Bean
    public Queue toCreateOrderQueue() {
        return new Queue(Constants.RabbitQueueName.TO_CREATE_ORDER, true, false, true, args);
    }

    @Bean
    public Queue toUpdateOrderQueue() {
        return new Queue(Constants.RabbitQueueName.TO_UPDATED_ORDER_QUEUE, true, false, true, args);
    }

    @Bean
    public Queue toUpdateGoodsQueue() {
        return new Queue(Constants.RabbitQueueName.TO_UPDATED_GOODS_QUQUE, true, false, true, args);
    }

    /**
     * 重置座位状态
     *
     * @return
     */
    @Bean
    public Queue toResetSeatQueue() {
        args.put("x-dead-letter-exchange", Constants.DEAD_LETTER_EXCHANGE);
        // 设置死信routingKey
        args.put("x-dead-letter-routing-key", Constants.DEAD_LETTER_ROUTINKEY);
        return new Queue(Constants.RabbitQueueName.TO_RESET_SEAT_QUQUE, true, false, true, args);
    }

    /**
     * 删除订单
     *
     * @return
     */
    @Bean
    public Queue toDelOrderQueue() {
        return new Queue(Constants.RabbitQueueName.TO_DEL_ORDER_QUQUE, true, false, true, args);
    }

    /**
     * 重置联系人
     *
     * @return
     */
    @Bean
    public Queue toResetLinkUserQueue() {
        return new Queue(Constants.RabbitQueueName.TO_RESET_LINKUSER_QUQUE, true, false, true, args);
    }

    @Bean
    TopicExchange topicExchange() {
        return new TopicExchange(
                Constants.RabbitQueueName.TOPIC_EXCHANGE,
                true,
                true);
    }

    @Bean
    public Binding bindingToQg() {
        return BindingBuilder.bind(toQgQueue()).to(topicExchange()).with("key.toQg");
    }

    @Bean
    public Binding bindingToCreateOrder() {
        return BindingBuilder.bind(toCreateOrderQueue()).to(topicExchange()).with("key.toCreateOrder");
    }

    @Bean
    public Binding bindingToUpdateOrder() {
        return BindingBuilder.bind(toUpdateOrderQueue()).to(topicExchange()).with("key.toUpdateOrder");
    }

    @Bean
    public Binding bindingToUpdateGoods() {
        return BindingBuilder.bind(toUpdateGoodsQueue()).to(topicExchange()).with("key.toUpdateGoods");
    }

    @Bean
    public Binding bindingToResetSeat() {
        return BindingBuilder.bind(toResetSeatQueue()).to(topicExchange()).with(Constants.RabbitQueueName.TO_RESET_SEAT_QUQUE);
    }

    @Bean
    public Binding bindingToDelOrder() {
        return BindingBuilder.bind(toDelOrderQueue()).to(topicExchange()).with(Constants.RabbitQueueName.TO_DEL_ORDER_QUQUE);
    }

    @Bean
    public Binding bindingToResetLinkUser() {
        return BindingBuilder.bind(toResetLinkUserQueue()).to(topicExchange()).with(Constants.RabbitQueueName.TO_RESET_LINKUSER_QUQUE);
    }
}

//new Queue(queue: 队列名称,durable： 是否持久化,exclusive：是否排外的,autoDelete：是否自动删除)
//参考文章：https://blog.csdn.net/fsgsggd/article/details/81349553

3.在所需事务service下添加如下类

@Autowired
private RabbitTemplate rabbitTemplate;

4.死信队列：如果遇到需要重置的情况，发送者将消息直接发送到接收者，如果中间出现问题，重置可能会出现失败的情况，所以需要将消息通过中间件发送，如果重置消息发送异常，那么将其发送到死信队列，由死信队列将消息不断发送至接收者，直到接收成功为止

此外，如果当消息发送到中间件，中间件宕机，由于中间件有持久化概念，消息会存在硬盘中，当恢复运行时继续发送消息

//重置方法
private void sendRestSeatMsg(Long schedulerId, String[] seatArray) {
        Map<String,Object> paramSeat = new HashMap<>();
        paramSeat.put("scheduleId",schedulerId);
        paramSeat.put("seats",seatArray);
        rabbitTemplate.convertAndSend(Constants.RabbitQueueName.TOPIC_EXCHANGE,
                Constants.RabbitQueueName.TO_RESET_SEAT_QUQUE, paramSeat, new MessagePostProcessor() {
                    @Override
                    public Message postProcessMessage(Message message) throws AmqpException {
                        //设置消息持久化
                        message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
                        return message;
                    }
                });
    }
//convertAndSend：交换机将信息发送给所有的消费者
//参数：（交换机名，Routing key（队列名），数据，消息持久化）

5.消息接收，通过 @RabbitListener(queues = 消息队列名)接收

出现异常时，通过 channel.basicNack()将消息放入死信队列

//重置座位消息消费者
    @RabbitListener(queues = Constants.RabbitQueueName.TO_RESET_SEAT_QUQUE)
    public void resetSeatMsg(Map<String,Object> resetSeatMap, Message message, Channel channel) throws Exception {
        Long scheduleId = (Long)resetSeatMap.get("scheduleId");
        String[] seatArray = (String[]) resetSeatMap.get("seats");
        try {
            //具体重置业务
        }catch (Exception e){
            //消费者自身业务发生异常  将消息放入到死信队列
            channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,false);
        }
    }
//basicNack（deliveryTag,multiple,requeue）
//deliveryTag:该消息的index
//multiple：是否批量.true:将一次性拒绝所有小于deliveryTag的消息
//requeue：被拒绝的是否重新入队列 注意：如果设置为true ，则会添加在队列的末端
//参考文章：https://www.jianshu.com/p/537cb84ba72f