一种基于动态控制的虚拟账户交易管理方法及系统与流程

1.本技术涉及虚拟账户交易管理领域，具体而言，提供了一种交易调度动态控制机制，在其中对不同类型虚拟账务交易应用可插拔组件及动态加载插拔组件参数链。


背景技术：

2.随着互联网经济的发展，互联网金融也越来越深入到人们生活的方方面面。很多公司、企业、金融机构设立了种类繁多的各种虚拟账户交易系统。虚拟账户的使用范围不断扩大，但随之而来的安全问题也时有发生，需要进行有效监管和正确引导。
3.因此，为了保证资金的安全性，需要为每种虚拟账户交易系统都配置一套相应的交易管理方法和系统来管理和维护虚拟交易的正常运行。所述交易管理方法和系统必须是健全的、可靠的、完善的。
4.目前，虚拟账户交易管理领域采用的主流管理方式包括： 1）数据库读写分离机制，该方式将交易控制组件参数、业务参数等放入数据库，虚拟账务交易管理系统在事中通过访问数据库来完成交易。
[0005] 2）系统缓存方式，该方式将交易控制组件参数、业务参数放入系统的内存。高效的缓存系统可提升系统吸能，而虚拟账户交易管理系统在需要时从缓存中获取组件参数及业务参数。
[0006] 3）交易控制组件及参数微服务化，该方式将交易控制组件、参数独立构建成一个微服务，供虚拟账户交易管理系统进行远程调用。
[0007]
但是，目前这几种现有主流技术都存在各自的问题，例如： 1）数据库读写分离机制问题：系统与数据库之间是一种强耦合，因此，当在高频请求及高并发的场景下，交易响应时间、数据库性能下降明显。
[0008] 2）系统缓存方式问题：首先，系统缓存成本很高，难以适用于大型交易系统。其次，一些nosql存在脑裂问题（即分区耐受性问题），在交易量较大的情况下网络要求很高。
[0009] 3）交易组件及参数微服务化问题：系统之间信息同步存在差异，系统io、网络通信的压力也较大。
[0010]
有鉴于此，希望能够提供一种新颖的虚拟账户交易管理方式，以解决现有的这些主流虚拟账户交易处理方式存在的各种问题。


技术实现要素：

[0011]
本技术提供了一种实现了组件链配置的模版化、通用性和可维护性的虚拟账户交易管理方案。
[0012]
根据本技术的第一方面，提供了一种与前端业务系统对接的虚拟账户交易管理系统，包括：前端部分，包括：由一组通信进程以及通信服务模块组成的虚拟账户交易管理系统前置，被配置为
负责由前端业务系统输出的所述交易请求报文的格式转换，管理和调度所述前端业务系统所发起的交易请求；后端部分，包括：虚拟账户交易管理总线，被配置为根据由所述虚拟账户交易管理系统前置提供的交易请求的交易类型选择相应的函数化的交易控制组件，并根据相应的业务参数对所选的函数化的交易控制组件排序以构建交易控制组件链；交易控制组件，所述交易控制组件被函数化，并被配置用于执行涉及交易的各种交易控制功能；以及业务参数组件，被配置为提供构建所述交易控制组件链所需的业务参数。
[0013]
根据本技术的第二方面，提供了一种虚拟账户交易管理方案，包括：对虚拟账户交易管理系统中的每个交易控制组件进行函数化；将包含所有函数化的交易控制组件的函数库以及业务参数组件加载到系统缓存；虚拟账户交易管理系统前置从前端业务系统接收交易请求，并在将所述交易请求转换成报文形式后传送给虚拟账户交易管理总线，其中所述交易请求包括交易的业务代码；所述虚拟账户交易管理总线从所述虚拟账户交易管理系统前置接收所述交易请求并进行解析，并且根据从所述交易请求中解析出的所述业务代码从加载的所述交易控制组件的函数库中选择相应的函数化的交易控制组件，并根据相应的业务参数对所选的函数化的交易控制组件排序以构建交易控制组件链。
[0014]
提供本概述以便以简化的形式介绍以下在详细描述中进一步描述的一些概念。本概述并不旨在标识所要求保护主题的关键特征或必要特征，也不旨在用于限制所要求保护主题的范围。
附图说明
[0015]
为了描述可获得本发明的上述和其它优点和特征的方式，将通过参考附图中示出的本发明的具体实施例来呈现以上简要描述的本发明的更具体描述。可以理解，这些附图只描绘了本发明的各典型实施例，并且因此不被认为是对其范围的限制，将通过使用附图并利用附加特征和细节来描述和解释本发明，在附图中：图1示出了根据本技术的一个实施例的一种虚拟账户交易管理系统的示意性架构框图。
[0016]
图2示出了根据本技术的一个实施例的一种虚拟账户交易管理方法的示意性流程图。
[0017]
图3示出了根据本技术的一个实施例的一个开户业务类型的控制组件链的示例数据结构。
具体实施方式
[0018]
本技术提出了一种新颖的虚拟账户交易管理方法和系统，以在提供交易控制组件、参数配置的灵活性的同时，也解决了现有虚拟账户交易管理系统存在的性能、耦合性、可靠性等问题。
[0019]
如图1所示，提供了根据本技术的一个实施例的一种虚拟账户交易管理系统的整体架构示意图。
[0020]
如图所示，首先，虚拟账户交易管理系统与一个或多个前端业务系统对接。所述前端业务系统包括例如代收付系统、收件宝系统、跨境支付管理系统、
……
等等，被作为虚拟账户交易管理系统与客户对接的外部系统来提供。通过这些不同功能的前端业务系统可以向虚拟账户交易管理系统请求不同类型的业务交易。
[0021]
具体而言，前端业务系统被配置成业务受理渠道，主要包括接收来自客户系统的业务请求信息（报文格式，由业务系统自行与客户定义），对其验签后进行解析，根据各自系统要求进行权限管理、客户化本地信息等，按与虚拟账户交易管理系统前置定义格式输出相应的交易请求报文。
[0022]
而本技术的虚拟账户交易管理系统从整体上可由两部分组成：一是由虚拟账户交易管理系统前置组成的前端部分。
[0023]
所述虚拟账户交易管理系统前置则被配置为负责由前端业务系统输出的所述交易请求报文的格式转换，管理和调度前端业务系统所发起的交易请求，减轻虚拟账户交易管理系统的负担，随后输出虚拟账户交易管理系统的业务请求接口报文。
[0024]
具体而言，在上述前端部分中，基于tcp/ip协议来实现系统的各组件之间的数据同步交互。系统的虚拟账户交易管理系统前置是由一组通信进程以及通信服务模块组成。这些通信进程负责按照通信线路配置信息建立虚拟账户交易管理系统与相应的联网机构之间的通信连接，从通信端口接收交易消息，向通信端口发送交易消息，监视通信链路状态，并报告通信链路状态变化。一旦发现某个通信链路存在通信故障，通信服务模块立即重新建立新的通信链路来取代故障的通信链路。
[0025]
二是由虚拟账户交易管理总线以及交易控制组件（交易控制组件a、交易控制组件b、交易控制组件c、
……
）和业务参数组件组成的后端部分。
[0026]
其中，所述虚拟账户交易管理总线被配置为根据由虚拟账户交易管理系统前置提供的具体交易类型数据选择出相应的交易控制组件的函数，并根据业务参数对所选交易控制组件的函数排序以构建交易控制组件链。
[0027]
交易控制组件链由交易控制组件的函数以参数形式组合而成，并根据具体的业务类型的属性对链中的各组件制定执行顺序以及异常处理。交易控制组件链加载在系统内存中，并被进一步配置为动态管理交易控制、参数组件链，根据前置请求或系统实时负载对组件链里面的组件动态进行执行顺序管理、增加及删除组件。
[0028]
交易控制组件被配置为用于执行虚拟账户业务权限的增加、删除、账户状态检查、交易金额检查、清分记账、余额查询等涉及交易的各种交易控制功能。不同的交易控制组件可具有不同的交易功能，并且可根据具体交易类型被灵活选择和组合以实现该交易类型所需的各种交易功能。并且，通过增加相关功能的交易控制组件，所述交易控制组件可以不断地横向扩展，以扩展更多的新功能。
[0029]
而业务参数组件则被配置为提供构建上述交易控制组件链所需的业务参数。所述业务参数组件包括诸如客户信息、账户信息、风险控制信息、实时交易量及并发交易数信息以及交易控制组件链参数等等信息并以规定的格式加载在系统内存中。业务参数组件还包括交易控制组件链参数，所述交易控制组件链参数可以包括例如交易控制组件的对应的业务流程（编号）、交易控制组件在该流程中的调用序号、执行异常时的处理信息以及其他组件链参数。因此，通过在系统内存管理中加载所述组件链配置参数，可以增加机器学习能
力，并且通过根据系统监控不同业务系统的交易量、业务属性、系统压力等参数来改进组件链配置并选择最优组件链。
[0030]
利用所述业务参数组件中的这些参数可以保证交易控制组件链的正确构建及工作。
[0031]
所述业务参数组件在系统初始化时被加载到系统缓存，以供后续构建控制组件链时调用。
[0032]
另外，还提供了系统管理及监控组件以对上述这些组件进行统一管理、协调和监控，从而保证了整个系统的正常运行。
[0033]
所有这些组件或模块可由硬件、软件或固件等来实现，并且，它们可以通过各种通信介质（包括诸如有线网络或直接线连接之类的有线介质，以及诸如声学、rf、红外及其他无线介质之类的无线介质）来彼此进行数据通信。
[0034]
通过将整个系统纵向拆分成前端部分和后端部分，可以实现系统与数据库之间解耦，并提高单机交易处理能力，提升开发、运维效率。
[0035]
在了解了本技术的虚拟账户交易管理系统的基本结构之后，结合该结构示例在图2中示出了根据本技术的一个实施例的一种虚拟账户交易管理方法的示意性流程图。
[0036]
在该示例中，虚拟账户交易管理系统主要由虚拟账户交易管理前置、虚拟账户交易管理总线、存储有业务参数组件并加载了实现各种业务功能的函数化的交易控制组件和其他信息的系统内存以及系统管理及监控组件这几大部分组成。这些部分在系统管理及监控组件的统一管理、协调和监控下，保证了整个系统的正常运行。
[0037] 与常见的虚拟账户交易管理系统相比，在本技术的方案中， 系统以函数来构建各个交易控制组件，即每个函数执行所述虚拟账户交易管理系统的一个交易功能，而非采用传统的固定专用程序模块的方式。通过将虚拟账户交易管理系统的各个交易控制组件函数化，随后再由虚拟账户交易管理总线根据交易业务类型将选择所需的函数化的交易控制组件将其链化以构建组件链，实现了系统配置的模块化和通用化，并提高了系统的功能的可扩展性。
[0038]
下面结合图2中的具体流程来描述下本技术的虚拟账户交易管理方法的示例流程。
[0039] 首先，在步骤202处， 对系统进行初始化，所述初始化主要包括对虚拟账户交易管理系统中的每个交易控制组件进行函数化。
[0040]
如前所述，在所述虚拟账户交易管理系统中，每个交易控制组件都被函数化，通过先将每个交易控制组件函数化，随后再利用函数调用的方式来加载请求的业务类型所需的交易控制组件，可以实现组件功能配置的模版化、通用性，简化因例如新增、修改、删除账务交易类型的功能而需要改造相关系统的工作。
[0041]
例如，如果需要对虚拟账户交易管理系统中的某个交易控制组件的功能进行升级改进，在传统的将交易控制组件作为软件中的一个功能模块而非函数的方案中，必须对每个虚拟账户交易管理系统的该交易控制组件的功能的代码都进行改写，这无疑是工作量巨大的。而在本技术的方案中，则由于该交易控制组件是以函数形式存在的，而虚拟账户交易管理系统仅仅是根据交易请求的类型调用这些函数，因此，只需要修改函数库中的与该交易控制组件相关联的函数的代码，则分布在各地的所有的虚拟账户交易管理系统都能调用
到经过修改的该交易控制组件的函数，从而一次维护就能实现全部系统的升级更新。类似地，其他的诸如增加和删除交易控制组件的操作也可以以上述方式来一次实现。
[0042]
所述交易控制组件的函数化的具体过程可以包括下述步骤： 首先，在第一步，为交易控制组件的每个功能构建一个“基函数”，所述基函数是指用于实现交易控制组件的一个功能的一段函数代码。作为一个示例，下面示例出一个基函数的通用函数代码结构：#include "sotplib.h"#include "sotpfunc.h"#include "sotperr.h"#include "fas_glb.h"#include "fas_err.h"#include "svc_bus.h"#include "rsn_cd.h"#include "ssn_data.h"#include "shm_data.h"int
ꢀꢀ
writefunchead(file *fp){
ꢀꢀꢀꢀ
int ret;
ꢀꢀꢀꢀ
char funcnm[30] ={0};
ꢀꢀꢀꢀ
if(fprintf(fp, "%s\n", "#include \"svc_bus.h\"") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀ
if(fprintf(fp, "%s\n", "#include \"fas_err.h\"") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
if(fprintf(fp, "%s\n", "#include \"fas_glb.h\"") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
if(fprintf(fp, "%s\n", "#include \"sotplib.h\"") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
if(fprintf(fp, "%s\n", "#include \"sotpfunc.h\"") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
if(fprintf(fp, "%s\n", "#include \"sotperr.h\"") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
if(fprintf(fp, "%s\n", "#include \"shm_data.h\"") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
ret = getfuncnm( funcnm );
ꢀꢀꢀꢀ
if( ret ) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"getfuncnm error \n") ;
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
if(fprintf(fp, "%s%s%s\n", "int ",funcnm, "(int opr_tp, fas_svc_bus_t *svc_bus_data) {") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
if(fprintf(fp, "%s\n", "int ret = succ") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
return succ;}int
ꢀꢀ
writefuncbody(file *fp, char *funccode){
ꢀꢀꢀꢀ
int ret;
ꢀꢀꢀꢀ
int i;
ꢀꢀꢀꢀ
char funcnm[30] ={0};
ꢀꢀꢀꢀ
char code[1024];
ꢀꢀꢀꢀ
func_opr_tp funcoprtp;
ꢀꢀꢀꢀ
if(fprintf(fp, "ret = %s( opr_tp, svc_bus_data ); \n", "funccode") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
if(fprintf(fp, "if (ret) {\n", "}") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
if(fprintf(fp, "_sot_log(__file__, __line__, log_lvl_fatal,\"%s error\\n\",funccode)") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
if(fprintf(fp, "return fail;\n", "}") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
if(fprintf(fp, "}\n", "}") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
ret = getfuncoprtp(&funcoprtp, funccode);
ꢀꢀꢀꢀ
if( ret ) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal, "getfuncoprtp error.\n");
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
if(fprintf(fp, "switch (opr_tp) {\n") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
for(i = 0; i 《 funcoprtp.oprnm; i++) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
if(fprintf(fp, "case %d:\n",funcoprtp.oprtp[i].opr_tp) 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀꢀ
ret = getoprtpcode(code, funcoprtp.oprtp[i].opr_tp, funccode);
ꢀꢀꢀꢀꢀꢀꢀꢀ
if( ret ) {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal, "getoprtpcode error.\n");
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀꢀ
if(fprintf(fp, "%s\n", code) 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀꢀ
if(fprintf(fp, "break;\n") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
if(fprintf(fp, "}\n") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
return succ;}int
ꢀꢀ
writefunctail(file *fp){
ꢀꢀꢀꢀ
int ret;
ꢀꢀꢀꢀ
char funcnm[30] ={0};
ꢀꢀꢀꢀ
if(fprintf(fp, "%s\n", "return succ;") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
if(fprintf(fp, "%s\n", "}") 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"write file[%s] error
ꢀ‑‑ꢀ
[%s].\n", fp, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
return succ;} 如上面的代码所示，所述基函数主要可以包括写文件头（writefunchead）、写文件体（writefuncbody）以及写文件尾（writefunctail ）三个部分。各个基函数的写文件头和写文件尾部分可以采用通用代码来实现，而写文件体部分则需要根据所要实现的功能来编写代码（所述代码与传统的实现该功能的程序代码相类似，但以函数形式实现，因此，不再一一详述）。
[0043]
下面以c013_checkacntcfb这个实现“检查虚拟账户冻结余额是否足够”交易功能的函数为例，来具体描述如何根据上述基函数生成代码来生成相应的交易控制功能的函数。
[0044]
示例：#include "fas_glb.h"#include "fas_db.h"#include "fas_err.h"#include "rsn_cd.h"#include "svc_bus.h"int c013_checkacntcfb(int opr_tp, fas_svc_bus_t *svc_bus_data){
ꢀꢀꢀꢀ
int
ꢀꢀꢀꢀꢀ
ret;
ꢀꢀꢀ
ret = dbtblbasicacntopr( svc_bus_data);
ꢀꢀꢀꢀ
if (ret 《 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,“dbtblbasicacntopr error\n”,);
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
switch (opr_tp) {
ꢀꢀꢀꢀ
case 0:
ꢀꢀꢀꢀꢀꢀꢀꢀ
if (fasacntinfbuf.cf_balance 《 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
strcpy(svc_bus_data-》txnloginf.dest_rsn_rsp_cd, rsn_acnt_cfb_below_zero);
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀꢀ
break;
ꢀꢀꢀꢀ
case 1:
ꢀꢀꢀꢀꢀꢀꢀꢀ
if (fasacntinfbuf.cf_balance 《 svc_bus_data-》txnloginf.src_txn_amt) {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
strcpy(svc_bus_data-》txnloginf.dest_rsn_rsp_cd, rsn_acnt_cfb_lt_txn_amt);
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀꢀ
break;
ꢀꢀꢀꢀ
case 2:
ꢀꢀꢀꢀꢀꢀꢀꢀ
if (fasacntinfbuf.cf_balance 《 svc_bus_data-》txnloginf.src_txn_amt) {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
strcpy(svc_bus_data-》txnloginf.dest_rsn_rsp_cd, rsn_acnt_cfb_lt_txn_amt);
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀꢀ
break;
ꢀꢀꢀꢀ
default:
ꢀꢀꢀꢀꢀꢀꢀꢀ
strcpy(svc_bus_data-》txnloginf.dest_rsn_rsp_cd, rsn_unknown_acnt_blc_tp);
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
return succ;}
ꢀꢀ
应该理解，上述交易功能的函数代码仅仅是出于说明的目的示出，并非局限于此。事实上，其他的交易功能也可以利用类似的方式来实现，在此不再累述。
[0045]
交易控制组件可能包括多种不同的功能，因此，为了能够实现一个交易控制组件的函数化，还需要将这些不同的功能的函数代码（也即基函数）整合起来。因此，在构建了所有基函数之后，还需要执行下述流程来实现所述交易控制组件的函数化：第二步，加载系统基函数库，所述基函数库包括了实现各种交易功能的多个基函数，并且加载一般是指将数据存储到缓存（例如系统内存中）；第三步，根据交易数据中的函数名称加载文件；第四步，调用基函数的写文件头来在文件中写入文件头；第五步，根据交易数据的基函数名称，在存储基函数的内存中的基函数动态库中匹配是否存在相应的基函数，如果存在，则调用该基函数的写文件体函数写入文件中，如果不存在，则报错并且流程结束；第六步，按交易数据中的基函数的个数循环执行上述第五步骤以调用各基函数的写文件体函数写入文件中，直至文件包括了交易数据的所有基函数为止；第七步，调用基函数的写文件尾来在文件中写入文件尾。
[0046]
经过上述流程的处理，就可以构造出一个交易控制组件的函数化文件。所述函数化文件可以被加载和调用以供后续的交易控制组件链的构建。
[0047]
下面是实现上述这些步骤的示例程序代码：int
ꢀꢀ
a002_gencomponent(int opr_tp, fas_svc_bus_t *svc_bus_data){
ꢀꢀꢀꢀ
int
ꢀꢀꢀꢀꢀ
i,j;
ꢀꢀꢀꢀ
int
ꢀꢀꢀꢀꢀ
ret = succ;
ꢀꢀꢀꢀ
int
ꢀꢀꢀꢀꢀ
rsplen = 0;
ꢀꢀꢀꢀ
void
ꢀꢀꢀꢀ
*pg_handle;
ꢀꢀꢀꢀ
char
ꢀꢀꢀꢀ
filefullname[fil_path_head_len+fil_path_len+fil_nm_chara_len + 1];
ꢀꢀꢀꢀ
fas_svc_bus_t
ꢀꢀꢀꢀꢀꢀꢀ
fassvcdata = {0};
ꢀꢀꢀ
//txn data
ꢀꢀꢀꢀ
sharefunc_shm_t
ꢀꢀꢀꢀꢀ
*gp_sharefuncshm;
ꢀꢀꢀꢀꢀ
file
ꢀꢀꢀꢀ
*fp;
ꢀꢀ
//pointer to a func file
ꢀꢀꢀꢀ
int
ꢀꢀꢀꢀꢀ
(*hfunc)(int , void *);
ꢀꢀ
//pointer to a base function
ꢀꢀꢀꢀ
pg_handle = dlopen(lib_name, rtld_lazy);
ꢀꢀꢀꢀ
if (pg_handle == null) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"dlopen [%s] fail, %s\n",
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
lib_name,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
dlerror());
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
sprintf(filefullname, "%s/%s", filepath, fassvcdata-》funcinf.filenm );
ꢀꢀꢀꢀ
if((fp = fopen(filefullname, "rb")) == null ) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"open file[%s] err
ꢀ‑‑ꢀ
[%s].\n",
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
filefullname, strerror(errno));
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
writefunchead(fp); //write file head
ꢀꢀꢀꢀ
g_sharefuncnum = 0;
ꢀꢀꢀꢀ
for( j = 0; j 《 fassvcdata-》funcinf.funcnum; j++ ) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
for( i = 0; i 《 gp_sharefuncshm-》rownum; i++ ) {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
if (strcmp(gp_sharefuncshm[g_sharefuncnum-1].funccode, fassvcdata-》funcinf.func[j].funccode) != 0) { //search base function
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
g_sharefuncnum++;
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
if( g_sharefuncnum 》= gp_sharefuncshm-》rownum ) {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal, "not found base function[%s]\n", fassvcdata-》funcinf.func[j].funccode);
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
dlclose(pg_handle);
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
hfunc = (int (*)(int, void *))dlsym(pg_handle, fassvcdata-》funcinf.func[j].funccode); //confirm the base function in the dll
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
if (hfunc == null) {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal, "dlsym error
ꢀ‑ꢀ
%s!!\n", dlerror());
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
dlclose(pg_handle);
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
writefuncbody(fp,fassvcdata-》funcinf.func[j].funccode)
ꢀꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
dlclose(pg_handle);
ꢀꢀꢀꢀ
writefunctail(fp);
ꢀꢀꢀꢀ
return succ;} 利用上述程序代码就可以实现虚拟账户交易管理系统中的各交易控制组件的函数化。
[0048]
除了上述函数化过程之外，所述初始化还包括一些常规操作，例如将包含所有函数化的交易控制组件的函数库加载到缓存（例如系统内存）中，将各个业务参数组件也加载到缓存（例如系统内存）中等等。
[0049]
使用系统主机内存来预先加载所述交易控制组件的函数库和业务参数组件，可以解决缓存与缓存存储的系统耦合、高频交易所带来的网络通信压力。
[0050]
在完成初始化之后，系统开始正常运行工作以处理各种交易请求。
[0051]
首先，在步骤204处，虚拟账户交易管理系统前置从前端业务系统接收交易请求，并将所述交易请求转换成报文形式，随后传送给虚拟账户交易管理总线。所述交易请求可以包括交易类型（例如转账、余额查询、虚拟账户业务权限的增加和删除、账户状态检查、交易金额检查、清分记账等等各种交易类型）、交易金额、交易时间、交易对象以及其他交易信息。根据交易类型的不同，所述交易请求包含的交易信息也各不相同。另外，所述交易请求通常通过格式转换变成报文形式的数据结构。
[0052]
在很多场景中，所述交易请求报文是在前端业务系统处加密后再被传送给虚拟账户交易管理系统的。
[0053]
随后，在步骤206处，虚拟账户交易管理总线接收经转换后的交易请求并对其进行解析。
[0054]
具体而言，虚拟账户交易管理总线接收到所述交易请求之后，对所述报文形式的交易请求进行解析。所述解析包括从所述交易请求中解析出后续处理所需的各种数据字段。举例而言，可以从交易请求中解析出下述数据项：交易的业务代码，其指示了请求交易的类型，可被用于选择相应的控制组件链；客户代码，用于向相应的交易控制组件提供本地化客户的信息，比如客户的虚拟账号，客户的风险信息，客户的时、日、月交易量等；交易金额，用于在动账交易时提供给相应的交易控制组件；以及交易来源，用于配合上述交易的业务代码选择构建所述交易控制组件链，等等。
[0055]
在另一实施例中，如果所述交易请求被加密的话，则需要通过二次解析才能获得上述所需的数据字段（即先要对交易请求进行解密，再执行上述解析）。
[0056]
所述加密和解密可以采用现有的各种数据加密/解密通信技术，在此不再详述。
[0057]
在从所述交易请求中解析出所需的数据字段之后，流程进入到步骤208。在步骤208中，所述虚拟账户交易管理总线使用控制组件链设计模式来基于函数化的交易控制组件和对应的业务参数来构建一条用于处理所请求的交易业务的控制组件链。
[0058]
具体而言，在通过初始化将各交易控制组件进行函数化的基础上，所述虚拟账户交易管理总线可根据在前一步骤中解析出的交易的业务代码，从例如已加载到系统内存中的一组函数化的交易控制组件中选择出与该业务代码（也即交易类型）相关联的一个或多个交易控制组件的函数。基于相应的业务参数，这些交易控制组件被顺序配置为依次处理
同一个交易请求所涉及的各个操作，从而形成一个交易控制组件链，该链上的每个环节（即交易控制组件）负责其各自的业务处理功能。这样的一种链式组件结构也可被称为“职责链”。
[0059]
具体而言，根据解析出的交易的业务代码和业务参数组件中的对应的业务参数，先确定出与该业务代码所代表的交易类型涉及到的所有交易控制组件、其对应的函数名、该交易控制组件所对应的业务流程及该交易控制组件在该流程中的调用序号等信息。随后，根据所获取的这些信息从预先加载到系统缓存（例如系统内存）的交易控制组件的函数库中选择出相应的交易控制组件的函数，并按照交易流程的顺序按序排列这些函数（文件）以构建成所述控制组件链。举例而言，上述处理可以包括先根据业务代码读取在步骤202中创建的该交易控制组件的函数文件，随后根据业务参数组件中与该业务代码所代表的相对应业务流程的参数（例如各交易控制组件在该流程中的调用序号）将读取的交易控制组件的函数文件的函数代码按序写入一代码文件，从而构建出相应的控制组件链的配置文件。
[0060]
下面结合具体的代码来说明控制组件链的基本数据结构：
ꢀ“
commonparam
”ꢀ
: {“txnid
”ꢀ
:
ꢀ“
txnid”,“component
”ꢀ
:
ꢀ”
component1”“component
”ꢀ
:
ꢀ”
component2”“component
”ꢀ
:
ꢀ”
component3”“component
”ꢀ
:
ꢀ”
component4”“component
”ꢀ
:
ꢀ”
component5”...} 在上述结构中，“component”代表一个交易控制组件。而要将该交易控制组件添加到内存中相应的业务流程的上述组件控制链的代码中，则可以利用下述示例的组件加载代码：int
ꢀꢀ
a001_addcomponent(int opr_tp, fas_svc_bus_t *svc_bus_data){
ꢀꢀꢀꢀ
int
ꢀꢀꢀꢀꢀ
i = 0;
ꢀꢀꢀꢀ
int
ꢀꢀꢀꢀꢀ
ret = succ;
ꢀꢀꢀꢀ
int
ꢀꢀꢀꢀꢀ
rsplen = 0;
ꢀꢀꢀꢀ
ssn_svc_data_t
ꢀꢀ
ssnsvcdata = {0};
ꢀꢀ
//交易数据
ꢀꢀꢀꢀ
component_t
ꢀꢀꢀꢀꢀ
component = {0};
ꢀꢀꢀ
//内存结构体
ꢀꢀꢀꢀ
svc_shm_t
ꢀꢀꢀꢀꢀꢀꢀ
*gp_svcshm;
ꢀꢀꢀꢀ
char componentbusi[4 + 1]
ꢀꢀ
= {0};
ꢀꢀ
//组件加载的业务流程
ꢀꢀꢀꢀ
char componentcode[4 + 1]
ꢀꢀ
= {0};
ꢀꢀ
//组件编码
ꢀꢀꢀꢀ
char componentname[20 + 1] = {0};
ꢀꢀ
//组件函数名称
ꢀꢀꢀꢀ
int
ꢀꢀ
step = 0, next_step_succ = 0, next_step_fail = 0;
ꢀꢀꢀꢀ
strcpy( componentbusi, svc_bus_data-》componentbusi );
ꢀꢀꢀꢀ
strcpy( componentcode, svc_bus_data-》componentcode );
ꢀꢀꢀꢀ
strcpy( componentname, svc_bus_data-》componentname );
ꢀꢀꢀꢀ
step = svc_bus_data-》componentstep;
ꢀꢀꢀꢀ
next_step_succ = svc_bus_data-》componentnextstepsucc;
ꢀꢀꢀꢀ
next_step_fail = svc_bus_data-》componentnextstepfail;
ꢀꢀꢀꢀ
offset = getshmoffset("component", &errcode); //获取系统内存地址
ꢀꢀꢀꢀ
if (offset 《= 0) {
ꢀꢀꢀꢀꢀꢀꢀꢀ
_sot_log(__file__, __line__, log_lvl_fatal,
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
"fatal: getshmoffset of v_fas_acnt_prod error!\n");
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
getshmblockhead(offset, &gp_svcshm);
ꢀꢀꢀꢀ
switch (opr_tp) { //0: add component
ꢀꢀꢀꢀ
case 0:
ꢀꢀꢀꢀꢀꢀꢀꢀ
for(; i 《 gp_svcshm-》businum; i++) {
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
if( !memcmp( gp_svcshm-》svcbus[i].svc_index, componentbusi, 4 ) )
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
break;
ꢀꢀꢀꢀꢀꢀꢀꢀ
}
ꢀꢀꢀꢀꢀꢀꢀꢀ
if( i 》= gp_svcshm-》businum )
ꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀꢀꢀꢀꢀ
strcpy(component.svc_index, componentbusi);
ꢀꢀꢀꢀꢀꢀꢀꢀ
strcpy(component.func_cd, componentcode);
ꢀꢀꢀꢀꢀꢀꢀꢀ
strcpy(component.func_nm, componentname);
ꢀꢀꢀꢀꢀꢀꢀꢀ
component.step_no = step;
ꢀꢀꢀꢀꢀꢀꢀꢀ
component.next_step_succ = next_step_succ;
ꢀꢀꢀꢀꢀꢀꢀꢀ
component.next_step_fail = next_step_fail;
ꢀꢀꢀꢀꢀꢀꢀꢀ
memcpy( &gp_svcshm-》svcbus[i].component[componentnum], &component, sizeof(component) );
ꢀꢀꢀꢀꢀꢀꢀꢀ
break;
ꢀꢀꢀꢀ
default:
ꢀꢀꢀꢀꢀꢀꢀꢀ
strcpy(svc_bus_data-》txnloginf.dest_rsn_rsp_cd, rsn_unknown_ssn_tp);
ꢀꢀꢀꢀꢀꢀꢀꢀ
return fail;
ꢀꢀꢀꢀ
}
ꢀꢀꢀꢀ
return succ;} 通过执行上述的代码，可以实现对业务流程中的各交易控制组件的函数的调用和组装，也即在系统内存中动态添加一条交易组件控制链。
[0061]
在图3中示出了一个开户业务类型的交易控制组件链的示例。如图所示，所述组件
链中比较重要的列的含义如下所示：svc_index:业务代码编号，在此示例中编号“2010”代表开户业务；step_no:执行步骤序号，也即表明了该交易控制组件的各个函数在该业务流程中的执行顺序；flw_cd：交易控制组件名称；func_nm:交易控制组件执行的代码；flw_opr_tp:交易控制组件的操作方式；next_step_succ:交易控制组件执行成功后要执行下一步骤的序号；next_step_fail:交易控制组件执行失败后要执行下一步骤的序号。
[0062]
如图所示，开户业务流程所包括的组件链（以编号“2010”为标识）包括了11个交易控制组件的函数。
[0063]
虚拟账户交易管理系统会根据业务系统的交易请求报文中的业务代码从交易控制组件函数库中检索与该业务代码相关联的各个交易控制组件的函数，并根据交易参数中提供的调用序号，顺序排列检索到的这些交易控制组件的函数，从而构建出如图3所示的控制组件链。
[0064]
在该图示中，所述开户业务的交易控制组件链包括下述交易控制组件：t001：交易流水号组件，调用后如成功则继续调用组件t022，失败继续调用t991；t022：交易记库组件，调用后如成功则继续调用组件z001，失败继续调用z002；z001：交易事务提交组件，调用后如成功则继续调用组件r101，失败继续调用z002；r101：业务系统权限检查组件，调用后如成功则继续调用组件f101，失败继续调用t021；c003 ：检查客户虚拟账户状态控制组件，调用后如成功则继续调用组件f101，失败继续调用t021；f101 ：新增客户虚拟账户控制组件，调用后如成功则继续调用组件t021，失败继续调用t021；t021： 交易返回码填写控制组件，调用后如成功则继续调用组件t031，失败继续调用t031；t031 ：更新交易状态，交易返回码等信息控制组件，调用后如成功则继续调用组件z001，失败继续调用z002；z001：交易事务提交组件，调用后如成功则结束组件链执行，失败继续调用z002；z002： 交易记录回滚组件，调用后如成功则继续调用组件 t991，失败继续调用 t991；t991：检查返回码是否赋值组件，调用后如成功则结束组件链执行，失败则结束组件链执行。
[0065]
最下面的t001组件属于“2012”表示的另一个交易控制组件链，在此不再详述。
[0066]
除了图3所示的开户业务的控制组件链之外，还可以通过如上所述的构建流程构建其他交易业务类型的控制组件链，例如查询余额组件链，用于按报文中的虚拟账户查询相应的余额，适用于特定动账类型的虚拟账户交易；业务参数配置组件链，用于按相应的交易类型，配置虚拟账户的交易权限，动态扩展组件链参数配置等；清分记账组件链，用于动账类交易实时进行账户科目记账
……
。这些组件链的构建流程都可以使用上述方案来实现，在此不再一一详述。
[0067]
除此之外，系统管理及监控组件在上述方法流程的执行过程中负责对这些组件进行统一管理、协调和监控，从而保证了整个系统的正常运行。
[0068]
综上所述，所述虚拟账户交易管理系统通过以函数化编程方式编程交易控制组
件，并根据交易类型动态加载及扩展组件链配置，使得系统可以很容易地实现横向扩展部署，降低了处理压力，并且提升了交易数据的并发量、吞吐量。同时，所述系统实现了组件链配置的模版化、通用性和可维护性，并简化了因新增账务交易类型需要改造相关系统的工作。
[0069]
并且通过使用系统主机内存来存储交易控制组件的函数和交易控制参数，解决了缓存与缓存存储系统耦合、高频交易带来的网络通信压力。
[0070]
再者，所述系统的纵向拆分可实现系统与数据库之间的解耦及提高单机交易处理能力，提升开发、运维效率。
[0071]
虽然以上描述了不同的实施例，但应当理解的是它们只是作为示例而非限制。（诸）相关领域的技术人员将领会，在不偏离如所附权利要求书所定义的本技术的精神和范围的情况下，可以在形式和细节方面进行各种修改。因此，此处所公开的本发明的宽度和范围不应被上述所公开的示例性实施例所限制，而应当仅根据所附权利要求书及其等同替换来定义。