logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

可靠事件实现微服务下最终一致性事务

 WindySky 2017-11-16
通过《消费者实现应用内分布式事务》、《生产者实现应用内分布式事务管理》、《实现持久订阅消费者》三个章节的实践，其实我们已经可以通过消息队列实现多应用的分布式事务，应用内的事务保证了消息不会被重复生产消费、持久化订阅保证了消息一定会被消费（进入死信队列特殊处理），但其对于业务来说耦合性还是太强，在进行业务处理的同时消息处理名，其采用的仍然是应用内的事务处理，并不适合在大型高性能高并发系统实践，那么本章将通过本地事务+消息队列+外部事件定义表+定时任务实现解耦。
（目前主要实现微服务下最终一致性事务的方案主要是：可靠事件；补偿模式；TCC（Try-Confirm-Cancel）；三种，本案例为可靠事件方式）

场景描述：
本场景就拿最常用的转账业务阐述：
在工行ICBC有账号Card001，其中存于500元；
在中行BOC有账号Card002，其中也存有500元；
此时从Card001账号转账至Card002账号300元。

系统设计：
工行系统ICBCPro，该工程主要实现两个功能（实现转出金额生成转账事件；定时任务发出转账事件至消息队列），主要参考《生产者实现应用内分布式事务管理》实现；
中行系统BOCPro，该工程主要实现两个功能（从消息队列下载转账事件；定时任务对转账事件处理并更新转入账号金额），主要参考《消费者实现应用内分布式事务》实现；
此场景仅需要通过P2P消息模式即可。

构建ICBCPro工程
A、实现转出金额生成转账事件
1、构建数据库相关表以及基础数据：
转出账号数据

转出事件记录

消息队列

消息控制台

2、执行单元测试代码实现转账，此时账户扣除与转账事件记录均在本地事务内：

//ICBC中账户card001转出300元

  1. @Test  
  2.     public void tranfer(){  
  3.         EventLog eventLog = new EventLog();  
  4.         eventLog.setAmount(new BigDecimal(300));  
  5.         eventLog.setFromcard("card001");  
  6.         eventLog.setTocard("card002");  
  7.         eventLog.setEventstate(EventState.NEW);  
  8.         eventLog.setTransferDate(new Date());  
  9.         eventLogService.transfer(eventLog,new BigDecimal(300));   
  10.     }  

账户信息：

事件记录


B、定时任务发出转账事件至消息队列
对于事件记录表，我们可以定义一个定时任务，将所有的NEW状态事件全部发出，此时需要保证消息的可靠性，采用XA事务实现，但已经不影响我们业务的响应了，实现解耦、快速响应，下面贴出核心实现代码：
1、首选实现数据排它锁场景下的查询与更新：
  1. /** 
  2.      * 在排它锁场景下数据更新，保证数据的可靠性 
  3.      */  
  4.     @Override  
  5.     public void updateEventstateById(String id, EventState eventState) {  
  6.         EventLog eventLog=findEventLog4Update(id);  
  7.         eventLog.setEventstate(eventState);  
  8.         emJ1.merge(eventLog);  
  9.     }  
  10.   
  11.     /** 
  12.      * 实现排它锁查询 
  13.      */  
  14.     @Override  
  15.     public EventLog findEventLog4Update(String id){  
  16.         EventLog eventLog=emJ1.find(EventLog.class, id, LockModeType.PESSIMISTIC_WRITE);  
  17.         return eventLog;  
  18.     }  

2、在service定义查询所有NEW状态的事件、并采用XA事务管理NEW状态事件的发送与更新（为了验证了事务生效，设定了一个fromcard为空的数据触发异常），在异常情况下我们也需要保证countDownLatch执行，避免线程阻塞：
  1. @Service  
  2. public class EventLogService {  
  3.     @Autowired  
  4.     private EventLogRepository eventLogRepository;  
  5.     @Resource(name="jmsQueueMessagingTemplate")  
  6.     private JmsMessagingTemplate jmsQueueMessagingTemplate;  
  7.     @Autowired  
  8.     @Qualifier("icbc2boc")  
  9.     private Queue icbc2boc;  
  10. ....  
  11.       
  12.     /** 
  13.      * 根据eventstate获取EventLog数据集 
  14.      * @param eventstate 
  15.      * @return 
  16.      */  
  17.     @Transactional(transactionManager="transactionManager1",propagation=Propagation.SUPPORTS,readOnly=true)  
  18.     public List<EventLog> findByEventState(EventState eventstate){  
  19.         return eventLogRepository.findByEventstate(eventstate);  
  20.     }  
  21.       
  22.     /** 
  23.      * XA事务 
  24.      * @param id 
  25.      * @param eventstate 
  26.      */  
  27.     @Transactional(transactionManager="transactionManagerJTA",propagation=Propagation.REQUIRES_NEW)  
  28.     public void transferToMQ(EventLog eventLog,EventState eventstate,CountDownLatch countDownLatch){  
  29.         try {  
  30.             System.out.println(Thread.currentThread().getName()+"本次处理数据:"+eventLog.getFromcard()+"、"+eventLog.getEventstate());  
  31.             //再次数据库查询判断,此时用到排它锁--在两个定时任务连续执行，一旦出现程序提交事务命令至数据库，  
  32.             //但数据库还未执行，此时我们全表查询的结果中当前数据行仍为修改前数据，故会造成重复消费  
  33.             eventLog=eventLogRepository.findEventLog4Update(eventLog.getId());  
  34.             if(EventState.Publish.equals(eventLog.getEventstate())){  
  35.                 System.out.println(Thread.currentThread().getName()+"数据:"+eventLog.getFromcard()+"无需处理");  
  36.                 return;  
  37.             }  
  38.             //payload  
  39.             jmsQueueMessagingTemplate.convertAndSend(icbc2boc,eventLog);  
  40.             eventLogRepository.updateEventstateById(eventLog.getId(), eventstate);  
  41.             //构造异常场景验证XA事务  
  42.             if(eventLog.getFromcard()==null){  
  43.                 System.out.println(Thread.currentThread().getName()+"数据异常，不处理");  
  44.                 System.out.println(1/0);  
  45.             }else{  
  46.                 System.out.println(Thread.currentThread().getName()+":"+eventLog.getFromcard()+"数据处理成功");  
  47.             }  
  48.         } finally {  
  49.             countDownLatch.countDown();  
  50.         }  
  51.     }  
  52. }  
3、定义Job，实现转出任务，并通过线程池异步处理待处理事件集合，通过并发提高处理性能，通过countDownLatch保证了每个任务所有线程处理完成后启动下一次任务；
  1. /**  
  2.  * 转出任务  
  3.  * @author song  
  4.  */  
  5. @PersistJobDataAfterExecution  
  6. @DisallowConcurrentExecution //保证每次任务执行完毕，设置为串行执行  
  7. public class TransferJob  extends QuartzJobBean {  
  8.     private Logger logger=LoggerFactory.getLogger(TransferJob.class);  
  9.     @Autowired  
  10.     @Qualifier("quartzThreadPool")  
  11.     private ThreadPoolTaskExecutor quartzThreadPool;  
  12.     @Autowired  
  13.     private EventLogService eventLogService;  
  14.       
  15.     @Override  
  16.     protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {  
  17.         logger.info("本次批处理开始");  
  18.         //获取所有未发送状态的Event  
  19.         List<EventLog> list=eventLogService.findByEventState(EventState.NEW);  
  20.         //  
  21.         final CountDownLatch countDownLatch=new CountDownLatch(list.size());  
  22.           
  23.         //遍历发送  
  24.         for(final EventLog eventLog:list){  
  25.             //通过线程池提交任务执行，大大提高处理集合效率  
  26.             quartzThreadPool.submit(new Runnable() {  
  27.                   
  28.                 @Override  
  29.                 public void run() {  
  30.                     eventLogService.transferToMQ(eventLog,EventState.Publish,countDownLatch);  
  31.                 }  
  32.             });  
  33.         }  
  34.           
  35.         //保证所有线程执行完成后退出  
  36.         try {  
  37.             countDownLatch.await();  
  38.         } catch (InterruptedException e) {  
  39.             e.printStackTrace();  
  40.         }  
  41.         logger.info("本次批处理完成");  
  42.     }  
  43. }  
4、定义转出任务、触发器、调度器以及处理线程池：
  1. @Bean(name="tranferJob")  
  2.     public JobDetailFactoryBean tranferJob(){  
  3.         JobDetailFactoryBean factoryBean=new JobDetailFactoryBean();  
  4.         //定义任务类  
  5.         factoryBean.setJobClass(TransferJob.class);  
  6.         //表示任务完成之后是否依然保留到数据库,默认false  
  7.         factoryBean.setDurability(true);  
  8.         //为Ture时当Quartz服务被中止后，再次启动或集群中其他机器接手任务时会尝试恢复执行之前未完成的所有任务，默认false  
  9.         factoryBean.setRequestsRecovery(true);  
  10.         return factoryBean;  
  11.     }  
  12.       
  13.     /**  
  14.      * 注册job1的触发器  
  15.      * @return  
  16.      */  
  17.     @Bean(name="transferJobTrigger")  
  18.     public CronTriggerFactoryBean transferJobTrigger(){  
  19.         //触发器  
  20.         CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();  
  21.         cronTriggerFactoryBean.setCronExpression("*/5 * * * * ?");  
  22.         cronTriggerFactoryBean.setJobDetail(tranferJob().getObject());  
  23.         //调度工厂实例化后，经过5秒开始执行调度  
  24.         cronTriggerFactoryBean.setStartDelay(30000);  
  25.         cronTriggerFactoryBean.setGroup("tranfer");  
  26.         cronTriggerFactoryBean.setName("tranfer");  
  27.         return cronTriggerFactoryBean;  
  28.     }  
  29.   
  30.     /**  
  31.      * 调度工厂，加载触发器，并设置自动启动、启动时延  
  32.      * @return  
  33.      */  
  34.     @Bean(name="transferSchedulerFactoryBean")  
  35.     public SchedulerFactoryBean transferSchedulerFactoryBean(){  
  36.         //调度工厂  
  37.         SchedulerFactoryBean schedulerFactoryBean= new SchedulerFactoryBean();  
  38.         schedulerFactoryBean.setConfigLocation(new ClassPathResource("quartz.properties"));  
  39.         schedulerFactoryBean.setApplicationContextSchedulerContextKey("applicationContextKey");  
  40.         //集群Cluster下设置dataSource  
  41. //      schedulerFactoryBean.setDataSource(dataSource);  
  42.         //QuartzScheduler启动时更新己存在的Job，不用每次修改targetObject后删除qrtz_job_details表对应记录了  
  43.         schedulerFactoryBean.setOverwriteExistingJobs(true);  
  44.         //QuartzScheduler延时启动20S，应用启动完后 QuartzScheduler 再启动  
  45.         schedulerFactoryBean.setStartupDelay(20);  
  46.         //自动启动  
  47.         schedulerFactoryBean.setAutoStartup(true);  
  48.         schedulerFactoryBean.setTriggers(transferJobTrigger().getObject());  
  49.         //自定义的JobFactory解决job中service的bean注入  
  50.         schedulerFactoryBean.setJobFactory(jobFactory);  
  51.         return schedulerFactoryBean;  
  52.     }  
  53.       
  54.     /**  
  55.      * 用于处理待转账数据发至消息队列的线程池  
  56.      * @return  
  57.      */  
  58.     @Bean(name="quartzThreadPool")  
  59.     public ThreadPoolTaskExecutor getThreadPoolTaskExecutor(){  
  60.         ThreadPoolTaskExecutor pool=new ThreadPoolTaskExecutor();  
  61.         pool.setCorePoolSize(10);  
  62.         pool.setQueueCapacity(100);  
  63.         pool.setMaxPoolSize(10);  
  64.         pool.setKeepAliveSeconds(10);  
  65.         //避免应用关闭，任务没有执行完成，起到shutdownhook钩子的作用  
  66.         pool.setWaitForTasksToCompleteOnShutdown(true);  
  67.         //空闲时核心线程也不退出  
  68.         pool.setAllowCoreThreadTimeOut(false);  
  69.         //设置拒绝策略，不可执行的任务将被抛弃  
  70.         pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());  
  71.         return pool;  
  72.     }  

小结
特别注意：
1、周期时间刚好两个定时任务连续执行，出现java程序提交事务紧接第二个任务启动，但数据库未完成命令，此时后续任务已经查询数据，全表过滤能够再次获取未提交数据行原始数据，会造成二次消费，故需要对其采用排它锁方式，二次查询判断后决定是否消费，从而规避二次消费问题；
2、注意在Service中不能随便catch异常，避免分布式事务未回滚，造成重复消费；
3、通过CountDownLatch，实现任务线程等待所有的子任务线程执行完毕后方可退出本次任务，执行下一个任务，故其一定要在finally中实现countdown，避免造成任务线程阻塞；
4、需要设置OpenEntityManagerInViewInterceptor拦截器，避免提示session过早关闭问题；
5、数据库DataSource必须定义好destroyMethod，避免程序关闭，事务还未提交的情况下出现连接池已经关闭；
6、设置好连接池需要等待已提交任务完成后方可shutdown；

优化空间：
1、根据数据特征进行任务分割，比如自增ID场景下，根据0、1、2等最后一位尾数分割不同的定时任务，配置任务集群，从而实现分布式高可用集群处理；
2、在数据查询处理过程中，优化sql，提高单次查询性能；
3、添加独立的定时任务，将Publish已消费数据转储，减轻单表压力；
4、目前已经加入线程池异步处理数据集合，提高单次任务执行效率；
5、一旦数据库压力比较大的情况下，也可以将Event分库操作，减轻服务器数据库连接、IO压力；
6、采用微服务模式，将两个功能实现服务分离；
7、也可以在定时任务中添加比如50MS的sleep时长，保证数据库服务器端事务提交成功，取消排它锁将进一步提高性能较小数据库死锁问题；

遗留问题：
1、在开发环境下，手动关闭程序MQ连接会过早关闭，修改数据后事务未提交，出现MySQL数据库行已经被执行排他锁；

构建BOCPro工程
A、从消息队列下载转账事件
1、构建数据库BOC数据库相关表以及基础数据：

事件表暂时为空

消息队列，有一条转账数据


2、配置队列消息模板：
  1. @Configuration  
  2. public class JmsMessageConfiguration {  
  3.     @Autowired  
  4.     @Qualifier(value="jmsQueueTemplate")  
  5.     private JmsTemplate jmsQueueTemplate;  
  6.       
  7.     /**  
  8.      * 定义点对点队列  
  9.      * @return  
  10.      */  
  11.     @Bean(name="icbc2boc")  
  12.     public Queue queue() {  
  13.         return new ActiveMQQueue("icbc2boc");  
  14.     }  
  15.       
  16.     /**  
  17.      * 创建处理队列消息模板  
  18.      * @return  
  19.      */  
  20.     @Bean(name="jmsQueueMessagingTemplate")  
  21.     public JmsMessagingTemplate jmsQueueMessagingTemplate() {  
  22.         JmsMessagingTemplate jmsMessagingTemplate =new JmsMessagingTemplate(jmsQueueTemplate);  
  23.         //通过MappingJackson2MessageConverter实现Object转换  
  24.         jmsMessagingTemplate.setMessageConverter(new MappingJackson2MessageConverter());  
  25.         return new JmsMessagingTemplate(jmsQueueTemplate);  
  26.     }  
  27.       
  28. }  
3、配置监听器，监听转账事件消息：
  1. @Component  
  2. public class TraferIn {  
  3.   
  4.     @Autowired  
  5.     @Qualifier("icbc2boc")  
  6.     private Queue queue;  
  7.     @Autowired  
  8.     @Qualifier("jmsQueueMessagingTemplate")  
  9.     private JmsMessagingTemplate jmsQueueMessagingTemplate;  
  10.     @Autowired  
  11.     private EventLogService eventLogService;  
  12.       
  13.     /**  
  14.      * 定义监听转账事件监听  
  15.      * @param text  
  16.      * @throws Exception  
  17.      */  
  18.     @JmsListener(destination = "icbc2boc",containerFactory="jmsListenerContainerFactory4Queue")//ActiveMQ.DLQ  
  19.     public void receiveQueue(EventLog eventLog) throws Exception {  
  20.         System.out.println("接受到的事件数据："+eventLog.toString());  
  21.         eventLogService.mq2transfer(eventLog, new BigDecimal(300));  
  22.     }  
  23. }  

4、采用分布式事务管理下载的消息队列事件，模拟事务失效，验证成功：
  1. /**  
  2.      *  XA事务  
  3.      * @param eventLog  
  4.      * @param amount  
  5.      */  
  6.     @Transactional(transactionManager="transactionManagerJTA",propagation=Propagation.REQUIRED)  
  7.     public void mq2transfer(EventLog eventLog,BigDecimal amount){  
  8.         //保存事件日志  
  9.         eventLogRepository.saveEvetLog(eventLog);  
  10. //      System.out.println(1/0);  
  11.     }  
5、需要采用XA事务，故我们不能直接通过EventLogRepository保存数据，定义自定义保存方法：
  1. /**  
  2.      * 采用分布式事务数据源保存事件  
  3.      */  
  4.     @Override  
  5.     public EventLog saveEvetLog(EventLog eventLog) {  
  6.         return emJ1.merge(eventLog);  
  7.     }  
6、启动程序监听后，收到事件

数据库添加了一条NEW状态事件

消费后消息队列被清空



B、定时任务对转账事件处理并更新转入账号金额
通过定时任务扫描下载的所有事件，并启动线程池异步快速处理所有的转账事件，可能一批次事件中会出现同个账号多次记录的场景，更新操作为非幂等操作，故我们需要采用排它锁的方式对数据行更新。并且通过本地事务的方式管理事件和账号表更新，从而大大提高了业务处理速度。通过此方式也实现了业务和事件的解耦。
1、本地为本地事务处理，故我们可以很方便在EventLogRepository通过接口定义即可解决查询、更新，主要包含查询所有的NEW状态事件、查询单个t_card表实现排它锁（解决多线程下的幂等性）、更新事件状态，特别关注在接口中如何实现原生SQL排它锁查询的注解定义：
  1. /**  
  2.      * 实现排它锁  
  3.      * @param id  
  4.      * @return  
  5.      */  
  6.     @Query(value="select t.id from t_card t where t.id=:id for update",nativeQuery=true)  
  7.     void findCard4UpdateById(@Param("id")String id);  
  8.   
  9.     /**  
  10.      * 更新EventLog状态  
  11.      * @param id  
  12.      * @param eventstate  
  13.      * @return  
  14.      */  
  15.     @Modifying  
  16.     @Query(value = "update EventLog e set e.eventstate=:eventstate  where e.id = :id ")  
  17.     int updateEventstateById(@Param("id")String id,@Param("eventstate")EventState eventstate);  
  18.       
  19.     /**  
  20.      * 根据EventState查询所有EventLog  
  21.      * @param EventState  
  22.      * @return  
  23.      */  
  24.     List<EventLog> findByEventstate(EventState eventState);  
2、采用ICBCCPro项目中一样的原生SQL更新语句，主要处理账号金额调整，其实也可以通过接口定义实现，多个方式玩玩：
  1. /**  
  2.      * 执行原生语句实现更新  
  3.      */  
  4.     @Override  
  5.     public int executeUpdateNativeSQL(String strSQL) {  
  6.         return em1.createNativeQuery(strSQL, Integer.class).executeUpdate();  
  7.     }  
3、定义service中真正处理转账事件的逻辑，在其中我们在多线程的场景下，对事件表和Card表采用了不一样的锁机制，事件表通过乐观锁避免重复消费，保证事件处理幂等性：
  1. /**  
  2.      * 本地事务  
  3.      * @param id  
  4.      * @param eventstate  
  5.      */  
  6.     @Transactional(transactionManager="transactionManager1",propagation=Propagation.REQUIRES_NEW)  
  7.     public void transfer(EventLog eventLog,EventState eventstate,CountDownLatch countDownLatch){  
  8.         try {  
  9.             System.out.println(Thread.currentThread().getName()+"本次处理数据转入账号:"+eventLog.getTocard()+"、"+eventLog.getEventstate());  
  10.             //通过乐观锁方式再次判断，保证事件的可靠消息，仅在极端情况下会出现重复消费，故采用乐观锁  
  11.             int updateCount=eventLogRepository.updateEventstateById(eventLog.getId(),eventstate);  
  12.             //如果等于则表明已经处理过  
  13.             if(updateCount==0){  
  14.                 System.out.println(Thread.currentThread().getName()+"数据收款卡号:"+eventLog.getTocard()+"无需处理");  
  15.                 return;  
  16.             }  
  17.             //没有被处理过需要继续更新账户金额  
  18.             //更新查询，采用排它锁方式，避免在多线程任务下，出现多个线程修改同一个卡号，从而事务幂等性  
  19.             eventLogRepository.findCard4UpdateById(eventLog.getTocard());  
  20.             //更新账户信息，转入累加，属于非幂等操作  
  21.             eventLogRepository.executeUpdateNativeSQL("update t_card set amount=amount+"+eventLog.getAmount()+" where id='"+eventLog.getTocard()+"'");  
  22. //          System.out.println(1/0);  
  23.             System.out.println(Thread.currentThread().getName()+":"+eventLog.getFromcard()+"数据处理成功");  
  24.         } finally {  
  25.             countDownLatch.countDown();  
  26.         }  
  27.     }  
4、定义定时任务，其主要注入了一个线程池协助我们快速异步处理所有事件，通过CountDownLatch 保证了同一次任务所有事件处理完成后方可退出任务线程，然后启动下一次任务，保证任务串行执行：
  1. @PersistJobDataAfterExecution  
  2. @DisallowConcurrentExecution //保证每次任务执行完毕，设置为串行执行  
  3. public class TransferJob  extends QuartzJobBean {  
  4.     private Logger logger=LoggerFactory.getLogger(TransferJob.class);  
  5.     @Autowired  
  6.     @Qualifier("quartzThreadPool")  
  7.     private ThreadPoolTaskExecutor quartzThreadPool;  
  8.     @Autowired  
  9.     private EventLogService eventLogService;  
  10.       
  11.     @Override  
  12.     protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {  
  13.         logger.info("本次批处理开始");  
  14.         //获取所有未发送状态的Event  
  15.         List<EventLog> list=eventLogService.findByEventState(EventState.NEW);  
  16.         //  
  17.         final CountDownLatch countDownLatch=new CountDownLatch(list.size());  
  18.           
  19.         //遍历发送  
  20.         for(final EventLog eventLog:list){  
  21.             //通过线程池提交任务执行，大大提高处理集合效率  
  22.             quartzThreadPool.submit(new Runnable() {  
  23.                   
  24.                 @Override  
  25.                 public void run() {  
  26.                     eventLogService.transfer(eventLog, EventState.Publish, countDownLatch);  
  27.                 }  
  28.             });  
  29.         }  
  30.           
  31.         //保证所有线程执行完成后退出  
  32.         try {  
  33.             countDownLatch.await();  
  34.         } catch (InterruptedException e) {  
  35.             e.printStackTrace();  
  36.         }  
  37.         logger.info("本次批处理完成");  
  38.     }  
  39. }  

5、启动定时任务后

数据库，事件表状态更新：

金额中card金额累计：


小结
特别注意：
1、对应不同的表和操作，我们需要采用不一样的锁机制，首先判断操作是否具有幂等性；
2、注意在Service中不能随便catch异常，避免分布式事务未回滚，造成重复消费；
3、通过CountDownLatch，实现任务线程等待所有的子任务线程执行完毕后方可退出本次任务，执行下一个任务，故其一定要在finally中实现countdown，避免造成任务线程阻塞；
4、需要设置OpenEntityManagerInViewInterceptor拦截器，避免提示session过早关闭问题；
5、数据库DataSource必须定义好destroyMethod，避免程序关闭，事务还未提交的情况下出现连接池已经关闭；
6、设置好连接池需要等待已提交任务完成后方可shutdown；

优化空间：
1、采用微服务模式，将两个功能实现服务分离；
2、A功能：根据队列消息的特性，在有多个消费者的情况下，其也仅仅会被消费一次，故我们可以构建多个消费者服务器，从而实现异步下载压力水平分摊；
3、设定合理的数据库连接池大小，从而实现限流作用，避免数据库服务器压力过大；
4、B功能：根据数据特征进行任务分割，比如自增ID场景下，根据0、1、2等最后一位尾数分割不同的定时任务，配置任务集群，从而实现分布式高可用集群处理；
5、在数据查询处理过程中，优化sql，提高单次查询性能；
6、添加独立的定时任务，将Publish已消费数据转储，减轻单表压力；
7、目前已经加入线程池异步处理数据集合，提高单次任务执行效率；
8、一旦数据库压力比较大的情况下，也可以根据账号的分库情况将Event分库操作，减轻服务器数据库连接、IO压力；

总结
1、通过微服务理念，实现服务分离，更加容易进行服务治理与水平扩展；
2、通过本地事务处理业务实现高性能；
3、通过P2P模式消息+Mysql+排它锁+分布式事务+串行任务保证了事件不会重复发送、不会重复消费（可靠传递），并且实现了系统解耦、异步处理、流量销峰；
4、通过对事件的生产+消费实现了最终一致性事务；

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： WindySky > 《分布式事务》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多