首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >流程控制引擎组件化

流程控制引擎组件化

作者头像
smartguys
发布2018-08-31 16:50:25
1.1K1
发布2018-08-31 16:50:25
举报
文章被收录于专栏:smartguyssmartguys

 流程控制引擎组件化

在较大规模的业务系统中经常会有这样的模块,它按照一定的业务流程调用其它模块来实现一定的业务逻辑,我们姑且称之为流程引擎。这里称之为引擎有两层含义,一、突显其在业务系统的核心重要位置。二、它又是复杂不好维护的,通常由资深程序员把持。这样的引擎不仅代码繁多,与各个模块的接口复杂,并且一定程度对外是不透明的,就像一个黑盒模块。当一个新手想对其进行哪怕是一点点修改的时候都将会是一个灾难。本文就来讨论如何将这样一个庞大的引擎进行组件化改造,使其拥有代码级的流程图,使代码的维护难度降低一个量级,让新手也可以很快知道要如何修改代码,给引擎增加新的功能。

  我们来看两张图,分别是数控机床和机器人流水线。他们都是自动化的,就像我们的业务流程引擎一样。数控机床简洁、高效。但维护的时候需要专业人员,想增加新功能几乎不可能。机器人流水线,透明,看着有点复杂。但可以随时对流水线上任意部分进行升级,改造,替换。回到我们的业务流程引擎,我们到底希望是上面的哪一种?不难想到,由于业务需求的易变性,我们更倾向于第二种方案。但往往我们的代码是第一种情况,并且代码的组织是混乱的,并不是数控机床那种优雅。

数控机床

机器人流水线

当我们面对一个不熟悉的引擎的时候,我们看到的是下面这样子。

当我们花了一个月时间,仔细研读了几万行的代码后,我们看到的是下面这样子。

虽然我们已经了解了引擎内部的情况,但就像图中所描绘的样子,当要给引擎增加一个新的功能的时候,新增的功能和代码很容易影响原来正确的系统,一个小局部(零件)的问题,都会影响到整个系统。那么,我们如何来改变现有的流程引擎,以实现方便地增加新的功能?

如上图所示,如果我们的流程是一个流水线的话,我们就可以轻易地在流水线中增加新的组件,以实现新的功能。流程组件具有这样的特征:每个组件都是一个独立的个体,不受其它组件的影响。组件具有统一的接口,新增的组件可以方便和原有的组件一起工作。可以根据业务需要挑选合适的组件,组成一个新的业务流程。当把这些组件组合到一起,就形成了组件链表的概念。一个个独立的组件,就像链表里面的一个个节点,组件节点通过组件指针连接起来。一个流程的执行过程就像是对这个链表的遍历。并且这个链表不仅可以只是个单链表,而且可以是多分支链表,以应对流程中多条件分支的情况。

下面我们来看看代码是如何来实现的。

组件节点:

 例子:

这里的Execute()函数就是实现每个业务组件具体功能的地方,在这个函数里面可能调用其它模块。

空组件节点:

业务组件节点:

开闭原则:每个组件都是一个独立体(类),组件之间是一种松耦合的关系。流程中某个组件的改动,或者新增加一个组件,并不会影响到其它组件。支持以一种“对扩展开放,对修改封闭”的方式来为流程增加新的功能。从而不会将错误引入原有的稳定、正确的代码中。组件就像流水线上的每个节点,独立可替换。

流程组装:每个组件都有一个统一的编号ID。初始化时,通过按一定顺序读入这些ID,来进行流程的组装。流程中每个功能模块的调用顺序不再是固定写死的,而是在初始化时动态配置生成的。从而使流程功能的调整(增加,删除)变得很容易,不再用修改代码,而是调整流程组装配置列表的参数。

  由于流程可能是复杂的,具有复杂的分支情况,这里我们设计了一套编码方法来应对这个情况。

流程编码方法:

当我们有如下流程图需要实现的时候,下面图片可另外窗口打开。

就可以按上面的编码方案生成相应的流程代码,注意这里面说的是代码。这里的流程组装配置列表与流程图是一一对应的。从流程组装配置列表就可以轻松看到计费控制的整个流程图,而不用再发很多时间去了解代码,进而再画流程图。代码化的流程图是自维护的,即跟实际的情况是同步的,不再需要另外地去维护。想像一下,当你接到一个需要维护的复杂引擎的时候,这个引擎的流程图就在你面前,而不再需要你花费一个月时间,阅读数万行代码,自己一点点去画出来。这是何等的进步——The source code is the design

流程组装配置列表

组件化的优点:

a)将流程和被流程调用的子模块进行解耦。例如:批价函数,m_pPriceGuiding->ExecuteRating();在现有的在线流程中共有38处地方进行了调用,而按新的设计方案只会在一个组件(ExecuteRating)中进行调用,要用的批价的地方,只要将其加到流程组装配置列表即可。可以想象,如果ExecuteRating()函数接口改变了,对于原有的在线流程将会是一个灾难,而新的设计将可以轻松应对。注意:这并不是一个特例,在流程中几乎所有对子模块的调用都存在这种情况。

  b)组件的复用和移植。新的设计改变了原来以整个流程为最小单位的方式,而是一个组件为系统的最小单位。每个组件都是功能独立的,互不影响的方法集。不仅可以在不同流程间进行复用,甚至于可以跨版本地复用。包括组件移植时,成本也是很低的,只要将组件的代码文件进行移植即可,移植的是文件而不是代码。

  c)一些组件会趋于稳定。原来以流程为最小单位设计,任何的改变都会影响到整个流程,导致每次升版时流程的代码总是有很大的变化。而新的设计以组件为系统最小的单位,有一些组件会趋于稳定,一定程度上保持不变。从而分隔了系统中变化和不变的部分。使系统从整体上更加健壮。

  下面介绍一些代码的细节。

RatingCtrlComponent.h
#ifndef RATINGCTRLCOMPONENT_H_
#define RATINGCTRLCOMPONENT_H_

class RatingCtrlComponent
{
public:
    virtual ~RatingCtrlComponent()
    {
    }
    /**
    * @brief 组件流程执行接口
    *
    * @param pRatableEvent [in/out]
    * @return bool
    */
    virtual bool Execute(TRatableEvent& pRatableEvent) = 0;
};

#endif
RatingCtrlDectorator .h
#ifndef RATINGCTRLDECTORATOR_H_
#define RATINGCTRLDECTORATOR_H_

#include "RatingCtrlComponent.h"

class RatingCtrlDectorator : public RatingCtrlComponent
{
public:
    RatingCtrlDectorator(RatingCtrlComponent* pComponentA) : m_pComponentA(pComponentA)
    {
    }
    virtual ~RatingCtrlDectorator()
    {
    }
    /**
    * @brief 组件流程执行接口
    *
    * @param pRatableEvent [in/out]
    * @return bool
    */
    virtual bool Execute(TRatableEvent& pRatableEvent) = 0;

protected:
    RatingCtrlComponent* m_pComponentA; ///< 该组件的下一个组件(A分支)
};

#endif
ComponentFactory.h
#ifndef COMPONENTFACTORY_H_
#define COMPONENTFACTORY_H_


#include <list>
#include <vector>
#include "ComponentDefine.h"
#include "RatingCtrlComponent.h"


class ComponentFactory
{
public:
    ComponentFactory()
    {
    }
    virtual ~ComponentFactory()
    {
        ClearComponent();
    }

    /**
     * @brief 装配组件
     *
     * 根据编码[一个数组]装配组件。
     * 将各个组件构成一个流程分支链表。
     *
     * @param viComponentID [in]
     * @return RatingCtrlComponent 流程的头结点
     */
    RatingCtrlComponent* BuildComponent(vector<int>& viComponentID);
    void ClearComponent();

protected:
    virtual RatingCtrlComponent* CreateComponent(int iComponentID, RatingCtrlComponent* pComponent,
                                                 list<RatingCtrlComponent*>& lpComponent) = 0;

private:
    list<RatingCtrlComponent*> m_lpComponent;
    vector<RatingCtrlComponent*> m_vpComponent;
};

#endif
ComponentFactory.cpp
#include "ComponentFactory.h"

void ComponentFactory::ClearComponent()
{
    vector<RatingCtrlComponent*>::iterator itr;

    for (itr = m_vpComponent.begin(); itr != m_vpComponent.end(); ++itr)
    {
        delete * itr;
        *itr = NULL;
    }
}


/*
下面的代码很短,却完了一件精妙的工作.组件以一种近似网状的结构组织起来,
就像所有的网络流算法一样,程序的执行过程就是选择一条路径遍历的过程.
不同的是这边的分支是根据业务不同的而进行选择的。如此复杂的想法却以
这么简单的方式来实现,甚为精妙!-----by liang.shishi
*/
RatingCtrlComponent* ComponentFactory::BuildComponent(vector<int>& viComponentID)
{
    if (viComponentID.empty())
        return NULL;

    m_lpComponent.clear();

    RatingCtrlComponent* pComponent = NULL;

    vector<int>::iterator itr = viComponentID.end() - 1;
    // 增加默认基础类
    if (*itr != NONE_COMPONENT)
    {
        viComponentID.push_back(NONE_COMPONENT);
    }

    for (itr = viComponentID.end() - 1; itr >= viComponentID.begin(); --itr)
    {
        if (*itr < 0)
        {
            if (*itr == -1)
            {
                // 正常分支结束后,放在容器后面
                m_lpComponent.push_back(pComponent);
            }
            else
            {
                for (int i = 0; i < (*itr)*(-1); i++)
                {
                    // 多分支情况,放容器前面
                    m_lpComponent.push_front(pComponent);
                }
            }

            // 处理以0结束的分支
            if ((itr - 1) >= viComponentID.begin() && *(itr - 1) == 0)
            {
                pComponent = NULL;
            }
            else
            {
                pComponent = m_lpComponent.front();
                m_lpComponent.pop_front();
            }

            continue;
        }

        pComponent = CreateComponent(*itr, pComponent, m_lpComponent);

        // 组装失败
        if (pComponent == NULL)
        {
            ClearComponent();
            // LOG
            return NULL;
        }

        m_vpComponent.push_back(pComponent);
    }

    return pComponent;
}
RatingCtrlFactory .h
#ifndef RATINGCTRLFACTORY_H_
#define RATINGCTRLFACTORY_H_

#include "ComponentFactory.h"


class RatingCtrlFactory : public ComponentFactory
{
public:
    /**
     * @brief 创建组件
     *
     * 根据iComponentID创建对应的组件,用pComponent初始化新组件,最后返回新组件给pComponent。
     * 对于分支组件,需要根据lpComponent做特殊处理~
     *
     * @param iComponentID [in]
     * @param pComponent [in/out]
     * @param lpComponent [in/out]
     */
    virtual RatingCtrlComponent* CreateComponent(int iComponentID, RatingCtrlComponent* pComponent,
                                                 list<RatingCtrlComponent*>& lpComponent);

private:
    RatingCtrlComponent* Back(list<RatingCtrlComponent*>& lpComponent);
};

#endif
#include "RatingCtrlFactory.h"
#include "NoneComponent.h"

RatingCtrlComponent* RatingCtrlFactory::Back(list<RatingCtrlComponent*>& lpComponent)
{
    RatingCtrlComponent* pComponent = lpComponent.back();
    lpComponent.pop_back();

    return pComponent;
}

// 当遇到多分支的时候,应该先将pComponent放回链表首,再从链表尾取出相应数量的组件指针进行组装.
RatingCtrlComponent* RatingCtrlFactory::CreateComponent(int iComponentID, RatingCtrlComponent* pComponent,
                                                        list<RatingCtrlComponent*>& lpComponent)
{
    ADD_TRACE("%s RatingCtrlFactory::CreateComponent IN: iComponentID: %d, pComponent: %p.\n", LOG_PREFIX, iComponentID,
              pComponent);

    if (iComponentID != NONE_COMPONENT && pComponent == NULL)
    {
        ADD_TRACE("%s RatingCtrlFactory::CreateComponent OUT: iComponentID: %d, pComponent: %p.\n", LOG_PREFIX, iComponentID,
                  pComponent);
        return NULL;
    }


    switch (iComponentID)
    {
    case NONE_COMPONENT:
        {
            if (pComponent != NULL)
            {
                return NULL;
            }

            pComponent = new NoneComponent();
            break;
        }
    case EXECUTE_INITIALIZE:
        {
            pComponent = new ExecuteInitialize(pComponent);
            break;
        }
    case EXECUTE_PROCESS_IN:
        {
            lpComponent.push_front(pComponent);

            if (lpComponent.size() < 4)
            {
                return NULL;
            }

            pComponent = new ExecuteProcessIN(Back(lpComponent), Back(lpComponent), Back(lpComponent), Back(lpComponent));

            break;
        }
        default:
        {
            return NULL;
        }
    }

    return pComponent;
}

复杂分机的代码实现:

#ifndef EXECUTEPROCESSIN_H_
#define EXECUTEPROCESSIN_H_

#include "RatingCtrlDectorator.h"

class ExecuteProcessIN : public RatingCtrlDectorator
{
public:
    ExecuteProcessIN(RatingCtrlComponent* pComponentA, RatingCtrlComponent* pComponentB, RatingCtrlComponent* pComponentC,
                     RatingCtrlComponent* pComponentD) : RatingCtrlDectorator(pComponentA), m_pComponentB(pComponentB),
                                                         m_pComponentC(pComponentC), m_pComponentD(pComponentD)
    {
    }
    virtual ~ExecuteProcessIN()
    {
    }

    /**
     * @brief IN业务流程选择
     *
     * 根据 ExecuteId 选择流程
     * A:初始包流程; B:更新包流程; C:结束包鉴权; D:异常流程
     *
     * @param pRatableEvent [in]
     * @return bool
     */
    virtual bool Execute(TRatableEvent& pRatableEvent);

private:
    RatingCtrlComponent* m_pComponentB;
    RatingCtrlComponent* m_pComponentC;
    RatingCtrlComponent* m_pComponentD;
};

#endif
#include "ExecuteProcessIN.h"

bool ExecuteProcessIN::Execute(TRatableEvent& pRatableEvent)
{
    ADD_TRACE("%s ExecuteProcessIN::Execute() Begin.\n", LOG_PREFIX);

    int iExecuteId = pRatableEvent.GetAttrEx(EA::EXECUTE_ID)->AsInteger();

    switch (iExecuteId)
    {
    case EXECUTE_ID_INIT:
        {
            ADD_TRACE("%s ExecuteProcessIN::Execute() End Goto EXECUTE_ID_INIT Process.\n", LOG_PREFIX);
            return m_pComponentA->Execute(pRatableEvent);
        }
    case EXECUTE_ID_UPDATE:
        {
            ADD_TRACE("%s ExecuteProcessIN::Execute() End Goto EXECUTE_ID_UPDATE Process.\n", LOG_PREFIX);
            return m_pComponentB->Execute(pRatableEvent);
        }
    case EXECUTE_ID_FINISH:
        {
            ADD_TRACE("%s ExecuteProcessIN::Execute() End Goto EXECUTE_ID_FINISH Process.\n", LOG_PREFIX);
            return m_pComponentC->Execute(pRatableEvent);
        }
    case EXECUTE_ID_EMCDR:
        {
            ADD_TRACE("%s ExecuteProcessIN::Execute() End Goto EXECUTE_ID_EMCDR Process.\n", LOG_PREFIX);
            return m_pComponentD->Execute(pRatableEvent);
        }
    default:
        {
            pRatableEvent.SetAttr(EA::OCS_RESULT_CODE, CCA::DIAMETER_RATING_FAILED);
            ADD_ERROR("ZSmart-Charging-Online-1015",
                      "%s ExecuteProcessIN::ExecuteRatableEvent() GetExecuteId Failed. iExecuteId = [%d], ReturnCode = [%d]\n",
                      LOG_PREFIX, iExecuteId, pRatableEvent.GetAttrEx(EA::OCS_RESULT_CODE)->AsInteger());
        }
    }

    ADD_TRACE("%s ExecuteProcessIN::Execute() Fail.\n", LOG_PREFIX);
    return false;
}

最终复杂的流程图:

本文参与 腾讯云自媒体分享计划,分享自作者个人站点/博客。
原始发表:2018-08-10 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  •  流程控制引擎组件化
相关产品与服务
容器服务
腾讯云容器服务(Tencent Kubernetes Engine, TKE)基于原生 kubernetes 提供以容器为核心的、高度可扩展的高性能容器管理服务,覆盖 Serverless、边缘计算、分布式云等多种业务部署场景,业内首创单个集群兼容多种计算节点的容器资源管理模式。同时产品作为云原生 Finops 领先布道者,主导开源项目Crane,全面助力客户实现资源优化、成本控制。
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档