规则引擎_规则引擎微服务 - CSDN
精华内容
参与话题
  • 规则引擎概述

    万次阅读 多人点赞 2017-08-13 13:09:50
    我是阿里巴巴做规则引擎相关工作多年的java工程师一枚,本文只讲一些个人对“规则引擎”的看法,欢迎大家一起探讨。 1、“规则引擎”的实际用途和价值 2、“规则引擎”的一般实现方式 3、“规则引擎”发展的一些坎坷

    我是阿里巴巴做规则引擎相关工作多年的java工程师一枚,本职工作就是通过规则引擎、规则管理平台等技术输出,来应对阿里巴巴复杂多变的上层规则相关业务的支持。

    限于技术保密、安全等因素,本文只讲一些个人对“规则引擎”的看法,欢迎大家一起探讨。

    总体来说,要搞清楚“规则引擎”,需要很好的回答以下几个问题。

    1、“规则引擎”的实际用途和价值

    2、“规则引擎”的一般实现方式

    3、“规则引擎”发展的一些坎坷

    一、“规则引擎”的实际用途和价值

    规则引擎和流程引擎一起,是使用在大规模复杂业务场景下必备的业务框架技术,使用这两门技术搭建起来的系统能够很好的梳理清楚业务逻辑,并且方便快速的修改业务逻辑,甚至可以做到需求的实时生效。

    1、举个通俗易懂的选择出行交通工具的例子。

    这里写图片描述

    2、hard code的代价非常大,随着业务的膨胀会使开发人员和规则需求方非常的疲惫。

    这里写图片描述

    3、“规则引擎”技术的运用会使整个业务发生很大变化。

    这里写图片描述

    从上面的案例可以看出,规则引擎最大的价值就在于通过以下的三个过程,大大的缓解了频繁的需求变化给整个业务系统带来的灾难。

    • a、逼迫系统开发人员和业务专家梳理业务,定义统一的BOM(业务对象模型)。

    • b、业务专家可以快速的制定修改规则,然后交由规则引擎自动化地来处理分析。

    • c、规则引擎代替系统开发人员,解决由规则条件关联动作变化带来的开发工作。

    二、“规则引擎”的一般实现方式

    一套规则引擎总体就是要做到以下的目标:

    建立规则语言标准,动态编辑,自动化执行。

    很多业务系统一般会使用某种脚本语言来实现,比如groovy,jruby,javascript,原因很简单单,因为脚本语言本质上可以解决变量识别和自动运行的问题,而且扩展性强,表达能力强,动态部署生效。

    另外,其他比如决策表等类似excel的输入,form表单的配置化 也可以转化为脚本语言。

    三、“规则引擎”发展的一些坎坷

    1、规则管理的复杂性:

    • a、优先级问题:比如你买了50块钱的东西,有满30减10,满50减20,系统会优先使用哪个规则呢?

    • b、冲突问题:假设有10条相关的法律规定,伤害致人死亡,会有可能判死刑。然后《未成年人保护法》规定,未满18周岁,不能判处死刑。这种情况下,系统对未成年人的杀人罪该如何判定呢?

    • c、规则列表的选择问题:很多时候,这可能只是个规则管理的业务模型问题,但是如何设计出一套足够应对所有的业务场景的模型还是非常难的。

    2、面向运营人员的规则的页面配置化

    • a、通过一套通用的form表单来配置规则,产生规则脚本。

    最佳的实践可能是采用 表单———>json,xml格式化数据———>规则脚本,这样可以很好的分离配置界面和脚本的强耦合关系,方便以后的维护。

    3、规则运行效率的问题

    如果你google下“规则引擎”,一般会有关于JSR94 和rete算法的介绍。
    https://www.ibm.com/developerworks/cn/java/j-java-rules/
    Rule Base(knowledge base,规则库,知识库)
    Working Memory(fact base,事实库)
    Inference Engine(推理引擎)
    Pattern Matcher(模式匹配器)
    Agenda(议事日程)
    Execution Engine(执行引擎)
    这里写图片描述

    规则引擎通过匹配规则库和事实库,挑选出对应的规则到日程,最后执行对应的action。

    本质上,“专家决策系统规则引擎模型”和rate算法,解决的是大量重复的condition匹配效率的问题,以及规则冲突规范的问题,和脚本的性能比较不在同一个层面上。

    具体,大家可以看看开源规则引擎:drools的实现方式。

    当然,实际业务场景并不一定适合这套比价重量级的规则模型,会遇到学习成本高,灵活性差,rate算法不能发挥优势反而初始化成本很高的问题。

    以上是个人结合工作实践,将一些个人对“规则引擎”的看法。

    本人在阿里巴巴长期担任和负责规则引擎、流程引擎相关的技术开发,并且这方面也相当的缺乏人才。

    这个是我们底层脚本引擎的开源项目:https://github.com/alibaba/qlExpress

    欢迎对这方面感兴趣的人请联系我哦。
    微信: 371754252
    email: tianqiao@taobao.com

    展开全文
  • 规则引擎入门

    千次阅读 2015-03-21 18:32:42
    什么是规则引擎 规则引擎由推理引擎发展而来,是一种嵌入在应用程序中的组件,实现了将业务决策从应用程序代码中分离出来,并使用预定义的语义模块编写业务决策。接受数据输入,解释业务规则,并根据业务规则做出...
    什么是规则引擎?
    规则引擎由推理引擎发展而来,是一种嵌入在应用程序中的组件,实现了将业务决策从应用程序代码中分离出来,并使用预定义的语义模块编写业务决策。接受数据输入,解释业务规则,并根据业务规则做出业务决策。
    参考:
    http://baike.baidu.com/link?url=BfAR-sxz1ryvOZ4uSVCqn9Csy51U5qCUaIomAQBogPE7FOxbbDB-2iXWR6N8FReIkoNNdc-Hk4y0sxKWpknWd_

    规则引擎和工作流引擎有什么区别?
    工作流引擎主要是通过流程引擎来驱动业务的流转的,适合业务过程已经固定下来或比较明确。
    规则引擎说白了,就是对业务一些特殊算法的封装,不过将它们以规则表达式的形式提出来,放到前端,可以定义和修改。
    在工作流中,也有自己的规则引擎,一般是路由或者流转等进行各类条件判断时用到。
    另一种观点:
    工作流引擎现在演化为 业务过程管理,最基本的概念还是业务过程的流转,而业务规则侧重业务逻辑的控制.
    比如零售行业的价格规则,它会针对 客户 商品/品类 地理位置等设计一个非常复杂的价格管理体系;与业务规则非常紧密的是事件引擎,比如政府部门的应急处理系统;业界都有很出名的软件和这些概念匹配,比如IBM、oracle\sap\SG等,目前市场份额方面,IBM处于绝对垄断地位,它的产品分别叫IBM Business Process Manager和IBM Operational Decision Manager(规则与事件)
    参考:
    http://bbs.csdn.net/topics/390729750

    著名的规则引擎有哪些?
    开源的代表是Drools,商业的代表是VisualRules ,iLog。
    参考:
    国内外主流工作流引擎及规则引擎分析
    http://wenku.baidu.com/link?url=NtBwBfRxrr6hgYZ8CRkc4sbMoQMiTSr-Q7U_WV-XEiwEYcGdIz2l4Dh8BmtqeQw4JWW2kwKDfB4nlQf4uFxguvXpv6bgoHo9-YgDEx0eV3O
    (好文!农信银!虽然有个别地方不专业)

    开源的规则引擎有哪些?
    java的比较少,目前只有8个,最出名的是Drools
    参考:
    http://www.open-open.com/41.htm

    什么是事件引擎?
    没有找到这个概念。
    找到事件处理引擎。规则引擎是其核心部分。
    参考《复杂事件处理引擎关键技术研究》
    http://www.docin.com/p-771991437.html

    什么是推理引擎?什么是推理机?
    推理机就是推理引擎,推理机是专家系统的核心部分,专家系统是人工智能的一个分支。
    规则引擎是基于规则的推理引擎,一种简单的推理引擎。

    规则引擎的推理包括正向推理和反向推理。

    参考:

    http://www.cnblogs.com/holbrook/archive/2012/03/20/2408526.html

    工作流引擎是否包含流程引擎与规则引擎?
    找不到流程引擎的概念。
    有些文章说的流程引擎差不多等同于工作流引擎,或者是工作流引擎的核心部分。
    工作流引擎肯定包含规则引擎,主要是业务流转的规则。

    IBM Business Process Manager和iLog有什么关系?
    前者是业务流程管理,后者是规则引擎。

    农信银的文章里提到activiti支持规则引擎camel,camel是啥?
    apache camel从官网描述上看,并不是一个规则引擎,而更倾向于企业集成模式。
    比如,把企业的A地址路由转向到B地址。
    他的比较产品不应该是drools,而更应该是mule、fuse等。
    所以open-open里的规则引擎没有它。(根据农信银这点上有点瞎来)
    参考:
    http://camel.apache.org/
    http://www.open-open.com/lib/view/open1340807942296.html

    =====================

    什么叫柔性的工作流?
    组织内部的各类流程能够对内外部环境做出快速适应。
    参考:
    http://tieba.baidu.com/p/1670470075
    柔性工作流的研究-中南大学 http://www.docin.com/p-49568762.html

    本文出自:ouyida3的csdn blog
    2015.3.21
    展开全文
  • 开源规则引擎 drools

    万次阅读 2018-08-06 21:30:34
    前言 在很多企业的 IT 业务系统中,经常会有大量的业务规则配置,而且随着企业管理者的决策变化,这些业务规则也会随之发生更改。...规则引擎是一种推理引擎,它是根据已有的事实,从规则知识库中匹配规则...

    前言

    在很多企业的 IT 业务系统中,经常会有大量的业务规则配置,而且随着企业管理者的决策变化,这些业务规则也会随之发生更改。为了适应这样的需求,我们的 IT 业务系统应该能快速且低成本的更新。适应这样的需求,一般的作法是将业务规则的配置单独拿出来,使之与业务系统保持低耦合。目前,实现这样的功能的程序,已经被开发成为规则引擎。

    规则引擎是一种推理引擎,它是根据已有的事实,从规则知识库中匹配规则,并处理存在冲突的规则,执行最后筛选通过的规则。因此,规则引擎是人工智能(AI)研究领域的一部分,具有一定的选择判断性、人工智能性和富含知识性。目前,比较流行的规则引擎有商业规则引擎 iLog 和开源规则引擎 drools。本文将对开源规则引擎 drools 做详细介绍,并通过分析一个在汽车保险行业中的实际应用案例,让读者对开源规则流引擎有一个更深刻的理解。

    1. 基于 rete 算法的规则引擎

    在 AI 领域,产生式系统是一个很重要的理论,产生式推理分为正向推理和逆向推理产生式,其规则的一般形式是:IF 条件 THEN 操作。rete 算法是实现产生式系统中正向推理的高效模式匹配算法,通过形成一个 rete 网络进行模式匹配,利用基于规则的系统的时间冗余性和结构相似性特征 [8],提高系统模式匹配效率。本文将介绍的 Drools 引擎就是利用 rete 算法对规则进行分析,形成 rete 网络,对模式进行匹配。

    1.1 rete 算法研究

    1.1.1 rete 算法概述

    Rete 算法最初是由卡内基梅隆大学的 Charles L.Forgy 博士在 1974 年发表的论文中所阐述的算法 , 该算法提供了专家系统的一个高效实现。自 Rete 算法提出以后 , 它就被用到一些大型的规则系统中 , 像 ILog、Jess、JBoss Rules 等都是基于 RETE 算法的规则引擎 [7]。

    Rete 在拉丁语中译为”net”,即网络。Rete 匹配算法是一种进行大量模式集合和大量对象集合间比较的高效方法,通过网络筛选的方法找出所有匹配各个模式的对象和规则。

    其核心思想是将分离的匹配项根据内容动态构造匹配树,以达到显著降低计算量的效果。Rete 算法可以被分为两个部分:规则编译和规则执行 [7]。当 Rete 算法进行事实的断言时,包含三个阶段:匹配、选择和执行,称做 match-select-act cycle。

    1.1.2 rete 算法相关概念

    Rete 算法规则相关的概念有如下几个:

    Fact:已经存在的事实,它是指对象之间及对象属性之间的多元关系,为简单起见,事实用一个三元组来表示:(标识符 ^ 属性 值)[1],例如如下事实:

    w1:(B1 ^ on B2) w6:(B2 ^color blue)
    w2:(B1 ^ on B3) w7:(B3 ^left-of B4)
    w3:(B1 ^ color red) w8:(B3 ^on table)
    w4:(B2 ^on table) w9:(B3 ^color red)
    w5:(B2 ^left-of B3)

    Rule:规则,包含条件和行为两部分,条件部分又叫左手元(LHS),行为部分又叫右手元(RHS)。条件部分可以有多条条件,并且可以用 and 或 or 连接 [1]。其一般形式如下:

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    (name-of-this-production

     LHS /*one or more conditions*/

     -->

     RHS /*one or more actions*/

     )

    例如,下面的例子:

     (find-stack-of-two-blocks-to-the-left-of-a-red-block

     (^on)

     (^left-of)

     (^color red)

     -->

     ...RHS...

     )

     Patten:模式,也就是规则的条件部分,是已知事实的泛化形式,是未实例化的多元关系 <sup>[1]</sup>。比如,前面的那条规则的条件部分:

     (^on)

     (^left-of)

     (^color red)

     Rete 网络的概念 <sup>[1][9][10]</sup>如下:

    RootNode:Rete 网络的根节点,所有对象通过 Root 节点进入网络。

    ObjectTypeNode:对象类型节点,保证所传入的对象只会进入自己类型所在的网络,提高了工作效率。

    AlphaNode:Alpha 节点是规则的条件部分的一个模式,一个对象只有和本节点匹配成功后,才能继续向下传播。

    JoinNode:用作连接(jion)操作的节点,相当于 and,相当于数据库的表连接操作,属于 betaNode 类型的节点。BetaNode 节点用于比较两个对象和它们的字段。两个对象可能是相同或不同的类型。我们将这两个输入称为左和右。BetaNode 的左输入通常是一组对象的数组。BetaNode 具有记忆功能。左边的输入被称为 Beta Memory,会记住所有到达过的语义。右边的输入成为 Alpha Memory,会记住所有到达过的对象。

    NotNode:根据右边输入对左边输入的对象数组进行过滤,两个 NotNode 可以完成‘ exists ’检查。

    LeftInputAdapterNodes:将单个对象转化成对象数组。

    Terminal Nodes 被用来表明一条规则已经匹配了它的所有条件(conditions)。

    图 1 展示的是一个简单的 rete 网络:

    图 1. RETE 网络

    图 1. RETE 网络

    1.1.3 创建 rete 网络

    Rete 算法的编译结果是创建了规则集对应的 Rete 网络 , 它是一个事实可以在其中流动的图。创建 rete 网络的过程 [1]如下: 1) 创建根节点; 2) 加入一条规则 1 (Alpha 节点从 1 开始,Beta 节点从 2 开始 ); a. 取出规则中的一个模式 1,检查模式中的参数类型,如果是新类型,则加入一个类型节点; b. 检查模式 1 对应的 Alpha 节点是否已存在,如果存在则记录下节点位置,如果没有则将模式 1 作为一个 Alpha 节点加入到网络中,同时根据 Alpha 节点的模式建立 Alpha 内存表; c. 重复 b 直到所有的模式处理完毕; d. 组合 Beta 节点,按照如下方式: Beta(2) 左输入节点为 Alpha(1),右输入节点为 Alpha(2) Beta(i) 左输入节点为 Beta(i-1),右输入节点为 Alpha(i) i>2 并将两个父节点的内存表内联成为自己的内存表; e. 重复 d 直到所有的 Beta 节点处理完毕; f. 将动作(Then 部分)封装成叶节点(Action 节点)作为 Beta(n) 的输出节点; 3) 重复 2) 直到所有规则处理完毕; 执行完上述步骤,建立的 rete 网络如下图 2 (a 图为含有 3 个规则的 rete 网络,b 图为含有一个规则的 rete 网络 ):

    图 2. beta-network and alpha-network

    图 2. beta-network and alpha-network

    上图(a 图和 b 图),他们的左边的部分都是 beta-network, 右边都是 alpha-network, 圆圈是 join-node。右边的 alpha-network 是根据事实库和规则条件构建的,其中除 alpha-network 节点的节点都是根据每一条规则条件的模式 , 从事实库中 match 过来的,即在编译构建网络的过程中静态建立的。只要事实库是稳定的,RETE 算法的执行效率应该是非常高的,其原因就是已经通过静态的编译,构建了 alpha-network。左边的 beta-network 表现出了 rules 的内容,其中 p1,p2,p3 共享了许多 BetaMemory 和 join-node, 这样能加快匹配速度。

    1.1.4 Rete 算法的匹配过程

    匹配过程如下: 1) 对于每个事实,通过 select 操作进行过滤,使事实沿着 rete 网达到合适的 alpha 节点。2) 对于收到的每一个事实的 alpha 节点,用 Project( 投影操作 ) 将那些适当的变量绑定分离出来。使各个新的变量绑定集沿 rete 网到达适当的 bete 节点。3) 对于收到新的变量绑定的 beta 节点,使用 Project 操作产生新的绑定集,使这些新的变量绑定沿 rete 网络至下一个 beta 节点以至最后的 Project。4) 对于每条规则,用 project 操作将结论实例化所需的绑定分离出来。

    如果把 rete 算法类比到关系型数据库操作,则事实集合就是一个关系,每条规则就是一个查询,再将每个事实绑定到每个模式上的操作看作一个 Select 操作,记一条规则为 P,规则中的模式为 c1,c2,…,ci, Select 操作的结果记为 r(ci), 则规则 P 的匹配即为 r(c1)◇r(c2)◇…◇(rci)。其中◇表示关系的连接(Join)操作。

    Rete 网络的连接(Join)和投影 (Project) 和对数据库的操作形象对比如图 3 所示:

    图 3. join and project

    图 3. join and project

    1.1.5 Rete 算法的特点、不足和建议 Rete 算法有如下特点:

    a. Rete 算法是一种启发式算法,不同规则之间往往含有相同的模式,因此在 beta-network 中可以共享 BetaMemory 和 betanode。如果某个 betanode 被 N 条规则共享,则算法在此节点上效率会提高 N 倍。

    b. Rete 算法由于采用 AlphaMemory 和 BetaMemory 来存储事实,当事实集合变化不大时,保存在 alpha 和 beta 节点中的状态不需要太多变化,避免了大量的重复计算,提高了匹配效率。

    c. 从 Rete 网络可以看出,Rete 匹配速度与规则数目无关,这是因为事实只有满足本节点才会继续向下沿网络传递。

    Rete 算法的不足:

    a. 事实的删除与事实的添加顺序相同, 除了要执行与事实添加相同的计算外, 还需要执行查找, 开销很高 [3]。

    b. RETE 算法使用了β存储区存储已计算的中间结果, 以牺牲空间换取时间, 从而加快系统的速度。然而β存储区根据规则的条件与事实的数目而成指数级增长, 所以当规则与事实很多时, 会耗尽系统资源 [3]。

    针对 Rete 算法的特点和不足,在应用或者开发基于 Rete 算法的规则引擎时,提出如下建议:

    a. 容易变化的规则尽量置后匹配,可以减少规则的变化带来规则库的变化。

    b. 约束性较为通用或较强的模式尽量置前匹配,可以避免不必要的匹配。

    c. 针对 Rete 算法内存开销大和事实增加删除影响效率的问题,技术上应该在 alpha 内存和 beata 内存中,只存储指向内存的指针,并对指针建里索引(可用 hash 表或者非平衡二叉树)。

    d. Rete 算法 JoinNode 可以扩展为 AndJoinNode 和 OrJoinNode,两种节点可以再进行组合 [5]。

    1.2 基于 Rete 算法的 drools 开源规则引擎

    1.2.1 Drools 规则引擎简介

    Drools 具有一个易于访问企业策略、易于调整以及易于管理的开源业务 规则引擎,符合业内标准,速度快、效率高。业务分析师或审核人员可以利用它轻松查看业务规则,从而检验已编码的规则是否执行了所需的业务规则。其前身是 Codehaus 的一个开源项目叫 Drools,最近被纳入 JBoss 门下,更名为 JBoss Rules,成为了 JBoss 应用服务器的规则引擎。

    Drools 被分为两个主要的部分:编译和运行时。编译是将规则描述文件按 ANTLR 3 语法进行解析,对语法进行正确性的检查,然后产生一种中间结构“descr”,descr 用 AST 来描述规则。目前,Drools 支持四种规则描述文件,分别是:drl 文件、 xls 文件、brl 文件和 dsl 文件,其中,常用的描述文件是 drl 文件和 xls 文件,而 xls 文件更易于维护,更直观,更为被业务人员所理解。运行时是将 AST传到 PackageBuilder,由 PackagBuilder来产生 RuleBase,它包含了一个或多个 Package 对象。

    Drools 的语法规则将在实践中介绍,下面分析 drools 的原理。

    1.2.2 Drools 规则引擎原理

    Drools 中的 Rete 算法被称为 ReteOO,表示 Drools 为面向对象系统(Object Oriented systems)增强并优化了 Rete 算法。

    在 Drools 中,规则被存 放在 Production Memory(规则库)中,推理机要匹配的 facts(事实)被存在 Working Memory(工作内存)中。当时事实被插入到工作内存中后,规则引擎会把事实和规则库里的模式进行匹配,对于匹配成功的规则再由 Agenda 负责具体执行推理算法中被激发规则的结论部分,同时 Agenda 通过冲突决策策略管理这些冲突规则的执行顺序,Drools 中规则冲突决策策略有:(1) 优先级策略 (2) 复杂度优先策略 (3) 简单性优先策略 (4) 广度策略 (5) 深度策略 (6) 装载序号策略 (7) 随机策略 [5][6]。

    图 4. Drools 的原理示意图

    图 4. Drools 的原理示意图

    2. 应用实践

    2.1 需求描述

    在汽车保险行业中,每个地区都会有自己的车险投保规则,而且这些投保规则会经常变动,为适应这样的业务需求,可以采用 drools 开源规则引擎。 在本文介绍的例子中,具体业务需求是:应用应该能够根据前台传入的车辆信息和地区信息,从车辆和套餐的关系配置中匹配这辆车可用的套餐;然后,根据从套餐配置中获取套餐信息,套餐信息中包含了该套餐可用的险别(如车损险、乘客责任和盗抢险诸如之类的称之为险别);最后从险别配置中获取险别信息。

    2.2 需求分析

    由于每个地区的规则不一样,所以要对规则进行分组,每个地区的车辆和套餐的关系配置和套餐配置要分别在不同的文件中,而险别是不变信息,各个地区用同一个险别配置。车辆和套餐的关系配置放在一个 RuelTable 中,套餐配置放在另一个 RuelTable 中,这两个 RuelTable 在用一个 xls 文件中描述即可。

    这样配置后,每次引擎先根据地区代码执行相应的规则文件;进入规则文件后,再根据车辆信息过滤套餐找出适合这辆车的套餐,然后更新传入的对象,这时会重新匹配规则(已经匹配过的不应该再匹配,后面代码中会介绍);然后再匹配套餐,匹配后,更新对象;最后进入险别对应的文件匹配险别。

    2.3 代码实践

    首先,建立 Drools BRMS 应用。Drools BRMS 是一个管理和编译规则和规则流的 Web 应用程序,可以部署在大部分的支持 J2SE 1.5 的 Web 容器下,如 Tomcat6。Drools BRMS 架构体系分为三大部分,第一部分是 UI 层,提供了一个基于 Ajax 技术的业务规则编辑、管理工具。第二部分是规则文件仓库层,将规则文件统一保持在文件系统或关系数据库。最后一个是 Drools 的核心引擎,用来对用户提交的规则文件进行验证、编译和部署。开发人员通过规则文件的编辑部署,生成了包含 rule 的 package 对象,这是引擎可直接操作的内存对象。BRMS 通过一个 URL 提供对这个对象的 HTTP 访问。第三方可以通过 Agent 相关 API 来访问这个 URL,程序自动下载这个 Package 对象就直接可以在规则引擎运行,得到规则执行的结果。

    然后,将 BOM(Business Object Model 业务规则引擎所要操作的对象 )、规则流文件(图 2-2 所对应的文件)和规则文件(图 2-3 和图 2-4 所对应的文件)上传到 BRMS 中。下面对各个文件进行介绍。

    图 5 描述的是 BOM 对象,分别是 GeProposalInfo、GeCar、GeComboArea、GeCombo 和 GeKind,他们的关系从图中可以很明显的看出,这里不再赘述。

    图 5. BOM 类

    图 5. BOM 类

    图 6 中,开始节点是表示流程的开始。在 diverge 分枝节点处按 GeComboArea 里的 AreaCode 属性值有四个分枝,这四个分枝按优先级只要有一个满足条件就继续向下执行。diverge 分枝节点有 And、Xor 和 Or 三种类型,其含义分别是执行所有分枝、执行按优先级首先符合条件的分枝、执行所有符合条件的分枝。RuleTask 规则任务节点对应的是这个 RuleGroup 规则组里的规则。执行完地区层次的规则后,进入 converge 聚合节点,此节点等待分枝节点中任何一个节点执行完毕后执行。converge 分枝节点有 And、Xor、n-of-m 和 Discriminator 四种类型,其含义分别是等待所有分枝执行完毕、按优先级只等待一个分枝执行完、等待一个分枝执行完,但每个分枝执行完后会导致继续等待下一个分枝执行和等待在 m 个分枝中有 n 个分枝执行完毕。规则任务节点 Rule_Kind 是执行 Rule_Kind 规则组里的规则。结束节点标志着规则流执行完毕。

    图 6. 规则流

    图 6. 规则流

    图 7 和图 8 分别是 beijing.xls 和 kind.xls 的截图。在决策表中,不同作用的表格用不同颜色区分。在黑色区中,有一个 RuleTable 关键词,它表示本决策表从这开始,解析的时候也就是从这按从上到下和从左到右的顺序开始解析,其后是表名称。CONDITION 是表明此列为条件的关键词。和并列中 pi:GeProposalInfo 的意思是从 workmemory 中选取类型为 GeProposalInfo 的一个对象赋值给 pi。car.carType matches ".*$param.*"的含义是查看 pi 中对象 car 中的 carType 属性值是否包含此列单元格中的值。".*$param.*"为正则表达式,$param 为对单元格中值的引用。Matches 是一个操作。RULEFLOW-GROUP 是对规则分组的关键字,它和规则任务节点对应。PRIORITY 设置规则执行优先级,数值越大越先被执行。ACTION 是规则的行为部分,可以在单元格中写 java 代码。另外,单元格中有内容表示执行匹配或执行 java 代码,没有内容表示什么都不做,跳过。

    图 7. 规则表定义一

    图 7. 规则表定义一

    图 8. 规则表定义二

    图 8. 规则表定义二

    图 9 是 beijing.xls 和 kind.xls 里的规则生成的 rete 网络。在编写规则中,我们采用了本文的建议 a(将容易变化的规则尽量放后)和 b(将强约束条件放前),这样产生的 rete 网络匹配效率会更高。如图 2-5 中,在红色节点(类型节点)下会有对 updateFlag 的三个分枝,updateFlag 是强约束条件且不会变化太大,仅在此节点上,匹配效率就提高了三分之一。

    图 9. 生成的 Rete 网络

    图 9. 生成的 Rete 网络

    最后,我们对我们的应用程序端的调用做一下阐述。

    第一步:创建规则库

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    KnowledgeBase kbase = readKnowledgeBase();

     readKnowledgeBase 方法必须是单例方法,其内容如下:

     创建 kbuilder 对象(用来编译规则的对象)

     KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();

        Brms 应用程序上规则包(也就是规则库)所在 url 地址 String urlString = "http://localhost:8080/drools-5.1.1guvnor/org.drools.guvnor.Guvnor/package/combo";

            URL url = new URL(urlString);

            UrlResource urlResource = (UrlResource)ResourceFactory.newUrlResource(url);

     只要设置采用基本授权就可登录 Brms

            urlResource.setBasicAuthentication("enabled");

     将已经编译好的规则包加入 kbuilder 对象,此处加入的是 pkg 类型

            kbuilder.add(urlResource, ResourceType.PKG);

     创建 KnowledgeAgent(ruleaget 类是不稳定或实验中的代理类)代理,它负责维护与 brms 里的规则保持版本一致性

            KnowledgeAgent kagent = KnowledgeAgentFactory.newKnowledgeAgent("combo");

            KnowledgeBase kbase = kagent.getKnowledgeBase();

     将规则包加入规则库

            kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());

            return kbase;

    第二步:创建 workmemory 并插入对象

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    创建 workmemory 对象 ksession

     StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();

     设置初始值

            GeComboArea ca = new GeComboArea();

            ca.setAreaCode("010");

            GeCar c=new GeCar();

            c.setCarAge(9);

            c.setCarPrice(15000);

            c.setCarType("华晨 bmw11 年款");

            GeProposalInfo pi=new GeProposalInfo();

            pi.setCar(c);

            pi.setComboArea(ca);

     将 pi 插入 workmemory 中,此时会构建 rete 网络

            ksession.insert(pi);

    第三步:执行规则流和规则

    1

    2

    3

    4

    激活规则流

     ksession.startProcess("com.sample.ruleflow");

     激活规则

            ksession.fireAllRules();

    第四步:释放资源

    1

    ksession.dispose();

    3. 总结

    本文通过深入剖析 rete 算法和基于 rete 算法的规则引擎,发现了算法中存在的问题,提出了算法改进的意见,同时也阐述了在应用规则引擎时应该注意的问题,并通过实例对规则引擎进行了实践。

    展开全文
  • 规则引擎概述及选型

    万次阅读 2020-08-14 09:47:02
    规则引擎概述及选型

    一、规则引擎概述:

      规则引擎由推理引擎发展而来,是一种嵌入在应用程序中的组件,实现了将业务决策从应用程序代码中分离出来,并使用预定义的语义模块编写业务决策。
      规则引擎具体执行可以分为接受数据输入,解释业务规则,根据业务规则做出业务决策几个过程。
      使用规则引擎可以把复杂、冗余的业务规则同整个支撑系统分离开,做到架构的可复用移植。
      规则引擎通常允许您在不重新启动系统或部署新的可执行代码的情况下更改规则。规则引擎不是一个新的东西的魔法盒,它旨在成为一个提供更高级别抽象的工具,以便您可以更少地关注开发细节。

    Rules engines are not really intended to handle workflow or process executions nor are workflow engines or process management tools designed to do rules.

    规则引擎的起源:

      Java规则引擎起源于基于规则的专家系统(RBES),而基于规则的专家系统又是专家系统的其中一个分支。专家系统属于人工智能的范畴,它模仿人类的推理方式,使用试探性的方法进行推理,并使用人类能理解的术语解释和证明它的推理结论。专家系统有很多分类:神经网络、基于案例推理和基于规则系统等。
      RBES包括三部分:Rule Base(knowledge base)、Working Memory(fact base)和Inference Engine(推理引擎)。它们的结构如下所示:
    在这里插入图片描述
      推理引擎包括三部分:模式匹配器(Pattern Matcher)、议程(Agenda)和执行引擎(Execution Engine)。推理引擎通过决定哪些规则满足事实或目标,并授予规则优先级,满足事实或目标的规则被加入议程。模式匹配器决定选择执行哪个规则,何时执行规则;议程管理模式匹配器挑选出来的规则的执行次序;执行引擎负责执行规则和其他动作。
      和人类的思维相对应,推理引擎存在两者推理方式:演绎法(Forward- Chaining)和归纳法(Backward-Chaining)。演绎法从一个初始的事实出发,不断地应用规则得出结论(或执行指定的动作)。而归纳法则是根据假设,不断地寻找符合假设的事实。Rete算法是目前效率最高的一个Forward-Chaining推理算法,许多Java规则引擎都是基于 Rete算法来进行推理计算的。
      推理引擎的推理步骤如下:
        ⑴将初始数据(fact)输入Working Memory。
        ⑵使用Pattern Matcher比较规则库(rule base)中的规则(rule)和数据(fact)。
        ⑶如果执行规则存在冲突(conflict),即同时激活了多个规则,将冲突的规则放入冲突集合。
        ⑷解决冲突,将激活的规则按顺序放入Agenda。
        ⑸使用执行引擎执行Agenda中的规则。重复步骤⑵至⑸,直到执行完毕所有Agenda中的规则。
      上述即是规则引擎的原始架构,Java规则引擎就是从这一原始架构演变而来的。

    规则引擎的相关构件:

      规则引擎是一种根据规则中包含的指定过滤条件,判断其能否匹配运行时刻的实时条件来执行规则中所规定的动作的引擎。与规则引擎相关的有四个基本概念,为更好地理解规则引擎的工作原理,下面将对这些概念进行逐一介绍。

        ⑴信息元(Information Unit)

        信息元是规则引擎的基本建筑块,它是一个包含了特定事件的所有信息的对象。这些信息包括:消息、产生事件的应用程序标识、事件产生事件、信息元类型、相关规则集、通用方法、通用属性以及一些系统相关信息等等。

        ⑵信息服务(Information Services)

        信息服务产生信息元对象。每个信息服务产生它自己类型相对应的信息元对象。即特定信息服务根据信息元所产生每个信息元对象有相同的格式,但可以有不同的属性和规则集。需要注意的是,在一台机器上可以运行许多不同的信息服务,还可以运行同一信息服务的不同实例。但无论如何,每个信息服务只产生它自己类型相对应的信息元。

        ⑶规则集(Rule Set)

        顾名思义,规则集就是许多规则的集合。每条规则包含一个条件过滤器和多个动作。一个条件过滤器可以包含多个过滤条件。条件过滤器是多个布尔表达式的组合,其组合结果仍然是一个布尔类型的。在程序运行时,动作将会在条件过滤器值为真的情况下执行。除了一般的执行动作,还有三类比较特别的动作,它们分别是:放弃动作(Discard Action)、包含动作(Include Action)和使信息元对象内容持久化的动作。

        ⑷队列管理器(Queue Manager)

        队列管理器用来管理来自不同信息服务的信息元对象的队列。
      如下图所示,处理过程分为四个阶段进行:信息服务接受事件并将其转化为信息元,然后这些信息元被传给队列管理器,最后规则引擎接收这些信息元并应用它们自身携带的规则加以执行,直到队列管理器中不再有信息元。
    在这里插入图片描述

    规则引擎的工作机制:

      下面研究规则引擎的内部处理过程。如下图所示,规则引擎从队列管理器中依次接收信息元,然后依规则的定义顺序检查信息元所带规则集中的规则。规则引擎检查第一个规则并对其条件过滤器求值,如果值为假,所有与此规则相关的动作皆被忽略并继续执行下一条规则。如果第二条规则的过滤器值为真,所有与此规则相关的动作皆依定义顺序执行,执行完毕继续下一条规则。该信息元中的所有规则执行完毕后,信息元将被销毁,然后从队列管理器接收下一个信息元。在这个过程中并未考虑两个特殊动作:放弃动作(Discard Action)和包含动作(Include Action)。放弃动作如果被执行,将会跳过其所在信息元中接下来的所有规则,并销毁所在信息元,规则引擎继续接收队列管理器中的下一个信息元。包含动作其实就是动作中包含其它现存规则集的动作。包含动作如果被执行,规则引擎将暂停并进入被包含的规则集,执行完毕后,规则引擎还会返回原来暂停的地方继续执行。这一过程将递归进行。
    在这里插入图片描述
      Java规则引擎的工作机制与上述规则引擎机制十分类似,只不过对上述概念进行了重新包装组合。Java规则引擎对提交给引擎的Java数据对象进行检索,根据这些对象的当前属性值和它们之间的关系,从加载到引擎的规则集中发现符合条件的规则,创建这些规则的执行实例。这些实例将在引擎接到执行指令时、依照某种优先序依次执行。一般来讲,Java规则引擎内部由下面几个部分构成:工作内存(Working Memory)即工作区,用于存放被引擎引用的数据对象集合;规则执行队列,用于存放被激活的规则执行实例;静态规则区,用于存放所有被加载的业务规则,这些规则将按照某种数据结构组织,当工作区中的数据发生改变后,引擎需要迅速根据工作区中的对象现状,调整规则执行队列中的规则执行实例。Java规则引擎的结构示意图如下图所示。
    在这里插入图片描述
      当引擎执行时,会根据规则执行队列中的优先顺序逐条执行规则执行实例,由于规则的执行部分可能会改变工作区的数据对象,从而会使队列中的某些规则执行实例因为条件改变而失效,必须从队列中撤销,也可能会激活原来不满足条件的规则,生成新的规则执行实例进入队列。于是就产生了一种“动态”的规则执行链,形成规则的推理机制。这种规则的“链式”反应完全是由工作区中的数据驱动的。
      任何一个规则引擎都需要很好地解决规则的推理机制和规则条件匹配的效率问题。规则条件匹配的效率决定了引擎的性能,引擎需要迅速测试工作区中的数据对象,从加载的规则集中发现符合条件的规则,生成规则执行实例。1982年美国卡耐基·梅隆大学的 Charles L. Forgy发明了一种叫Rete算法,很好地解决了这方面的问题。目前世界顶尖的商用业务规则引擎产品基本上都使用Rete算法。
    Rete算法浅析

    Java规则引擎API(JSR-94):

      过去大部分的规则引擎开发并没有规范化,有其自有的API,这使得其与外部程序交互集成不够灵活。转而使用另外一种产品时往往意味需要重写应用程序逻辑和API调用,代价较大。为了使规则引擎技术标准化,Java社区制定了Java规则引擎API(JSR-94)规范。它为Java平台访问规则引擎定义了一些简单的API。
      Java规则引擎API由javax.rules包定义,是访问规则引擎的标准企业级API。Java规则引擎API允许客户程序使用统一的方式和不同厂商的规则引擎产品交互,就像使用JDBC编写独立于厂商访问不同的数据库产品一样。Java规则引擎API包括创建和管理规则集合的机制,在Working Memory中添加,删除和修改对象的机制,以及初始化,重置和执行规则引擎的机制。

      Java规则引擎API分为两个主要部分:规则管理API(the rules administration API)和运行时客户API(the Runtime client API)。

        ⑴规则管理API:

        规则管理API在javax.rules.admin中定义,包括装载规则以及与规则对应的动作(执行集 execution sets)以及实例化规则引擎。规则可以从外部资源中装载,比如URI,Input streams,XML streams和readers等等。同时管理API提供了注册和取消注册执行集以及对执行集进行维护的机制。使用admin包定义规则有助于对客户访问运行规则进行控制管理,它通过在执行集上定义许可权使得未经授权的用户无法访问受控规则。
        管理API使用类RuleServiceProvider来获得规则管理(RuleAdministrator)接口的实例。规则管理接口提供方法注册和取消注册执行集。规则管理器(RuleAdministrator)提供了本地和远程的RuleExecutionSetProvider。在前面已提及,RuleExecutionSetProvider负责创建规则执行集。规则执行集可以从如XML streams,input streams等来源中创建。这些数据来源及其内容经汇集和序列化后传送到远程的运行规则引擎的服务器上。大多数应用程序中,远程规则引擎或远程规则数据来源的情况并不多见。为了避免这些情况中的网络开销,API规定了可以从运行在同一JVM中规则库中读取数据的本地RuleExecutionSetProvider。
        规则执行集接口除了拥有能够获得有关规则执行集的方法,还有能够检索在规则执行集中定义的所有规则对象。这使得客户能够知道规则集中的规则对象并且按照自己需要来使用它们。

        ⑵运行时客户API:

        运行时API定义在javax.rules包中,为规则引擎用户运行规则获得结果提供了类和方法。运行时客户只能访问那些使用规则管理API注册过的规则,运行时API帮助用户获得规则对话并且在这个对话中执行规则。
        运行时API提供了对厂商规则引擎API实现的类似于JDBC的访问方法。规则引擎厂商通过类RuleServiceProvider(类RuleServiceProvider提供了对具体规则引擎实现的运行时和管理API的访问)将其规则引擎实现提供给客户,并获得RuleServiceProvider唯一标识规则引擎的URL。
        URL推荐标准用法是使用类似“com.mycompany.myrulesengine.rules.RuleServiceProvider”这样的Internet域名空间,这将有助于访问URL的唯一性。类RuleServiceProvider内部实现了规则管理和运行时访问所需的接口。所有的RuleServiceProvider要想被客户所访问都必须用RuleServiceProviderManager进行注册。注册方式类似于JDBC API的DriverManager和Driver。
        运行时接口是运行时API的关键部分。运行时接口提供了用于创建规则会话(RuleSession)的方法,规则会话如前所述是用来运行规则的。运行时API同时也提供了访问在service provider注册过的所有规则执行集(RuleExecutionSets)。规则会话接口定义了客户使用的会话的类型,客户根据自己运行规则的方式可以选择使用有状态会话或者无状态会话。
        无状态会话的工作方式就像一个无状态会话bean。客户可以发送单个输入对象或一列对象来获得输出对象。当客户需要一个与规则引擎间的专用会话时,有状态会话就很有用。输入的对象通过addObject() 方法可以加入到会话当中。同一个会话当中可以加入多个对象。对话中已有对象可以通过使用updateObject()方法得到更新。只要客户与规则引擎间的会话依然存在,会话中的对象就不会丢失。
        RuleExecutionSetMetaData接口提供给客户让其查找规则执行集的元数据(metadata)。元数据通过规则会话接口(RuleSession Interface)提供给用户。

      Java规则引擎API安全问题:

        规则引擎API将管理API和运行时API加以分开,从而为这些包提供了较好粒度的安全控制。规则引擎API并没有提供明显的安全机制,它可以和J2EE规范中定义的标准安全API联合使用。安全可以由以下机制提供,如Java 认证和授权服务(JAAS),Java加密扩展(JCE),Java安全套接字扩展(JSSE),或者其它定制的安全API。使用JAAS可以定义规则执行集的许可权限,从而只有授权用户才能访问。

      异常与日志:

        规则引擎API定义了javax.rules.RuleException作为规则引擎异常层次的根类。所有其它异常都继承于这个根类。规则引擎中定义的异常都是受控制的异常(checked exceptions),所以捕获异常的任务就交给了规则引擎。规则引擎API没有提供明确的日志机制,但是它建议将Java Logging API用于规则引擎API。

    规则引擎的优势:

      ①声明式编程。

      规则引擎允许你描述做什么而不是如何去做。(规则比编码更容易阅读)

      ②逻辑与数据分离。

      数据保存在系统对象中,逻辑保存在规则中。这根本性的打破了面向对象系统中将数据和逻辑耦合起来的局面。这样做的结果是,将来逻辑发生改变时更容易被维护,因为逻辑保存在规则中。这点在逻辑是跨领域或多领域中使用时尤其有用。通过将逻辑集中在一个或数个清晰的规则文件中,取代了之前分散在代码中的局面。

      ③速度及可测量性。

      Rete算法、Leaps算法,以及由此衍生出来的Drools的Rete、Leaps算法,提供了对系统数据对象非常有效率的匹配。这些都是高效率尤其当你的数据是不完全的改变(规则引擎能够记得之前的匹配)。这些算法经过了大量实际考验的证明。

      ④知识集中化。

      通过使用规则,将建立一个可执行的规则库。这意味着规则库代表着现实中的业务策略的唯一对应,理想情况下可读性高的规则还可以被当作文档使用。

      ⑤工具集成。

      常见的IDE工具为规则的修改与管理、即时获得反馈、内容验证与修补提供了可靠支持。

      ⑥解释机制。

      通过将规则引擎的决断与决断的原因一起记录下来,规则系统提供了很好的“解释机制”。

      ⑦易懂的规则。

      通过建立对象模型以及DSL(域定义语言),你可以用接近自然语言的方式来编写规则。这让非技术人员与领域专家可以用他们自己的逻辑来理解规则(因为程序的复杂性已经被隐藏起来了) 。

    规则引擎的应用场景:

      相对于业务系统,规则引擎可以认为是一个独立于业务系统的模块,负责一些规则的计算等。
      一般来说,规则引擎主要应用在下面的场景中:
        1、风控模型配置,风控规则的设置。
        2、用户积分等配置,如日常操作引起积分变化等。
        3、简单的离线计算,各类数据量比较小的统计等。

    规则引擎的使用注意:

      规则引擎作为一个单独模块,有其自身的笨重与复杂,并不是所有相关业务系统都需要引入规则引擎。
        1、必须建立一些数据模型。
        2、考虑规则的冲突、优先级等。
        3、控制规则的复杂度,以免给规则配置人员增加过多的学习成本。
      由此可见,对于一些时间周期短、规则复杂且不常变更的项目,规则引擎并不十分适用。


    二、规则引擎选型比较:

    常用规则引擎:

      目前的规则引擎系统中,使用较多的开源规则引擎是Drools,另外还有商用的规则管理系统BRMS是ILOG JRules。这两款规则引擎设计和实现都比较复杂,学习成本高,适用于大型应用系统。

      ①Drools:

      Drools 是用 Java 语言编写的开放源码规则引擎,基于Apache协议,基于RETE算法,于2005年被JBoss收购。

      特性:

        1、简化系统架构,优化应用。
        2、提高系统的可维护性和维护成本。
        3、方便系统的整合。
        4、减少编写“硬代码”业务规则的成本和风险。

      ②Ilog JRules:

      IBM WebSphere ILOG JRules 是目前业界领先的业务规则管理平台。与传统的由 IT 人员用硬代码来维护规则的做法不同,ILOG JRules 让业务用户能够在不依赖或者有限依赖于 IT 人员的情况下,快速创建、修改、测试和部署业务规则,以满足经常变化的业务需求。ILOG JRules 提供了一整套的工具,帮助开发人员和业务人员进行规则的全生命周期管理。

      主要组件:

        1、Rule Studio(RS) 面向开发人员使用的开发环境,用于规则的建模和编写。
        2、Rule Scenario Manager 规则测试工具。
        3、Rule Team Server(RTS) 基于Web的管理环境,面向业务人员使用,用于规则发布、管理、存储。
        4、Rule Execution Server(RES) 面向运维人员使用,用于规则执行、监控。

      ③Easy Rules:

      Easy Rules 是一款 Java 规则引擎,它的诞生启发自有Martin Fowler 一篇名为 “Should I use a Rules Engine?” 文章。Easy Rules 提供了规则抽象来创建带有条件和操作的规则,以及运行一组规则来评估条件和执行操作的RulesEngine API。

      特性:

        1、轻量级框架和易于学习的API。
        2、基于POJO的开发。
        3、通过高效的抽象来定义业务规则并轻松应用它们。
        4、支持创建复合规则。
        5、使用表达式语言定义规则的能力。

      ④Jess:

      Jess是Java平台上的规则引擎,它是CLIPS程序设计语言的超集,由Sandia国家实验室的Ernest Friedman-Hill开发。Jess提供适合自动化专家系统的逻辑编程,它常被称作“专家系统外壳”。近年来,智能代理系统也在相似的能力上发展起来。

      ⑤Visual Rules:

      旗正VisualRules是由国家科技部和财政部的创新基金支持,专门针对国内规则引擎市场空白的情况,结合国内项目的特点而开发的一款业务规则管理系统(BRMS)产品。

      ⑥Aviator:

      Aviator是一个高性能、轻量级的java语言实现的表达式求值引擎,主要用于各种表达式的动态求值。
      详见:Aviator学习笔记

    展开全文
  • 流程/规则引擎框架-Baikal介绍

    千次阅读 2020-09-11 15:56:18
    但往往这类活动变动性较大,持续性较短,因为活动玩法的不断扩充与产品运营的脑洞不断扩大,刚开始写的一系列通用的规则往往付之一炬,久而久之,就只剩下一些相对独立的抽象出来的基本模块,让后再通过摞代码方式将...
  • 规则引擎详解

    千次阅读 2018-12-21 21:16:00
    规则引擎(flagleader)由推理引擎发展而来,是一种嵌入在应用程序中的组件,实现了将业务决策从应用程序代码中分离出来,并使用预定义的语义模块编写业务决策。接受数据输入,解释业务规则,并根据业务规则做出业务...
  • Drool规则引擎详解(一)

    万次阅读 2018-12-25 15:29:17
    Drools是一个基于java的规则引擎,开源的,可以将复杂多变的规则从硬编码中解放出来,以规则脚本的形式存放在文件中,使得规则的变更不需要修正代码重启机器就可以立即在线上环境生效。 &amp;nbsp;本文所使用的...
  • 规则引擎

    千次阅读 2018-01-03 10:08:51
    规则引擎现在很多商用软件开发本质为对于规则的一种软件化开发,对规则的实现,通过定义一个规则引擎可以更快更方便的实现标准业务下的业务流程,简化开发过程保证了绝大部分业务流程可以通过配置完成。 一、概要 ...
  • 常见规则引擎技术

    万次阅读 2013-10-17 09:10:29
    目前最好的商用规则管理系统BRMS是ILOG JRules,最普遍使用的开源规则引擎是Drools,Java规则引擎的规范是JSR94,分别简要介绍如下: (1)ILOG JRules ILOG JRules 是ILOG 的旗舰级企业规则引擎产品,ILOG JRules ...
  • 29款 业务规则引擎开源软件

    万次阅读 2016-06-05 09:29:01
    业务规则平台 JBoss BRMS JBoss BRMS 是红帽公司的企业业务规则管理系统(BRMS)产品线,帮助构建智能化、集成化的企业。 包括集成业务规则管理、业务流程管理(BPM)和复杂事件处理(CEP)的支持。BRMS ...
  • 开源规则引擎Drools、URule简介

    万次阅读 2018-07-02 13:56:42
    最近要开始做一个风控项目,大概看了下有很多指标,于是决定调研一下开源业务规则引擎。首先我们要明白什么是规则引擎规则引擎是一种嵌套在应用程序中的组件,实现将业务规则从应用程序代码中分离出来。规则引擎...
  • 《Drools7.0.0.Final规则引擎教程》第1章 Drools简介

    万次阅读 多人点赞 2017-07-11 18:59:17
    1.1 什么是规则引擎规则引擎是由推理引擎发展而来,是一种嵌入在应用程序中的组件,实现了将业务决策从应用程序代码中分离出来,并使用预定义的语义模块编写业务决策。接受数据输入,解释业务规则,并根据业务规则...
  • 建立规则应用、发布RES、生成调用规则的WebService客户端。 1. 建立xom java bean项目。   2. 建立rule project   选择1中的java项目   3. 在2中项目内将bom的属性中文化 双击属性 点击编辑       输
  • Java规则引擎工作原理及其应用

    千次阅读 2016-06-05 08:44:49
     目前,Java社区推动并发展了一种引人注目的新技术——Java规则引擎(Rule Engine)。利用它就可以在应用系统中分离商业决策者的商业决策逻辑和应用开发者的技术决策,并把这些商业决策放在中心数据库或其他统一的...
  • 规则引擎的出现就是制定一套规则检验的模型,下面来看下具体的设计。 核心UML图 组件介绍 主要分为以下三个关键模块 规则实体 存储规则属性 规则检验器 执行规则检验,检验不通过可以自定义文案,该文案可以展示给...
  • 规则引擎使用特定的语法编写业务规则,规则引擎可以接受数据输入、解释业务规则、并根据业务规则做出相应的决策。   通俗来说,规则引擎就是负责执行系统中规则的插件,亦可以作为一个远程系统供业务系统调用。 ...
  • 旗正规则引擎设计思路

    千次阅读 2011-05-03 11:10:00
     很多人都有疑惑,既然已经有很多成熟的规则引擎产品,并且开源的规则引擎产品也有很多,应用也很广泛,又何必去搞一个商业的规则引擎产品呢。在国内的环境下,并不认同这类商业的中间件产品,特别是国产的。...
  • CEP之于Drools规则引擎

    千次阅读 2017-02-04 10:49:06
    接受大量的数据输入,解释业务规则,并根据业务规则做出业务决策; 复杂系统开发面临的现状_ _ _引入CEP的好处_ _ _ 对于CEP使用人员: 把业务规则的创建、修改和维护的权利交给业务人员; 提高业务灵活性; 加强...
  • Drools7规则引擎入门教程

    万人学习 2019-12-30 11:03:29
    Drools规则引擎是一种嵌套在应用程序中的组件,它实现了将业务规则从应用程序代码中分离出来。本次课程的主要内容分为以下几个方面: 1.规则引擎、 Drools规则引擎简介 2.Drools规则引擎各类基础知识点讲解,如...
  • 通过本系列教程的学习,从零基础到完成项目集成,带你快速进入Drools规则引擎的世界。课程内容详细,适用于初学者。
1 2 3 4 5 ... 20
收藏数 237,378
精华内容 94,951
关键字:

规则引擎