如果你是想要知道Rete算法，那么小编深有体会，专门为你找到了非常适合你的文章，通过阅读你或许就能找到答案。

ETE是什么时间

ETE在时间中是预计途中时间。

ETE：abbr.教育及训练机构（Educational and Training Establishment)；电子测试装备（Electronic Test Equipment)；应急收发报设备（Emergency Transceiver Equipment)。

例句：

ETE Algorithm is a pattern match algorithm with a high efficiency.

RETE算法是一种效率很高的模式匹配算法。

Influence of comp ete practice of ATC on the competing power of Chinese textile industry.

ATC协议的完全实施对中国纺织行业竞争力的影响。

Java规则引擎如何集成

Java 规则引擎是一种嵌入在 Java 程序中的组件，它的任务是把当前提交给引擎的 Java 数据对象 ( 原料 ) 与加载在引擎中的业务规则（ app ）进行测试和比对，激活那些符合当前数据状态下的业务规则，根据业务规则中声明的执行逻辑，触发应用程序中对应的操作。

引言：

目前， Java 社区推动并发展了一种引人注目的新技术 ——Java 规则引擎（ Rule Engine ）。利用它就可以在应用系统中分离商业决策者的商业决策逻辑和应用开发者的技术决策，并把这些商业决策放在中心数据库或其他统一的地方，让它们能在运行时可以动态地管理和修改，从而为企业保持灵活性和竞争力提供有效的技术支持。

规则引擎的原理

1 、基于规则的专家系统（ RBES ）简介

Java 规则引擎起源于基于规则的专家系统，而基于规则的专家系统又是专家系统的其中一个分支。专家系统属于人工智能的范畴，它模仿人类的推理方式，使用试探性的方法进行推理，并使用人类能理解的术语解释和证明它的推理结论。为了更深入地了解 Java 规则引擎，下面简要地介绍基于规则的专家系统。 RBES 包括三部分：Rule Base （ knowledge base ）、 Working Memory （ fact base ）和 Inference Engine 。它们的结构如下系统所示：

图 1 基于规则的专家系统构成

如图 1 所示，推理引擎包括三部分：模式匹配器（ Pattern Matcher ）、议程（ Agenda ）和执行引擎（Execution Engine ）。推理引擎通过决定哪些规则满足事实或目标，并授予规则优先级，满足事实或目标的规则被加入议程。模式匹配器决定选择执行哪个规则，何时执行规则；议程管理模式匹配器挑选出来的规则的执行次序；执行引擎负责执行规则和其他动作。

和人类的思维相对应，推理引擎存在两者推理方式：演绎法（ Forward-Chaining ）和归纳法（ Backward-Chaining ）。演绎法从一个初始的事实出发，不断地应用规则得出结论（或执行指定的动作）。而归纳法则是根据假设，不断地寻找符合假设的事实。 Rete 算法是目前效率最高的一个 Forward-Chaining 推理算法，许多 Java 规则引擎都是基于 Rete 算法来进行推理计算的。

推理引擎的推理步骤如下：

(1) 将初始数据（ fact ）输入 Working Memory 。

(2) 使用 PatternMatcher 比较规则库（ rule base ）中的规则（ rule ）和数据（ fact ）。

(3) 如果执行规则存在冲突（ conflict ），即同时激活了多个规则，将冲突的规则放入冲突集合。

(4) 解决冲突，将激活的规则按顺序放入 Agenda 。

(5) 使用执行引擎执行 Agenda 中的规则。重复步骤 2 至 5 ，直到执行完毕所有 Agenda 中的规则。

上述即是规则引擎的原始架构， Java 规则引擎就是从这一原始架构演变而来的。

2 、规则引擎相关构件

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

1) 信息元（ InformationUnit ）

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

2) 信息服务（ InformationServices ）

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

3) 规则集（ Rule Set ）

顾名思义，规则集就是许多规则的集合。每条规则包 含一个条件过滤器 和多个动作 。一个条件过滤器可以包含多个过滤条件。条件过滤器是多个布尔表达式的组合，其组合结果仍然是一个布尔类型的。在程序运行时， 动作将会在条件过滤器值为 true 的情况下执行。除了一般的执行动作，还有三类比较特别的动作，它们分别是：放弃动作（ Discard Action ）、包含动作（ Include Action ）和使信息元对象内容持久化的动作。前两种动作类型的区别将在 2.3 规则引擎工作机制小节介绍。

4) 队列管理器（ QueueManager ）

队列管理器用来管理来自不同信息服务的信息元对象的队列。

下面将研究规则引擎的这些相关构件是如何协同工作的。

如图 2 所示，处理过程分为四个阶段进行：信息服务接受事件并将其转化为信息元，然后这些信息元被传给队列管理器，最后规则引擎接收这些信息元并应用它们自身携带的规则加以执行，直到队列管理器中不再有信息元。

图 2 处理过程协作图

3 、规则引擎的工作机制

下面专门研究规则引擎的内部处理过程。如图 3 所示，规则引擎从队列管理器中依次接收信息元，然后依规则的定义顺序检查信息元所带规则集中的规则（规则已经排队就绪等待信息元的到来）。如图所示，规则引擎检查第一个规则并对其条件过滤器求值，如果值为假，所有与此规则相关的动作皆被忽略并继续执行下一条规则。如果第二条规则的过滤器值为真，所有与此规则相关的动作皆依定义顺序执行，执行完毕继续下一条规则。该信息元中的所有规则执行完毕后，信息元将被销毁 ，然后从队列管理器接收下一个信息元。在这个过程中并未考虑两个特殊动作：放弃动作（ Discard Action ）和包含动作（ Include Action ）。放弃动作如果被执行，将会跳过其所在信息元中接下来的所有规则，并销毁所在信息元，规则引擎继续接收队列管理器中的下一个信息元 ( 就是短路了 ) 。包含动作其实就是动作中包含其它现存规则集的动作。包含动作如果被执行，规则引擎将暂停并进入被包含的规则集，执行完毕后，规则引擎还会返回原来暂停的地方继续执行。这一过程将递归进行。

图 3 规则引擎工作机制

Java 规则引擎的工作机制与上述规则引擎机制十分类似，只不过对上述概念进行了重新包装组合。 Java 规则引擎对提交给引擎的 Java 数据对象进行检索，根据这些对象的当前属性值和它们之间的关系，从加载到引擎的规则集中发现符合条件的规则，创建这些规则的执行实例。这些实例将在引擎接到执行指令时、依照某种优先序依次执行。一般来讲， Java 规则引擎内部由下面几个部分构成：

工作内存（ Working Memory ）即工作区，用于存放被引擎引用的数据对象集合；

规则执行队列，用于存放被激活的规则执行实例 ;

静态规则区，用于存放所有被加载的业务规则，这些规则将按照某种数据结构组织，

当工作区中的数据发生改变后，引擎需要迅速根据工作区中的对象现状，调整规则执行队列中的规则执行实例。Java 规则引擎的结构示意图如图 4 所示。

图 4 Java 规则引擎工作机制

当引擎执行时，会根据规则执行队列中的优先顺序逐条执行规则执行实例，由于规则的执行部分可能会改变工作区的数据对象，从而会使队列中的某些规则执行实例因为条件改变而失效，必须从队列中撤销，也可能会激活原来不满足条件的规则，生成新的规则执行实例进入队列。于是就产生了一种 “ 动态 ” 的规则执行链，形成规则的推理机制。这种规则的 “ 链式 ” 反应完全是由工作区中的数据驱动的。

任何一个规则引擎都需要很好地解决规则的推理机制 和规则条件匹配的效率问题 。规则条件匹配的效率决定了引擎的性能，引擎需要迅速测试工作区中的数据对象，从加载的规则集中发现符合条件的规则，生成规则执行实例。1982 年美国卡耐基 • 梅隆大学的 Charles L. Forgy 发明了一种叫 Rete 算法，很好地解决了这方面的问题。目前世界顶尖的商用业务规则引擎产品基本上都使用 Rete 算法。

求Rete算法实现代码

Rete 在拉丁语中是 ”net” ，有网络的意思。 RETE 算法可以分为两部分：规则编译（ rule compilation ）和运行时执行（ runtime execution ）。

编译算法描述了规则如何在 Production Memory 中产生一个有效的辨别网络。用一个非技术性的词来说，一个辨别网络就是用来过滤数据。方法是通过数据在网络中的传播来过滤数据。在顶端节点将会有很多匹配的数据。当我们顺着网络向下走，匹配的数据将会越来越少。在网络的最底部是终端节点（ terminal nodes ）。在 Dr Forgy 的 1982 年的论文中，他描述了 4 种基本节点： root , 1-input, 2-input and terminal 。下图是 Drools 中的 RETE 节点类型：

Figure 1. Rete Nodes

根节点（ RootNode ）是所有的对象进入网络的入口。然后，从根节点立即进入到 ObjectTypeNode 。 ObjectTypeNode 的作用是使引擎只做它需要做的事情。例如，我们有两个对象集： Account 和 Order 。如果规则引擎需要对每个对象都进行一个周期的评估，那会浪费很多的时间。为了提高效率，引擎将只让匹配 object type 的对象通过到达节点。通过这种方法，如果一个应用 assert 一个新的 account ，它不会将 Order 对象传递到节点中。很多现代 RETE 实现都有专门的 ObjectTypeNode 。在一些情况下， ObjectTypeNode 被用散列法进一步优化。

Figure 2 . ObjectTypeNodes

ObjectTypeNode 能够传播到 AlphaNodes, LeftInputAdapterNodes 和 BetaNodes 。

1-input 节点通常被称为 AlphaNode 。 AlphaNodes 被用来评估字面条件（ literal conditions ）。虽然， 1982 年的论文只提到了相等条件（指的字面上相等），很多 RETE 实现支持其他的操作。例如， Account.name = = “Mr Trout” 是一个字面条件。当一条规则对于一种 object type 有多条的字面条件，这些字面条件将被链接在一起。这是说，如果一个应用 assert 一个 account 对象，在它能到达下一个 AlphaNode 之前，它必须先满足第一个字面条件。在 Dr. Forgy 的论文中，他用 IntraElement conditions 来表述。下面的图说明了 Cheese 的 AlphaNode 组合（ name = = “cheddar” ， strength = = “strong” ）：

Figure 3. AlphaNodes

Drools 通过散列法优化了从 ObjectTypeNode 到 AlphaNode 的传播。每次一个 AlphaNode 被加到一个 ObjectTypeNode 的时候，就以字面值（ literal value ）作为 key ，以 AlphaNode 作为 value 加入 HashMap 。当一个新的实例进入 ObjectTypeNode 的时候，不用传递到每一个 AlphaNode ，它可以直接从 HashMap 中获得正确的 AlphaNode ，避免了不必要的字面检查。

!--[if !supportEmptyParas]--

2-input 节点通常被称为 BetaNode 。 Drools 中有两种 BetaNode ： JoinNode 和 NotNode 。 BetaNodes 被用来对 2 个对象进行对比。这两个对象可以是同种类型，也可以是不同类型。

我们约定 BetaNodes 的 2 个输入称为左边（ left ）和右边（ right ）。一个 BetaNode 的左边输入通常是 a list of objects 。在 Drools 中，这是一个数组。右边输入是 a single object 。两个 NotNode 可以完成‘ exists ’检查。 Drools 通过将索引应用在 BetaNodes 上扩展了 RETE 算法。下图展示了一个 JoinNode 的使用：

Figure 4 . JoinNode

注意到图中的左边输入用到了一个 LeftInputAdapterNode ，这个节点的作用是将一个 single Object 转化为一个单对象数组（ single Object Tuple ），传播到 JoinNode 节点。因为我们上面提到过左边输入通常是 a list of objects 。

!--[if !supportEmptyParas]--

Terminal nodes 被用来表明一条规则已经匹配了它的所有条件（ conditions ）。 在这点，我们说这条规则有了一个完全匹配（ full match ）。在一些情况下，一条带有“或”条件的规则可以有超过一个的 terminal node 。

Drools 通过节点的共享来提高规则引擎的性能。因为很多的规则可能存在部分相同的模式，节点的共享允许我们对内存中的节点数量进行压缩，以提供遍历节点的过程。下面的两个规则就共享了部分节点：

这里我们先不探讨这两条 rule 到的是什么意思，单从一个直观的感觉，这两条 rule 在它们的 LHS 中基本都是一样的，只是最后的 favouriteCheese ，一条规则是等于 $cheddar ，而另一条规则是不等于 $cheddar 。下面是这两条规则的节点图：

Figure 5 . Node Sharing

从图上可以看到，编译后的 RETE 网络中， AlphaNode 是共享的，而 BetaNode 不是共享的。上面说的相等和不相等就体现在 BetaNode 的不同。然后这两条规则有各自的 Terminal Node 。

!--[if !supportEmptyParas]--

RETE 算法的第二个部分是运行时（ runtime ）。当一个应用 assert 一个对象，引擎将数据传递到 root node 。从那里，它进入 ObjectTypeNode 并 沿着网络向下传播。当数据匹配一个节点的条件，节点就将它记录到相应的内存中。这样做的原因有以下几点：主要的原因是可以带来更快的性能。虽然记住完全或 部分匹配的对象需要内存，它提供了速度和可伸缩性的特点。当一条规则的所有条件都满足，这就是完全匹配。而只有部分条件满足，就是部分匹配。（我觉得引擎 在每个节点都有其对应的内存来储存满足该节点条件的对象，这就造成了如果一个对象是完全匹配，那这个对象就会在每个节点的对应内存中都存有其映象。）

2. Leaps 算法：

Production systems 的 Leaps 算法使用了一种“ lazy ”方法来评估条件（ conditions ）。一种 Leaps 算法的修改版本的实现，作为 Drools v3 的一部分，尝试结合 Leaps 和 RETE 方法的最好的特点来处理 Working Memory 中的 facts 。

古典的 Leaps 方法将所有的 asserted 的 facts ，按照其被 asserted 在 Working Memory 中的顺序（ FIFO ），放在主堆栈中。它一个个的检查 facts ，通过迭代匹配 data type 的 facts 集合来找出每一个相关规则的匹配。当一个匹配的数据被发现时，系统记住此时的迭代位置以备待会的继续迭代，并且激发规则结果（ consequence ）。当结果（ consequence ）执行完成以后，系统就会继续处理处于主堆栈顶部的 fact 。如此反复。

rule

when

Cheese( $chedddar : name == " cheddar " )

$person : Person( favouriteCheese != $cheddar )

then

System.out.println( $person.getName() + " does likes cheddar " );

end

rule

when

Cheese( $chedddar : name == " cheddar " )

$person : Person( favouriteCheese == $cheddar )

then

System.out.println( $person.getName() + " likes cheddar " );

end

本文来自CSDN博客，转载请标明出处：

RETE算法的Rete算法

.Rete算法由 Carnegie Mellon University 的Dr Charles L. Forgy设计发明，

在1974年初次发表他的工作底稿。

单词‘Rete’来自拉丁文的网一词，发音为 ri ti orree-tee。