TGITCIC
TGITCIC

微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率

问题描述

这也是一起真实的生产事故，如下图所示

微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率_第1张图片

这种“雪崩”是属于企业内部系统雪崩。

我们都知道如果是在外部http (包括一切restful、soap请求、http类型调用）调用上如果存在：a->b->c->d假设系统b为“中间段”，任意一点出错，如果你的http设置的时间超长或者是no connection time或者是无熔断。都会一路上“倒卡系统b“。这叫雪崩。

可是在我们的企业内部系统间也是存在这种”系统间雪崩“效应的。特别是在跑批场景，比如说：

  1. 柜面收银把数据、扫码购、人脸往交易记录往中台发；
  2. 交易中台再把数据二传手转到第三方分析引擎；
  3. 第三方分析引擎一旦出错，就会出现上述这种结果”第三方分析引擎卡死->交易中台卡死->柜面收银“；

然后就是一堆”鸡飞狗跳“，不断加内存、升CPU直到频繁重启都搞不定问题的解决，终于业务老板吃不消了要求改造，然后一群人连问题都找不到，于是就有了：

  1. 喂，你少发点数据！
  2. 喂，我只管发你吃不住数据管我什么事？
  3. 喂，我们没问题是你不行影响到了我们因此这个问题要你来改！

哎呀，那叫一个踢皮球！哎呀，那叫一个“热闹”！哎呀，那叫一个急！

解决方案的理论基础

我们知道了外部级联雪崩，同为内网的企业间系统其实也有雪崩而且更容易出现雪崩。

如上图，当有一个系统处于另外两个legacy系统间，此时这个系统会很“难受”。因为legacy要么是erp要么是c/s传统架构。

企业内的legacy讲究的是业务幂等。因此使用的都是基于DB的悲观锁来做的交易行为。这样的系统，150并发对它们来说已经是it's a myth了。你一个跑批发起，一个大for循环，中大型企业这种类型的跑批至少存在有150-300多种，每一种日交易量好点的都是1万-3万笔流水，银行金融都是讲10万流水的。然后把10万流水乘渠道乘帐目类型得到的用于循环的一个笛卡尔积动不动就是上百万。

上百万的记录套在一个for循环里，往下游的legacy送，对于先进点的“中间地位的交易系统”来说，多线程不是问题，哗啦一下开启个几百个线程，每个线程上千数据的往外就送。

哎呀。。。不需要1分钟，下游系统卡爆。

一旦下游系统卡爆就反向影响中间地位的交易系统，于是就有了这种“雪崩”，具体表现就是突然间前端APP应用或者是小程序应用变得很慢很慢。

然后就是上述一堆甩锅开始了。

因此，解决这一类问题我们需要本着如下的设计原则，这个原则也就是一些先进的大厂经常在面试P6, P7级别或者以上人员希望听到侯选人能够说出以下这些点：

  • 多线程必须做到每个线程间不污染；
  • 支持重跑、重试、严重错误记录；
  • 线程数恒定、可控，跑批时间可以稍长点（都跑批了，你不在乎长那么几十秒，而实际多线程运用了好甚至远远千倍高于设计了不好的盲目开几百上千线程的应用）；
  • 任务处理不过来时运用“弹性横向扩充应用”来解决分布式计算而不是一味增大线程数；
  • 资源尽可能利用少（整个job运行期间：内存<10%利用率，CPU<10%利用率，TCP文件打开数控制在整体文件句柄的10%甚至5%）；
  • 充分利用“计算机的CPU时间片轮流转“、充分利用并行计算、充分利用缓存、内存、异步；

因此，”跑批“两个字看似simple，but it means everything。是一个高度集成计算机科学专业知识的设计与制作。

此处顺便就补足一下“培训班-只教CRUD”这种急功近利的方式无法教给大家的真正的计算机科学程序员所需要的知识，我们市面上90%的猿们正是缺少了这些核心知识因此才造就了“X农”这个名词的存在，也正是缺少了这些基础知识点造成了一切系统本应该（是个编程的就需要基本应该做到）围绕着这些知识点展开却没能做到的“根本原因”，也造成了我们绝大多数系统有功能无性能，门店数、顾客数稍稍一多系统就爆了，一个系统连半年寿命都达不到（跳脱上北广-大厂的领域，国内绝大多数系统真心无性能，这一点不夸张）：

  1. HTTP=TCP=OS（我们拿unix/linux来举例）的ulimit数，这个数最大到65,535，但你要考虑到OS还有其它的应用要用到文件句柄数，一般来说可以给到web应用的数量为一半，差不多32,000即并发可被打开的http数量，一个大for循环或者不加控制的线程数可以在1分钟内轻而易举到达这个阀值，一旦到了这个阀值，该OS上的应用全“卡死”；
  2. CPU利用率>80%时，你这台OS上的一切应用都处于”假死“状态，你可以自己拿jmeter，并发线程写个1万，跑1分钟试试，直接把自己电脑搞挂了；
  3. 内存占用率>90%时，如同CPU利用率>80%情况；
  4. 特别在万、十万、百万数据循环时，如果你不做sleep, wait的待待，CPU会像一个以11秒百米冲刺的速度的人保持这个速度要跑完45公里一样，它的“肺”不需要多久就爆了。你得让他“喘口气”，这就是CPU分片轮流转。很多人在这种跑批处理时都不知道sleep；
  5. 前端的APP/小程序应用经常会在跑批时被卡死就是因为很多人以为前后端分离，但实际前端的API是落到后端的spring boot的应用上的呀，而后端和跑批如果正好处于同一个应用而此时跑批正在耗你的http进程，势必也会影响到你的前端访问，因为TO B端的跑批把可用的http连接用完了前端用户如何连得进来呢？都认为前后端分离，但是前端你有API请求呀，要不你不要API请求了，你就一个纯静态应用那么后台就算shutdown也不会影响前台了，这是很多传统甲方型公司的IT甚至CTO一层都想不到的点，毫不夸张的说目前市面上90%（全国范围）甲方型IT都是这种认知；
  6. 把“系统间的强关联改成弱关联”，把出问题的点、范围约束在尽可能小的范围，那么要多用“异步”架构，这样就不会形成雪崩，要崩也是单崩。崩坏了你的上游或者下游正好暴露出来他们的系统里的问题，如果你要连着跟着一起崩，那么当出现这种问题时就是一锅混水，3个系统本来是两个系统不行，排查解决也可以精准到系统。你现在去“搅和在一起”。。。这是“死也要陪着别人一起死喽？你们间多友情？”；
  7. 减少传统OLTP型DB的使用或者干脆能不用就不用，一条数据库行级锁就可以一路卡爆你们的系统。适当的使用NOSQL如：mongodb、redis，你会发现同样数据量使用NOSQL的效率是传统DB的千倍、万倍以上；
  8. 一条条update、insert循环1,000次和把1,000条update语句组装在一起一次性提交，前后性能相差几十有的甚至达到上千倍，因为数据库乐于做“批量一次性提交“而非一条条提交。网络传输亦是如此。比如说你往百度网盘上传3万个文件每个文件只有20K，你可能要上传几小时，而你把3万个文件打成一个ZIP包一次性上传不会超过15分钟。因为网络IO频繁读写是极其”低效“的；
  9. HTTP或者任何连接不得无超时设定，超时又要尽可能设的短。并且任何连接包括HTTP连接都有两个timeout。一个叫createConnectionTimeout，一个叫readTimeout。createConnectionTime是指两个系统间建立连接通道所用时间，这个时间如果是企业内网>2秒或者4秒，我们算4秒吧，已经算很夸张了，这代表要建立的系统间有一个系统早己经“挂了”。而readTimeout就是http request->response的时间，这个时间就是一次“交易”的时间，在互联网to c端微服务领域我们甚至要求这个readTimeout达到100毫秒或者100毫秒内，可想而知留给你交易一笔交易的时间有多少，为什么要少呢？你时间也可以长呀，处理一笔交易10几秒，好。。。一路雪崩若干系统模块、系统组件、甚至系统，然后全局雪崩、然后小程序/APP白屏、卡死，真happy！因此readTimeout我们控制在4 秒吧，两个参数的关系是readTimeout的时间>createConnectionTime。很多合理的系统的createConnectionTimeout的设定一般不会超过2秒；

好了，大的原则不过如上9点，那么根据上述9点，我们把我们最新的设计展现出来，如何做到“可控恒定线程数、又能做到业务幂等、又能做到效率不差（事实上只会更高）而系统资源开销更少”的来做到以上这件事呢？

提出解决方案

微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率_第2张图片

 AS-IS & TO-B，是TOGAF企业架构常用的一种架构设计手法。

  • AS-IS代表：己有/现有设计；
  • TO-B代表：未来、目标、我们要设计成什么样；

在TO-B架构设计里我们可以看到设计的目标如下几点：

  • 把A-B-C三个系统间的跑批，从强粘连引起的大范围雪崩约束到小范围雪崩；
  • 我们为了保TO C端即小程序/APP不被卡死，那就算雪崩我们也把这个雪崩控制在后台，不会“反射/反弹”到前端，因此我们利用异步；
  • 如果要异步就必须要使用到暂存队列，这个暂存队列可以使用mq也可以自己使用“流水表+带状态字段”来制作异步job，具体设计我们分解到后面详细设计中去解说；
  • 上游端把数据一条条发过来，交易系统把它吃下来落流水表后直接返回响应，这种请求即readTimeout不会超过1秒；
  • 存下来后利用一个异步的job把流水读出来然后以可控线程数的异步机制发送往下游系统“扔”过去；

这就是我们的设计思路，彻底解耦。

解释两个为什么

这两个为什么一旦搞懂其实就搞清了整个设计的核心思想了，非常重要，因此特在此做深度解释。

为什么一定一定要讲究“发送线程为可控、恒定线程”呢？

这个设计运行在一个jvm里，发送线程是恒定的可控的，一般来说这个线程数不易设置超过50，正如我一直以来所说，一般上游或者下游系统都是legacy，这种legacy不要看很“贵”，但真的连150并发都吃不住的。因为这些系统都是“强交易（其实这只是这些系统过于老旧-平均20年前技术栈设计而成导致）”，都是基于DB的悲观锁设计，那么我们有这个“责任”去保护好这些系统。

对于这些系统永远要控制好发往它的请求数要控制住、不搞死，对于整个企业的IT来说“共赢”才能赢，单部门赢不是赢，因此这个设计是很重要的，不能只考虑自己的系统“爽”。

为什么一定要用异步暂存呢

我们可以控制好我们送出去的量不把别人搞死，你怎么保证别人送过来的量不把你搞死呢？这些legacy系统之所以legacy就如我上文所说的根源是这些系统的设计很古老，他们可能连多线程都没法用，很多银行金融型企业甚至用的还是单片机、C来做的，哪来的多线程、微服务、分布式这种先进的技术手段，诚然，在当时那个年代这些系统很先进，但是它们没有跟上时代在进化的潮流中被时代已经淘汰。

那它们发往你的数据高度有可能是“不控线程、直接大量请求泛滥”进你的系统的。因此，你的系统要有能力“挡”，挡住了后呢一点点把这些内部legacy过来的流量“消化”掉。

因此此处就需要使用到异步、暂存、队列这种手法了。

详细设计

对于“前面可以挡得住，挡得住可以吃得下，输出可以控”的核心原则。我们可以用两种手段来落地我们的设计。

  1. 使用MQ+可控数量MQ的Consumer+RestTemplate的方式；
  2. 使用MQ+MongoDb来做流水表+SpringBoot线程池+Redisson自续约锁+RestTemplate的方式；

这两种方式又涉及到以下的细节技术。

我特别喜欢在设计转化到实际落地前把要用到的技术栈全部准备好，这是一个好习惯。我不知道大家有没有去过天津，吃过那里的小吃？

在天津，老清老早，天还蒙蒙亮时，你来到天津特别是一些小胡同，看到有一个摊，老板在凌晨4、5点就已经把水烧好、把料都准备好了，一小碟子精盐、一小碟子蒜、一小碟子花生、一小碟子芝麻、葱、酱、虾皮，摆了一桌面。

客人来了后：老板，来一碗老面茶。

老板用手快速的在各个碟子间游走着，拿起这个，拿起那个，快速的往一个海碗里撒入这些预先准备好的料，然后拿了一个大勺，往早已经烧热的大汤锅里这么一撩，然后往满是小料的海碗里这么一浇，喊一声“来了您哎，慢慢吃”。

客人呢？一手拿着果子咬一口一嘴油，另一只手拿着勺这么喝一口老面茶，那叫一个香。

所以呢，我们就把我们的这些“小料”都预先给它准备好了。

序号 技术栈名
1 spring boot 2.4.2
2 webflux来做我们的controller
3 spring boot的thread pool
4 spring boot的quartz
5 spring boot redisson自续约锁
6 spring boot rabbitmqTemplate
7 spring boot mongoTemplate
8 mysql 5.7
9 MongoDb 3.2.x
10 RabbitMq 3.8.x
11 Redis6.x
12 apache jmeter 5.3

这些技术分解成两个spring boot工程：

  1. SkyPayment，用于模拟我们的中台/电商核心交易平台，它会提供一个回调接口，该接口接受一条http请求，这个http请求会达到几万的量，用于模拟上游端往SkyPayment工程里喂入海量的数据，此处的海量数据我们会使用jmeter的Arrival Threads来模拟出这个高并发的量来；
  2. SkyDownStreamSystem，用于模拟下游系统。即当上游（jmeter）往SkyPayment系统喂入海量的高并发数据时，SkyPayment把这个数据以“二传手”的身份传递给到SkyDownStreamSystem，SkyDownStreamSystem接到SkyPayment转过来的数据对数据库里的payment表的status做状态修改以模拟“入库”、“记帐”的动作；

系统设计要求：

  1. 这两个工程在运行时，面对几万级别的瞬时流量压入时必须从开始到结束，压入多少数据最终处理完多少数据；
  2. 有任何数据处理出错系统可以重复、补偿处理；
  3. 这两个系统中的http连接数必须控制在很小的并发数内，以便于任何系统不会被打爆；
  4. 在满足了以上三个点的同时还需要做到当海量数据全部发完后，系统可以在SkyPayment端传输完成后的1分钟内把所有的几万条数据处理完毕；
  5. 全过程每个项目的内存使用不超过2G、CPU不超过10%；

下面开始动手了。

详细设计-用于模拟下游系统的SkyDownStream项目结构

微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率_第3张图片

用于入库的controller

   @PostMapping(value = "/updateStatusInBatch", produces = "application/json")
    @ResponseBody
    public Mono updateStatusInBatch(@RequestBody List paymentList) {
        ResponseBean resp = new ResponseBean();
        try {
            downStreamService.updatePaymentStatusByList(paymentList);
            resp = new ResponseBean(ResponseCodeEnum.SUCCESS.getCode(), "success");
        } catch (Exception e) {
            resp = new ResponseBean(ResponseCodeEnum.FAIL.getCode(), "system error");
            logger.error(">>>>>>updateStatusInBatch error: " + e.getMessage(), e);
        }
        return Mono.just(resp);
    }

DownStreamService.java 


    @TimeLogger
    @Transactional(rollbackFor = Exception.class)
    public void updatePaymentStatusByList(List paymentList) throws Exception {
        downStreamDao.updatePaymentStatusByList(paymentList);
    }

DownStreamDao.java


    public void updatePaymentStatusByList(List paymentList);



	
		
		
		
	


	
		update sky_payment set status=#{status} where
		pay_id=#{payId}
	

	
		
			update sky_payment set status=#{payment.status}  where pay_id=#{payment.payId}

大家可以看到此处我有两个dao，一个DAO是根据一条条的pay_id来入库，另一个DAO是用的是batchUpdate方法。

此处为什么我要强调使用batchUpdate？想想我上面提到过的9大基本知识点中的1,000个循环一条条写数据库和一次1,000条一提交，性能可以差几十甚至上千倍的梗。因此在POC代码中我不仅仅实现了RabbitMq和使用NOSQL来实现可控异步多线程分布式计算这两种方式外我还在每个方式中使用了“一条条插入更新数据”和“批量更新数据”两种方式进行了对比，以验证一条条数据插/更新和批量插/更新的效率有多少可怕的区别。

PaymentBean.java

/**
 * 系统项目名称 org.mk.demo.skypayment.vo PaymentBean.java
 * 
 * Feb 1, 2022-11:12:17 PM 2022XX公司-版权所有
 * 
 */
package org.mk.demo.downstreamsystem.vo;

import java.io.Serializable;

/**
 * 
 * PaymentBean
 * 
 * 
 * Feb 1, 2022 11:12:17 PM
 * 
 * @version 1.0.0
 * 
 */
public class PaymentBean implements Serializable {

    private int payId;

    public int getPayId() {
        return payId;
    }

    public void setPayId(int payId) {
        this.payId = payId;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public double getTransfAmount() {
        return transfAmount;
    }

    public void setTransfAmount(double transfAmount) {
        this.transfAmount = transfAmount;
    }

    private int status;
    private double transfAmount = 0;
}

SkyDownStream系统的application.yml配置

mysql:
  datasource:
    db:
      type: com.alibaba.druid.pool.DruidDataSource
      driverClassName: com.mysql.jdbc.Driver
      minIdle: 50
      initialSize: 50
      maxActive: 300
      maxWait: 1000
      testOnBorrow: false
      testOnReturn: true
      testWhileIdle: true
      validationQuery: select 1
      validationQueryTimeout: 1
      timeBetweenEvictionRunsMillis: 5000
      ConnectionErrorRetryAttempts: 3
      NotFullTimeoutRetryCount: 3
      numTestsPerEvictionRun: 10
      minEvictableIdleTimeMillis: 480000
      maxEvictableIdleTimeMillis: 480000
      keepAliveBetweenTimeMillis: 480000
      keepalive: true
      poolPreparedStatements: true
      maxPoolPreparedStatementPerConnectionSize: 512
      maxOpenPreparedStatements: 512
    master: #master db
      type: com.alibaba.druid.pool.DruidDataSource
      driverClassName: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/ecom?useUnicode=true&characterEncoding=utf-8&useSSL=false&useAffectedRows=true&autoReconnect=true&allowMultiQueries=true
      username: root
      password: 111111
    slaver: #slaver db
      type: com.alibaba.druid.pool.DruidDataSource
      driverClassName: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3307/ecom?useUnicode=true&characterEncoding=utf-8&useSSL=false&useAffectedRows=true&autoReconnect=true&allowMultiQueries=true
      username: root
      password: 111111     
server:
  port: 9082
  tomcat:
    max-http-post-size: -1
    accept-count: 1000
    max-threads: 1000
    min-spare-threads: 150
    max-connections: 10000
  max-http-header-size: 10240000

spring:
  application:
    name: skydownstreamsystem
  servlet:
    multipart:
      max-file-size: 10MB
      max-request-size: 10MB
    context-path: /skydownstreamsystem

SkyDownStream的pom.xml（parent pom.xml和SkyPayment工程共用）


	4.0.0
	
		org.mk.demo
		springboot-demo
		0.0.1
	
	skydownstreamsystem
	
		
			org.springframework.boot
			spring-boot-starter-web
			${spring-boot.version}
			
				
					org.slf4j
					slf4j-log4j12
				
				
					org.springframework.boot
					spring-boot-starter-logging
				
			
		
		
		
			org.springframework.boot
			spring-boot-starter-amqp
			
				
					org.springframework.boot
					spring-boot-starter-logging
				
			
		
		
		
			org.springframework.boot
			spring-boot-starter-jdbc
			
				
					org.springframework.boot
					spring-boot-starter-logging
				
			
		
		
			mysql
			mysql-connector-java
		
		
			com.alibaba
			druid
		
		
		
			org.springframework.boot
			spring-boot-starter-data-redis
			
				
					org.springframework.boot
					spring-boot-starter-logging
				
				
					org.slf4j
					slf4j-log4j12
				
			
		
		
			org.mybatis.spring.boot
			mybatis-spring-boot-starter
		
		
		
			redis.clients
			jedis
		
		
		
			org.redisson
			redisson-spring-boot-starter
			3.13.6
			
				
					org.redisson
					redisson-spring-data-23
				
			
		
		
			org.apache.commons
			commons-lang3
		
		
		
			org.redisson
			redisson-spring-data-21
			3.13.1
		
		
			org.springframework.boot
			spring-boot-starter-test
			test
			
				
					org.springframework.boot
					spring-boot-starter-logging
				
				
					org.slf4j
					slf4j-log4j12
				
			
		
		
			org.springframework.boot
			spring-boot-starter-log4j2
			
				
					org.apache.logging.log4j
					log4j-core
				
				
					org.apache.logging.log4j
					log4j-api
				
			
		
		
		
			org.apache.logging.log4j
			log4j-api
			${log4j2.version}
		
		
			org.apache.logging.log4j
			log4j-core
			${log4j2.version}
		
		
		
			org.aspectj
			aspectjweaver
		
		
			com.lmax
			disruptor
		
		
			com.alibaba
			fastjson
		
		
			com.fasterxml.jackson.core
			jackson-databind
		
		
			com.google.guava
			guava
		
		
			com.alibaba
			fastjson
		
		
			com.fasterxml.jackson.core
			jackson-databind
		

		
		
			org.mk.demo
			common-util
			${common-util.version}
		
		
			org.mk.demo
			db-common
			${db-common.version}

skyDownStream-下游系统运行起来后怎么用

微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率_第4张图片

请求报文示例

[
    {
        "payId": "1",
        "status": "6"
    },
    {
        "payId": "2",
        "status": "6"
    },
    {
        "payId": "3",
        "status": "6"
    },
    {
        "payId": "4",
        "status": "6"
    },
    {
        "payId": "5",
        "status": "6"
    },
    {
        "payId": "10",
        "status": "6"
    }
]

skypayment数据库表结构

CREATE TABLE `sky_payment` (
  `pay_id` int(11) NOT NULL AUTO_INCREMENT,
  `status` tinyint(3) DEFAULT NULL,
  `transf_amount` varchar(45) DEFAULT NULL,
  `created_date` timestamp NULL DEFAULT CURRENT_TIMESTAMP,
  `updated_date` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`pay_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;

我自己写了一个store procedure往这个表里喂入了800多万条数据。因为数据量超过500万后，这种批量操作如果做了不好，很容易出现数据库死锁、主从延迟、数据库事务过长这些幺蛾子问题的发生，从而以此充分模拟线上生产环境。

而实际我们的线上生产环境的数据量涉及到这条出事情跑批的单表数据根本没我自己模拟的数据量大。

详细设计-RabbitMq解决方案

微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率_第5张图片

SkyDownStream下游系统就这样了，重点在于我们模拟我们的中台/商城交易系统的SkyPayment系统。

我们先用RabbitMQ+可控消费数+可控线程数的方案来实现

先上SkyPayment和SkyDownStream系统所共用的parent pom。

parent pom.xml


	4.0.0
	org.mk.demo
	springboot-demo
	0.0.1
	pom
	
		1.8
		0.8.3
		0.0.1
		2.4.2
		
		
		3.4.13
		
		2020.0.1
		2.7.3
		4.0.1
		2.8.0
		
		1.2.6
		27.0.1-jre
		1.2.59
		2.7.3
		1.1.4
		
		5.1.46
		3.4.2
		1.8.13
		1.8.14-RELEASE
		1.0.0
		4.1.42.Final
		0.1.4
		1.16.22
		3.1.0
		2.1.0
		1.2.3
		1.3.10.RELEASE
		1.0.2
		4.0.0
		2.4.6
		2.9.2
		1.9.6
		1.5.23
		1.5.22
		1.5.22
		1.9.5
		0.0.1
		3.1.6
		2.11.1
		2.8.6
		2.5.8
		0.1.4
		1.7.25
		2.0-M2-groovy-2.5
		2.2.0
		3.10.0
		2.6
		5.0.0
		${java.version}
		${java.version}
		3.8.1
		3.2.3
		3.1.1
		2.2.3
		1.4.197
		3.4.14
		4.4.10
		4.5.6
		3.0.0
		UTF-8
		UTF-8
		2.0.22-RELEASE
		4.1.0
		4.1.0
		4.1.0
		1.6.1
		3.1.0
		3.10.0
		2.6
		5.0.0
		2.2.5.RELEASE
		2.2.1.RELEASE
		3.16.1
		2.17.1
		0.0.1
		0.0.1
		0.0.1
		0.0.1
	
	
		
			
			
			
				org.redisson
				redisson-spring-boot-starter
				${redission.version}
				
			
			
				org.redisson
				redisson-spring-data-21
				${redission.version}
			
			
				com.alibaba.cloud
				spring-cloud-alibaba-dependencies
				${spring-cloud-alibaba.version}
				pom
				import
			
			
				com.alibaba.cloud
				spring-cloud-starter-alibaba-nacos-discovery
				
				${nacos-discovery.version}
			
			
				com.aldi.jdbc
				sharding
				${aldi-sharding.version}
			
			
			
				com.auth0
				java-jwt
				${java-jwt.version}
			
			
				cn.hutool
				hutool-crypto
				${hutool-crypto.version}
			
			
			
				org.apache.poi
				poi
				${poi.version}
			
			
				org.apache.poi
				poi-ooxml
				${poi-ooxml.version}
			
			
				org.apache.poi
				poi-ooxml
				${poi-ooxml.version}
			
			
				org.apache.poi
				poi-ooxml-schemas
				${poi-ooxml-schemas.version}
			
			
				dom4j
				dom4j
				${dom4j.version}
			
			
				org.apache.xmlbeans
				xmlbeans
				${xmlbeans.version}
			
			
			
				com.odianyun.architecture
				oseq-aldi
				${oseq-aldi.version}
			
			
				org.apache.httpcomponents
				httpcore
				${httpcore.version}
			

			
				org.apache.httpcomponents
				httpclient
				${httpclient.version}
			
			
				org.apache.zookeeper
				zookeeper
				${zkclient.version}
				
					
						log4j
						log4j
					
					
						org.slf4j
						slf4j-log4j12
					
				
			
			
			
				org.quartz-scheduler
				quartz
				${quartz.version}
			
			
				org.quartz-scheduler
				quartz-jobs
				${quartz.version}
			
			
			
				org.springframework.cloud
				spring-cloud-dependencies
				Hoxton.SR7
				pom
				import
			

			
			
				org.mockito
				mockito-core
				${mockito-core.version}
				test
			
			
			
				com.auth0
				java-jwt
				${java-jwt.version}
			
			
				cn.hutool
				hutool-crypto
				${hutool-crypto.version}
			

			
				org.springframework.boot
				spring-boot-starter-actuator
				${spring-boot.version}
			
			
			
				org.logback-extensions
				logback-ext-spring
				${logback-ext-spring.version}
			
			
				org.slf4j
				jcl-over-slf4j
				${jcl-over-slf4j.version}
			

			
			
				com.h2database
				h2
				${h2.version}
			

			
				org.apache.zookeeper
				zookeeper
				${zookeeper.version}
				
					
						org.slf4j
						slf4j-log4j12
					
					
						log4j
						log4j
					
				
			

			
			
				com.xuxueli
				xxl-job-core
				${xxljob.version}
			
			
				org.springframework.boot
				spring-boot-starter-test
				${spring-boot.version}
				test
				
					
						org.springframework.boot
						spring-boot-starter-logging
					
					
						org.slf4j
						slf4j-log4j12
					
				
			
			
				org.spockframework
				spock-core
				1.3-groovy-2.4
				test
			
			
				org.spockframework
				spock-spring
				1.3-RC1-groovy-2.4
				test
			
			
				org.codehaus.groovy
				groovy-all
				2.4.6
			

			
				com.google.code.gson
				gson
				${gson.version}
			
			
				com.fasterxml.jackson.core
				jackson-databind
				${jackson-databind.version}
			
			
				org.springframework.boot
				spring-boot-starter-web-services
				${spring-boot.version}
			
			
				org.apache.cxf
				cxf-rt-frontend-jaxws
				${cxf.version}
			
			
				org.apache.cxf
				cxf-rt-transports-http
				${cxf.version}
			
			
				org.springframework.boot
				spring-boot-starter-security
				${spring-boot.version}
			

			
				io.github.swagger2markup
				swagger2markup
				1.3.1
			
			
				io.springfox
				springfox-swagger2
				${swagger.version}
			

			
				io.springfox
				springfox-swagger-ui
				${swagger.version}
			

			
				com.github.xiaoymin
				swagger-bootstrap-ui
				${swagger-bootstrap-ui.version}
			

			
				io.swagger
				swagger-annotations
				${swagger-annotations.version}
			

			
				io.swagger
				swagger-models
				${swagger-models.version}
			
			
				org.sky
				sky-sharding-jdbc
				${sky-sharding-jdbc.version}
			
			
				com.googlecode.xmemcached
				xmemcached
				${xmemcached.version}
			
			
				org.apache.shardingsphere
				sharding-jdbc-core
				${shardingsphere.jdbc.version}
			
			
			
				org.springframework.kafka
				spring-kafka
				1.3.10.RELEASE
			
			
				org.mybatis.spring.boot
				mybatis-spring-boot-starter
				${mybatis.version}
			
			
				com.github.pagehelper
				pagehelper-spring-boot-starter
				${pagehelper-mybatis.version}
			
			
				org.springframework.boot
				spring-boot-starter-web
				${spring-boot.version}
				
					
						org.slf4j
						slf4j-log4j12
					
					
						org.springframework.boot
						spring-boot-starter-logging
					
				
			
			
				org.springframework.boot
				spring-boot-dependencies
				${spring-boot.version}
				pom
				import
			
			
				org.apache.dubbo
				dubbo-spring-boot-starter
				${dubbo.version}
				
					
						org.slf4j
						slf4j-log4j12
					
					
						org.springframework.boot
						spring-boot-starter-logging
					
				
			
			
				org.apache.dubbo
				dubbo
				${dubbo.version}
				
					
						javax.servlet
						servlet-api
					
				
			
			
				org.apache.curator
				curator-framework
				${curator-framework.version}
			

			
				org.apache.curator
				curator-recipes
				${curator-recipes.version}
			
			
				mysql
				mysql-connector-java
				${mysql-connector-java.version}
			
			
				com.alibaba
				druid
				${druid.version}
			
			
				com.alibaba
				druid-spring-boot-starter
				${druid.version}
			
			
				com.lmax
				disruptor
				${disruptor.version}
			
			
				com.google.guava
				guava
				${guava.version}
			
			
				com.alibaba
				fastjson
				${fastjson.version}
			
			
				org.apache.dubbo
				dubbo-registry-nacos
				${dubbo-registry-nacos.version}
			
			
				com.alibaba.nacos
				nacos-client
				${nacos-client.version}
			
			
				org.aspectj
				aspectjweaver
				${aspectj.version}
			
			
				org.springframework.boot
				spring-boot-starter-data-redis
				${spring-boot.version}
			
			
				io.seata
				seata-all
				${seata.version}
			
			
				io.netty
				netty-all
				${netty.version}
			
			
				org.projectlombok
				lombok
				${lombok.version}
			
			
			
				com.alibaba.boot
				nacos-config-spring-boot-starter
				${nacos.spring.version}
				
					
						nacos-client
						com.alibaba.nacos
					
				
			

			
				net.sourceforge.groboutils
				groboutils-core
				5
			
			
				commons-lang
				commons-lang
				${commons-lang.version}
			
		
	
	
		redis-common
		common-util
		db-common
		skypayment
		skydownstreamsystem
		httptools-common

SkyPayment的pom.xml文件


	4.0.0
	
		org.mk.demo
		springboot-demo
		0.0.1
	
	skypayment
	


		
			io.netty
			netty-all
		


		
			org.springframework.boot
			spring-boot-starter-web
			${spring-boot.version}
			
				
					org.slf4j
					slf4j-log4j12
				
				
					org.springframework.boot
					spring-boot-starter-logging
				
			
		
		
		
			org.springframework.boot
			spring-boot-starter-quartz
			
				
					org.springframework.boot
					spring-boot-starter-logging
				
			
		
		
			org.quartz-scheduler
			quartz
		
		
			org.quartz-scheduler
			quartz-jobs
		

		
		
			org.springframework.boot
			spring-boot-starter-amqp
			
				
					org.springframework.boot
					spring-boot-starter-logging
				
			
		
		
		
			org.springframework.boot
			spring-boot-starter-jdbc
			
				
					org.springframework.boot
					spring-boot-starter-logging
				
			
		
		
			mysql
			mysql-connector-java
		
		
			com.alibaba
			druid
		
		
		
			org.springframework.boot
			spring-boot-starter-data-redis
			
				
					org.springframework.boot
					spring-boot-starter-logging
				
				
					org.slf4j
					slf4j-log4j12
				
			
		
		
			org.mybatis.spring.boot
			mybatis-spring-boot-starter
		
		
		
			redis.clients
			jedis
		
		
		
			org.redisson
			redisson-spring-boot-starter
			${redission.version}
			
		
		
			org.redisson
			redisson-spring-data-21
			${redission.version}
		
		
			org.apache.commons
			commons-lang3
		
		
			org.springframework.boot
			spring-boot-starter-test
			test
			
				
					org.springframework.boot
					spring-boot-starter-logging
				
				
					org.slf4j
					slf4j-log4j12
				
			
		
		
			org.springframework.boot
			spring-boot-starter-log4j2
			
				
					org.apache.logging.log4j
					log4j-core
				
				
					org.apache.logging.log4j
					log4j-api
				
			
		
		
		
			org.apache.logging.log4j
			log4j-api
			${log4j2.version}
		
		
			org.apache.logging.log4j
			log4j-core
			${log4j2.version}
		
		
		
			org.aspectj
			aspectjweaver
		
		
			com.lmax
			disruptor
		
		
			com.alibaba
			fastjson
		
		
			com.fasterxml.jackson.core
			jackson-databind
		
		
			com.google.guava
			guava
		
		
			com.alibaba
			fastjson
		
		
			com.fasterxml.jackson.core
			jackson-databind
		
		
			org.springframework.boot
			spring-boot-starter-data-mongodb
		
		
		
			org.mk.demo
			redis-common
			${redis-common.version}
		
		
			org.mk.demo
			common-util
			${common-util.version}
		
		
			org.mk.demo
			db-common
			${db-common.version}
		
		
			org.mk.demo
			httptools-common
			${httptools-common.version}

PaymentController.java

这个文件就是用来接受jmeter压入海量高并发数据的那个“回调接口”。

/**
 * 系统项目名称 org.mk.demo.skypayment.controller PaymentController.java
 * 
 * Feb 3, 2022-12:08:59 AM 2022XX公司-版权所有
 * 
 */
package org.mk.demo.skypayment.controller;

import javax.annotation.Resource;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.mk.demo.util.response.ResponseBean;
import org.mk.demo.util.response.ResponseCodeEnum;
import org.mk.demo.skypayment.service.Publisher;
import org.mk.demo.skypayment.vo.PaymentBean;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import reactor.core.publisher.Mono;

/**
 * 
 * PaymentController
 * 
 * 
 * Feb 3, 2022 12:08:59 AM
 * 
 * @version 1.0.0
 * 
 */

@RestController
public class PaymentController {
    private Logger logger = LogManager.getLogger(this.getClass());

    @Resource
    private Publisher publisher;

    @PostMapping(value = "/updateStatus", produces = "application/json")
    @ResponseBody
    public Mono updateStatus(@RequestBody PaymentBean payment) {
        ResponseBean resp = new ResponseBean();
        try {
            publisher.publishPaymentStatusChange(payment);
            resp = new ResponseBean(ResponseCodeEnum.SUCCESS.getCode(), "success");
        } catch (Exception e) {
            resp = new ResponseBean(ResponseCodeEnum.FAIL.getCode(), "system error");
            logger.error(">>>>>>updateStatus error: " + e.getMessage(), e);
        }
        return Mono.just(resp);
    }
}

这个接口会如此来接受jmeter“汹涌压过来的数据”

微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率_第6张图片

 publisher.java

从controller可以看到，进来一条数据就往mq里写一条数据

/**
 * 系统项目名称 org.mk.demo.rabbitmqdemo.service Publisher.java
 * 
 * Nov 19, 2021-11:38:39 AM 2021XX公司-版权所有
 * 
 */
package org.mk.demo.skypayment.service;

import org.mk.demo.skypayment.config.mq.RabbitMqConfig;
import org.mk.demo.skypayment.vo.PaymentBean;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 
 * Publisher
 * 
 * 
 * Nov 19, 2021 11:38:39 AM
 * 
 * @version 1.0.0
 * 
 */
@Component

public class Publisher {
    private Logger logger = LoggerFactory.getLogger(this.getClass());
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void publishPaymentStatusChange(PaymentBean payment) {
        try {
            rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
            rabbitTemplate.convertAndSend(RabbitMqConfig.PAYMENT_EXCHANGE, RabbitMqConfig.PAYMENT_QUEUE, payment);
        } catch (Exception ex) {
            logger.error(">>>>>>publish exception: " + ex.getMessage(), ex);
        }
    }
}

相应的rabbitTemplate的配置

RabbitMqConfig.java

/**
 * 系统项目名称 org.mk.demo.rabbitmqdemo.config RabbitMqConfig.java
 * 
 * Nov 19, 2021-11:30:43 AM 2021XX公司-版权所有
 * 
 */
package org.mk.demo.skypayment.config.mq;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.ExchangeBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.QueueBuilder;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

/**
 * 
 * RabbitMqConfig
 * 
 * 
 * Nov 19, 2021 11:30:43 AM
 * 
 * @version 1.0.0
 * 
 */
@Component
public class RabbitMqConfig {
    /**
     * 主要测试一个死信队列，功能主要实现延时消费，原理是先把消息发到正常队列， 正常队列有超时时间，当达到时间后自动发到死信队列，然后由消费者去消费死信队列里的消息.
     */
    public static final String PAYMENT_EXCHANGE = "payment.exchange";
    public static final String PAYMENT_DL_EXCHANGE = "payment.dl.exchange";
    public static final String PAYMENT_QUEUE = "payment.queue";
    public static final String PAYMENT_DEAD_QUEUE = "payment.queue.dead";

    public static final String PAYMENT_FANOUT_EXCHANGE = "paymentFanoutExchange";
    /**
     * 单位为微秒.
     */
    @Value("${queue.expire:5000}")
    private long queueExpire;

    /**
     * 创建普通交换机.
     */
    @Bean
    public TopicExchange paymentExchange() {
        return (TopicExchange)ExchangeBuilder.topicExchange(PAYMENT_EXCHANGE).durable(true).build();
    }

    /**
     * 创建死信交换机.
     */
    @Bean
    public TopicExchange paymentExchangeDl() {
        return (TopicExchange)ExchangeBuilder.topicExchange(PAYMENT_DL_EXCHANGE).durable(true).build();
    }

    /**
     * 创建普通队列.
     */
    @Bean
    public Queue paymentQueue() {
        return QueueBuilder.durable(PAYMENT_QUEUE).withArgument("x-dead-letter-exchange", PAYMENT_DL_EXCHANGE)// 设置死信交换机
            .withArgument("x-message-ttl", queueExpire).withArgument("x-dead-letter-routing-key", PAYMENT_DEAD_QUEUE)// 设置死信routingKey
            .build();
    }

    /**
     * 创建死信队列.
     */
    @Bean
    public Queue paymentDelayQueue() {
        return QueueBuilder.durable(PAYMENT_DEAD_QUEUE).build();
    }

    /**
     * 绑定死信队列.
     */
    @Bean
    public Binding bindDeadBuilders() {
        return BindingBuilder.bind(paymentDelayQueue()).to(paymentExchangeDl()).with(PAYMENT_DEAD_QUEUE);
    }

    /**
     * 绑定普通队列.
     *
     * @return
     */
    @Bean
    public Binding bindBuilders() {
        return BindingBuilder.bind(paymentQueue()).to(paymentExchange()).with(PAYMENT_QUEUE);
    }

    /**
     * 广播交换机.
     *
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(PAYMENT_FANOUT_EXCHANGE);
    }

    @Bean
    public RabbitTemplate rabbitTemplate(final ConnectionFactory connectionFactory) {
        final RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMessageConverter(producerJackson2MessageConverter());
        return rabbitTemplate;
    }

    @Bean
    public Jackson2JsonMessageConverter producerJackson2MessageConverter() {
        return new Jackson2JsonMessageConverter();
    }
}

RabbitMqListenerConfig.java

/**
 * 系统项目名称 org.mk.demo.skypayment.config.mq RabbitMqListenerConfig.java
 * 
 * Feb 3, 2022-12:35:21 AM 2022XX公司-版权所有
 * 
 */
package org.mk.demo.skypayment.config.mq;

import org.springframework.amqp.rabbit.annotation.RabbitListenerConfigurer;
import org.springframework.amqp.rabbit.listener.RabbitListenerEndpointRegistrar;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.converter.MappingJackson2MessageConverter;
import org.springframework.messaging.handler.annotation.support.DefaultMessageHandlerMethodFactory;
import org.springframework.messaging.handler.annotation.support.MessageHandlerMethodFactory;

/**
 * 
 * RabbitMqListenerConfig
 * 
 * 
 * Feb 3, 2022 12:35:21 AM
 * 
 * @version 1.0.0
 * 
 */
@Configuration
public class RabbitMqListenerConfig implements RabbitListenerConfigurer {

    /* (non-Javadoc)
     * @see org.springframework.amqp.rabbit.annotation.RabbitListenerConfigurer#configureRabbitListeners(org.springframework.amqp.rabbit.listener.RabbitListenerEndpointRegistrar)
     */
    @Override
    public void configureRabbitListeners(RabbitListenerEndpointRegistrar registor) {
        registor.setMessageHandlerMethodFactory(messageHandlerMethodFactory());

    }

    @Bean
    MessageHandlerMethodFactory messageHandlerMethodFactory() {
        DefaultMessageHandlerMethodFactory messageHandlerMethodFactory = new DefaultMessageHandlerMethodFactory();
        messageHandlerMethodFactory.setMessageConverter(consumerJackson2MessageConverter());
        return messageHandlerMethodFactory;
    }

    @Bean
    public MappingJackson2MessageConverter consumerJackson2MessageConverter() {
        return new MappingJackson2MessageConverter();
    }
}

RabbitMQ消费端-Subscriber.java

/**
 * 系统项目名称 org.mk.demo.rabbitmqdemo.service Subscriber.java
 * 
 * Nov 19, 2021-11:47:02 AM 2021XX公司-版权所有
 * 
 */
package org.mk.demo.skypayment.service;

import javax.annotation.Resource;

import org.mk.demo.skypayment.config.mq.RabbitMqConfig;
import org.mk.demo.skypayment.vo.PaymentBean;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * 
 * Subscriber
 * 
 * 
 * Nov 19, 2021 11:47:02 AM
 * 
 * @version 1.0.0
 * 
 */
@Component
public class Subscriber {
    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Resource
    private PaymentService paymentService;

    @RabbitListener(queues = RabbitMqConfig.PAYMENT_QUEUE)
    public void receiveDL(PaymentBean payment) {
        try {
            if (payment != null) {
                paymentService.UpdateRemotePaymentStatusById(payment, false);
            }
        } catch (Exception ex) {
            logger.error(">>>>>>Subscriber from dead queue exception: " + ex.getMessage(), ex);
        }
    }
}

这个消费端我们的核心配置在application.yml里有配置如下的内容

  rabbitmq:
    publisher-confirm-type: CORRELATED
    listener:
       ## simple类型
       simple:
         #最小消费者数量
         concurrency: 32
         #最大的消费者数量
         maxConcurrency: 64
         #指定一个请求能处理多少个消息，如果有事务的话，必须大于等于transaction数量
         prefetch: 32

所以，这个配置决定了我们的最大消费者每秒是64个。

然后我们在我们的每一个消费端里打开一条通向SkyDownStream的/updateStatusInBatch请求，也就意味着它在每一秒不会向下游发起超过64个并发的restTemplate请求。

RestTemplate配置

HttpConfig.java

package org.mk.demo.config.http;

import java.util.ArrayList;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.BufferingClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

@Configuration
@ConfigurationProperties(prefix = "http.rest.connection")

public class HttpConfig {
    private Logger logger = LoggerFactory.getLogger(this.getClass());

    public int getConnectionTimeout() {
        return connectionTimeout;
    }

    public void setConnectionTimeout(int connectionTimeout) {
        this.connectionTimeout = connectionTimeout;
    }

    public int getReadTimeout() {
        return readTimeout;
    }

    public void setReadTimeout(int readTimeout) {
        this.readTimeout = readTimeout;
    }

    private int connectionTimeout;
    private int readTimeout;

    @Bean
    public RestTemplate restTemplate(ClientHttpRequestFactory factory) {
        RestTemplate restTemplate = new RestTemplate(new BufferingClientHttpRequestFactory(factory));
        List interceptors = new ArrayList<>();
        interceptors.add(new LoggingRequestInterceptor());
        restTemplate.setInterceptors(interceptors);
        return restTemplate;
    }

    @Bean
    public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();// 默认的是JDK提供http连接，需要的话可以//通过setRequestFactory方法替换为例如Apache
                                                                                      // HttpComponents、Netty或//OkHttp等其它HTTP
                                                                                      // library。
        logger.info(">>>>>>http.rest.connection.readTimeout setted to->{}", readTimeout);
        logger.info(">>>>>>http.rest.connection.connectionTimeout setted to->{}", connectionTimeout);
        factory.setReadTimeout(readTimeout);// 单位为ms
        factory.setConnectTimeout(connectionTimeout);// 单位为ms
        return factory;
    }
}

LoggingRequestInterceptor.java

package org.mk.demo.config.http;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;

public class LoggingRequestInterceptor implements ClientHttpRequestInterceptor {
	private Logger logger = LoggerFactory.getLogger(this.getClass());

	@Override
	public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)
			throws IOException {
		traceRequest(request, body);
		ClientHttpResponse response = execution.execute(request, body);
		traceResponse(response);
		return response;
	}

	private void traceRequest(HttpRequest request, byte[] body) throws IOException {
		logger.debug("===========================request begin================================================");
		logger.debug("URI         : {}", request.getURI());
		logger.debug("Method      : {}", request.getMethod());
		logger.debug("Headers     : {}", request.getHeaders());
		logger.debug("Request body: {}", new String(body, "UTF-8"));
		logger.debug("==========================request end================================================");
	}

	private void traceResponse(ClientHttpResponse response) throws IOException {
		StringBuilder inputStringBuilder = new StringBuilder();
		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(response.getBody(), "UTF-8"));
		String line = bufferedReader.readLine();
		while (line != null) {
			inputStringBuilder.append(line);
			inputStringBuilder.append('\n');
			line = bufferedReader.readLine();
		}
		logger.debug("============================response begin==========================================");
		logger.debug("Status code  : {}", response.getStatusCode());
		logger.debug("Status text  : {}", response.getStatusText());
		logger.debug("Headers      : {}", response.getHeaders());
		logger.debug("Response body: {}", inputStringBuilder.toString());
		logger.debug("=======================response end=================================================");
	}

}

RestTemplate的核心配置

http:
  rest:
    connection:
      readTimeout: 4000
      connectionTimeout: 2000
      downstreamsystem-url: http://localhost:9082/updateStatus
      downstreamsystem-batch-url: http://localhost:9082/updateStatusInBatch

可以从上述配置看到我们的ReadTimeout为4秒，connectionTimeout为2秒。以便于就算系统出了问题也可以及时的“断开”。

一味的放长等待时间是绝大多数出问题项目程序猿们的掩耳盗铃。微服务讲究的是一秒原则，>=1秒的任何请求都属于慢请求（无论外部并发到达10万每秒还是100万每秒的请求），比起掩耳盗铃，我们更应该关注如何把你的交易处理的响应压缩到“更短的时间”，这才是程序员。

SkyPayment项目的全application.yml文件内容

mysql:
  datasource:
    db:
      type: com.alibaba.druid.pool.DruidDataSource
      driverClassName: com.mysql.jdbc.Driver
      minIdle: 50
      initialSize: 50
      maxActive: 300
      maxWait: 1000
      testOnBorrow: false
      testOnReturn: true
      testWhileIdle: true
      validationQuery: select 1
      validationQueryTimeout: 1
      timeBetweenEvictionRunsMillis: 5000
      ConnectionErrorRetryAttempts: 3
      NotFullTimeoutRetryCount: 3
      numTestsPerEvictionRun: 10
      minEvictableIdleTimeMillis: 480000
      maxEvictableIdleTimeMillis: 480000
      keepAliveBetweenTimeMillis: 480000
      keepalive: true
      poolPreparedStatements: true
      maxPoolPreparedStatementPerConnectionSize: 512
      maxOpenPreparedStatements: 512
    master: #master db
      type: com.alibaba.druid.pool.DruidDataSource
      driverClassName: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/ecom?useUnicode=true&characterEncoding=utf-8&useSSL=false&useAffectedRows=true&autoReconnect=true&allowMultiQueries=true
      username: root
      password: 111111
    slaver: #slaver db
      type: com.alibaba.druid.pool.DruidDataSource
      driverClassName: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3307/ecom?useUnicode=true&characterEncoding=utf-8&useSSL=false&useAffectedRows=true&autoReconnect=true&allowMultiQueries=true
      username: root
      password: 111111     
server:
  port: 9080
  tomcat:
    max-http-post-size: -1
  max-http-header-size: 10240000

spring:
  application:
    name: skypayment
  servlet:
    multipart:
      max-file-size: 10MB
      max-request-size: 10MB
    context-path: /skypayment
  data:
    mongodb:
      uri: mongodb://skypayment:111111@localhost:27017,localhost:27018/skypayment
  quartz:
    properties:
      org:
        quartz:
          scheduler:
            instanceName: DefaultQuartzScheduler
            instanceId: AUTO
            makeSchedulerThreadDaemon: true
          threadPool:
            class: org.quartz.simpl.SimpleThreadPool
            makeThreadsDaemons: true
            threadCount: 20
            threadPriority: 5
          jobStore:
            class: org.quartz.simpl.RAMJobStore
            #            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
            #            tablePrefix: qrtz_
            #            isClustered: false
            misfireThreshold: 60000
    #job-store-type: jdbc
    #jdbc:
    #  initialize-schema: never
    auto-startup: true
    overwrite-existing-jobs: true
    startup-delay: 10000
    wait-for-jobs-to-complete-on-shutdown: true
  redis:
    password: 111111
    #nodes: localhost:7001
    redisson:
      nodes: redis://127.0.0.1:27001,redis://127.0.0.1:27002,redis://127.0.0.1:27003
    sentinel: 
      nodes: localhost:27001,localhost:27002,localhost:27003
      master: master1
    database: 0
    switchFlag: 1
    lettuce:
      pool:
        max-active: 100
        max-wait: 10000
        max-idle: 25
        min-idl: 2
        shutdown-timeout: 2000
        timeBetweenEvictionRunsMillis: 5000
    timeout: 5000
     #配置rabbitMq 服务器
  rabbitmq:
    addresses: localhost:5672
    username: admin
    password: admin
    #虚拟host 可以不设置,使用server默认host
    virtual-host: /
    publisher-confirm-type: CORRELATED
    listener:
       ## simple类型
       simple:
         #最小消费者数量
         concurrency: 32
         #最大的消费者数量
         maxConcurrency: 64
         #指定一个请求能处理多少个消息，如果有事务的话，必须大于等于transaction数量
         prefetch: 32
         retry: 
           enabled: false
#rabbitmq的超时用于队列的超时使用
queue:
  expire: 1000
http:
  rest:
    connection:
      readTimeout: 4000
      connectionTimeout: 2000
      downstreamsystem-url: http://localhost:9082/updateStatus
      downstreamsystem-batch-url: http://localhost:9082/updateStatusInBatch
job:
  corn:
      updatePaymentStatus: 0/1 * * * * ? 
threadpool:
  corePoolSize: 25
  maxPoolSize: 50
  queueCapacity: 5000
  keepAliveSeconds: 100
  threadNamePrefix: syntask-thread
  waitForTasksToCompleteOnShutdown: true
  awaitTerminationSeconds: 100

基于RabbitMQ可控消费者的运行演示

运行起SkyDownStream和SkyPayment，在运行前分别往两个项目中植入Glowroot探针。

  • SkyPayment的glowroot监控运行在http://localhost:9000端；
  • SkyDownStream的glowroot监控运行在http://localhost:9001端；

然后我们使用jmeter的Arrival Thread Groups往SkyPayment里压入这么多请求。

微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率_第7张图片

 线程在刚开始时会一个个发起，过了15秒当线程到达“全发起”后，要维持5分钟的持续运行。

此时我们观察我们的SkyPayment端的glowroot监控和SkyDownStream端的glowroot监控。我们可以看到，无论是SkyPayment端（查看httpclient在jvm中的对象数）还是在SkyDownStream端（查看socket对象数）没有超过64个并发过。

微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率_第8张图片

我们进而观察JVM运行情况，可以看到没有一个项目超过2GB内存的。

微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率_第9张图片

 当jmeter端的24,720个请求全部发完后，SkyPayment的控制台继续还有持续的输出，然后过了40秒不到，我们查看数据库skypayment表，表内的status状态全部被update完成了。

以上运行说明系统达到设计指标。

别急，我们下面来看用NOSQL-MongoDb来实现暂存队列、使用线程池来实现的另一种跑批，你们会发觉，这种设计的性能和扩展性要强于使用RabbitMQ的可控消费端数量技术的几倍。

详细设计-基于NoSql做缓存队列并使用线程池制作的分布式跑批解决方案

微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率_第10张图片

 在这个设计里面整体的系统在运作机制上是这样的：

  1. 还是利用RabbitMQ，前端流量来一条请求用publisher塞到一个mq队列中；
  2. 在队列中可控消费者数量，每个消费者执行一条写mongodb的操作，把数据写入到mongodb中的一个叫“paymentBean”的collection中以形成流水，并把paymentBean里的flag这个字段置成-1，代表“未处理”；
  3. 前端的操作截止第2步结束，然后系统自带一个quartz，每秒运行一次。每一次运行取出一批flag=-1的记录以List的形式发到下游系统-SkyDownStream系统中；
  4. 在发送时我们使用spring boot自带的线程池，以最大不超过50个线程的并发然后使用RestTemplate往下游系统发，发完一批-50条记录后再把暂存流水表即mongodb的paymentBean collection中的flag字段改成1；
  5. 在第4步的“发送请求和把己发送的数据的flag变更“过程中，我们用redisson自续约锁把这个过程锁上，以防止一个 quartz job还没处理完后一个quartz job跟上造成资源竞争、数据污染。同时，更重要的是我们这个设计是云原生的，即意味着这样的系统可以不受限于单机可多幅本的运行，由其是当多幅本运行起来后不同的job会产生并发资源竞争并最终造成“数据库行级死锁”。因此我们才会使用redisson自续约锁来避免出现上述的场景；

动手实现代码

PaymentBean用于映射Mongodb的paymentBean Collection

/**
 * 系统项目名称 org.mk.demo.skypayment.vo PaymentBean.java
 * 
 * Feb 1, 2022-11:12:17 PM 2022XX公司-版权所有
 * 
 */
package org.mk.demo.skypayment.vo;

import java.io.Serializable;

import org.mk.demo.skypayment.config.mongo.AutoIncKey;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Field;

/**
 * 
 * PaymentBean
 * 
 * 
 * Feb 1, 2022 11:12:17 PM
 * 
 * @version 1.0.0
 * 
 */
public class PaymentBean implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @AutoIncKey
    @Field("flowId")
    private int flowId;

    public int getFlowId() {
        return flowId;
    }

    public void setFlowId(int flowId) {
        this.flowId = flowId;
    }

    private int flag;

    public int getFlag() {
        return flag;
    }

    public void setFlag(int flag) {
        this.flag = flag;
    }

    private int payId;

    public int getPayId() {
        return payId;
    }

    public void setPayId(int payId) {
        this.payId = payId;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public double getTransfAmount() {
        return transfAmount;
    }

    public void setTransfAmount(double transfAmount) {
        this.transfAmount = transfAmount;
    }

    private int status;
    private double transfAmount = 0;
}

MongoTemplate中对于主键自增长-自定义的AutoIncKey的设计

/**
 * 系统项目名称 org.mk.demo.skypayment.config.mongo AutoIncKey.java
 * 
 * Feb 18, 2022-2:41:07 PM 2022XX公司-版权所有
 * 
 */
package org.mk.demo.skypayment.config.mongo;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 
 * AutoIncKey
 * 
 * 
 * Feb 18, 2022 2:41:07 PM
 * 
 * @version 1.0.0
 * 
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoIncKey {}

Mongo内自增长主键IncInfo.java

/**
 * 系统项目名称 org.mk.demo.skypayment.config.mongo IncInfo.java
 * 
 * Feb 18, 2022-2:41:37 PM 2022XX公司-版权所有
 * 
 */
package org.mk.demo.skypayment.config.mongo;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

/**
 * 
 * IncInfo
 * 
 * 
 * Feb 18, 2022 2:41:37 PM
 * 
 * @version 1.0.0
 * 
 */
@Document(collection = "inc")
public class IncInfo {
    @Id
    private String id;// 主键

    @Field
    private String collName;// 需要自增id的集合名称(这里设置为MyDomain)

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getCollName() {
        return collName;
    }

    public void setCollName(String collName) {
        this.collName = collName;
    }

    public Integer getIncId() {
        return incId;
    }

    public void setIncId(Integer incId) {
        this.incId = incId;
    }

    @Field
    private Integer incId;// 当前自增id值

}

SaveEventListener.java-用于对于在mongodb内新增一条记录自增长的操作

/**
 * 系统项目名称 org.mk.demo.skypayment.config.mongo SaveEventListener.java
 * 
 * Feb 18, 2022-2:29:43 PM 2022XX公司-版权所有
 * 
 */
package org.mk.demo.skypayment.config.mongo;

import org.mk.demo.skypayment.vo.PaymentBean;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.FindAndModifyOptions;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.mapping.event.AbstractMongoEventListener;
import org.springframework.data.mongodb.core.mapping.event.BeforeConvertEvent;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Component;
import org.springframework.util.ReflectionUtils;
import java.lang.reflect.Field;

/**
 * 
 * SaveEventListener
 * 
 * 
 * Feb 18, 2022 2:29:43 PM
 * 
 * @version 1.0.0
 * 
 */
@Component
public class SaveEventListener extends AbstractMongoEventListener {
    private Logger logger = LoggerFactory.getLogger(this.getClass());
    @Autowired
    private MongoTemplate mongoTemplate;

    @Override
    public void onBeforeConvert(BeforeConvertEvent event) {
        logger.info(event.getSource().toString());
        PaymentBean source = (PaymentBean)event.getSource();
        if (source != null) {
            ReflectionUtils.doWithFields(source.getClass(), new ReflectionUtils.FieldCallback() {
                public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
                    ReflectionUtils.makeAccessible(field);
                    // 如果字段添加了我们自定义的AutoIncKey注解
                    if (field.isAnnotationPresent(AutoIncKey.class)) {
                        // 设置自增ID
                        field.set(source, getNextId(source.getClass().getSimpleName()));
                    }
                }
            });
        }

    }

    private Integer getNextId(String collName) {
        Query query = new Query(Criteria.where("collName").is(collName));
        Update update = new Update();
        update.inc("incId", 1);
        FindAndModifyOptions options = new FindAndModifyOptions();
        options.upsert(true);
        options.returnNew(true);
        IncInfo inc = mongoTemplate.findAndModify(query, update, options, IncInfo.class);
        return inc.getIncId();
    }
}


有了上述工具类后，我们在原有SkyPayment项目结构里加入一个consumer，这个consumer不同于基于RabbitMQ的例子中的subscriber，这个subscriber接受到一条请求就往mongodb的paymentBean collection内新增一条记录，并把这条记录里的flag字段置成-1，代表未处理。


SubscriberAndRunJob.java


/**
 * 系统项目名称 org.mk.demo.skypayment.service SubscriberToJob.java
 * 
 * Feb 16, 2022-1:46:59 PM 2022XX公司-版权所有
 * 
 */
package org.mk.demo.skypayment.service;

import javax.annotation.Resource;

import org.mk.demo.skypayment.config.mq.RabbitMqConfig;
import org.mk.demo.skypayment.vo.PaymentBean;
import org.mk.demo.util.CloneUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * 
 * SubscriberToJob
 * 
 * 
 * Feb 16, 2022 1:46:59 PM
 * 
 * @version 1.0.0
 * 
 */
@Component
public class SubscriberAndRunJob {
    private Logger logger = LoggerFactory.getLogger(this.getClass());
    @Resource
    private PaymentService paymentService;

    @RabbitListener(queues = RabbitMqConfig.PAYMENT_QUEUE)
    public void receiveDL(PaymentBean payment) throws Exception {
        try {
            if (payment != null) {
                PaymentBean paymentFlow = CloneUtil.clone(payment);
                paymentFlow.setFlag(-1);
                paymentService.mongoAddPaymentFlow(paymentFlow);
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
    }
}



微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率_第11张图片


 定义每秒运行一次job的quartz


  quartz:
    properties:
      org:
        quartz:
          scheduler:
            instanceName: DefaultQuartzScheduler
            instanceId: AUTO
            makeSchedulerThreadDaemon: true
          threadPool:
            class: org.quartz.simpl.SimpleThreadPool
            makeThreadsDaemons: true
            threadCount: 20
            threadPriority: 5
          jobStore:
            class: org.quartz.simpl.RAMJobStore
            #            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
            #            tablePrefix: qrtz_
            #            isClustered: false
            misfireThreshold: 60000
    #job-store-type: jdbc
    #jdbc:
    #  initialize-schema: never
    auto-startup: true
    overwrite-existing-jobs: true
    startup-delay: 10000
    wait-for-jobs-to-complete-on-shutdown: true


相应的quartz自动装配


JobCronProperties.java


package org.mk.demo.skypayment.config.quartz;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties("job.corn")
public class JobCronProperties {
    
    private String updatePaymentStatus;

    public String getUpdatePaymentStatus() {
        return updatePaymentStatus;
    }

    public void setUpdatePaymentStatus(String updatePaymentStatus) {
        this.updatePaymentStatus = updatePaymentStatus;
    }

}



JobConfig.java


/**
 * 系统项目名称 org.mk.demo.skypayment.config.quartz JobConfig.java
 * 
 * Feb 16, 2022-2:25:15 PM 2022XX公司-版权所有
 * 
 */
package org.mk.demo.skypayment.config.quartz;

import javax.annotation.Resource;

import org.mk.demo.skypayment.service.PaymentJob;
import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 
 * JobConfig
 * 
 * 
 * Feb 16, 2022 2:25:15 PM
 * 
 * @version 1.0.0
 * 
 */
@Configuration
@EnableConfigurationProperties({JobCronProperties.class})
public class JobConfig {
    @Resource
    private JobCronProperties jobCronProperties;

    @Bean
    public JobDetail autoCancelJob() {
        return JobBuilder.newJob(PaymentJob.class).withIdentity(PaymentJob.class.getName(), "updatePaymentStatus")
            .requestRecovery().storeDurably().build();
    }

    @Bean
    public Trigger autoCancelTrigger(JobDetail autoCancelJob) {
        return TriggerBuilder.newTrigger().forJob(autoCancelJob)
            .withSchedule(CronScheduleBuilder.cronSchedule(jobCronProperties.getUpdatePaymentStatus()))
            .withIdentity(PaymentJob.class.getName(), "updatePaymentStatus").build();
    }
}



PaymentJob.java


/**
 * 系统项目名称 org.mk.demo.skypayment.service PaymentJob.java
 * 
 * Feb 16, 2022-4:00:14 PM 2022XX公司-版权所有
 * 
 */
package org.mk.demo.skypayment.service;

import java.util.List;

import javax.annotation.Resource;

import org.mk.demo.skypayment.vo.PaymentBean;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * 
 * PaymentJob
 * 
 * 
 * Feb 16, 2022 4:00:14 PM
 * 
 * @version 1.0.0
 * 
 */
public class PaymentJob extends QuartzJobBean {
    private final Logger logger = LoggerFactory.getLogger(getClass());

    /* (non-Javadoc)
     * @see org.springframework.scheduling.quartz.QuartzJobBean#executeInternal(org.quartz.JobExecutionContext)
     */
    @Resource
    private PaymentService paymentService;

    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        logger.info(">>>>>>Start updatePaymentStatus job");
        try {
            List unhandledPaymentFlowList = paymentService.mongoGetUnhandledPaymentFlow();
            if (unhandledPaymentFlowList != null && unhandledPaymentFlowList.size() > 0) {
                // 改用mongo方法修改流水表
                paymentService.mongoRemotePaymentStatusByList(unhandledPaymentFlowList, true);
                Thread.sleep(50);
            }
        } catch (

        Exception e) {
            logger.error(">>>>>>execute batch update paymentstatus error: " + e.getMessage(), e);
        }
    }

}



这个job每秒钟运行一次，每次运行时拿到flag=-1的流水，它是通过paymentService.mongoGetUnhandledPaymentFlow方法得到。


PaymentService中的mongoGetUnhandledPaymentFlow方法


    public List mongoGetUnhandledPaymentFlow() {
        List paymentFlowList = new ArrayList();
        try {
            Query query = new Query(Criteria.where("flag").is(-1));
            paymentFlowList = mongoTemplate.find(query, PaymentBean.class);
        } catch (Exception e) {
            logger.error(">>>>>>getUnhandledPaymentFlow from mongo error: " + e.getMessage(), e);
        }
        return paymentFlowList;
    }


查到后调用PaymentService中的mongoRemotePaymentStatusByList方法往下游系统SkyDownStream里送就行了。


PaymentService.mongoRemotePaymentStatusByList方法


    @Async("callRemoteUpdatePaymentStatusInBatch")
    public ResponseBean mongoRemotePaymentStatusByList(List paymentList, boolean batchFlag) {
        ResponseBean resp = null;
        if (paymentList == null || paymentList.size() < 1) {// 只要有flag=-1的未处理数据才进入发送处理过程
            return new ResponseBean(ResponseCodeEnum.SUCCESS.getCode(), "暂无需要处理的数据");
        }
        RLock lock = redissonSentinel.getLock(ConstantsVal.UPDATE_PAYMENT_LOCK);
        try {
            boolean islock = lock.tryLock(0, TimeUnit.SECONDS);
            if (islock) {
                ResponseEntity responseEntity =
                    restTemplate.postForEntity(downStreamSystemBatchUrl, paymentList, ResponseBean.class);
                // 返回json数据
                resp = responseEntity.getBody();
                if (batchFlag) {
                    if (resp.getCode() == 0) {
                        // 改成使用mongoUpdate
                        // paymentDao.updatePaymentFlowDoneByList(paymentList);
                        for (PaymentBean paymentFlow : paymentList) {
                            Query query = Query.query(Criteria.where("_id").is(paymentFlow.getFlowId()));
                            Update update = Update.update("flag", 1);
                            mongoTemplate.upsert(query, update, "paymentBean");
                        }
                    }
                }
            } else {
                resp = new ResponseBean(ResponseCodeEnum.WAITING.getCode(), "请稍侯");
                logger.info(">>>>>>前面任务进行中,请稍侯!");
            }
        } catch (Exception e) {
            logger.error(">>>>>>remote remoteUpdatePaymentStatusById error: " + e.getMessage(), e);
            resp = new ResponseBean(ResponseCodeEnum.FAIL.getCode(), "system error");
        } finally {
            try {
                lock.unlock();
            } catch (Exception e) {
            }
        }
        return resp;
    }


注意看这个方法有三处需要注意


    

  1. 这个方法头上有一个@Async("callRemoteUpdatePaymentStatusInBatch")，代表了这个方法会自动走spring boot线程池；
    2. 

  2. 使用了Redisson自续约锁，来保证不会出现资源竞争造成的“死锁”；
    3. 

  3. 通过RestTemplate送到下游系统一旦成功后把MongoDb中的流水表的flag改成1；
    4. 



spring boot线程池设定


ThreadPoolConfig.java


package org.mk.demo.skypayment.config.thread;

import java.util.concurrent.Executor;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@EnableAsync
@Configuration
@ConfigurationProperties(prefix = "threadpool")
public class ThreadPoolConfig {
    
    @Bean("callRemoteUpdatePaymentStatusInBatch")
    public Executor syncTaskBatchExecutor() {
        // ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        ThreadPoolTaskExecutor taskExecutor = new VisiableThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(corePoolSize);
        taskExecutor.setMaxPoolSize(maxPoolSize);
        taskExecutor.setQueueCapacity(queueCapacity);
        taskExecutor.setKeepAliveSeconds(keepAliveSeconds);
        taskExecutor.setThreadNamePrefix(threadNamePrefix);
        taskExecutor.setWaitForTasksToCompleteOnShutdown(waitForTasksToCompleteOnShutdown);
        taskExecutor.setAwaitTerminationSeconds(awaitTerminationSeconds);
        return taskExecutor;
    }
    
    @Value("${threadpool.corePoolSize}")
    private int corePoolSize;

    @Value("${threadpool.maxPoolSize}")
    private int maxPoolSize;

    @Value("${threadpool.queueCapacity}")
    private int queueCapacity;

    @Value("${threadpool.keepAliveSeconds}")
    private int keepAliveSeconds;

    @Value("${threadpool.threadNamePrefix}")
    private String threadNamePrefix;

    @Value("${threadpool.waitForTasksToCompleteOnShutdown}")
    private boolean waitForTasksToCompleteOnShutdown;

    @Value("${threadpool.awaitTerminationSeconds}")
    private int awaitTerminationSeconds;
}



VisiableThreadPoolTaskExecutor.java


/**
 * 系统项目名称 org.mk.demo.odychannelweb.config VisiableThreadPoolTaskExecutor.java
 * 
 * Jan 31, 2021-4:21:14 AM 2021XX公司-版权所有
 * 
 */
package org.mk.demo.skypayment.config.thread;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.util.concurrent.ListenableFuture;

import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 
 * VisiableThreadPoolTaskExecutor
 * 
 * 
 * Jan 31, 2021 4:21:14 AM
 * 
 * @version 1.0.0
 * 
 */
public class VisiableThreadPoolTaskExecutor extends ThreadPoolTaskExecutor {
    protected final Logger logger = LoggerFactory.getLogger(this.getClass());

    private void showThreadPoolInfo(String prefix) {
        ThreadPoolExecutor threadPoolExecutor = getThreadPoolExecutor();

        if (null == threadPoolExecutor) {
            return;
        }

        logger.info("{}, {},taskCount [{}], completedTaskCount [{}], activeCount [{}], queueSize [{}]",
            this.getThreadNamePrefix(), prefix, threadPoolExecutor.getTaskCount(),
            threadPoolExecutor.getCompletedTaskCount(), threadPoolExecutor.getActiveCount(),
            threadPoolExecutor.getQueue().size());
    }

    @Override
    public void execute(Runnable task) {
        showThreadPoolInfo("1. do execute");
        super.execute(task);
    }

    @Override
    public void execute(Runnable task, long startTimeout) {
        showThreadPoolInfo("2. do execute");
        super.execute(task, startTimeout);
    }

    @Override
    public Future submit(Runnable task) {
        showThreadPoolInfo("1. do submit");
        return super.submit(task);
    }

    @Override
    public  Future submit(Callable task) {
        showThreadPoolInfo("2. do submit");
        return super.submit(task);
    }

    @Override
    public ListenableFuture submitListenable(Runnable task) {
        showThreadPoolInfo("1. do submitListenable");
        return super.submitListenable(task);
    }

    @Override
    public  ListenableFuture submitListenable(Callable task) {
        showThreadPoolInfo("2. do submitListenable");
        return super.submitListenable(task);
    }
}



运行基于NOSQL暂存队列的可控线程数跑批例子的效果


我们把SkyPayment工程运行起来，并拿jmeter同样喂入这么多样本数据


微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率_第12张图片


然后我们观察着系统，当jmeter达到峰值时开始进入5分钟的持续并发时间，然后我们先来看在如此大并发下，下游系统SkyDownStream系统中的socket被打开数，即意味着这个下游系统一秒内被并发调用数


微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率_第13张图片


 运行全过程中，这个值始终没有变过，说明我们对下游的访问并发数控制的很好。


我们在mongodb中查询flag=-1的数据


微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率_第14张图片


我们发觉这个值一会83，一会29，一会61。这说明在如此高并发的插入下，我们的流水消耗速度相当正常。


要知道这可是2万4千的请求像潮水一样汹涌的插入流水表，如果我们的job的消耗速度跟不上，那么这个flag=-1的记录数是会飞速的、直线的上升的。而不是像这样：进入一些后即马上被消耗掉一些。


这说明系统进入和消耗的速度基本上达到平衡。而在系统运行过程中：


    

  • SkyPayment没有超过2GB内存；
    • 

  • SkyDownStream没有超过1GB内存；
    • 



前端的jmeter的并发结束后，SkyPayment里的Job也几乎是在同一时刻结束的。


系统整体远远优于“基于MQ可控消费者数”的跑批设计。


总结


这是因为以下几点细节造成的如此大的差距：


    

  1. 尽量使用NOSQL或者最好不要使用DB；
    2. 

  2. 要锁也要用分布式锁如：Redis锁，而不要用Synchronized这种锁；
    3. 

  3. 一批一提交而不要一条条的请求去提交；
    4. 

  4. 线程可控-我们把我们的多线程只控制在不超过最大50个并发，实际比一些动不动开个1,000个线程数的劣质设计性能还要优；
    5. 



所以以上4点结合我之前有一篇博客：微服务设计指导-微服务各层间应该如何调用中所提到的5个层次：


微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率_第15张图片


 现在各位知道，微服务的设计上要求我们对于IT系统的综合知识的掌握有多么重要了！你说它是技术它也不属于纯技术，我觉得它更像一种“思想”、一种“艺术”。


结束本篇博客。


 


 

























你可能感兴趣的:(微服务,云原生,雪崩,微服务,分布式跑批,高并发跑批)






    

  • 微服务下功能权限与数据权限的设计与实现
nbsaas-boot
微服务java架构

    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    

    • 

  • 腾讯云技术深度探索：构建高效云原生微服务架构
我的运维人生
云原生架构腾讯云运维开发技术共享

    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
    

    • 

  • GitHub上克隆项目
bigbig猩猩
github

    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
    

    • 

  • 01-Git初识
Meereen
Gitgit

    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
    

    • 

  • nosql数据库技术与应用知识点
皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库

    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
    

    • 

  • OPENAIGC开发者大赛企业组AI黑马奖 | AIGC数智传媒解决方案
RPA中国
人工智能AIGC传媒

    在第二届拯救者杯OPENAIGC开发者大赛中，涌现出一批技术突出、创意卓越的作品。为了让这些优秀项目被更多人看到，我们特意开设了优秀作品报道专栏，旨在展示其独特之处和开发者的精彩故事。无论您是技术专家还是爱好者，希望能带给您不一样的知识和启发。让我们一起探索AIGC的无限可能，见证科技与创意的完美融合！创未来AI应用赛-企业组AI黑马奖作品名称：AIGC数智传媒解决方案参赛团队：深圳市三象智能技术
    

    • 

  • Kafka是如何保证数据的安全性、可靠性和分区的
喜欢猪猪
kafka分布式

    Kafka作为一个高性能、可扩展的分布式流处理平台，通过多种机制来确保数据的安全性、可靠性和分区的有效管理。以下是关于Kafka如何保证数据安全性、可靠性和分区的详细解析：一、数据安全性SSL/TLS加密：Kafka支持SSL/TLS协议，通过配置SSL证书和密钥来加密数据传输，确保数据在传输过程中不会被窃取或篡改。这一机制有效防止了中间人攻击，保护了数据的安全性。SASL认证：Kafka支持多种
    

    • 

  • 2022-10-10
幸福芳芳

    10.10日觉察日记1.事件：开晨会员工来不齐，路远的请假，离得近的也请假，一律不批！2.感受：生气，气愤（情绪如何转化或使用）3.想法：1.今年已经很少开晨会了，非必要不会通知开会的，临近点了再打电话请假，又不是特别忙的季节，借口都会找～～2.不来的按公司标准执行负激励，待岗处理！我为你们负责，你们安全重要会议都不参加，自己都不为自己负责！以后有事也别找我！尤其是经销商老板，自己都不清楚自己用工
    

    • 

  • MongoDB知识概括
GeorgeLin98
持久层mongodb

    MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
    

    • 

  • 06选课支付模块之基于消息队列发送支付通知消息
echo 云清
学成在线javarabbitmq消息队列支付通知学成在线

    消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
    

    • 

  • WebMagic：强大的Java爬虫框架解析与实战
Aaron_945
Javajava爬虫开发语言

    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    

    • 

  • 华为云分布式缓存服务DCS 8月新特性发布
华为云PaaS服务小智
华为云分布式缓存

    分布式缓存服务（DistributedCacheService，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS8月的特性更新内容，一起来看看吧！
    

    • 

  • 2021-09-10
彧瑛

    [cp]九月果香，九月菊黄，九月忽然想起，是谁在播撒着希望？九月我们收集阳光，九月我们深情歌唱，一个感动的季节，被求知的眼睛珍藏。一寸一寸的粉笔，染白您的头发，腾然而起点燃成烛，照亮别人，让后来者攀上崖顶，让后来者踏着你的双肩，送一批批学子上路。黑发积霜织日月，粉笔无言写春秋。这就是老师的一生一一人类灵魂工程师的真实写照。粉笔里飞舞着您的万千情丝，书写着您的青春岁月；教室里定格着您的音容笑貌，记录
    

    • 

  • 浅谈MapReduce
Android路上的人
Hadoop分布式计算mapreduce分布式框架hadoop

    从今天开始，本人将会开始对另一项技术的学习，就是当下炙手可热的Hadoop分布式就算技术。目前国内外的诸多公司因为业务发展的需要，都纷纷用了此平台。国内的比如BAT啦，国外的在这方面走的更加的前面，就不一一列举了。但是Hadoop作为Apache的一个开源项目，在下面有非常多的子项目，比如HDFS，HBase,Hive，Pig,等等，要先彻底学习整个Hadoop，仅仅凭借一个的力量，是远远不够的。
    

    • 

  • Redis:缓存击穿
我的程序快快跑啊
缓存redisjava

    缓存击穿(热点key)：部分key(被高并发访问且缓存重建业务复杂的)失效,无数请求会直接到数据库，造成巨大压力1.互斥锁：可以保证强一致性线程一：未命中之后，获取互斥锁，再查询数据库重建缓存，写入缓存，释放锁线程二：查询未命中，未获得锁(已由线程一获得)，等待一会，缓存命中互斥锁实现方式：redis中setnxkeyvalue:改变对应key的value,仅当value不存在时执行，以此来实现互
    

    • 

  • 努力不需要仪式感
宇韩叔叔

    在一次踏青活动中，我认识了彩虹，一个皮肤很白的小美女。她对自己的外形不太满意，一米六的身高，体重接近130斤。听说我是一个跑步爱好者，她马上加微信，希望每天能跟我一起晨跑，锻炼出一个好身材。我满口答应，承诺每天电话催她起床，到约定地点一起跑。第一天见面，彩虹让我眼前一亮：崭新的运动服、高束的马尾辫、箍在大臂上的手机袋，浑身上下都透着一股踌躇满志的精气神。我开始跟她讲路线和跑步要领，她却摆摆手示意我
    

    • 

  • 你给予我别人羡慕的一切，我却失去了自己，致敬为家庭付出一切的女神们
跃界一

    如果嫁的老公家有万贯，两栋6楼高的房子，家公为你们家买的一套商品房写上了你的名字，还为你买了一辆车，你会开心吗？或许一般的人看起来很开心，可实际上拥有这一切的这个人开心吗？这些财产的拥有者叫北冰，在外人看来，家庭和睦，每天不用为生计烦恼，是多么的幸福。未出嫁前，北冰性格开朗且好玩乐观，喜欢社交，聚会和k歌，是个潮流个性的女生。她有消耗不完精力，能到处跑。出嫁之后，她成了一个规规矩矩的家庭妇女。每天
    

    • 

  • 去公园
8b78bb8a54f2

    昨天天气很好，爸爸带我去了公园,公园里面很好玩，那里有青青的河水,也有小鱼，小鱼在河水里面欢快地游来游去，他们可开心了。还有红红的花朵，绿绿的草，我和弟弟在公园里面跑啊，跳啊，可开心了！图片发自App
    

    • 

  • 网关gateway学习总结
猪猪365
学习总结学习总结

    一微服务概述:微服务网关就是一个系统!通过暴露该微服务的网关系统,方便我们进行相关的鉴权,安全控制,日志的统一处理,易于监控的相关功能!实现微服务网关技术都有哪些呢?1nginx:nginx是一个高性能的http和反向代理web的服务器,同事也提供了IMAP/POP3/SMTP服务.他可以支撑5万并发链接,并且cpu,内存等资源消耗非常的低,运行非常的稳定!2Zuul:Zuul是Netflix公司
    

    • 

  • KVM+GFS分布式存储系统构建KVM高可用
henan程序媛
分布式GFS高可用KVM

    一、案列分析1.1案列概述本章案例主要使用之前章节所学的KVM及GlusterFs技术,结合起来从而实现KVM高可用。利用GlusterFs分布式复制卷，对KVM虚拟机文件进行分布存储和冗余。分布式复制卷主要用于需要冗余的情况下把一个文件存放在两个或两个以上的节点,当其中一个节点数据丢失或者损坏之后，KVM仍然能够通过卷组找到另一节点上存储的虚拟机文件，以保证虚拟机正常运行。当节点修复之后，Glu
    

    • 

  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
叶准鑫Natalie

    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    

    • 

  • Hadoop
傲雪凌霜，松柏长青
后端大数据hadoop大数据分布式

    ApacheHadoop是一个开源的分布式计算框架，主要用于处理海量数据集。它具有高度的可扩展性、容错性和高效的分布式存储与计算能力。Hadoop核心由四个主要模块组成，分别是HDFS（分布式文件系统）、MapReduce（分布式计算框架）、YARN（资源管理）和HadoopCommon（公共工具和库）。1.HDFS（HadoopDistributedFileSystem）HDFS是Hadoop生
    

    • 

  • 共读《绿野仙踪》有感 ——战胜自己就是勇敢的人
倚窗听雨_1ac2

    今天我和孩子们一起共读的是《绿野仙踪》——路遇胆小狮。我发现这本书每一章的开头儿，都是对环境的描写。有干燥的堪萨斯州，有美丽的芒奇金人的国度，有通往翡翠城沿途优美的风景，有黑暗的森林......而这一章，重点描述了密林深处可怕的咆哮声。他们一行四人走在堆满黄树叶和枯树枝的黄砖路上。就在这样的情况下，他们遇到了一头大狮子。大狮子挥到了稻草人，扑倒了铁皮人。这危险时刻，托托虽小，却也敢面对强敌。它跑上
    

    • 

  • 留住那一天
临泽四中领读者初三10班代友婷

    那天，阳光明媚，微风正好；那天，空气中洋溢着喜悦的气息；那天，笑容在我们的脸上定格。我想，留住那一天。为期两天的运动会，承载着我许多快乐的回忆。还记得，走方阵时，大家神情严肃，姿势端正，齐刷刷的走过主席台。每个人都用尽自己最大的力气喊出我们的梦想，喊出那16个字:“晨曦晨曦，旭日朝阳，初露锋芒，必然夺冠！”是的，我们是晨曦班，充满朝气的晨曦班，为梦想而努力奋斗的晨曦班！还记得，跑接力赛时，运动员们
    

    • 

  • 谈哲学
本仙老四

    我是谁？从哪里来？要到哪里去？最近看了些西方哲学类书籍，忽然就有了这些哲学式的思考。世界真的如我们所看到的这样吗？还是只是我们觉得它是这样？或者它根本就不存在。哲学书是引发人思考的好书籍，即使你觉得读起来枯燥无味也要坚持阅读，之后你会发现受益无穷。大家都说哲学起源于西方，文艺复兴时期的哲学对欧洲的发展起到了重要作用。其实早在中国古代就有一批哲人出现，老子、庄子、孟子、孔子……他们的思想各有独到之处
    

    • 

  • mybatis 二级缓存失效_Mybatis 缓存原理及失效情况解析
weixin_39844942
mybatis二级缓存失效

    这篇文章主要介绍了Mybatis缓存原理及失效情况解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1、什么是缓存[Cache]存在内存中的临时数据。将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。2、为什么要使用缓存减少和数据库的交互次
    

    • 

  • [转载] NoSQL简介
weixin_30325793
大数据数据库运维

    摘自“百度百科”。NoSQL，泛指非关系型的数据库。随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。虽然NoSQL流行语
    

    • 

  • 大模型训练数据库Common Crawl
WindyChanChan
数据集语言模型数据库

    CommonCrawl介绍‌‌CommonCrawl是一个非营利组织，致力于通过大规模分布式爬虫系统定期抓取整个Web并将其存储在一个可公开访问的数据库中。CommonCrawl的数据收集和处理过程包括使用Python开源爬虫工具收集全球范围内的网站数据，并将其上传到‌CommonCrawl基金会的数据仓库中。该项目从2008年开始，至今已经积累了大量的原始网页数据、元数据和文本提取数据。这些数据
    

    • 

  • 慢速连接攻击是什么？慢速连接攻击怎么防护？
快快小毛毛
网络ddos服务器

    慢速连接攻击（SlowConnectionAttack），又称慢速攻击（SlowlorisAttack），是一种网络攻击技术，旨在通过占用服务器上的所有可用连接资源来使其无法响应正常请求。与传统的拒绝服务（DoS）和分布式拒绝服务（DDoS）攻击不同，慢速攻击并不依赖于发送大量数据包来消耗带宽，而是利用HTTP、TCP或SSL等协议的特性，通过发送大量不完整的请求或缓慢发送数据来占用服务器资源，使
    

    • 

  • 分布式锁和spring事务管理
暴躁的鱼
锁及事务分布式springjava

    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    

    • 

  • jQuery 键盘事件keydown ,keypress ,keyup介绍
107x
jsjquerykeydownkeypresskeyup

    本文章总结了下些关于jQuery 键盘事件keydown ,keypress ,keyup介绍，有需要了解的朋友可参考。
一、首先需要知道的是： 1、keydown() keydown事件会在键盘按下时触发. 2、keyup()  代码如下 复制代码
$('input').keyup(funciton(){      
    

    • 

  • AngularJS中的Promise
bijian1013
JavaScriptAngularJSPromise

    一.Promise
        Promise是一个接口，它用来处理的对象具有这样的特点：在未来某一时刻（主要是异步调用）会从服务端返回或者被填充属性。其核心是，promise是一个带有then()函数的对象。
        为了展示它的优点，下面来看一个例子，其中需要获取用户当前的配置文件：
var cu
    

    • 

  • c++ 用数组实现栈类
CrazyMizzz
数据结构C++

    #include<iostream>
#include<cassert>
using namespace std;
template<class T, int SIZE = 50>
class Stack{
private:
T list[SIZE];//数组存放栈的元素
int top;//栈顶位置
public:
Stack(
    

    • 

  • java和c语言的雷同
麦田的设计者
java递归scaner

    软件启动时的初始化代码，加载用户信息2015年5月27号
从头学java二
1、语言的三种基本结构：顺序、选择、循环。废话不多说，需要指出一下几点：
     a、return语句的功能除了作为函数返回值以外，还起到结束本函数的功能，return后的语句
不会再继续执行。
     b、for循环相比于whi
    

    • 

  • LINUX环境并发服务器的三种实现模型
被触发
linux

    服务器设计技术有很多，按使用的协议来分有TCP服务器和UDP服务器。按处理方式来分有循环服务器和并发服务器。
1  循环服务器与并发服务器模型
在网络程序里面，一般来说都是许多客户对应一个服务器，为了处理客户的请求，对服务端的程序就提出了特殊的要求。
目前最常用的服务器模型有：
·循环服务器：服务器在同一时刻只能响应一个客户端的请求
·并发服务器：服
    

    • 

  • Oracle数据库查询指令
肆无忌惮_
oracle数据库

    20140920
 
单表查询
-- 查询************************************************************************************************************
-- 使用scott用户登录
 
-- 查看emp表
 
desc emp
 

    

    • 

  • ext右下角浮动窗口
知了ing
JavaScriptext

    第一种
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/
    

    • 

  • 浅谈REDIS数据库的键值设计
矮蛋蛋
redis

    http://www.cnblogs.com/aidandan/
原文地址：http://www.hoterran.info/redis_kv_design
丰富的数据结构使得redis的设计非常的有趣。不像关系型数据库那样，DEV和DBA需要深度沟通，review每行sql语句，也不像memcached那样，不需要DBA的参与。redis的DBA需要熟悉数据结构，并能了解使用场景。

    

    • 

  • maven编译可执行jar包
alleni123
maven

    http://stackoverflow.com/questions/574594/how-can-i-create-an-executable-jar-with-dependencies-using-maven
<build>
<plugins>
<plugin>
<artifactId>maven-asse
    

    • 

  • 人力资源在现代企业中的作用
百合不是茶
HR 企业管理

    //人力资源在在企业中的作用人力资源为什么会存在，人力资源究竟是干什么的 人力资源管理是对管理模式一次大的创新，人力资源兴起的原因有以下点： 工业时代的国际化竞争，现代市场的风险管控等等。所以人力资源 在现代经济竞争中的优势明显的存在，人力资源在集团类公司中存在着 明显的优势(鸿海集团)，有一次笔者亲自去体验过红海集团的招聘，只 知道人力资源是管理企业招聘的 当时我被招聘上了，当时给我们培训 的人
    

    • 

  • Linux自启动设置详解
bijian1013
linux

    linux有自己一套完整的启动体系，抓住了linux启动的脉络，linux的启动过程将不再神秘。
阅读之前建议先看一下附图。
本文中假设inittab中设置的init tree为：
/etc/rc.d/rc0.d
/etc/rc.d/rc1.d
/etc/rc.d/rc2.d
/etc/rc.d/rc3.d
/etc/rc.d/rc4.d
/etc/rc.d/rc5.d
/etc
    

    • 

  • Spring Aop Schema实现
bijian1013
javaspringAOP

    本例使用的是Spring2.5
1.Aop配置文件spring-aop.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmln
    

    • 

  • 【Gson七】Gson预定义类型适配器
bit1129
gson

    Gson提供了丰富的预定义类型适配器，在对象和JSON串之间进行序列化和反序列化时，指定对象和字符串之间的转换方式，
  DateTypeAdapter
 
public final class DateTypeAdapter extends TypeAdapter<Date> {
public static final TypeAdapterFacto
    

    • 

  • 【Spark八十八】Spark Streaming累加器操作（updateStateByKey)
bit1129
update

    在实时计算的实际应用中，有时除了需要关心一个时间间隔内的数据，有时还可能会对整个实时计算的所有时间间隔内产生的相关数据进行统计。
比如： 对Nginx的access.log实时监控请求404时，有时除了需要统计某个时间间隔内出现的次数，有时还需要统计一整天出现了多少次404，也就是说404监控横跨多个时间间隔。
 
Spark Streaming的解决方案是累加器，工作原理是，定义
    

    • 

  • linux系统下通过shell脚本快速找到哪个进程在写文件
ronin47

    一个文件正在被进程写 我想查看这个进程 文件一直在增大 找不到谁在写 使用lsof也没找到
这个问题挺有普遍性的，解决方法应该很多，这里我给大家提个比较直观的方法。
linux下每个文件都会在某个块设备上存放，当然也都有相应的inode, 那么透过vfs.write我们就可以知道谁在不停的写入特定的设备上的inode。
幸运的是systemtap的安装包里带了inodewatch.stp，位
    

    • 

  • java-两种方法求第一个最长的可重复子串
bylijinnan
java算法

    
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class MaxPrefix {
public static void main(String[] args) {
String str="abbdabcdabcx"; 
    

    • 

  • Netty源码学习-ServerBootstrap启动及事件处理过程
bylijinnan
javanetty

    Netty是采用了Reactor模式的多线程版本，建议先看下面这篇文章了解一下Reactor模式：
http://bylijinnan.iteye.com/blog/1992325
Netty的启动及事件处理的流程，基本上是按照上面这篇文章来走的
文章里面提到的操作，每一步都能在Netty里面找到对应的代码
其中Reactor里面的Acceptor就对应Netty的ServerBo
    

    • 

  • servelt filter listener 的生命周期
cngolon
filterlistenerservelt生命周期

    1. servlet    当第一次请求一个servlet资源时，servlet容器创建这个servlet实例，并调用他的 init(ServletConfig config)做一些初始化的工作，然后调用它的service方法处理请求。当第二次请求这个servlet资源时，servlet容器就不在创建实例，而是直接调用它的service方法处理请求，也就是说
    

    • 

  • jmpopups获取input元素值
ctrain
JavaScript

    jmpopups 获取弹出层form表单
首先，我有一个div，里面包含了一个表单，默认是隐藏的，使用jmpopups时，会弹出这个隐藏的div，其实jmpopups是将我们的代码生成一份拷贝。
当我直接获取这个form表单中的文本框时，使用方法：$('#form input[name=test1]').val()；这样是获取不到的。
我们必须到jmpopups生成的代码中去查找这个值，$(
    

    • 

  • vi查找替换命令详解
daizj
linux正则表达式替换查找vim

    一、查找
查找命令
/pattern<Enter> ：向下查找pattern匹配字符串
?pattern<Enter>：向上查找pattern匹配字符串
使用了查找命令之后，使用如下两个键快速查找：
n：按照同一方向继续查找
N：按照反方向查找
字符串匹配
pattern是需要匹配的字符串，例如：
1:  /abc<En
    

    • 

  • 对网站中的js,css文件进行打包
dcj3sjt126com
PHP打包

    一，为什么要用smarty进行打包
apache中也有给js,css这样的静态文件进行打包压缩的模块，但是本文所说的不是以这种方式进行的打包，而是和smarty结合的方式来把网站中的js,css文件进行打包。
为什么要进行打包呢，主要目的是为了合理的管理自己的代码 。现在有好多网站，你查看一下网站的源码的话，你会发现网站的头部有大量的JS文件和CSS文件，网站的尾部也有可能有大量的J
    

    • 

  • php Yii: 出现undefined offset 或者 undefined index解决方案
dcj3sjt126com
undefined

    在开发Yii 时，在程序中定义了如下方式：
       if($this->menuoption[2] === 'test')，那么在运行程序时会报：undefined offset:2，这样的错误主要是由于php.ini 里的错误等级太高了，在windows下错误等级
    

    • 

  • linux 文件格式（1） sed工具
eksliang
linuxlinux sed工具sed工具linux sed详解

    转载请出自出处：
http://eksliang.iteye.com/blog/2106082
简介
      sed 是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾
    

    • 

  • Android应用程序获取系统权限
gqdy365
android

    引用
如何使Android应用程序获取系统权限
        第一个方法简单点，不过需要在Android系统源码的环境下用make来编译：
        1. 在应用程序的AndroidManifest.xml中的manifest节点
    

    • 

  • HoverTree开发日志之验证码
hvt
.netC#asp.nethovertreewebform

    HoverTree是一个ASP.NET的开源CMS，目前包含文章系统，图库和留言板功能。代码完全开放，文章内容页生成了静态的HTM页面，留言板提供留言审核功能，文章可以发布HTML源代码，图片上传同时生成高品质缩略图。推出之后得到许多网友的支持，再此表示感谢！留言板不断收到许多有益留言，但同时也有不少广告，因此决定在提交留言页面增加验证码功能。ASP.NET验证码在网上找，如果不是很多，就是特别多
    

    • 

  • JSON API：用 JSON 构建 API 的标准指南中文版
justjavac
json

    译文地址：https://github.com/justjavac/json-api-zh_CN
如果你和你的团队曾经争论过使用什么方式构建合理 JSON 响应格式， 那么 JSON API 就是你的 anti-bikeshedding 武器。
通过遵循共同的约定，可以提高开发效率，利用更普遍的工具，可以是你更加专注于开发重点：你的程序。
基于 JSON API 的客户端还能够充分利用缓存，
    

    • 

  • 数据结构随记_2
lx.asymmetric
数据结构笔记

    第三章 栈与队列
一．简答题
1. 在一个循环队列中，队首指针指向队首元素的  前一个    位置。 
2.在具有n个单元的循环队列中，队满时共有  n-1  个元素。 
3. 向栈中压入元素的操作是先  移动栈顶指针&n
    

    • 

  • Linux下的监控工具dstat
网络接口
linux

    1) 工具说明dstat是一个用来替换 vmstat,iostat netstat,nfsstat和ifstat这些命令的工具, 是一个全能系统信息统计工具. 与sysstat相比, dstat拥有一个彩色的界面, 在手动观察性能状况时, 数据比较显眼容易观察; 而且dstat支持即时刷新, 譬如输入dstat 3, 即每三秒收集一次, 但最新的数据都会每秒刷新显示. 和sysstat相同的是, 
    

    • 

  • C 语言初级入门--二维数组和指针
1140566087
二维数组c/c++指针

    /*
二维数组的定义和二维数组元素的引用
二维数组的定义：
当数组中的每个元素带有两个下标时，称这样的数组为二维数组；
(逻辑上把数组看成一个具有行和列的表格或一个矩阵);
语法：
类型名 数组名[常量表达式1][常量表达式2]
二维数组的引用：
引用二维数组元素时必须带有两个下标，引用形式如下：
例如：
int a[3][4];  引用：
    

    • 

  • 10点睛Spring4.1-Application Event
wiselyman
application

    10.1 Application Event
Spring使用Application Event给bean之间的消息通讯提供了手段
应按照如下部分实现bean之间的消息通讯
继承ApplicationEvent类实现自己的事件
实现继承ApplicationListener接口实现监听事件
使用ApplicationContext发布消息

    

    •