CN1896954A - 用于复杂多业务的动态编译器的构件化实现 - Google Patents

用于复杂多业务的动态编译器的构件化实现 Download PDF

Info

Publication number
CN1896954A
CN1896954A CNA2006101065507A CN200610106550A CN1896954A CN 1896954 A CN1896954 A CN 1896954A CN A2006101065507 A CNA2006101065507 A CN A2006101065507A CN 200610106550 A CN200610106550 A CN 200610106550A CN 1896954 A CN1896954 A CN 1896954A
Authority
CN
China
Prior art keywords
variable
service
compiler
class
expression
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Pending
Application number
CNA2006101065507A
Other languages
English (en)
Inventor
邵九松
黄诚
王涛
俞东
纪振华
柏松
施大伟
周仲华
欧小祥
周连华
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
LIAN Technology (Nanjing) Co., Ltd.
Original Assignee
LINKAGE SYSTEM INTEGRATION CO Ltd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by LINKAGE SYSTEM INTEGRATION CO Ltd filed Critical LINKAGE SYSTEM INTEGRATION CO Ltd
Priority to CNA2006101065507A priority Critical patent/CN1896954A/zh
Publication of CN1896954A publication Critical patent/CN1896954A/zh
Pending legal-status Critical Current

Links

Landscapes

  • Devices For Executing Special Programs (AREA)

Abstract

复杂多业务的动态编译器的实现方法，采用构件化设计，采用compositor模式进行设计，使用二叉搜索树放置变量列表，快速定位到变量，该方法同时包括编译和解释2个部分，对于一条业务规则只编译一次，在编译之后不再重新解释，变成纯粹的内存操作，即变成对compositor节点树的操作，从而以极快的速度完成业务解析。本发明的特点是：在电信计费系统的实际使用表明，极大提高的编码的工作量，在设计过程中，只对核心通用业务进行处理，而把各省的特殊业务事先预留接口，由动态解释器完成。

Description

用于复杂多业务的动态编译器的构件化实现
                           技术领域
本发明属于电信运营商大规模准确数据处理应用技术，尤其是电信运营中用于复杂多业务的动态编译器的构件化实现。
                           背景技术
随着通信业务的不断迅速发展，各电信运营商推出更多更复杂的业务，并且原有业务规则也在不断变化，电信业务的发展对软件设计和编码提出的更高要求，然而即使使用多种设计模式，也难以适应电信业务不断发展的需求，迫切需要系统有一种通用编码方式，来适应业务的变化和扩展。
目前的电信计费系统在对增加和修改业务时，没有一种统一的解决办法，很多时刻是采用硬编码的方式解决，当一种业务发生变化或产生一种新的业务时，往往是找到业务相对应的代码进行修改，也有部分业务会采用配置解决的方式，但配置放置的地点各不相同，有把配置放在数据库中，有放置在文件中，不同的业务有不同的配置文件，不同配置方式，没有固定统一的格式。
电信业务系统版本会应用于许多省份，不同的省份有不同的业务，按传统的方法要对不同的业务进行编码形成业务模块，在需要的省份进行增减，不同的省份对相同的业务也可能要求有不同的处理方式，按传统的方案，要为不同的省份做一个版本，在实施时进行增减。
传统的做法我们称之为“重新开发系统适应新需求”方式。
随着业务的迅速发展，采用传统的方法代码的改写量越来越多，版本也越来越多，但一次改写代码都面临危险，都要重新编译，各省的业务要作不同处理，版本越来越多，系统变得越来越不稳定，越来越难以维护，人员的流动使版本更是雪上加霜，迫切需要一种统一的、有柔韧性的、可扩展解决方案，将变化和改动集中于一点，使设计更容易，维护人员更方便，而且这个方案要尽量减少代码的修改量，最好是由配置解决，从而解决核心代码的稳定性，
如前所述，传统的“重新开发系统适用新需求”的解决方案，已经产生系统难以适应电信运营商业务发展，难以适应运营商需求，系统也难以维护的情况。通过多年在电信领域的经验，并通过了解设计模式，我们了解到在诸多模式中有一种叫interpreter模式，该模式核心思想是让程序在运行期间可以解释配置信息，生成机器代码，从而达到不修改代码，由配置来解决问题的目的，由此决定基于解释器模式，并结合其他设计模式，设计一种基于动态编译技术的解决方案，从而彻底解决上述问题。这种技术就是“基于解析器的动态编译技术”。
                            发明内容
本发明的目的是：复杂多业务的动态编译器的实现采用构件化设计思想进行设计。该方法可以作为独立的可配置的应用模块存在于应用平台，采用compositor模式进行设计，使用二叉搜索树放置变量列表，可以快速定位到变量。
本发明的技术解决方案是：复杂多业务的动态编译器的实现方法，采用构件化设计，采用compositor(编译)模式进行设计，使用二叉搜索树放置变量列表，快速定位到变量，该方法同时包括编译和解释2个部分，对于一条业务规则只编译一次，在编译之后不再重新解释，变成纯粹的内存操作，即变成对compositor节点树的操作，从而以极快的速度完成业务解析。
本发明将各利配置方式，业务配置集中于一点，在增加修改业务，系统维护时只要找到专门的配置文件，修改特定的配置项或新增配置项即可解决业务修改和新增的业务等问题。
本发明采用外部的字符串影射系统内存中的变量，通过修改字符串值来修改内部变量，通过预先定义的函数完成业务变换。
本发明适用于每一种支持标准c/c++的系统都可使用该方法。
本发明动态编译过程中按如下步骤：编译过程如下：读入规则\判断操作符号\根据操作符号进行\生成解释器语法树：解释过程如下：调用动态编译内存绑定接口绑定内存变量，读入动态编译规则。调用编译过程生成内存语法树；读取话单，把话单变量绑定到动态编译变量内存，调用语法树解析接口生成结果，解析接口调用解析树，反复递归得；系统根据语法树接口的处理进行相应处理。
该发明同时包括编译和解释2个部分，对于一条业务规则编译只需一次，在编译之后不再重新解释，变成纯粹的内存操作，即变成对compositor节点树的操作，从而以极快的速度完成业务解析。采用解释器方式的优点在于
1、由配置解决问题，可无限扩展；
2、不需要修改核心代码，核心代码相对稳定；
3、不需要重新编译，便于移植；
4、可自由增减业务规则，容易维护。
本发明的特点是：在电信计费系统的实际使用表明，极大提高的编码的工作量，在设计过程中，只对核心通用业务进行处理，而把各省的特殊业务事先预留接口，由动态解释器完成。
在项目维护过程中，对各省系统得新增需求首先采用动态编译的思想，配置动态编译规则，不需修改任何代码，完成用户需求。
在电信综合结算系统的模块都可以见到动态编译的使用，从预处理，批价，分拣，上传下发都可以自由的调用动态编译接口，无需重编码，重编译，提升了系统的安全性。动态编译经过改造，能以极快的速度运行，做到对程序性能基本没有影响。
                             附图说明
图1是本发明编译过程示意图
图2是本发明解释过程示意图
                           具体实施方式
具体实现方案参见附图。动态编译采用构件化设计思想进行设计。该技术可以作为独立的模块可被各需要运用动态编译功能的模块调用，只要配置文件中配置动态编译规则，动态编译规则中的常量应用程序中要有定义，规则中的函数模块已实现即可。
动态编译的几个关键对象类设计如下：
●VariantList类，该类定义变量列表，该类包含一个二叉搜索树，树的节点由一个字符串为查找键和一个内存地址组成，使用二叉搜索树可以在对数时间搜索到变量，从而得到变量的值或进行修改；
●Expression(解释)功能类及子类，该类为compositor模式的实现，Expression为纯虚类，表达式类都继承自Expression，包含不可递归节点类(也就是不含一个Expression的一个指针)的常量类和变量类，和其他可递归节点类(包含Expression的一个和多个指针)，可递归节点完成与，或，非，和其他自定义函数，最后一个Expression的实例成为语法树；
●Interpreter类，该类负责解释动态编译规则字符串，生成语法树；
●Compile类，该类为包装类，提供所有的调用接口
动态编译的业务规则的配置方式
输入项：输入为一个字符串表达式，具体语法规则如下：
Figure A20061010655000051
变量名：变量是以’$’符号开始的，变量名可以为字母，也可以为变量名+字母。
Figure A20061010655000052
表达式：表达式可以是以操作值+操作符+操作值的形式，也可以是表达式+操作符+操作值的形式。
操作值：可以是表达式，可以是以单引号”括起来的任意字符，可以是$变量名，可以是函数名(或者函数的参数)，也可以是数字。
Figure A20061010655000054
函数参数：可以是任意表达式。
Figure A20061010655000055
操作符：逻辑与’and’符号，或者逻辑或’or’符号，运算符号’+，’-，’*’，’/’。
输出项：表达式是否符合语法规则的标识、表达式的运算结果。
编译类的结构定义如下：
　　public:

　　    Interpreter(){m_SyntaxTree.push_back(NULL);}

　　    ~Interpreter();

　　        bool DcfineVariable(const char *VariableName,const char *
VariableAddress);

　　const char *Operation(char *Result,int Length,int *Error,const char *Context);

　　void DumpVar(void){}

　　    //私有类

　　private:

　　    //解释器各种表达式基类
        <!-- SIPO <DP n="3"> -->
        <dp n="d3"/>
　　   class Expression

　　       public:

　 　      Expression(){}

　　       virtual ~Expression(){}

　　       virtual const char *Execute()=0;

　　       virtual const char *SyntaxAnalyze(Interpreter *pInterpreter,const char
*Context,int &ErrorNo)=0;

　　       virtual const char *ExpType(){return(const char *)"Expression";}

　　   friend class Expression;

　　   //终结符表达式，叶子节点不需要在进行语法分析

　　   //语法树中的叶子结点，一些常量字符串，如’11’，’12’，’011’等

　　   class LiteralExp:public Expression

　　   {   public:

　　       explicit LiteralExp(const char *Literal):m_Literal(Literal){}

　　       virtual ~LiteralExp(){}

　　       const char *Execute(){return m_Literal.c_str();}

　　       const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo){return NULL;}

　　       const char *ExpType(){return(const char *)"LiteralExp";}

　　   private:

　　       string m_Literal;};

　　   friend class LiteralExp;

　　       //表达式中出现的变量，语法树中的叶子结点

　　   class VariableExp:public Expression

　　   {   public:

　　      explicit VariableExp(const char *pVarAddress):m_pVarAddress(pVarAddress)
{}     ~VariableExp(){}

　　       const char *Execute(){return m_pVarAddress;}

　　       const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo){return NULL;}

　　       const char *ExpType(){return(const char *)"VariableExp";}

　　   private:

　　       const char *m_pVarAddress;};

　　   friend class VariableExp;

　　       //函数表达式

　　       //like(exp1,exp2)

　　   class LikeExp:public Expression

　　   {   public:

　　       LikeExp():m_LeftExp(0),m_RightExp(0){}

　　       ~LikeExp();

　　       const char *Execute();

　　       const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo);

　　       const char *ExpType(){return(const char *)"LikeExp";}

　　    private:
        <!-- SIPO <DP n="4"> -->
        <dp n="d4"/>
　　        bool Compare(const char *CompareString,const char *CompareMod);

　　        Expression *m_LeftExp;

　　        Expression *m_RightExp;};

　　    friend class LikeExp;

　　        //not(exp)

　　    class NotExp:public Expression

　　    {   public:

　　        NotExp():m_BoolExp(0){}

　　        ~NotExp();

　　        const char *Execute();

　　        const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo);

　　        const char *ExpType(){return(const char *)"NotExp";}

　　    private:

　　        Expression *m_BoolExp;};

　　    friend class NotExp;

　　        //if(exp,true_return,false_return)

　　    class IfExp:public Expression

　　    {   public:

　　        IfExp():m_BoolExp(0),m_True_RetExp(0),m_False_RetExp(0){}

　　        ~IfExp();

　　        const char *Execute();

　　        const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo);

　　        const char *ExpType(){return(const char *)"IfExp";}

　　    private:

　　        Expression *m_BoolExp;

　　        Expression *m_True_RetExp;

　　        Expression *m_False_RetExp;};

　　    friend class IfExp;

　　    //case(conditionl,result1,condition2,result2,....,default_result)

　　    class CaseExp:public Expression

　　    {   public:

　　        CaseExp(){}

　　        ~CaseExp();

　　        const char * Execute();

　　        const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo);

　　        const char *ExpType(){return(const char *)"CaseExp";}

　　            private:

　　        vector＜Expression *>m_ExpArray;};

　　    friend class CaseExp;

　　        //bool_expl and bool_exp2

　　    class AndExp:public Expression

　　    {   public:
        <!-- SIPO <DP n="5"> -->
        <dp n="d5"/>
　　        AndExp():m_LeftCondition(0),m_RightCondition(0){};

　　        ~AndExp()

　　    {   delete m_LeftCondition;

　　            delete m_RightCondition;}

　　        const char * Execute();

　　        const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo){return NULL;}

　　        const char *ExpType(){return(const char *)"AndExp";}

　　        void AddLeftExp(Expression *LeftExp){m_LeftCondition=LeftExp;}

void AddRightExp(Expression *RightExp){m_RightCondition=RightExp;}

　　    private:

　　        Expression *m_LeftCondition;

　　        Expression *m_RightCondition;};

　　    friend class AndExp;

　　        //bool_exp1 or bool_exp2

　　    class OrExp:public Expression

　　    {   public:

　　        OrExp():m_LeftCondition(0),m_RightCondition(0){};

　　        ~OrExp()

　　        {         delete m_LeftCondition;

　　              delete m_RightCondition;         }

　　        const char * Execute();

　　        const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo){return NULL;}

　　        const char *ExpType(){return(const char *)"OrExp";}

　　        void AddLeftExp(Expression *LeftExp){m_LeftCondition=LeftExp;}

　　        void AddRightExp(Expression *RightExp){m_RightCondition=RightExp;}

　　    private:

　　        Expression *m_LeftCondition;

　　        Expression *m_RightCondition;};

　　    friend class OrExp;

　　        //in(value,test_value1,test_value2,....)

　　    class InExp:public Expression

　　    {   public:

　　        InExp(){};

　　        ~InExp();

　　        const char * Execute();

　　        const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo);

　　        const char *ExpType(){return(const char *)"InExp";}

　　    private:

　　        vector＜Expression *＞m_ExpArray;};

　　    friend class InExp;

　　    //substring(string,{-}pos{,length})pos为正时从左到右从1开始，pos为
负时从右往左从-1开始
        <!-- SIPO <DP n="6"> -->
        <dp n="d6"/>
　　    //如果忽略length表示取到字符串末尾

　　    class SubStringExp:public Expression

　　    {   public:

　　        SubStringExp():m_StringExp(0),m_PosExp(0),m_LenExp(0){}

　　        ~SubStringExp();

　　        const char * Execute();

　　        const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo);

　　        const char *ExpType(){return(const char *)"SubStringExp";}

　　    private:

　　        Expression *m_StringExp;

　　        Expression *m_PosExp;

　　        Expression *m_LenExp;

　　        //存放结果

　　        char m_Buffer[255];};

　　    friend class SubStringExp;

　　        //connect(string1,string2)

　　    class ConnectExp:public Expression

　　    {   public:

　　        ConnectExp():m_FirstStrExp(0),m_SecondStrExp(0){}

　　        ~ConnectExp();

　　        const char * Execute();

　　        const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo);

　　        const char *ExpType(){return(const char *)"ConnectExp";}

　　    private:

　　        Expression *m_FirstStrExp;

　　        Expression *m_SecondStrExp;

　　        //存放结果

　　        char m_Buffer[255];};

　　    friend class ConnectExp;

　　        //set($VarExp,string)

　　    class SetExp:public Expression

　　    {   public:

　　        SetExp():m_VariableExp(0),m_StringExp(0){}

　　        ~SetExp();

　　        const char * Execute();

　　        const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo);

　　        const char *ExpType(){return(const char *)"SetExp";}

　　    private:

　　        Expression *m_VariableExp;

　　        Expression *m_StringExp;};

　　   friend class SetExp;

　　        //strabove(string1,string2)|strbelow(string1,string2)
        <!-- SIPO <DP n="7"> -->
        <dp n="d7"/>
　　    class StrCmpExp:public Expression

　　    {   public:

　　        explicit                                                StrCmpExp(bool
blsStrAbove):m_StringExp1(0),m_StringExp2(0),m_blsStrAboye(blsStrAbove){}

　　~StrCmpExp();

　　        const char * Execute();

　　        const char *SyntaxAnalyze(Interpreter *plnterpreter,const char *Context,
int &ErrorNo);

　　        const char *ExpType(){return m_blsStrAbove?(const char
*)"StrAbove":(const char *)"StrBelow";}

　　    private:

　　        Expression *m_StringExp1;

　　        Expression *m_StringExp2;

　　        bool m_blsStrAbove;};

　　    friend class StrCmpExp;

　　    //numabove(numstring1,numstring2)|numbelow(numstring1,numstring2)

　　    class NumCmpExp:public Expression

　　    {   public:

　　        explicit                                                NumCmpExp(bool
bNumStrAbove):m_NumStringExp1(0),m_NumStringExp2(0),m_bIsNumAbove(bNumStrAbove){}

　　         ~NumCmpExp();

　　         const char*Execute();

　　         const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo);

　　         const char *ExpType(){return m_bIsNumAbove?(const char
*)"NumAbove":(const char *)"NumBelow";}

　　    private:

　　        Expression *m_NumStringExp1;

　 　       Expression *m_NumStringExp2;

　　        bool m_bIsNumAbove;};

　　    friend class NumCmpExp;

　　        //isdatetime(string)

　　    class IsDateTimeExp:public Expression

　　    {   public:

　　        explicit IsDateTimeExp():m_StringExp(0){}

　　        ~IsDateTimeExp();

　　        const char * Execute();

　　        const char *SyntaxAnaIyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo);

　　        const char *ExpType(){return(const char *)"IsDateTimeExp";}

　　    private:

　　        Expression *m_StringExp;      };

　　    friend class IsDateTimeExp;

　　    //add by liusk 2003/10/23

　　    //计算字符串长度
        <!-- SIPO <DP n="8"> -->
        <dp n="d8"/>
　　  //length(string)

　　  class LengthExp:public Expression

　　  {   public:

　　      explicit LengthExp():m_StringExp(0){}

　　      ~LengthExp();

　　      const char *Execute();

　　      const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo);

　　      const char *ExpType(){return(const char *)"LengthExp";}

　　  private:

　　      char m_Length[30];

　　      Expression *m_StringExp;};

　　  friend class LengthExp;

　 　 //add by liusk 2003/10/23

　　  //如果value和搜索(serarch_n)列表中的任何一个相等则返回相应的
result,否则返回默认值default_result

　　  //与case函数的不同为，case为条件测试满足则返回，decode为比较测试与
一系列的值比较如果满足则返回对应的结果

　　  //decode(value_exp,search1,resultl,search2,result2,..,default_result)

　　  class DecodeExp:public Expression

　　  {   public:

　　      explicit DecodeExp(){}

　　      ~DecodeExp();

　　      const char *Execute();

　 　     const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo);

　　      const char *ExpType(){return(const char *)"DecodeExp";}

　　    private:

　　      vector＜Expression *＞m_ExpArray;};

　　    friend class DecodeExp;

　　    //add by liusk 2003/11/8

　　    //comma(exp1,exp2,exp3,....,expn)

　　    //逗号表达式，执行所有的表达式语句，但返回最后一个表达式的值

　　    //可做一些表达式的容器

　　    class CommaExp:public Expression

　　    {   public:

　　        expliciy CommaExp(){}

　　        ~CommaExp();

　　        const char * Execute();

　 　     const char *SyntaxAnalyze(Interpreter *pInterpreter,const char *Context,
int &ErrorNo);

　　        const char *ExpType(){return(const char *)"CommaExp";}

　　    private:

　　        vector＜Expression *＞m_ExpArray;};

　　    friend class CommaExp;
        <!-- SIPO <DP n="9"> -->
        <dp n="d9"/>
　　private:

　　    //变量列表

　　    map＜string,const char *＞m_VaribleList;

　　    //索引0未使用

　　veetor＜Expression *＞m_SyntaxTree;

　　   //语法分析过程
const char *CompileExp(const char *Context,Expression **SyntaxTree,int &ErrorNo);

　　const char *ValueExp(const char *Context,Expression **SyntaxTree,int &ErrorNo);}
该类中主要方法Operation()的实现方法如下：
    //第一次编译表达式时会强制修改表达式的前2个字节

　　//第1个字节是已编译标志OxEE，第2个字节是索引号

　　//建议在配规则时每条规则前面预留2个tab字符

　　//主要是为了能迅速定位一个表达式的语法树

　　const char *Interpreter::Operation(char *Result,int Length,int
*ErrorNo,const char *Context)

　　{  *ErrorNo=COMPILE_NOERROR;

　　   if(*(unsigned char *)Context==OxEE)

　　   { //try{运行时错误编号COMPILE_RUNTIME_

　　     //需由Expression对象抛出异常try

　　     //取表达式的索引编号

　　      return strncpy(Result,m_SyntaxTree[(unsigned int)*(Context+
1)]-＞Execute(),Length);}

　　      catch(...){

　　          *ErrorNo=COMPILE_RUNTIME_ERROR_UNKNOWN;

　　          return Result;    }   }   else    {

　　      //表达式超过最大限制

　　   //(索引编号使用一个字节存储1~255,由于0是字符串结束标志未使用0)

　　      if(m_SyntaxTree.size()＞=256)

　　      {     *ErrorNo=COMPILE_RUNTIME_ERROR_EXPOVERLIMIT;

　　         return Context;}

　　             Expression *pTempExp=NULL;

　　      const char *pPosition=NULL;

　　      pPosition=CompileExp(Context,&pTempExp,*ErrorNo);

　　      if(*ErrorNo !=COMPILE_NOERROR)

　　      {  return pPosition;      }

　　      //如还有剩余的字符串则说明表达式不符文法规则

　　      else if(*pPosition !=0)

　　      {   *ErrorNo=COMPILE_ERROR_INVALID_EXP;
        <!-- SIPO <DP n="10"> -->
        <dp n="d10"/>
　　             delete pTempExp;

　　             return pPosition;}

　　        //对表达式加索引，格式为：OxEE索引编号，从1~255

　　        //注：修改Context的第1个字节为OxEE(标志)，第2个字节为索引号

　　        *(unsigned char *)Context=OxEE;

　　        *(unsigned char *)(Context+1)=m_SyntaxTree.size();

　　        m_SyntaxTree.push_back(pTempExp);

　　        return Operation(Result,Length,ErrorNo,Context);}
该方法将统一以前纷繁的配置方式，业务配置集中于一点，在增加修改业务，系统维护时只要找到专门的配置文件，修改特定的配置项或新增配置项即可解决业务修改和新增的业务等问题。
以下是配置部分的代码，“#”开头部分是注释部分，业务规则中不作处理。“\”是表示下行继续。
#业务通道标志，网关局
[PP003]
#无效话单规则，false为不做丢弃不作分拣，TRUE为做分拣
InvalidRule=’false’
#分拣规则数
DispartRuleNum=2
#入网网间结算
DispartRule1=decode($InTrunkTsp,\
          $LocalTsp,decode($OutTrunkTsp,’-2’,’12’,’false’),\
’-2’,if(in($OutTrunkTsp,$LocalTsp,’-2’),’11’,’false’),\’11’)
#出网网间结算
DispartRule2=if(in($OutTrunkTsp,$LocalTsp,’-2’),’false’,’12’)
    #分拣路径规则
DispartPathRule=case(like($BusinessType,’1[12]’),’003’,’003’)
该技术采用外部的字符串影射系统内存中的变量，通过修改字符串值来修改内部变量，通过预先定义的函数完成业务变换，提高系统得灵活性，可维护性。
当业务规则变化、新增新业务时，只要修改该配置文件，不用修改代码，即可实现对业务的更新处理。
该方法由电信业务产生，但不针对特定的模块，每个系统模块都可通过接口使用该技术，该技术也不特定针对电信系统，事实上每一种业务系统都可使用动态编译技术。
该发明有很好的移植性，动态编译技术的实现不针对特定的主机，特定操作系统，每一种支持标准c/c++的系统都可使用该技术。
以下是动态编译预处理和无动态编译预处理效率(if…else..方式)的测试情况：
测试环境：1)应用服务器：IBM P650 8CPU 8G MEM
                        /CPU TYPE：PowerPC_POWER4
测试对象：预处理文件数为：20；每个文件50000条记录。
测试方法：将文件放置于预处理输入目录，启动1个预处理进程。
监控输入目录的文件个数直至为零，同时监控清单表数据记录数。配置4条动态编译规则，每条规则大概包含15个条件判断。
A、基于动态编译预处理测试：
系统耗时：205秒
处理速度：1000000÷205约＝4878条/秒
B、重新开发系统适应新需求方式的预处理测试：
系统耗时：198秒
处理速度：1000000÷43.5约＝5050条/秒
测试结论：速度基本相当。
使用案例：业务需求A省的电信综合结算系统要求将西门子交换机(编号102)只输出cf(35)，transit(31)二种话单，而B省电信综合结算系统要求将西门子交换机(编号102)输出cf(35)，moc(32)，mtc(33)三种话单
传统的解决办法：对A省和而B省各做一个版本，分别用if语句来控制实现。
只为A省和而B省在动态编译的配置文件中各配置一条不同的动态编译规则，即可解决。
A省：Case(case($sourceid,”102”)and(case($recordtype,”31”)or case($recordtype,”35”)),”true”)
B省：                             Case(case($sourceid,”102”)and(case($recordtype,”32”)       or     case($recordtype,”33”)   orcase($recordtype,”35”)),”true”)
从以上可以看出，基于动态编译的解决方案做到了版本独立，不同业务由配置解决。

Claims (6)

1、复杂多业务的动态编译器的实现方法，采用构件化设计，其特征是采用编译模式进行设计，使用二叉搜索树放置变量列表，快速定位到变量，该方法同时包括编译和解释2个部分，对于一条业务规则只编译一次，在编译之后不再重新解释，变成纯粹的内存操作，即变成对编译节点树的操作，从而以极快的速度完成业务解析。
2、由权利要求1所述的复杂多业务的动态编译器的实现方法，其特征是将各种配置方式，业务配置集中于一点，在增加修改业务，系统维护时只要找到专门的配置文件，修改特定的配置项或新增配置项即可解决业务修改和新增的业务等问题。
3、由权利要求1所述的复杂多业务的动态编译器的实现方法，其特征是采用外部的字符串影射系统内存中的变量，通过修改字符串值来修改内部变量，通过预先定义的函数完成业务变换。
4、由权利要求1所述的复杂多业务的动态编译器的实现方法，其特征是适用于每一种支持标准c/c++的系统都可使用该方法。
5、由权利要求1所述的复杂多业务的动态编译器的实现方法，其特征是动态编译过程中按如下步骤：编译过程如下：读入规则\判断操作符号\根据操作符号进行\生成解释器语法树：解释过程如下：调用动态编译内存绑定接口绑定内存变量，读入动态编译规则。调用编译过程生成内存语法树；读取话单，把话单变量绑定到动态编译变量内存，调用语法树解析接口生成结果，解析接口调用解析树，反复递归得；系统根据语法树接口的处理进行相应处理。
6、由权利要求1所述的复杂多业务的动态编译器的实现方法，其特征是动态编译的关键对象类的设计是，VariantList类，该类定义变量列表，该类包含一个二叉搜索树，树的节点由一个字符串为查找键和一个内存地址组成，使用二叉搜索树可以在对数时间搜索到变量，从而得到变量的值或进行修改；
●Expression功能类及子类，该类为compositor模式的实现，Expression为纯虚类，表达式类都继承自Expression，包含不可递归节点类(也就是不含一个Expression的一个指针)的常量类和变量类，和其他可递归节点类(包含Expression的一个和多个指针)，可递归节点完成与，或，非，和其他自定义函数，最后一个Expression的实例成为语法树；
●Interpreter类，该类负责解释动态编译规则字符串，生成语法树；
●Compile类，该类为包装类，提供所有的调用接口，
动态编译的业务规则的配置方式，
输入项：输入为一个字符串表达式，
输出项：表达式是否符合语法规则的标识、表达式的运算结果。
CNA2006101065507A 2006-04-27 2006-07-12 用于复杂多业务的动态编译器的构件化实现 Pending CN1896954A (zh)

Priority Applications (1)

Application Number Priority Date Filing Date Title
CNA2006101065507A CN1896954A (zh) 2006-04-27 2006-07-12 用于复杂多业务的动态编译器的构件化实现

Applications Claiming Priority (3)

Application Number Priority Date Filing Date Title
CN200610039945 2006-04-27
CN200610039945.X 2006-04-27
CNA2006101065507A CN1896954A (zh) 2006-04-27 2006-07-12 用于复杂多业务的动态编译器的构件化实现

Publications (1)

Publication Number Publication Date
CN1896954A true CN1896954A (zh) 2007-01-17

Family

ID=37609482

Family Applications (1)

Application Number Title Priority Date Filing Date
CNA2006101065507A Pending CN1896954A (zh) 2006-04-27 2006-07-12 用于复杂多业务的动态编译器的构件化实现

Country Status (1)

Country Link
CN (1) CN1896954A (zh)

Cited By (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101488095A (zh) * 2008-01-18 2009-07-22 松下电器产业株式会社 编译方法以及编译程序
CN103077038A (zh) * 2013-01-31 2013-05-01 北京金和软件股份有限公司 动态生成和编译.net项目的方法
CN106649340A (zh) * 2015-10-30 2017-05-10 北京国双科技有限公司 条件过滤数据的存取方法及装置
CN118193543A (zh) * 2024-05-15 2024-06-14 成都融见软件科技有限公司 一种基于eda的节点树的查找方法、电子设备及存储介质

Cited By (6)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN101488095A (zh) * 2008-01-18 2009-07-22 松下电器产业株式会社 编译方法以及编译程序
CN103077038A (zh) * 2013-01-31 2013-05-01 北京金和软件股份有限公司 动态生成和编译.net项目的方法
CN103077038B (zh) * 2013-01-31 2016-03-30 北京金和软件股份有限公司 动态生成和编译.net项目的方法
CN106649340A (zh) * 2015-10-30 2017-05-10 北京国双科技有限公司 条件过滤数据的存取方法及装置
CN118193543A (zh) * 2024-05-15 2024-06-14 成都融见软件科技有限公司 一种基于eda的节点树的查找方法、电子设备及存储介质
CN118193543B (zh) * 2024-05-15 2024-07-12 成都融见软件科技有限公司 一种基于eda的节点树的查找方法、电子设备及存储介质

Similar Documents

Publication Publication Date Title
CN110187885B (zh) 一种量子程序编译的中间代码生成方法及装置
CN1320454C (zh) 用于处理xml对象的程序设计语言扩展及相关应用
EP1174791B1 (en) Unified data type system and method
CN1278231C (zh) 将抽象句法表示法1数据模型化成对象模型的方法及系统
CN100337235C (zh) 访问数据库的方法及装置
CN1371499A (zh) 传统数据结构的对象特性元模型仿真器
CN1305609A (zh) 实现参数化类型与现有非参数化库兼容的方法
CN112379917B (zh) 浏览器兼容性提升方法、装置、设备及存储介质
CN1526104A (zh) 分析结构化数据
CN1858717A (zh) 一种数据编解码方法及其编解码器
CN100397397C (zh) 基于关系数据库的xml数据存储与访问方法
CN1896954A (zh) 用于复杂多业务的动态编译器的构件化实现
CN114265772B (zh) 一种测试用例的生成方法及一种测试方法
CN1976320A (zh) 数据访问控制方法及系统
CN1525317A (zh) 在标记中用于定义和使用子级说明的系统和方法
CN1255744C (zh) 智能卡通用高速发卡机及其发卡方法
CN1207662C (zh) 基于多代理的交互式Web服务调度方法
Irwin et al. Object oriented metrics: Precision tools and configurable visualisations
CN113971044A (zh) 组件文档生成方法、装置、设备及可读存储介质
CN1949175A (zh) 一种对软件中的数据进行替换的方法
CN111124422A (zh) 一种基于抽象语法树的eos智能合约语言转换方法
CN1900905A (zh) 测试描述语言的实现方法及其装置
CN1584885A (zh) 用于验证分层组织的消息的系统和方法
US7058651B2 (en) Method, computer program product, and system for automatic class generation with simultaneous customization and interchange capability
CN1667610A (zh) 一种基于标记的xml快速解码方法

Legal Events

Date Code Title Description
C06 Publication
PB01 Publication
C10 Entry into substantive examination
SE01 Entry into force of request for substantive examination
EE01 Entry into force of recordation of patent licensing contract

Assignee: LIAN Technology (Nanjing) Co., Ltd.

Assignor: Linkage System Integration Co., Ltd.

Contract fulfillment period: 2009.6.23 to 2027.8.30 contract change

Contract record no.: 2009320001548

Denomination of invention: Method for realizing structural dynamic compiler of complicated multi-service

License type: exclusive license

Record date: 2009.8.17

LIC Patent licence contract for exploitation submitted for record

Free format text: EXCLUSIVE LICENSE; TIME LIMIT OF IMPLEMENTING CONTACT: 2009.6.23 TO 2027.8.30; CHANGE OF CONTRACT

Name of requester: LIANCHUANG SCIENCE ( NANJING ) CO., LTD.

Effective date: 20090817

ASS Succession or assignment of patent right

Owner name: LIANCHUANG SCIENCE ( NANJING ) CO., LTD.

Free format text: FORMER OWNER: NANJING LIANCHUANG SCIENCE CO., LTD.

Effective date: 20091211

C41 Transfer of patent application or patent right or utility model
TA01 Transfer of patent application right

Effective date of registration: 20091211

Address after: 16 F, 12 Huai gate, Nanjing City, Jiangsu Province, China: 210013

Applicant after: LIAN Technology (Nanjing) Co., Ltd.

Address before: 16 F, 12 Huai gate, Nanjing City, Jiangsu Province, China: 210013

Applicant before: Linkage System Integration Co., Ltd.

C12 Rejection of a patent application after its publication
RJ01 Rejection of invention patent application after publication

Open date: 20070117