精华内容
下载资源
问答
  • java规则引擎

    2014-03-24 12:41:39
    java 规则引擎api使用,比如drools
  • java 规则引擎

    2019-11-19 13:08:10
    Java规则引擎商业产品有: l. ILOG公司的JRules(见http://www.ilog.com/produts/jrules/) 2. BlazeSoft公司的Blaze(见http://www.fairisaac.com) 3. Rules4J 4. Java Expert System Shell (JESS)(见...

    Java规则引擎商业产品有:

    l. ILOG公司的JRules(见 http://www.ilog.com/produts/jrules/)
    2. BlazeSoft公司的Blaze(见 http://www.fairisaac.com)
    3. Rules4J
    4. Java Expert System Shell (JESS)(见http://herzberg.ca.sandia.com/jess)

    Jess不是开源项目,它可以免费用于学术研究,但用于商业用途则要收费

    开源项目的实现包括:

    l. Drools项目(见 http://drools.org/
    Drools规则引擎应用Rete算法的改进形式Rete-II算法。从内部机制上讲,它使用了和Forgy的算法相同的概念和方法,但是增加了可与面向对象语言无缝连接的节点类型。

    最近Drools被纳入JBoss门下,更名为JBoss Rules,成为了JBoss应用服务器的规则引擎。

    有一篇入门的介绍文章,见:http://www.blogjava.net/guangnian0412/archive/2006/06/04/50251.aspx

    2. JLisa项目(见 http://jlisa.sourceforge.net/
    JLisa是用来构建业务规则的强大框架,它有着扩展了LISP优秀特色的优点,比Clips还要强大.这些特色对于多范例软件的开发是至关重要的。它实现了JSR94 Rule Engine API。

    3. OFBiz Rule Engine(不支持JSR 94)

    4. Mandarax(见 http://mandarax.sourceforge.net/
    Mandarax是一个规则引擎的纯Java实现。基于反向推理(归纳法)。能够较容易地实现多个数据源的集成。例如,数据库记录能方便地集成为事实集 (facts sets),reflection用来集成对象模型中的功能。支持XML标准(RuleML 0.8)。它提供了一个兼容J2EE的使用反向链接的接口引擎。目前不支持JSR 94。

    还有其他,在我们社区也有相关的介绍,例如:http://www.javaeye.com/topic/7803?page=7

    5、OFBiz Rule Engine - 支持归纳法(Backward chaining).最初代码基于Steven John Metsker的”Building Parsers in Java”,不支持JSR 94

     

    Aviator,EasyRules

    展开全文
  • JAVA规则引擎

    2020-07-31 12:38:23
    1 规则引擎概念 规则引擎是一种根据规则中包含的指定过滤条件,判断其能否匹配运行时刻的实时条件来执行规则中所规定的动作的引擎。 规则引擎由推理引擎发展而来,是一种嵌入在应用程序中的组件,实现了将业务决策从...

    一、概述
    1 规则引擎概念
    规则引擎是一种根据规则中包含的指定过滤条件,判断其能否匹配运行时刻的实时条件来执行规则中所规定的动作的引擎。

        规则引擎由推理引擎发展而来,是一种嵌入在应用程序中的组件,实现了将业务决策从应用程序代码中分离出来,
    并使用预定义的语义模块编写业务决策。
    
    规则引擎具体执行可以分为接受数据输入,解释业务规则,业务决策三个过程。
    

    2 规则引擎优势:
    声明式编程。规则引擎允许你描述做什么而不是如何去做,规则比编码更容易阅读。

       逻辑与数据分离。数据保存在系统对象中,逻辑保存在规则中。打破了面向对象系统中将数据和逻辑耦合起来的局面。
    由于逻辑保存在规则中,将来逻辑发生改变时更容易被维护。通过将逻辑集中在一个或数个清晰的规则文件中,
    取代了之前分散在代码中的局面。
    
      速度及可测量性。Rete算法、Leaps算法,以及由此衍生出来的Drools的Rete、Leaps算法,提供了对系统数据
    对象非常有效率的匹配。这些算法经过了大量实际考验的证明。
    
      知识集中化。通过使用规则,将建立一个可执行的规则库。这意味着规则库代表着现实中的业务策略的唯一对应,
    理想情况下可读性高的规则还可以被当作文档使用。
    
      解释机制。通过将规则引擎的决断与决断的原因一起记录下来,规则系统提供了很好的“解释机制”。
    
      易懂的规则。通过建立对象模型以及DSL(域定义语言),可以用接近自然语言的方式来编写规则。这让非技术人员
    与领域专家可以用他们自己的逻辑来理解规则(因为程序的复杂性已经被隐藏起来了) 。
    

    3 规则引擎应用场景
    相对于业务系统,规则引擎可以认为是一个独立于业务系统的模块,负责一些规则的计算等。一般来说,规则引擎主要应用在下面的场景中:

    风控模型配置,风控规则的设置。
    用户积分等配置,如日常操作引起积分变化等。
    简单的离线计算,各类数据量比较小的统计等。
    注意事项:规则引擎作为一个单独模块,有其自身的笨重与复杂,并不是所有相关业务系统都需要引入规则引擎。

    必须建立一些数据模型。
    考虑规则的冲突、优先级等。
    控制规则的复杂度,以免给规则配置人员增加过多的学习成本。
    由此可见,对于一些时间周期短、规则复杂且不常变更的项目,规则引擎并不十分适用。

    二、原理简介
    通常情况下,Java规则引擎内部由下面几个部分构成:工作内存(Working Memory)即工作区,用于存放被引擎引用的数据对象集合;规则执行队列,用于存放被激活的规则执行实例;静态规则区,用于存放所有被加载的业务规则,这些规则将按照某种数据结构组织,当工作区中的数据发生改变后,引擎需要迅速根据工作区中的对象现状,调整规则执行队列中的规则执行实例。Java规则引擎的结构示意图如图1所示。
    在这里插入图片描述

    图1 规则引擎执行结构图

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

    三、规则引擎选型比较
    以下项目均为开源,超链接中均有其github链接,上面有更为详尽的使用例子。表1 为综合对比结果。

    表 1规则引擎综合对比

    在这里插入图片描述

    3.1 Drools
    Drools是专注于解决业务代码和业务规则分离的引擎。Drools 规则是在 Java 应用程序上运行的,其要执行的步骤顺序由代码确定,Drools 规则引擎将业务规则转换成执行树。具体结构见图2。

    在这里插入图片描述

    图2 Drools流程图

    优点:非常活跃的社区支持;易用;快速的执行速度;在 Java 开发人员中流行;与 Java Rule Engine API
    (JSR 94)兼容。
    

    3.2 MVEL
    MVEL是一个功能强大的基于Java应用程序的表达式语言。作为一个表达式语言,旨在更高的效率,例如:直接支持集合、数组和字符串匹配等操作以及正则表达式。 MVEL用于执行使用Java语法编写的表达式。

       与Java不同,MVEL是动态类型(带有可选分类),也就是说在源文件中是没有类型限制的。一条MVEL表达式,简
    单
    的可以是单个标识符,复杂的则可能是一个充满了方法调用和内部集合创建的庞大的布尔表达式。
    
    目前最新的版本是2.0,具有以下特性:
    

    (1)动态JIT优化器。当负载超过一个确保代码产生的阈值时,选择性地产生字节代码,这大大减少了内存的使用量。新的静态类型检查和属性支持,允许集成类型安全表达;

    (2) 错误报告改善,包括行和列的错误信息;
    
    (3) 新的脚本语言特征。MVEL2.0 包含函数定义,如:闭包,lambda定义,标准循环构造(for, while, 
    do-while, do-until…)。
    
    (4) 改进的集成功能。迎合主流的需求,MVEL2.0支持基础类型的个性化属性处理器,集成到JIT中;
    
    (5) 集成不良,字节码生成编译时间慢,还增加了可扩展性问题;不用字节码生成运行时执行非常慢。
    

    3.3 Easy Rules
    Easy Rules 是一款 Java 规则引擎,easy-rules首先集成了mvel表达式,后续可能集成SpEL的一款轻量级规则引擎,Easy Rules 提供了规则抽象来创建带有条件和操作的规则,以及运行一组规则来评估条件和执行操作的RulesEngine API。

      easy rules有以下特性:轻量级框架;学习成本低;基于POJO;为定义业务引擎提供有用的抽象和简便的应用;
    从原始的规则组合成复杂的规则。它主要包括几个主要的类或接口:Rule,RulesEngine,RuleListener,
    Facts ,以及几个主要的注解:@Action,@Condition,@Fact,@Priority,@Rule
    

    3.4 Aviator
    Aviator是一个高性能、轻量级的java语言实现的表达式求值引擎,主要用于各种表达式的动态求值。Aviator的设计目标是轻量级和高性能 ,相比于Groovy、JRuby的笨重,Aviator非常小。

       但是Aviator的语法受到限制,它不是一门完整的语言,而只是语言的一小部分集合。其次,Aviator的实现
    思路与其他轻量级的求值器很不相同,其他求值器一般都是通过解释的方式运行,而Aviator则是直接将表达式编译
    成Java字节码,交给JVM去执行。其主要特点如下:
    

    (1)支持大部分运算操作符,包括算术操作符、关系运算符、逻辑操作符、正则匹配操作符(=~)、三元表达式?: ,并且支持操作符的优先级和括号强制优先级,具体请看后面的操作符列表;

    (2)支持函数调用和自定义函数;

    (3)支持正则表达式匹配,类似Ruby、Perl的匹配语法,并且支持类Ruby的$digit指向匹配分组。自动类型转换,当执行操作的时候,会自动判断操作数类型并做相应转换,无法转换即抛异常;

    (4)支持传入变量,支持类似a.b.c的嵌套变量访问;

    (5)性能优秀;

    (6)Aviator的限制,没有if else、do while等语句,没有赋值语句,仅支持逻辑表达式、算术表达式、三元表达式和正则匹配,没有位运算符。

    转载: https://my.oschina.net/woniuyi/blog/3119383

    展开全文
  • Java规则引擎

    2019-10-07 11:56:21
    Drools规则引擎 简介: Drools就是为了解决业务代码和业务规则分离的引擎。 Drools 规则是在 Java 应用程序上运行的,其要执行的步骤顺序由代码确定 ,为了实现这一点,Drools 规则引擎将业务规则转换成执行树。 ...

    一. Drools规则引擎

    1. 简介:
    Drools就是为了解决业务代码和业务规则分离的引擎。
    Drools 规则是在 Java 应用程序上运行的,其要执行的步骤顺序由代码确定
    ,为了实现这一点,Drools 规则引擎将业务规则转换成执行树。
    
    1. 特性:
    优点:
       1、简化系统架构,优化应用
       2、提高系统的可维护性和维护成本
       3、方便系统的整合
       4、减少编写“硬代码”业务规则的成本和风险
    

    3.原理:

     

    Drools.png

    1. 使用方式:

    (1)Maven 依赖:

    <dependencies>
        <dependency>
            <groupId>org.kie</groupId>
            <artifactId>kie-api</artifactId>
            <version>6.5.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-compiler</artifactId>
            <version>6.5.0.Final</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
    

    (2)新建配置文件/src/resources/META-INF/kmodule.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <kmodule xmlns="http://jboss.org/kie/6.0.0/kmodule">
        <kbase name="rules" packages="rules">
            <ksession name="myAgeSession"/>
        </kbase>
    </kmodule>
    

    (3)新建drools规则文件/src/resources/rules/age.drl

    import com.lrq.wechatDemo.domain.User               // 导入类
    
    dialect  "mvel"
    
    rule "age"                                      // 规则名,唯一
        when
            $user : User(age<15 || age>60)     //规则的条件部分
        then
            System.out.println("年龄不符合要求!");
    end
    

    工程搭建完毕,效果如图:

    项目结构.png

    测试用例:

    
    /**
     * CreateBy: haleyliu
     * CreateDate: 2018/12/26
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = {"classpath*:applicationContext.xml"})
    public class TestUser {
    
        private static KieContainer container = null;
        private KieSession statefulKieSession = null;
    
        @Test
        public void test(){
            KieServices kieServices = KieServices.Factory.get();
            container = kieServices.getKieClasspathContainer();
            statefulKieSession = container.newKieSession("myAgeSession");
            User user = new User("duval yang",12);
            statefulKieSession.insert(user);
            statefulKieSession.fireAllRules();
            statefulKieSession.dispose();
    
        }
    
    
    
    }
    
    

    二.Aviator表达式求值引擎

    1. 简介:
    Aviator是一个高性能、轻量级的java语言实现的表达式求值引擎,主要用于各
    种表达式的动态求值。现在已经有很多开源可用的java表达式求值引擎,为什
    么还需要Avaitor呢?
    
    Aviator的设计目标是轻量级和高性能 ,相比于Groovy、JRuby的笨重,Aviator
    非常小,加上依赖包也才450K,不算依赖包的话只有70K;当然,Aviator的语法
    是受限的,它不是一门完整的语言,而只是语言的一小部分集合。
    
    其次,Aviator的实现思路与其他轻量级的求值器很不相同,其他求值器一般都
    是通过解释的方式运行,而Aviator则是直接将表达式编译成Java字节码,交给
    JVM去执行。简单来说,Aviator的定位是介于Groovy这样的重量级脚本语言和
    IKExpression这样的轻量级表达式引擎之间。
    
    1. 特性:
    (1)支持大部分运算操作符,包括算术操作符、关系运算符、逻辑操作符、
    正则匹配操作符(=~)、三元表达式?: ,并且支持操作符的优先级和括号强制优
    先级,具体请看后面的操作符列表。
    (2)支持函数调用和自定义函数。
    (3)支持正则表达式匹配,类似Ruby、Perl的匹配语法,并且支持类Ruby的
    $digit指向匹配分组。自动类型转换,当执行操作的时候,会自动判断操作数类
    型并做相应转换,无法转换即抛异常。
    (4)支持传入变量,支持类似a.b.c的嵌套变量访问。
    (5)性能优秀。
    (6)Aviator的限制,没有if else、do while等语句,没有赋值语句,仅支持逻
    辑表达式、算术表达式、三元表达式和正则匹配。没有位运算符
    
    
    1. 整体结构:

       

      整体结构.png

    2. maven依赖:

    <dependency>
        <groupId>com.googlecode.aviator</groupId>
        <artifactId>aviator</artifactId>
        <version>${aviator.version}</version>
    </dependency>
    
    1. 执行方式
      执行表达式的方法有两个:execute()、exec();
      execute(),需要传递Map格式参数
      exec(),不需要传递Map
      示例:
    
    /**
     * CreateBy: haleyliu
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
            // exec执行方式,无需传递Map格式
            String age = "18";
            System.out.println(AviatorEvaluator.exec("'His age is '+ age +'!'", age));
    
    
    
            // execute执行方式,需传递Map格式
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("age", "18");
            System.out.println(AviatorEvaluator.execute("'His age is '+ age +'!'", 
    map));
    
        }
    }
    
    1. 使用函数
      Aviator可以使用两种函数:内置函数、自定义函数
      (1)内置函数

       

      Aviator内置函数.png

    Aviator内置函数.png

    
    /**
     * CreateBy: haleyliu
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
            Map<String,Object> map = new HashMap<>();
            map.put("s1","123qwer");
            map.put("s2","123");
    
      System.out.println(AviatorEvaluator.execute("string.startsWith(s1,s2)",map));
    
        }
    }
    
    
    

    (2)自定义函数

    自定义函数要继承AbstractFunction类,重写目标方法。

    
    /**
     * CreateBy: haleyliu
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
            // 注册自定义函数
            AviatorEvaluator.addFunction(new MultiplyFunction());
            // 方式1
            System.out.println(AviatorEvaluator.execute("multiply(12.23, -2.3)"));
            // 方式2
            Map<String, Object> params = new HashMap<>();
            params.put("a", 12.23);
            params.put("b", -2.3);
            System.out.println(AviatorEvaluator.execute("multiply(a, b)", params));
        }
    
    }
    
    class MultiplyFunction extends AbstractFunction{
        @Override
        public AviatorObject call(Map<String, Object> env, AviatorObject arg1, AviatorObject arg2) {
    
            double num1 = FunctionUtils.getNumberValue(arg1, env).doubleValue();
            double num2 = FunctionUtils.getNumberValue(arg2, env).doubleValue();
            return new AviatorDouble(num1 * num2);
        }
    
        @Override
        public String getName() {
            return "multiply";
        }
    
    }
    
    1. 常用操作符的使用
      (1)操作符列表

       

      操作符列表.png

    (2)常量和变量

     

    常量和变量.png

    (3)编译表达式

    
    /**
    * CreateBy: haleyliu
    * CreateDate: 2018/12/25
    */
    public class Test {
       public static void main(String[] args) {
           String expression = "a+(b-c)>100";
           // 编译表达式
           Expression compiledExp = AviatorEvaluator.compile(expression);
    
           Map<String, Object> env = new HashMap<>();
           env.put("a", 100.3);
           env.put("b", 45);
           env.put("c", -199.100);
    
           // 执行表达式
           Boolean result = (Boolean) compiledExp.execute(env);
           System.out.println(result);
    
       }
    }
    
    

    (4) 访问数组和集合
    List和数组用list[0]和array[0],Map用map.date

    /**
     * CreateBy: haleyliu
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
    
            final List<String> list = new ArrayList<>();
            list.add("hello");
            list.add(" world");
    
            final int[] array = new int[3];
            array[0] = 0;
            array[1] = 1;
            array[2] = 3;
    
            final Map<String, Date> map = new HashMap<>();
            map.put("date", new Date());
    
            Map<String, Object> env = new HashMap<>();
            env.put("list", list);
            env.put("array", array);
            env.put("map", map);
    
            System.out.println(AviatorEvaluator.execute(
                    "list[0]+':'+array[0]+':'+'today is '+map.date", env));
    
        }
    
    }
    

    (5) 三元比较符

    /**
     * CreateBy: haleyliu
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
    
            Map<String, Object> env = new HashMap<String, Object>();
            env.put("a", -5);
            String result = (String) AviatorEvaluator.execute("a>0? 'yes':'no'", env);
            System.out.println(result);
        }
    
    }
    

    (6) 正则表达式匹配

    
    /**
     * CreateBy: haleyliu
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
            String email = "hello2018@gmail.com";
            Map<String, Object> env = new HashMap<String, Object>();
            env.put("email", email);
            String username = (String) AviatorEvaluator.execute("email=~/([\\w0-8]+)@\\w+[\\.\\w+]+/ ? $1 : 'unknow' ", env);
            System.out.println(username);
        }
    }
    

    (7) 变量的语法糖衣

    
    /**
     * CreateBy: haleyliu
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
            User user = new User(1,"jack","18");
            Map<String, Object> env = new HashMap<>();
            env.put("user", user);
    
            String result = (String) AviatorEvaluator.execute(" '[user id='+ user.id + ',name='+user.name + ',age=' +user.age +']' ", env);
            System.out.println(result);
        }
    }
    
    
    /**
     * CreateBy: haleyliu
     * CreateDate: 2018/12/25
     */
    public class User {
    
        private int id;
    
        private String name;
    
        private String age;
    
        public User() {
        }
    
        public User(int id, String name, String age) {
            this.id = id;
            this.name = name;
            this.age = age;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAge() {
            return age;
        }
    
        public void setAge(String age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age='" + age + '\'' +
                    '}';
        }
    
    }
    

    (8) nil对象[任何对象都比nil大除了nil本身]

    nil是Aviator内置的常量,类似java中的null,表示空的值。nil跟null不同的在
    于,在java中null只能使用在==、!=的比较运算符,而nil还可以使用>、>=、
    <、<=等比较运算符。Aviator规定,[任何对象都比nil大除了nil本身]。用户传入
    的变量如果为null,将自动以nil替代。
    
            AviatorEvaluator.execute("nil == nil");  //true 
            AviatorEvaluator.execute(" 3> nil");    //true 
            AviatorEvaluator.execute(" true!= nil");    //true 
            AviatorEvaluator.execute(" ' '>nil ");  //true 
            AviatorEvaluator.execute(" a==nil ");   //true,a is null
    nil与String相加的时候,跟java一样显示为null
    
    

    (9) 日期比较

    
    /**
     * CreateBy: haleyliu
     * CreateDate: 2018/12/25
     */
    public class Test {
        public static void main(String[] args) {
            Map<String, Object> env = new HashMap<String, Object>();
            final Date date = new Date();
            String dateStr = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS").format(date);
            env.put("date", date);
            env.put("dateStr", dateStr);
    
            Boolean result = (Boolean) AviatorEvaluator.execute("date==dateStr",
     env);
            System.out.println(result);
    
            result = (Boolean) AviatorEvaluator.execute("date > '2009-12-20 
    00:00:00:00' ", env);
            System.out.println(result);
    
            result = (Boolean) AviatorEvaluator.execute("date < '2200-12-20 
    00:00:00:00' ", env);
            System.out.println(result);
    
            result = (Boolean) AviatorEvaluator.execute("date ==date ", env);
            System.out.println(result);
    
    
        }
    }
    

    (10) 语法手册

    数据类型

    • Number类型:数字类型,支持两种类型,分别对应Java的Long和Double,也就是说任何整数都将被转换为Long,而任何浮点数都将被转换为Double,包括用户传入的数值也是如此转换。不支持科学计数法,仅支持十进制。如-1、100、2.3等。

    • String类型: 字符串类型,单引号或者双引号括起来的文本串,如'hello world',变量如果传入的是String或者Character也将转为String类型。

    • Bool类型: 常量true和false,表示真值和假值,与java的Boolean.TRUE和Boolean.False对应。

    • Pattern类型: 类似Ruby、perl的正则表达式,以//括起来的字符串,如//d+/,内部实现为java.util.Pattern。

    • 变量类型: 与Java的变量命名规则相同,变量的值由用户传入,如"a"、"b"等

    • nil类型: 常量nil,类似java中的null,但是nil比较特殊,nil不仅可以参与==、!=的比较,也可以参与>、>=、<、<=的比较,Aviator规定任何类型都n大于nil除了nil本身,nil==nil返回true。用户传入的变量值如果为null,那么也将作为nil处理,nil打印为null。

    算术运算符

    Aviator支持常见的算术运算符,包括+ - <tt></tt> / % 五个二元运算符,和一元运算符"-"。其中 - <tt></tt> / %和一元的"-"仅能作用于Number类型。

    "+"不仅能用于Number类型,还可以用于String的相加,或者字符串与其他对象的相加。Aviator规定,任何类型与String相加,结果为String。

    逻辑运算符

    Avaitor的支持的逻辑运算符包括,一元否定运算符"!",以及逻辑与的"&&",逻辑或的"||"。逻辑运算符的操作数只能为Boolean。

    关系运算符

    Aviator支持的关系运算符包括"<" "<=" ">" ">=" 以及"=="和"!=" 。
    &&和||都执行短路规则。

    关系运算符可以作用于Number之间、String之间、Pattern之间、Boolean之间、变量之间以及其他类型与nil之间的关系比较,不同类型除了nil之外不能相互比较。

    Aviator规定任何对象都比nil大除了nil之外。

    匹配运算符

    匹配运算符"=~"用于String和Pattern的匹配,它的左操作数必须为String,右操作数必须为Pattern。匹配成功后,Pattern的分组将存于变量$num,num为分组索引。

    三元运算符

    Aviator没有提供if else语句,但是提供了三元运算符 "?:",形式为 bool ? exp1: exp2。 其中bool必须为结果为Boolean类型的表达式,而exp1和exp2可以为任何合法的Aviator表达式,并且不要求exp1和exp2返回的结果类型一致。

    1. 两种模式
      默认AviatorEvaluator以编译速度优先:
      AviatorEvaluator.setOptimize(AviatorEvaluator.COMPILE);
      你可以修改为运行速度优先,这会做更多的编译优化:
      AviatorEvaluator.setOptimize(AviatorEvaluator.EVAL);

    三.MVEL表达式解析器

    1.简介 :

    MVEL在很大程度上受到Java语法的启发,作为一个表达式语言,也有一些根本
    的区别,旨在更高的效率,例如:直接支持集合、数组和字符串匹配等操作以
    及正则表达式。 MVEL用于执行使用Java语法编写的表达式。
    

    2.特性:

    MVEL是一个功能强大的基于Java应用程序的表达式语言。
    目前最新的版本是2.0,具有以下特性:
    (1). 动态JIT优化器。当负载超过一个确保代码产生的阈值时,选择性地产生字
    节代码,这大大减少了内存的使用量。新的静态类型检查和属性支持,允许集成
    类型安全表达。
    (2). 错误报告的改善。包括行和列的错误信息。
    (3). 新的脚本语言特征。MVEL2.0 包含函数定义,如:闭包,lambda定义,
    标准循环构造(for, while, do-while, do-until…),空值安全导航操作,内联with
    -context运营 ,易变的(isdef)的测试运营等等。
    (4). 改进的集成功能。迎合主流的需求,MVEL2.0支持基础类型的个性化属性处理器,集成到JIT中。
    (5). 更快的模板引擎,支持线性模板定义,宏定义和个性化标记定义。
    (6). 新的交互式shell(MVELSH)。
    
    (7). 缺少可选类型安全
    (8). 集成不良,通常通过映射填入内容。没有字节码不能运作用字节码生成编
    译时间慢,还增加了可扩展性问题;不用字节码生成运行时执行非常慢
    (9). 内存消耗过大
    (10). Jar巨大/依赖规模
    

    3.原理:

    与java不同,MVEL是动态类型(带有可选分类),也就是说在源文件中是没有
    类型限制的。一条MVEL表达式,简单的可以是单个标识符,复杂的则可能是
    一个充满了方法调用和内部集合创建的庞大的布尔表达式。
    

    4.使用方式:
    maven引入jar:

    <dependency>
                <groupId>org.mvel</groupId>
                <artifactId>mvel2</artifactId>
                <version>2.3.1.Final</version>
            </dependency>
    
    

    测试:

    package com.lrq.wechatdemo.utils;
    
    import com.google.common.collect.Maps;
    import org.mvel2.MVEL;
    
    import java.util.Map;
    
    /**
     * CreateBy: haleyliu
     * CreateDate: 2018/12/26
     */
    public class MvelUtils {
    
        public static void main(String[] args) {
            String expression = "a == null && b == nil ";
            Map<String,Object> map = Maps.newHashMap();
            map.put("a",null);
            map.put("b",null);
    
            Object object = MVEL.eval(expression,map);
            System.out.println(object);
        }
    
    }
    

    四.EasyRules规则引擎

    1.简介:

    easy-rules首先集成了mvel表达式,后续可能集成SpEL的一款轻量
    级规则引擎
    

    2.特性:

    easy rules是一个简单而强大的java规则引擎,它有以下特性:
    
    轻量级框架,学习成本低
    基于POJO
    为定义业务引擎提供有用的抽象和简便的应用
    从原始的规则组合成复杂的规则
    它主要包括几个主要的类或接口:Rule,RulesEngine,RuleListener,Facts 
    还有几个主要的注解:@Action,@Condition,@Fact,@Priority,@Rule
    

    3.使用方式:

    @Rule可以标注name和description属性,每个rule的name要唯一,
    如果没有指定,则RuleProxy则默认取类名
    @Condition是条件判断,要求返回boolean值,表示是否满足条件
    
    @Action标注条件成立之后触发的方法
    
    @Priority标注该rule的优先级,默认是Integer.MAX_VALUE - 1,值
    越小越优先
    
    @Fact 我们要注意Facts的使用。Facts的用法很像Map,它是客户
    端和规则文件之间通信的桥梁。在客户端使用put方法向Facts中添
    加数据,在规则文件中通过key来得到相应的数据。
    

    有两种使用方式:

    1. java方式
      首先先创建规则并标注属性
    package com.lrq.wechatdemo.rules;
    
    import org.jeasy.rules.annotation.Action;
    import org.jeasy.rules.annotation.Condition;
    import org.jeasy.rules.annotation.Fact;
    import org.jeasy.rules.annotation.Rule;
    import org.jeasy.rules.support.UnitRuleGroup;
    
    /**
     * CreateBy: haleyliu
     * CreateDate: 2018/12/26
     */
    public class RuleClass {
    
        @Rule(priority = 1) //规则设定优先级
        public static class FizzRule {
            @Condition
            public boolean isFizz(@Fact("number") Integer number) {
                return number % 5 == 0;
            }
    
            @Action
            public void printFizz() {
                System.out.print("fizz\n");
            }
        }
    
        @Rule(priority = 2)
        public static class BuzzRule {
            @Condition
            public boolean isBuzz(@Fact("number") Integer number) {
                return number % 7 == 0;
            }
    
            @Action
            public void printBuzz() {
                System.out.print("buzz\n");
            }
        }
    
        public static class FizzBuzzRule extends UnitRuleGroup {
    
            public FizzBuzzRule(Object... rules) {
                for (Object rule : rules) {
                    addRule(rule);
                }
            }
    
            @Override
            public int getPriority() {
                return 0;
            }
        }
    
        @Rule(priority = 3)
        public static class NonFizzBuzzRule {
    
            @Condition
            public boolean isNotFizzNorBuzz(@Fact("number") Integer number) {
                // can return true, because this is the latest rule to trigger according to
                // assigned priorities
                // and in which case, the number is not fizz nor buzz
                return number % 5 != 0 || number % 7 != 0;
            }
    
            @Action
            public void printInput(@Fact("number") Integer number) {
                System.out.print(number+"\n");
            }
        }
    
    }
    

    然后客户端调用

    package com.lrq.wechatdemo.rules;
    
    import org.jeasy.rules.api.Facts;
    import org.jeasy.rules.api.Rules;
    import org.jeasy.rules.api.RulesEngine;
    import org.jeasy.rules.core.DefaultRulesEngine;
    import org.jeasy.rules.core.RulesEngineParameters;
    
    /**
     * CreateBy: haleyliu
     * CreateDate: 2018/12/26
     */
    public class RuleJavaClient {
        public static void main(String[] args) {
            // 创建规则引擎
            RulesEngineParameters parameters = new RulesEngineParameters().skipOnFirstAppliedRule(true);
            RulesEngine fizzBuzzEngine = new DefaultRulesEngine(parameters);
    
            // 创建规则集并注册规则
            Rules rules = new Rules();
            rules.register(new RuleClass.FizzRule());
            rules.register(new RuleClass.BuzzRule());
            rules.register(new RuleClass.FizzBuzzRule(new RuleClass.FizzRule(), new RuleClass.BuzzRule()));
            rules.register(new RuleClass.NonFizzBuzzRule());
    
            // 执行规则
            Facts facts = new Facts();
            for (int i = 1; i <= 100; i++) {
                facts.put("number", i);
                fizzBuzzEngine.fire(rules, facts);
                System.out.println();
            }
        }
    
    }
    
    

    2.yml方式

    resources目录下新建fizzbuzz.yml

    ---
    name: "fizz rule"
    description: "print fizz if the number is multiple of 5"
    priority: 1
    condition: "number % 5 == 0"
    actions:
    - "System.out.println(\"fizz\")"
    
    ---
    name: "buzz rule"
    description: "print buzz if the number is multiple of 7"
    priority: 2
    condition: "number % 7 == 0"
    actions:
    - "System.out.println(\"buzz\")"
    
    ---
    name: "fizzbuzz rule"
    description: "print fizzbuzz if the number is multiple of 5 and 7"
    priority: 0
    condition: "number % 5 == 0 && number % 7 == 0"
    actions:
    - "System.out.println(\"fizzbuzz\")"
    
    ---
    name: "non fizzbuzz rule"
    description: "print the number itself otherwise"
    priority: 3
    condition: "number % 5 != 0 || number % 7 != 0"
    actions:
    - "System.out.println(number)"
    

    客户端调用:

    package com.lrq.wechatdemo.rules;
    
    import org.jeasy.rules.api.Facts;
    import org.jeasy.rules.api.Rules;
    import org.jeasy.rules.api.RulesEngine;
    import org.jeasy.rules.core.DefaultRulesEngine;
    import org.jeasy.rules.core.RulesEngineParameters;
    import org.jeasy.rules.mvel.MVELRuleFactory;
    
    import java.io.FileNotFoundException;
    import java.io.FileReader;
    
    /**
     * CreateBy: haleyliu
     * CreateDate: 2018/12/26
     */
    public class RuleYmlClient {
    
        public static void main(String[] args) throws FileNotFoundException {
            // create a rules engine
            RulesEngineParameters parameters = new RulesEngineParameters().skipOnFirstAppliedRule(true);
            RulesEngine fizzBuzzEngine = new DefaultRulesEngine(parameters);
    
            // create rules
            Rules rules = MVELRuleFactory.createRulesFrom(new FileReader("fizzbuzz.yml"));
    
            // fire rules
            Facts facts = new Facts();
            for (int i = 1; i <= 100; i++) {
                facts.put("number", i);
                fizzBuzzEngine.fire(rules, facts);
                System.out.println();
            }
        }
    }
    展开全文
  • 作者:废物大师兄出处:https://www.cnblogs.com/cjsblog/p/13088017.html1. Easy Rules 概述Easy Rules是一个Java规则引擎,灵感来自一篇名为《Should I use a Rules Engine?》的文章规则引擎就是提供一种可选的...

    作者:废物大师兄

    出处:https://www.cnblogs.com/cjsblog/p/13088017.html

    1.  Easy Rules 概述

    Easy Rules是一个Java规则引擎,灵感来自一篇名为《Should I use a Rules Engine?》的文章 

    规则引擎就是提供一种可选的计算模型。与通常的命令式模型(由带有条件和循环的命令依次组成)不同,规则引擎基于生产规则系统。这是一组生产规则,每条规则都有一个条件(condition)和一个动作(action)———— 简单地说,可以将其看作是一组if-then语句。

    精妙之处在于规则可以按任何顺序编写,引擎会决定何时使用对顺序有意义的任何方式来计算它们。考虑它的一个好方法是系统运行所有规则,选择条件成立的规则,然后执行相应的操作。这样做的好处是,很多问题都很自然地符合这个模型:

    if car.owner.hasCellPhone then premium += 100;
    if car.model.theftRating > 4 then premium += 200;
    if car.owner.livesInDodgyArea && car.model.theftRating > 2 then premium += 300;

    规则引擎是一种工具,它使得这种计算模型编程变得更容易。它可能是一个完整的开发环境,或者一个可以在传统平台上工作的框架。生产规则计算模型最适合仅解决一部分计算问题,因此规则引擎可以更好地嵌入到较大的系统中。

    你可以自己构建一个简单的规则引擎。你所需要做的就是创建一组带有条件和动作的对象,将它们存储在一个集合中,然后遍历它们以评估条件并执行这些动作。 

    Easy Rules它提供Rule抽象以创建具有条件和动作的规则,并提供RuleEngine API,该API通过一组规则运行以评估条件并执行动作。 

    Easy Rules简单易用,只需两步:

    首先,定义规则,方式有很多种

    方式一:注解

    @Rule(name = "weather rule", description = "if it rains then take an umbrella")public class WeatherRule {    @Condition    public boolean itRains(@Fact("rain") boolean rain) {        return rain;    }    @Action    public void takeAnUmbrella() {        System.out.println("It rains, take an umbrella!");    }}

    方式二:链式编程

    Rule weatherRule = new RuleBuilder()        .name("weather rule")        .description("if it rains then take an umbrella")        .when(facts -> facts.get("rain").equals(true))        .then(facts -> System.out.println("It rains, take an umbrella!"))        .build();

    方式三:表达式

    Rule weatherRule = new MVELRule()        .name("weather rule")        .description("if it rains then take an umbrella")        .when("rain == true")        .then("System.out.println(\"It rains, take an umbrella!\");");

    方式四:yml配置文件

    例如:weather-rule.yml

    name: "weather rule"description: "if it rains then take an umbrella"condition: "rain == true"actions:  - "System.out.println(\"It rains, take an umbrella!\");"
    MVELRuleFactory ruleFactory = new MVELRuleFactory(new YamlRuleDefinitionReader());Rule weatherRule = ruleFactory.createRule(new FileReader("weather-rule.yml"));

    接下来,应用规则

    public class Test {    public static void main(String[] args) {        // define facts        Facts facts = new Facts();        facts.put("rain", true);        // define rules        Rule weatherRule = ...        Rules rules = new Rules();        rules.register(weatherRule);        // fire rules on known facts        RulesEngine rulesEngine = new DefaultRulesEngine();        rulesEngine.fire(rules, facts);    }}

    入门案例:Hello Easy Rules

        org.jeasy    easy-rules-core    4.0.0

    通过骨架创建maven项目:

    mvn archetype:generate \    -DarchetypeGroupId=org.jeasy \    -DarchetypeArtifactId=easy-rules-archetype \    -DarchetypeVersion=4.0.0

    默认给我们生成了一个HelloWorldRule规则,如下:

    package com.cjs.example.rules;import org.jeasy.rules.annotation.Action;import org.jeasy.rules.annotation.Condition;import org.jeasy.rules.annotation.Rule;@Rule(name = "Hello World rule", description = "Always say hello world")public class HelloWorldRule {    @Condition    public boolean when() {        return true;    }    @Action    public void then() throws Exception {        System.out.println("hello world");    }}

    7504b95c747ba96c50cfcb042213b9d2.png

    2.  规则定义

    2.1.  定义规则

    大多数业务规则可以用以下定义表示:

    • Name : 一个命名空间下的唯一的规则名称

    • Description : 规则的简要描述

    • Priority : 相对于其他规则的优先级

    • Facts : 事实,可立即为要处理的数据

    • Conditions : 为了应用规则而必须满足的一组条件

    • Actions : 当条件满足时执行的一组动作 

    Easy Rules为每个关键点提供了一个抽象来定义业务规则。

    在Easy Rules中,Rule接口代表规则

    public interface Rule {    /**    * This method encapsulates the rule's conditions.    * @return true if the rule should be applied given the provided facts, false otherwise    */    boolean evaluate(Facts facts);    /**    * This method encapsulates the rule's actions.    * @throws Exception if an error occurs during actions performing    */    void execute(Facts facts) throws Exception;    //Getters and setters for rule name, description and priority omitted.}

    evaluate方法封装了必须计算结果为TRUE才能触发规则的条件。execute方法封装了在满足规则条件时应该执行的动作。条件和操作由Condition和Action接口表示。

    定义规则有两种方式:

    • 通过在POJO类上添加注解

    • 通过RuleBuilder API编程

    可以在一个POJO类上添加@Rule注解,例如:

    @Rule(name = "my rule", description = "my rule description", priority = 1)public class MyRule {    @Condition    public boolean when(@Fact("fact") fact) {        //my rule conditions        return true;    }    @Action(order = 1)    public void then(Facts facts) throws Exception {        //my actions    }    @Action(order = 2)    public void finally() throws Exception {        //my final actions    }}

    @Condition注解指定规则条件
    @Fact注解指定参数
    @Action注解指定规则执行的动作

    RuleBuilder支持链式风格定义规则,例如:

    Rule rule = new RuleBuilder()                .name("myRule")                .description("myRuleDescription")                .priority(3)                .when(condition)                .then(action1)                .then(action2)                .build();

    组合规则

    CompositeRule由一组规则组成。这是一个典型地组合设计模式的实现。

    组合规则是一个抽象概念,因为可以以不同方式触发组合规则。

    Easy Rules自带三种CompositeRule实现:

    • UnitRuleGroup : 要么应用所有规则,要么不应用任何规则(AND逻辑)

    • ActivationRuleGroup : 它触发第一个适用规则,并忽略组中的其他规则(XOR逻辑)

    • ConditionalRuleGroup : 如果具有最高优先级的规则计算结果为true,则触发其余规则

    复合规则可以从基本规则创建并注册为常规规则:

    //Create a composite rule from two primitive rulesUnitRuleGroup myUnitRuleGroup = new UnitRuleGroup("myUnitRuleGroup", "unit of myRule1 and myRule2");myUnitRuleGroup.addRule(myRule1);myUnitRuleGroup.addRule(myRule2);//Register the composite rule as a regular ruleRules rules = new Rules();rules.register(myUnitRuleGroup);RulesEngine rulesEngine = new DefaultRulesEngine();rulesEngine.fire(rules, someFacts);

    每个规则都有优先级。它代表触发注册规则的默认顺序。默认情况下,较低的值表示较高的优先级。可以重写compareTo方法以提供自定义优先级策略。

    2.2.  定义事实

    在Easy Rules中,Fact API代表事实

    public class Fact {     private final String name;     private final T value;}

    1850fd24365127e88242a0dd4e88a899.png

    举个栗子:

    Fact fact = new Fact("foo", "bar");Facts facts = new Facts();facts.add(fact);

    或者,也可以用这样简写形式

    Facts facts = new Facts();facts.put("foo", "bar");

    用@Fact注解可以将Facts注入到condition和action方法中

    @Ruleclass WeatherRule {    @Condition    public boolean itRains(@Fact("rain") boolean rain) {        return rain;    }    @Action    public void takeAnUmbrella(Facts facts) {        System.out.println("It rains, take an umbrella!");        // can add/remove/modify facts    }}

    2.3.  定义规则引擎

    Easy Rules提供两种RulesEngine接口实现:

    • DefaultRulesEngine : 根据规则的自然顺序应用规则

    • InferenceRulesEngine : 持续对已知事实应用规则,直到不再适用任何规则为止 

    创建规则引擎:

    RulesEngine rulesEngine = new DefaultRulesEngine();// orRulesEngine rulesEngine = new InferenceRulesEngine();

    然后,注册规则

    rulesEngine.fire(rules, facts);

    规则引擎有一些可配置的参数,如下图所示:

    9b62cd4549a820f22a5522715526c925.png

    举个栗子:

    RulesEngineParameters parameters = new RulesEngineParameters()    .rulePriorityThreshold(10)    .skipOnFirstAppliedRule(true)    .skipOnFirstFailedRule(true)    .skipOnFirstNonTriggeredRule(true);RulesEngine rulesEngine = new DefaultRulesEngine(parameters);

    2.4. 定义规则监听器

    通过实现RuleListener接口

    public interface RuleListener {    /**     * Triggered before the evaluation of a rule.     *     * @param rule being evaluated     * @param facts known before evaluating the rule     * @return true if the rule should be evaluated, false otherwise     */    default boolean beforeEvaluate(Rule rule, Facts facts) {        return true;    }    /**     * Triggered after the evaluation of a rule.     *     * @param rule that has been evaluated     * @param facts known after evaluating the rule     * @param evaluationResult true if the rule evaluated to true, false otherwise     */    default void afterEvaluate(Rule rule, Facts facts, boolean evaluationResult) { }    /**     * Triggered on condition evaluation error due to any runtime exception.     *     * @param rule that has been evaluated     * @param facts known while evaluating the rule     * @param exception that happened while attempting to evaluate the condition.     */    default void onEvaluationError(Rule rule, Facts facts, Exception exception) { }    /**     * Triggered before the execution of a rule.     *     * @param rule the current rule     * @param facts known facts before executing the rule     */    default void beforeExecute(Rule rule, Facts facts) { }    /**     * Triggered after a rule has been executed successfully.     *     * @param rule the current rule     * @param facts known facts after executing the rule     */    default void onSuccess(Rule rule, Facts facts) { }    /**     * Triggered after a rule has failed.     *     * @param rule the current rule     * @param facts known facts after executing the rule     * @param exception the exception thrown when attempting to execute the rule     */    default void onFailure(Rule rule, Facts facts, Exception exception) { }}

    3.  示例

      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">    4.0.0    com.cjs.example    easy-rules-quickstart    1.0.0-SNAPSHOT    jar                        org.jeasy            easy-rules-core            4.0.0                            org.jeasy            easy-rules-support            4.0.0                            org.jeasy            easy-rules-mvel            4.0.0                            org.slf4j            slf4j-simple            1.7.30            

    d16c3e5fe80047107534fa7cd1dbbf33.png

    4.  扩展

    规则本质上是一个函数,如y=f(x1,x2,..,xn)

    规则引擎就是为了解决业务代码和业务规则分离的引擎,是一种嵌入在应用程序中的组件,实现了将业务决策从应用程序代码中分离。

    还有一种常见的方式是Java+Groovy来实现,Java内嵌Groovy脚本引擎进行业务规则剥离。

    https://github.com/j-easy/easy-rules/wiki

    如有文章对你有帮助,

    在看”和转发是对我最大的支持

    b98e93e91e1c45bdc8afea4bf0884ba7.gif

    关注Java开发宝典

    每天学习Java技术

    624e53bca59f9b12b1e52a820dfc3c3a.png

    点赞是最大的支持 ef96408ce6bed22b992ecdb7100c432b.gif

    展开全文
  • JAVA 规则引擎

    2018-08-21 13:47:00
    mark
  • 1. Easy Rules 概述Easy Rules是一个Java规则引擎,灵感来自一篇名为《Should I use a Rules Engine?》的文章规则引擎就是提供一种可选的计算模型。与通常的命令式模型(由带有条件和循环的命令依次组成)不同,规则...
  • 第 26 卷 第 6 期2005 年 11 月 微 计 算 机 应 用 ... Java 规则引擎 ———Drools 的介绍及应用 刘 伟 (中国科技大学 合肥 230026) 摘 要 :规则引擎技术是一项很有吸引力的技术。首先介绍了规则引擎的...
  • 1. Easy Rules 概述Easy Rules是一个Java规则引擎,灵感来自一篇名为《Should I use a Rules Engine?》的文章规则引擎就是提供一种可选的计算模型。与通常的命令式模型(由带有条件和循环的命令依次组成)不同,规则...
  • 1. Easy Rules 概述Easy Rules是一个Java规则引擎,灵感来自一篇名为《Should I use a Rules Engine?》的文章规则引擎就是提供一种可选的计算模型。与通常的命令式模型(由带有条件和循环的命令依次组成)不同,规则...
  • RuleEngine--一款使用简单,入门方便的数据库规则引擎_Rewen的专栏-CSDN博客_rulesenginehttps://blog.csdn.net/Rewen/article/details/79387493[Drools]JAVA规则引擎--Drools_quzishen的专栏-CSDN博客_drools规则...
  • Drools and jBPMconsist out of several projects:(Drools软件包提供的几个部分的功能)-----------------------------------------------------------------------------------------------------------------------...
  • Easy Rules是一个简单而强大的Java规则引擎,提供以下功能:轻量级框架和易于学习的API基于POJO的开发与注解的编程模型定义抽象的业务规则并轻松应用它们支持从简单规则创建组合规则的能力支持使用表达式语言(如...
  • //模拟用户指定规则 // String expression = "(redisCount('1','hour',fields('userid,ip,action')) >= 100)&&(redisCount('1','hour',fields('userid,ip,action')) )"; String expression = "redisCount('1','hour...
  • 轻量级规则引擎easy-rules--参考我们在写业务代码经常遇到需要一大堆if/else,会导致...最近在github上面看到一个傻瓜式的Java规则引擎Easy-Rules,这里结合自己写的demo介绍如何使用这个规则引擎,希望对大家有所...
  • Java规则引擎介绍

    2017-09-06 18:53:13
    作者“快乐成长”的JAVA规则引擎总结作者“无信不立”的【java规则引擎】一个基于drools规则引擎实现的数学计算例子
  • java规则引擎说明

    2013-09-14 11:41:52
    本文档对JAVA规则引擎是什么,如何使用进行了详细的说明。
  • Drools 规则是在 Java 应用程序上运行的,其要执行的步骤顺序由代码确定,为了实现这一点,Drools 规则引擎将业务规则转换成执行树。特性:优点: 1、简化系统架构,优化应用 2、提高系统的可维护性和维护成本 3...
  • 规则引擎 规则引擎开发教程 java规则引擎
  • Drools and jBPMconsist out of several projects:(Drools软件包提供的几个部分的功能)-----------------------------------------------------------------------------------------------------------------------...
  • Drools and jBPMconsist out of several projects:(Drools软件包提供的几个部分的功能)-----------------------------------------------------------------------------------------------------------------------...
  • 在本文中,我们将介绍一些最流行的Java规则引擎。 在应用程序中,业务规则很复杂(比如:优惠券的使用规则)。如果用源代码实现这些规则,很繁琐。通过规则引擎将业务逻辑与源代码分离,可以简化开发和维护。 在Java...
  • java规则引擎文档

    2008-09-09 09:24:38
    java规则引擎和J2EE,想更好的了解java规则引擎,就来下载吧!经典之作
  • https://www.cnblogs.com/holbrook/tag/%E8%A7%84%E5%88%99%E5%BC%95%E6%93%8E/ ... 漫话规则引擎(4): Java规则引擎规范:JSR94 Java World似乎总会出现一些接口规范,这样做的好处是可以面向接口编...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,977
精华内容 790
关键字:

java规则引擎

java 订阅