学成在线笔记十五：分布式事务(完结)

最新推荐文章于 2024-04-19 22:44:35 发布
最新推荐文章于 2024-04-19 22:44:35 发布
阅读量564 收藏
点赞数
分类专栏： 学成在线
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq1031893936/article/details/107402482
版权

分布式事务

概述

什么是分布式系统

部署在不同结点上的系统通过网络交互来完成协同工作的系统。

比如：充值加积分的业务，用户在充值系统向自己的账户充钱，在积分系统中自己积分相应的增加。充值系统和积分系统是两个不同的系统，一次充值加积分的业务就需要这两个系统协同工作来完成。

什么是事务

事务是指由一组操作组成的一个工作单元，这个工作单元具有原子性（atomicity）、一致性（consistency）、隔离性（isolation）和持久性（durability）。

原子性：执行单元中的操作要么全部执行成功，要么全部失败。如果有一部分成功一部分失败那么成功的操作要全部回滚到执行前的状态。一致性：执行一次事务会使用数据从一个正确的状态转换到另一个正确的状态，执行前后数据都是完整的。 隔离性：在该事务执行的过程中，任何数据的改变只存在于该事务之中，对外界没有影响，事务与事务之间是完全的隔离的。只有事务提交后其它事务才可以查询到最新的数据。 持久性：事务完成后对数据的改变会永久性的存储起来，即使发生断电宕机数据依然在。

什么是本地事务

本地事务就是用关系数据库来控制事务，关系数据库通常都具有ACID特性，传统的单体应用通常会将数据全部储在一个数据库中，会借助关系数据库来完成事务控制。

什么是分布式事务

在分布式系统中一次操作由多个系统协同完成，这种一次事务操作涉及多个系统通过网络协同完成的过程称为分布式事务。这里强调的是多个系统通过网络协同完成一个事务的过程，并不强调多个系统访问了不同的数据库，即使多个系统访问的是同一个数据库也是分布式事务，如下图：

https://imxushuai-01.coding.net/p/pic/d/pic/git/raw/3223a71f3eb98e232c058d074f5d57c4fbf0ac3a/%E5%AD%A6%E6%88%90%E5%9C%A8%E7%BA%BF-%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1%E7%A4%BA%E6%84%8F%E5%9B%BE1.jpg

另外一种分布式事务的表现是，一个应用程序使用了多个数据源连接了不同的数据库，当一次事务需要操作多个数据源，此时也属于分布式事务，当系统作了数据库拆分后会出现此种情况。

https://imxushuai-01.coding.net/p/pic/d/pic/git/raw/3223a71f3eb98e232c058d074f5d57c4fbf0ac3a/%E5%AD%A6%E6%88%90%E5%9C%A8%E7%BA%BF-%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1%E7%A4%BA%E6%84%8F%E5%9B%BE2.jpg

分布式场景例子

  • 电商系统中的下单扣库存

    电商系统中，订单系统和库存系统是两个系统，一次下单的操作由两个系统协同完成

  • 金融系统中的银行卡充值

    在金融系统中通过银行卡向平台充值需要通过银行系统和金融系统协同完成。

  • 教育系统中下单选课业务

    在线教育系统中，用户购买课程，下单支付成功后学生选课成功，此事务由订单系统和选课系统协同完成。

  • SNS系统的消息发送

    在社交系统中发送站内消息同时发送手机短信，一次消息发送由站内消息系统和手机通信系统协同完成。

CAP理论

如何进行分布式事务控制？CAP理论是分布式事务处理的理论基础，了解了CAP理论有助于我们研究分布式事务的处理方案。

CAP理论是：分布式系统在设计时只能在一致性(Consistency)、可用性(Availability)、分区容忍性(PartitionTolerance)中满足两种，无法兼顾三种。

https://imxushuai-01.coding.net/p/pic/d/pic/git/raw/ccc2b96762033b9e17e2b1ef6dcc081749315276/%E5%AD%A6%E6%88%90%E5%9C%A8%E7%BA%BF-CAP%E7%A4%BA%E6%84%8F%E5%9B%BE.jpg

一致性(Consistency)：服务A、B、C三个结点都存储了用户数据， 三个结点的数据需要保持同一时刻数据一致性。

可用性(Availability)：服务A、B、C三个结点，其中一个结点宕机不影响整个集群对外提供服务，如果只有服务A结点，当服务A宕机整个系统将无法提供服务，增加服务B、C是为了保证系统的可用性。

分区容忍性(Partition Tolerance)：分区容忍性就是允许系统通过网络协同工作，分区容忍性要解决由于网络分区导致数据的不完整及无法访问等问题。

分布式系统不可避免的出现了多个系统通过网络协同工作的场景，结点之间难免会出现网络中断、网延延迟等现象，这种现象一旦出现就导致数据被分散在不同的结点上，这就是网络分区。

分布式系统能否兼顾C、A、P？

在保证分区容忍性的前提下一致性和可用性无法兼顾，如果要提高系统的可用性就要增加多个结点，如果要保证数据的一致性就要实现每个结点的数据一致，结点越多可用性越好，但是数据一致性越差。所以，在进行分布式系统设计时，同时满足“一致性”、“可用性”和“分区容忍性”三者是几乎不可能的。

CAP有哪些组合方式？

  1. CA：放弃分区容忍性，加强一致性和可用性，关系数据库按照CA进行设计。
  2. AP：放弃一致性，加强可用性和分区容忍性，追求最终一致性，很多NoSQL数据库按照AP进行设计。
    说明：这里放弃一致性是指放弃强一致性，强一致性就是写入成功立刻要查询出最新数据。追求最终一致性是指允许暂时的数据不一致，只要最终在用户接受的时间内数据 一致即可。
  3. CP：放弃可用性，加强一致性和分区容忍性，一些强一致性要求的系统按CP进行设计，比如跨行转账，一次转账请求要等待双方银行系统都完成整个事务才算完成。

分布式事务解决方案

两阶段提交（2PC）

为解决分布式系统的数据一致性问题出现了两阶段提交协议（2 Phase Commitment Protocol），两阶段提交由
协调者和参与者组成，共经过两个阶段和三个操作，部分关系数据库如Oracle、MySQL支持两阶段提交协议，本节讲解关系数据库两阶段提交协议。

https://imxushuai-01.coding.net/p/pic/d/pic/git/raw/824aa579c84be902f84e3129ce7d678499adc359/%E5%AD%A6%E6%88%90%E5%9C%A8%E7%BA%BF-%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1-2PC.jpg

  1. 第一阶段：准备阶段（prepare）

    协调者通知参与者准备提交订单，参与者开始投票。协调者完成准备工作向协调者回应Yes。

  2. 第二阶段：提交(commit)/回滚(rollback)阶段

    协调者根据参与者的投票结果发起最终的提交指令。如果有参与者没有准备好则发起回滚指令。

2PC示例：以下单为例子

https://imxushuai-01.coding.net/p/pic/d/pic/git/raw/824aa579c84be902f84e3129ce7d678499adc359/%E5%AD%A6%E6%88%90%E5%9C%A8%E7%BA%BF-%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1-2PC%E7%A4%BA%E4%BE%8B.jpg

  1. 应用程序连接两个数据源。
  2. 应用程序通过事务协调器向两个库发起prepare，两个数据库收到消息分别执行本地事务（记录日志），但不提交，如果执行成功则回复yes，否则回复no。
  3. 事务协调器收到回复，只要有一方回复no则分别向参与者发起回滚事务，参与者开始回滚事务。
  4. 事务协调器收到回复，全部回复yes，此时向参与者发起提交事务。如果参与者有一方提交事务失败则由事务协调器发起回滚事务。

优点：实现强一致性，部分关系数据库支持（Oracle、MySQL等）。

缺点：整个事务的执行需要由协调者在多个节点之间去协调，增加了事务的执行时间，性能低下。

解决方案有：springboot + Atomikos / Bitronix

事务补偿（TCC）

TCC事务补偿是基于2PC实现的业务层事务控制方案，它是Try、Confirm和Cancel三个单词的首字母，含义如下：

  • Try 检查及预留业务资源

    完成提交事务前的检查，并预留好资源。

  • Confirm 确定执行业务操作

    对try阶段预留的资源正式执行。

  • Cancel 取消执行业务操作

    对try阶段预留的资源释放。

TCC示例：下单

https://imxushuai-01.coding.net/p/pic/d/pic/git/raw/f46aa69f988a3b7ba0288bb6452e626d6061acca/%E5%AD%A6%E6%88%90%E5%9C%A8%E7%BA%BF-%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1-TCC%E7%A4%BA%E4%BE%8B.jpg

  1. Try

    下单业务由订单服务和库存服务协同完成，在try阶段订单服务和库存服务完成检查和预留资源。订单服务检查当前是否满足提交订单的条件（比如：当前存在未完成订单的不允许提交新订单）。库存服务检查当前是否有充足的库存，并锁定资源。

  2. Confirm

    订单服务和库存服务成功完成Try后开始正式执行资源操作。订单服务向订单写一条订单信息。库存服务减去库存。

  3. Cancel

    如果订单服务和库存服务有一方出现失败则全部取消操作。订单服务需要删除新增的订单信息。库存服务将减去的库存再还原。

优点：最终保证数据的一致性，在业务层实现事务控制，灵活性好。

缺点：开发成本高，每个事务操作每个参与者都需要实现try,confirm,cancel三个接口。

注意：TCC的try,confirm,cancel接口都要实现幂等性，在为在try、confirm、cancel失败后要不断重试。

什么是幂等性？

幂等性是指同一个操作无论请求多少次，其结果都相同。

幂等操作实现方式有：

  1. 操作之前在业务方法进行判断如果执行过了就不再执行。
  2. 缓存所有请求和处理的结果，已经处理的请求则直接返回结果。
  3. 在数据库表中加一个状态字段（未处理，已处理），数据操作时判断未处理时再处理。

消息队列实现最终一致

消息队列实现最终一致示例：下单

https://imxushuai-01.coding.net/p/pic/d/pic/git/raw/475b1901d6709df70c9e0cc3a6845cbfd987d1e6/%E5%AD%A6%E6%88%90%E5%9C%A8%E7%BA%BF-%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1-%E6%B6%88%E6%81%AF%E9%98%9F%E5%88%97%E7%A4%BA%E4%BE%8B.jpg

  1. 订单服务和库存服务完成检查和预留资源。
  2. 订单服务在本地事务中完成添加订单表记录和添加“减少库存任务消息”。
  3. 由定时任务根据消息表的记录发送给MQ通知库存服务执行减库存操作。
  4. 库存服务执行减少库存，并且记录执行消息状态（为避免重复执行消息，在执行减库存之前查询是否执行过此消息）。
  5. 库存服务向MQ发送完成减少库存的消息。
  6. 订单服务接收到完成库存减少的消息后删除原来添加的“减少库存任务消息”。

实现最终事务一致要求：预留资源成功理论上要求正式执行成功，如果执行失败会进行重试，要求业务执行方法实现幂等。

优点 ：由MQ按异步的方式协调完成事务，性能较高。不用实现try,confirm,cancel接口，开发成本比TCC低。

缺点：此方式基于关系数据库本地事务来实现，会出现频繁读写数据库记录，浪费数据库资源，另外对于高并发操作不是最佳方案。

项目导入与数据库创建（省略）

定时任务

需求分析

根据分布式事务的研究结果，订单服务需要定时扫描任务表向MQ发送任务。本节研究定时任务处理的方案，并实现定时任务扫描任务表并向MQ发送消息。

实现定时任务的方案如下：

  1. 使用jdk的Timer和TimerTask实现

    可以实现简单的间隔执行任务，无法实现按日历去调度执行任务。

  2. 使用Quartz实现

    Quartz 是一个异步任务调度框架，功能丰富，可以实现按日历调度。

  3. 使用Spring Task实现

    Spring 3.0后提供Spring Task实现任务调度，支持按日历调度，相比Quartz功能稍简单，但是在开发基本够用，支持注解编程方式。

串行任务

串行任务比较简单，直接使用@Scheduled注解。

Cron表达式，也比较简单，不会有人没用过吧，不会吧不会吧不会吧！！！

实在没用过，可以使用在线的Cron表达式生成器。

注意：需要在Spring Boot启动类上添加@EnableScheduling注解

并行任务

创建异步任务配置类，配置线程池实现任务的并行执行

package com.xuecheng.order.config;

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;

import java.util.concurrent.Executor;

@Configuration
//@EnableScheduling // 未在启动类添加该注解的话,可以在这里添加
public class AsyncTaskConfig implements SchedulingConfigurer, AsyncConfigurer {
    
    // 线程池线程数量
    private int corePoolSize = 5;

    @Bean
    public ThreadPoolTaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.initialize();// 初始化线程池
        scheduler.setPoolSize(corePoolSize);// 线程池容量
        return scheduler;
    }

    @Override
    public Executor getAsyncExecutor() {
        return taskScheduler();
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return null;
    }

    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
        scheduledTaskRegistrar.setTaskScheduler(taskScheduler());
    }

}

配置好了，使用@Scheduled注解的方法，都将使用线程池运行。

订单服务定时发送消息

RabbitMQ配置

配置RabbitMQ的queue和exchange

package com.xuecheng.order.config;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfig {

    //添加选课任务交换机
    public static final String EX_LEARNING_ADDCHOOSECOURSE = "ex_learning_addchoosecourse";

    //添加选课消息队列
    public static final String XC_LEARNING_ADDCHOOSECOURSE = "xc_learning_addchoosecourse";

    //完成添加选课消息队列
    public static final String XC_LEARNING_FINISHADDCHOOSECOURSE = "xc_learning_finishaddchoosecourse";

    //添加选课路由key
    public static final String XC_LEARNING_ADDCHOOSECOURSE_KEY = "addchoosecourse";

    //完成添加选课路由key
    public static final String XC_LEARNING_FINISHADDCHOOSECOURSE_KEY = "finishaddchoosecourse";

    /**
     * 交换机配置
     *
     * @return the exchange
     */
    @Bean(EX_LEARNING_ADDCHOOSECOURSE)
    public Exchange EX_DECLARE() {
        return ExchangeBuilder.directExchange(EX_LEARNING_ADDCHOOSECOURSE).durable(true).build();
    }

    //声明队列
    @Bean(XC_LEARNING_FINISHADDCHOOSECOURSE)
    public Queue QUEUE_XC_LEARNING_FINISHADDCHOOSECOURSE() {
        return new Queue(XC_LEARNING_FINISHADDCHOOSECOURSE);
    }

    //声明队列
    @Bean(XC_LEARNING_ADDCHOOSECOURSE)
    public Queue QUEUE_XC_LEARNING_ADDCHOOSECOURSE() {
        return new Queue(XC_LEARNING_ADDCHOOSECOURSE);
    }

    /**
     * 绑定队列到交换机
     *
     * @param queue    the queue
     * @param exchange the exchange
     * @return the binding
     */
    @Bean
    public Binding BINDING_QUEUE_FINISHADDCHOOSECOURSE(@Qualifier(XC_LEARNING_FINISHADDCHOOSECOURSE) Queue queue, 
                                                       @Qualifier(EX_LEARNING_ADDCHOOSECOURSE) Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(XC_LEARNING_FINISHADDCHOOSECOURSE_KEY).noargs();
    }

    @Bean
    public Binding BINDING_QUEUE_ADDCHOOSECOURSE(@Qualifier(XC_LEARNING_ADDCHOOSECOURSE) Queue queue, 
                                                 @Qualifier(EX_LEARNING_ADDCHOOSECOURSE) Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(XC_LEARNING_ADDCHOOSECOURSE_KEY).noargs();
    }


}

查询待执行任务列表

dao

编写XcTaskRepository

package com.xuecheng.order.dao;

import com.xuecheng.framework.domain.task.XcTask;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import java.util.Date;

public interface XcTaskRepository extends JpaRepository<XcTask, String> {

    Page<XcTask> findByUpdateTimeBefore(Date updateTime, Pageable pageable);

    //更新任务处理时间
    @Modifying
    @Query("update XcTask t set t.updateTime = :updateTime where t.id = :id ")
    int updateTaskTime(@Param(value = "id") String id, @Param(value = "updateTime") Date updateTime);
}

service

编写TaskService

package com.xuecheng.order.service;

import com.xuecheng.framework.domain.task.XcTask;
import com.xuecheng.order.dao.XcTaskRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.util.Date;
import java.util.List;
import java.util.Optional;

@Slf4j
@Service
public class TaskService {

    @Autowired
    private XcTaskRepository xcTaskRepository;

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 查询指定时间的前 N 条任务
     *
     * @param updateTime 时间
     * @param n          前N条记录
     * @return task list
     */
    public List<XcTask> findTaskList(Date updateTime, int n) {
        Page<XcTask> taskPage = xcTaskRepository.findByUpdateTimeBefore(updateTime, PageRequest.of(0, n));
        return taskPage.getContent();
    }

    /**
     * 发送消息
     *
     * @param xcTask     任务对象
     * @param ex         交换机id
     * @param routingKey 路由key
     */
    @Transactional
    public void publish(XcTask xcTask, String ex, String routingKey) {
        //查询任务
        Optional<XcTask> taskOptional = xcTaskRepository.findById(xcTask.getId());
        if (taskOptional.isPresent()) {
            XcTask task = taskOptional.get();
            //String exchange, String routingKey, Object object
            rabbitTemplate.convertAndSend(ex, routingKey, task);
            //更新任务时间为当前时间
            task.setUpdateTime(new Date());
            xcTaskRepository.save(task);
        }
    }


}

task

编写任务类

package com.xuecheng.order.task;

import com.xuecheng.framework.domain.task.XcTask;
import com.xuecheng.order.service.TaskService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

/**
 * 定时发送消息到MQ
 */
@Slf4j
@Component
public class ChooseCourseTask {

    @Autowired
    private TaskService taskService;

    /**
     * 每分钟扫描消息表，发送到MQ
     */
    @Scheduled(fixedDelay = 60000)
    public void sendChooseCourseTask() {
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(new Date());
        calendar.add(GregorianCalendar.MINUTE, -1);
        Date time = calendar.getTime();
        List<XcTask> taskList = taskService.findTaskList(time, 1000);

        // 发送消息
        taskList.forEach(task -> {
            taskService.publish(task, task.getMqExchange(), task.getMqRoutingkey());
            log.info("[订单微服务] 发送选课消息到MQ, task id :[{}]", task.getId());
        });
    }

}

自动添加选课记录

学习服务添加选课记录

RabbitMQ配置

与订单服务RabbitMQ配置一致

dao

  • 选课dao

    package com.xuecheng.learning.dao;

import com.xuecheng.framework.domain.learning.XcLearningCourse;
import org.springframework.data.jpa.repository.JpaRepository;

public interface XcLearningCourseRepository extends JpaRepository<XcLearningCourse, String> {
    //根据用户和课程查询选课记录，用于判断是否添加选课
    XcLearningCourse findXcLearningCourseByUserIdAndCourseId(String userId, String courseId);
}

  • 历史任务dao

    package com.xuecheng.learning.dao;

import com.xuecheng.framework.domain.task.XcTaskHis;
import org.springframework.data.jpa.repository.JpaRepository;

public interface XcTaskHisRepository extends JpaRepository<XcTaskHis,String> {
}

service

LearningService新增方法

/**
     * 添加选课记录
     *
     * @param userId    选课用户
     * @param courseId  课程ID
     * @param valid     是否有效
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @param xcTask    选课任务
     * @return 选课结果
     */
    @Transactional
    public ResponseResult addcourse(String userId, String courseId, String valid,
                                    Date startTime, Date endTime, XcTask xcTask) {
        if (StringUtils.isEmpty(courseId)) {
            ExceptionCast.cast(LearningCode.LEARNING_GETMEDIA_ERROR);
        }

        if (StringUtils.isEmpty(userId)) {
            ExceptionCast.cast(LearningCode.CHOOSECOURSE_USERISNULL);
        }

        if (xcTask == null || StringUtils.isEmpty(xcTask.getId())) {
            ExceptionCast.cast(LearningCode.CHOOSECOURSE_TASKISNULL);
        }

        //查询历史任务
        Optional<XcTaskHis> optional = xcTaskHisRepository.findById(xcTask.getId());
        if (optional.isPresent()) {
            return new ResponseResult(CommonCode.SUCCESS);
        }
        XcLearningCourse xcLearningCourse = xcLearningCourseRepository.findXcLearningCourseByUserIdAndCourseId(userId, courseId);
        if (xcLearningCourse == null) {//没有选课记录则添加
            xcLearningCourse = new XcLearningCourse();
            xcLearningCourse.setUserId(userId);
            xcLearningCourse.setCourseId(courseId);
            xcLearningCourse.setValid(valid);
            xcLearningCourse.setStartTime(startTime);
            xcLearningCourse.setEndTime(endTime);
            xcLearningCourse.setStatus("501001");
            xcLearningCourseRepository.save(xcLearningCourse);
        } else {//有选课记录则更新日期
            xcLearningCourse.setValid(valid);
            xcLearningCourse.setStartTime(startTime);
            xcLearningCourse.setEndTime(endTime);
            xcLearningCourse.setStatus("501001");
            xcLearningCourseRepository.save(xcLearningCourse);
        }

        //向历史任务表播入记录
        Optional<XcTaskHis> optionalXcTaskHis = xcTaskHisRepository.findById(xcTask.getId());
        if (!optionalXcTaskHis.isPresent()) {
            //添加历史任务
            XcTaskHis xcTaskHis = new XcTaskHis();
            BeanUtils.copyProperties(xcTask, xcTaskHis);
            xcTaskHisRepository.save(xcTaskHis);
        }

        return new ResponseResult(CommonCode.SUCCESS);
    }

task

package com.xuecheng.learning.mq;

import com.alibaba.fastjson.JSON;
import com.xuecheng.framework.domain.task.XcTask;
import com.xuecheng.framework.model.response.ResponseResult;
import com.xuecheng.learning.config.RabbitMQConfig;
import com.xuecheng.learning.service.LearningService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;

@Slf4j
@Component
public class ChooseCourseTask {


    @Autowired
    LearningService learningService;

    @Autowired
    RabbitTemplate rabbitTemplate;

    /**
     * 接收选课任务
     */
    @RabbitListener(queues = {RabbitMQConfig.XC_LEARNING_ADDCHOOSECOURSE})
    public void receiveChoosecourseTask(XcTask xcTask) throws IOException {
        log.info("receive choose course task,taskId:{}", xcTask.getId());
        
        //接收到 的消息id
        String id = xcTask.getId();
        
        //添加选课
        try {
            String requestBody = xcTask.getRequestBody();
            Map map = JSON.parseObject(requestBody, Map.class);
            String userId = (String) map.get("userId");
            String courseId = (String) map.get("courseId");
            String valid = (String) map.get("valid");
            Date startTime = null;
            Date endTime = null;
            SimpleDateFormat dateFormat = new SimpleDateFormat("YYYY‐MM‐dd HH:mm:ss");
            if (map.get("startTime") != null) {
                startTime = dateFormat.parse((String) map.get("startTime"));
            }
            if (map.get("endTime") != null) {
                endTime = dateFormat.parse((String) map.get("endTime"));
            }
            
            //添加选课
            ResponseResult addcourse = learningService.addcourse(userId, courseId, valid, startTime, endTime, xcTask);
            
            //选课成功发送响应消息
            if (addcourse.isSuccess()) {
                //发送响应消息
                rabbitTemplate.convertAndSend(RabbitMQConfig.EX_LEARNING_ADDCHOOSECOURSE, RabbitMQConfig.XC_LEARNING_FINISHADDCHOOSECOURSE_KEY, xcTask);
                log.info("send finish choose course taskId:{}", id);
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("send finish choose course taskId:{}", id);
        }
    }
}

订单服务结束任务

dao

定义XcTaskHisRepository

package com.xuecheng.order.dao;

import com.xuecheng.framework.domain.task.XcTaskHis;
import org.springframework.data.jpa.repository.JpaRepository;

public interface XcTaskHisRepository extends JpaRepository<XcTaskHis, String> {
}

service

TaskService中新增方法

    @Autowired
    private XcTaskHisRepository xcTaskHisRepository;

	/**
     * 删除指定ID的任务并添加到历史任务中
     * 
     * @param taskId 任务id
     */
    @Transactional
    public void finishTask(String taskId) {
        Optional<XcTask> taskOptional = xcTaskRepository.findById(taskId);
        if (taskOptional.isPresent()) {
            XcTask xcTask = taskOptional.get();
            xcTask.setDeleteTime(new Date());
            XcTaskHis xcTaskHis = new XcTaskHis();
            BeanUtils.copyProperties(xcTask, xcTaskHis);
            xcTaskHisRepository.save(xcTaskHis);
            xcTaskRepository.delete(xcTask);
        }
    }

task

修改ChooseCourseTask，新增消息监听器方法

    /**
     * 接收选课响应结果
     */
    @RabbitListener(queues = {RabbitMQConfig.XC_LEARNING_FINISHADDCHOOSECOURSE})
    public void receiveFinishChoosecourseTask(XcTask task) throws IOException {
        log.info("receiveChoosecourseTask...{}",task.getId());
        //接收到 的消息id
        String id = task.getId();
        //删除任务，添加历史任务
        taskService.finishTask(id);
    }

完结

这个项目算是基本做完了，后面还一天的课程是关于DevOps的，不打算做了，也不打算写笔记了，之前做十次方的时候，DevOps基本上做了一整遍了，大致砍了，基本上没什么变化。

呼~~~，终于做完了。后面应该会出一片文章，文章内可以下载到我的代码和项目相关的其他资源。

下一个学习目标的话，目前我有几个打算：

  • 补一下数据结构和算法

    因为之前大学，这块没好好学

  • 尚硅谷：谷粒商城

    技术比较新，而且好像知识面涉及的挺全的，虽然商城项目做腻了，但是还想看看。

    技术涵盖：微服务架构+分布式+全栈+集群+部署+自动化运维+可视化CICD

  • JVM、源码、分布式理论、设计模式详解等…

    更深层次的内容，很有必要。

  • 大数据

    后面有转大数据的想法，emmm，不知道，到时候再看吧，还有很多东西没学。哎！谁叫自己懒呢。

imxushuai
关注
专栏目录
学成在线项目笔记
weixin_45479215的博客
07-03 363
异常捕捉类（ExceptionCatch） 我们要捕捉两种异常：自定义（可预测），框架自带的（不可预测） 知识点： ​ 说到异常肯定要与logger日志对象打交道，好记性不如烂笔头 ​ @ControllerAdvice //控制器增强 ​ ImmutableMap：这个map写完不能改，可以用做只读（com.google.common.collect.ImmutableMap） ​ ResultCode类：包装三个属性（操作成功与否，code数字，messag
分布式事务笔记
moou_1648的博客
02-11 106
Seata的四种模式：XA模式、AT模式、TCC模式、SAGA模式
学成在线笔记
01-22
在线教育的markdown笔记
学成在线-第19天-讲义-分布式事务
kai46385076的专栏
06-05 1018
1订单与选课需求分析 1.1订单支付流程 学成在线的课程分为免费和收费两种。对于收费课程，用户需提交订单并完成支付方可在线学习。 提交订单及支付流程如下： 1、用户提交订单需要先登录系统 2、提交订单，订单信息保存到订单数据库 3、订单支付，调用微信支付接口完成支付 4、完成支付，微信支付系统通知学成在线支付结果 5、学成在线接收到支付结果通知，更新支付结果 提交订单流程： 1、用户进入课程详...
学成在线学习笔记-序
qq_42279394的博客
06-03 414
2020.6.3，5月底我就开始学习 学成在线这个项目了，项目内容多，体系很大，需要花一定时间去学习，每天的任务量确实很大，视频讲的很细，自己本来就是一个拖延的人，所以想借用博客写一写笔记，顺便记录在其中遇到的一些问题，每天必反馈。 前面一些环境的搭建已经过了就不记录了，今天上午学习的内容是学习mongodb的一些增删查改方法： mongodb 查询方法 List all = cmsPageRepository.findAll();查所有 直接返回 Pageable pageable = PageReque
（二）分布式事务
ACMer_AK的博客
12-08 340
2PC 3PC TCC
【黑马-SpringCloudAlibaba】学习笔记10-Seata：实现分布式事务控制
qq_44897733的博客
11-10 517
实现分布式事务控制
Jmeter学习笔记十五：Jmeter3.3分布式压测实战
我们仨
03-11 1498
在使用Jmeter进行性能测试时，如果并发数比较大(比如项目需要支持1000并发)，单台电脑的配置(CPU和内存)可能无法支持，这时可以使用Jmeter提供的分布式测试的功能。 1.什么是分布式？ 由多台电脑共同完成同一个任务（请求）部署，我们称这种部署为分布式部署。 2.Jmeter分布式执行原理 一台电脑作为控制机(Controller)，其它电脑做为执行机(Agent); 执行时，...
分布式事务最经典的七种解决方案
最新发布
ehehhahs的博客
04-19 672
面试难免让人焦虑不安。经历过的人都懂的。但是如果你提前预测面试官要问你的问题并想出得体的回答方式，就会容易很多。此外，都说“面试造火箭，工作拧螺丝”，那对于准备面试的朋友，你只需懂一个字：刷！给我刷刷刷刷，使劲儿刷刷刷刷刷！今天既是来谈面试的，那就必须得来整点面试真题，这不花了我整28天，做了份“Java一线大厂高岗面试题解析合集：JAVA基础-中级-高级面试+SSM框架+分布式+性能调优+微服务+并发编程+网络+设计模式+数据结构与算法等”
Java 学成在线笔记
04-15
Java 学成在线笔记。 在线教育的markdown笔记 笔记 Java 学成在线笔记。
笔记：分布式大数据技术原理（一）Hadoop 框架
WeeeicheN 的博客
07-20 1233
前言-从 Hadoop 说起 什么是 Hadoop Apache Hadoop 软件库是一个框架，它允许使用简单的编程模型，实现跨计算机集群的大型数据集的分布式处理。它最初的设计目的是为了检测和处理应用程序层的故障，从单个机器扩展到数千台机器（这些机器可以是廉价的），每个机器提供本地计算和存储，而不是依靠硬件提供高可用性。 Hadoop 中有3个核心组件： 分布式文件系统：HDFS —— 实现将文件分布式存储在很多的服务器上 分布式运算编程框架：MapReduce —— 实现在很多机器上...
SpringCloud Alibaba微服务实战三十二 - 集成RocketMQ实现分布式事务
2401_84003690的博客
04-18 413
小编也是很有感触，如果一直都是在中小公司，没有接触过大型的互联网架构设计的话，只靠自己看书去提升可能一辈子都很难达到高级架构师的技术和认知高度。向厉害的人去学习是最有效减少时间摸索、精力浪费的方式。我们选择的这个行业就一直要持续的学习，又很吃青春饭。虽然大家可能经常见到说程序员年薪几十万，但这样的人毕竟不是大部份，要么是有名校光环，要么是在阿里华为这样的大企业。年龄一大，更有可能被裁。送给每一位想学习Java小伙伴，用来提升自己。
学成在线-第19天-讲义-分布式事务 四
qq_40208605的博客
02-24 144
2.4.3消息队列实现最终一致本方案是将分布式事务拆分成多个本地事务来完成，并且由消息队列异步协调完成，如下图：下边以下单减少库存为例来说明：1、订单服务和库存服务完成检查和预留资源。2、订单服务在本地事务中完成添加订单表记录和添加“减少库存任务消息”。3、由定时任务根据消息表的记录发送给MQ通知库存服务执行减库存操作。4、库存服务执行减少库存，并且记录执行消息状态（为避免重复执行消...
学成在线--day19 分布式事务
zgz102928的博客
03-21 185
学成在线笔记九：在线学习
Bbb的博客
06-15 391
准备环境（必须） 配置hosts文件 # xcEdu 127.0.0.1 localhost 127.0.0.1 eureka01 127.0.0.1 eureka02 127.0.0.1 www.xuecheng.com 127.0.0.1 ucenter.xuecheng.com 127.0.0.1 video.xuecheng.com 192.168.136.110 img.xuecheng.com 配置nginx 新增配置如下： #学成网媒体服务 server {
在线教育平台-day19-分布式事务
tobebetter9527的博客
11-21 104
1.订单支付流程 2.自动添加选课方案 1、支付成功后，订单服务向本地数据库更新订单状态并向消息表写入“添加选课消息”，通过本地数据库保证订单 状态和添加选课消息的事务。。 2、定时任务扫描消息表，取出“添加选课任务“并发向MQ。 3、学习服务接收到添加选课的消息，先查询本地数据库的历史消息表是否存在消息，存在则说明已经添加选课，否则向本地数据库添加选课，并向历史消息表添加选课消息。这里选课表和历史消息表在同一个数据库，通过本地事务保证。 4、学习服务接收到添加选课的消息，通过查询消息表判断如果已经添加
学成在线-第19天-讲义-分布式事务 一
qq_40208605的博客
02-24 213
1订单与选课需求分析1.1订单支付流程学成在线的课程分为免费和收费两种。对于收费课程，用户需提交订单并完成支付方可在线学习。提交订单及支付流程如下：1、用户提交订单需要先登录系统2、提交订单，订单信息保存到订单数据库3、订单支付，调用微信支付接口完成支付4、完成支付，微信支付系统通知学成在线支付结果5、学成在线接收到支付结果通知，更新支付结果提交订单流程：1、用户进入课程详...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值