[发明专利]一种适用于网络靶场构建的异步函数流程控制方法

权利要求书

1.一种适用于网络靶场构建的异步函数流程控制方法，其特征在于，包括以下步骤：

步骤一、设计异步函数流程控制机制类图；

步骤二、基于步骤一，用程序设计的方法对Promise/A+规则进行类定义和封装实现；

步骤三、基于步骤二，设计Promise/A+规则协程模式实现流程；

步骤四、基于步骤一，设计并发请求函数流程控制机制；

步骤一中，设计异步函数流程控制机制类图，使得该图中包含以下内容：

(1)“承诺”接口定义Promise过程的引用类型；接口中方法名和变量名均与Promise/A+规范一致，包括then、onFulfilled、onRejected、reject、resolve，接口中定义了等待、执行、拒绝三个常量，表示Promise的三种状态；

(2)“承诺”类实现“承诺”接口；该类对Promise过程进行具体定义，其中包含如下变量和函数功能：

1.“状态”变量用于保存“承诺”类实例的状态，初始值为“等待”；

2.“结果”变量用于保存Promise过程返回的结果值；

3.“取消后执行函数”变量指向取消Promise过程后所需执行的函数；

4.“内部封装函数”变量指向封装在“承诺”类实例内需要执行的函数；

5.“等待队列”变量保存了被链式调用的多个“承诺”类实例；6.“回调队列”变量保存了“承诺”类的对象处于“等待”状态下的回调函数；

7.“立即执行”函数负责调用“内部封装函数”变量所指向的函数；8.then函数完成Promise交互过程，then函数注册回调函数以接收Promise正确执行后的的返回值或Promise执行失败的原因返回值，并返回一个“承诺”类对象；

9.reslove函数和reject函数用于改变“承诺”类对象状态，其结果保存在“结果”变量中，“结果”变量将作为回调函数的参数使用；

10.“失败后调用”函数用于注册回调函数，将“结果”变量值作为回调函数参数，仅当“承诺”类对象“状态”变量值为“拒绝”时，“失败后调用”函数所注册的回调函数被调用；

11.“执行队列”函数用于建立函数队列，保存Promise过程中的回调函数；

12.“格式转换”函数能够对数据进行清理转换,即把数据转换为“承诺”类的对象；

(3)“承诺实现”类实现“承诺”接口；表示一个Promise过程被正确执行，并会立即执行then函数中注册的“onFulfilled”回调函数；(4)“承诺失败”类实现“承诺”接口；表示一个Promise过程没有被正确执行，并会立即执行then函数中注册的“onRejected”回调函数；

(5)“协程”类实现“承诺”接口；该类是Promise过程的一个具体封装实现；该类的构造函数调用一个外部迭代器，并且返回一个满足该迭代器最终返回值的“承诺”类；在执行过程中，该类维护一个“当前承诺”对象，用于保存满足迭代器当前返回值的“承诺”类对象，当每次迭代齐器返回的值被处理后，程序控制权将再次返回迭代器；

(6)“并发控制”类实现“承诺生成”接口；实现目的在于，使用一个“承诺”类对象控制多个“承诺”类对象的迭代执行，可用于并发请求函数资源池的流程控制，包括设定并发请求函数资源池出口速率、使用统一的处理逻辑处理请求池当中的数据；

(7)“取消时异常”、“集合异常”、“承诺异常”均继承系统的异常类，用于抛出程序中的异常和错误；

(8)“待执行队列”类实现了“待执行队列”接口，实现了一个FIFO队列用于保存待运行的回调函数，并等待调用这些回调函数；

步骤二中，Promise/A+规则实现流程为：

1→2→3→(4到10中的一种可能)→11→(12到14中的一种可能)→(15到18中的一种可能)→19

①构建“承诺”类实例“A”，将待执行函数地址赋值给“内部封装函数”变量；

②执行then函数，加载回调函数到“承诺”类实例中；

③判断“承诺”类实例“A”中“状态”变量值；

④若该实例“A”的“状态”变量值为“等待”，使用“A”中“回调队列”数组保存回调函数，等待调用；

⑤若该实例“A”的“状态”变量值为“拒绝”，且包含相应的回调函数，将该实例“A”的“结果”变量作为回调函数参数，并将该回调函数加入由“待执行队列”类构造的队列中；

⑥若该实例“A”的“状态”变量值为“拒绝”，且不包含相应的回调函数，将该实例“A”的“结果”变量转化为“承诺”类实例并返回；

⑦若该实例“A”的“状态”变量值为“执行”，且包含相应的回调函数，且该实例“A”的“结果”变量值为常量，则将该实例“A”的“结果”变量作为回调函数参数，并将该回调函数加入由“待执行队列”类构造的队列中；

⑧若实例“A”的“状态”变量值为“执行”，且实例“A”包含相应的回调函数，且实例“A”的“结果”变量类型为“承诺”接口，则调用“结果”变量的then方法加载之前实例“A”所包含的回调函数；

⑨若该实例“A”的“状态”变量值为“执行”，且包含相应的回调函数，且该实例“A”的“结果”变量中包含then方法，则将“结果”变量转化为“承诺”类型实例，之后调用转化后的“承诺”类实例的then方法加载之前“承诺”类实例“A”中所包含的回调方法；

⑩若该实例“A”的“状态”变量值为“执行”，且不包含相应的回调函数，则将该实例“A”的“结果”变量转化为“承诺”类实例并返回；

调用该实例“A”中“立即执行”方法执行“内部封装函数”变量所指的待执行函数；

若该实例“A”中“状态”变量值为“等待”则抛出错误，结束程序；

若该实例“A”中“状态”变量值不为“等待”，且“A”中“立即执行”方法成功执行，则将实例“A”中“状态”变量值设置为“执行”，并将“立即执行”函数的返回值保存在对象“A”中“结果”变量中；

若该实例“A”中“状态”变量值不为“等待”，且“A”中“立即执行”方法没有成功执行，则将实例“A”中“状态”变量值设置为“拒绝”，并将“立即执行”函数的返回值保存在实例“A”中“结果”变量中；

若该实例“A”中“回调队列”变量数组为空，则程序结束；

若该实例“A”中“回调队列”变量数组中包含回调函数，且实例“A”中“结果”变量中不包括then方法，则将实例“A”的“结果”变量作为回调函数参数，并将该回调函数加入由“待执行队列”类构造的队列中；

若该实例“A”中“回调队列”变量数组中包含回调函数，且“A”中“结果”变量是“承诺”类型对象，且“结果”变量中“状态”变量的值为“等待”，则将之前实例“A”中的“回调队列”变量数组与“结果”变量中的“回调队列”变量数组合并，等待后续处理；

若该实例“A”中“回调队列”变量数组中包含回调函数，且“A”中“结果”变量是“承诺”类型对象，且“结果”变量中“状态”变量的状态值不为“等待”，则调用“结果”变量中的then方法加载之前实例“A”中所包含的回调函数；

执行“待执行队列”类构造的队列中的全部函数；

步骤二的Promise/A+规则实现流程中，通过构建“承诺”类的实例来保存事件状态，一个“承诺”类实例表示一个事件，“承诺”类实例状态分为等待、执行、拒绝三种，“承诺”类实例状态只能由等待转化为执行或这拒绝，当对象状态改变后，不能再次改变状态，Promise类的中“状态”变量的类型为私有，改变一个“承诺”类对象的状态，只能通过执行他自身的reslove和reject方法，“内部封装函数”变量指向Promise事件所执行的函数，Then函数封装了事件执行成功或失败后，所需执行的回调函数；

“回调队列”为数组变量，保存了“承诺”类实例处于“等待”状态下的回调函数，“回调队列”数组内部格式为[Promise，onFulfilled,onRejected],其中Promise变量为then函数返回的新的“承诺”实例；onFulfilled,onRejected为then函数加载的回调函数，当处于“等待”状态下一个“承诺”类实例多次调用then函数，则所有的回调函数都将在“回调队列”数组中保存；

回调函数预先存储在由“待执行队列”类实现的先进先出队列中,队列中保存的回调函可以使用闭包形式，队列中实际保存了回调函数的空间地址；

步骤三中，将Promise/A+规则协程模式实现流程设计为：

①构造“承诺”类型实例result；

②建立generator变量指向一个外部迭代器；

③加载外部迭代器中当前元素，并将其转化为“承诺”类实例，“A”；

④若“承诺”类实例“A”的“状态”变量值为“执行”，则发送“A”中“结果”变量到外部迭代器，转到步骤⑤，若“承诺”类实例“A”的状态为“拒绝”，则将“A”中“结果”变量值作为错误原因抛出，转到步骤⑥；

⑤判断外部迭代器状态，若状态为invalid，说明迭代完成，调用result对象的resolve函数，其参数为“承诺”类实例“A”中“结果”变量值，转到步骤⑦，若状态为valid，说明迭代未完成，转到步骤⑥；

⑥将外部迭代器中的指针后移一次，返回步骤③；

⑦流程结束；

步骤三中，通过协程的方式，使执行程序和流程控制程序分离，程序使用一个迭代器生成请求队列，并创建了一个“承诺”类实例，用于保存代器迭代完成后的返回值或“承诺”类对象，用于后续处理，程序处理完迭代器返回的结果后，把控制权返还给迭代器，并回传结果值，这一过程完成了“承诺”类中的then方法，迭代器掌握控制权后，将回传结果作为参数继续执行后续函数，同时处理程序异常和错误，这一过程完成了“承诺”类中的“立即执行”、resolve方法；

步骤四中设计的并发请求函数流程控制机制的具体流程如下：

1.构建“并发控制类”A；

2.将外部迭代器地址赋值给A中的“迭代器”变量；

3.将请求函数执行成功或失败后需要执行的函数赋值给A中的onFulfilled和onRejected变量；

4.构建“承诺”类型变量，其“立即执行方法”变量将迭代调用A中“迭代”变量所指迭代器中所有的函数，并将该“承诺”类型变量赋值给A中的“总控”变量；

5.设置并行速率值，赋值给A中的“出口速率”变量；

6.设置A中“待发”数组大小等于“出口速率”变量；

7.调用A中的“载入”方法将“迭代器”变量中的当前元素存入“待发”数组中，并将该元素转化为“承诺”类实例；

8.调用A中的“迭代”方法，将“迭代器”变量中的指针后移一位；

9.重复步骤7和步骤8，直到“待发”数组被装满；

10.并发“待发”数组中的“承诺”实例；

11.若有并发请求完成，执行A中的“确认完成”方法，判定“迭代器”变量中是否还有元素，若有，则重复执行步骤7到步骤10；

12.当“迭代器”变量被全部迭代完成，A中的“总控”变量执行reslove方法，其参数值为空，以结束本次并发请求；

步骤四中，将所有的请求函数封装为“承诺”类对象，并使用一个存储数组缓存这些对象，之后并发执行，并发执行后，将完成请求所在的数组位置清空，并同步从迭代器中取回新的请求函数加入存储数组，迭代执行这一过程，直到迭代器中所内容被迭代完成，对存储“承诺”类对象的数组设置不同的空间大小取值，即完成对并发请求速率的控制；

步骤四中，将并发控制器设计为一个“承诺”类实例，使用一个“承诺”类实例来控制多个请求的并发执行，具体方法为，使控制器的“承诺”类实例的“内部封装函数”变量所指方法迭代执行存储数组中所有“承诺”类实例的“立即执行”方法，当调用控制器实例的“立即执行”方法后，存储数组中的所有实例的“立即执行”方法都会被迭代调用；迭代器中的所有内容被迭代完成后，控制器的“承诺”类实例会调用resolve方法，表示该控制器“承诺”类实例已经被执行；

步骤四中，迭代器中数据被转换为“承诺”类实例后存储在数组中并发执行，之后再次从迭代器取回数据保存到数组，等待后续迭代，在这一过程中，在“并发控制”类中设置了“互斥锁”变量和“迭代”方法来完成并发锁，其中“迭代”方法负责将迭代器中的函数递进一个位置，“互斥锁”变量是一个布尔类型，表示并发锁的开关；

当有进程或线程在调用“迭代”方法时，如果“互斥锁”变量为true，则返回，此时说明其他线程在调用该迭代器；否则，如果“互斥锁”变量为false，则设置“互斥锁”为true，并执行“迭代”方法，函数调用完毕后，“互斥锁”再次被设置为false，以实现线程锁。