一个类、二个接口实现规则引擎

一、规则流接口

package com.awsle.jrule.impl;
    
/**
 * 规则流接口
 */
public interface RuleProcessImpl {
    
    public String start(Object obj);
        
}

二、规则接口

package com.awsle.jrule.impl;
    
/**
 * 规则接口
 */
public interface RuleImpl {
    
    public Object start(Object obj);
        
}

三、规则脚本执行类

package com.awsle.jrule.util;
    
import java.io.InputStream;
import java.io.InputStreamReader;
    
import javax.script.Invocable;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
    
import com.awsle.jrule.impl.RuleImpl;
import com.awsle.jrule.impl.RuleProcessImpl;
    
/**
 * 规则引擎
 */
public class RuleInvoker {
    
    /**
     * 脚本引擎
     */
    private ScriptEngine engine = null;
    /**
     *
     */
    private ScriptEngineManager engineManager = null;
        
    private Invocable invocable = null;
        
    private InputStreamReader reader = null;
        
    private InputStream inputStream = null;
        
    private RuleProcessImpl ruleProcessImpl = null;
        
    private RuleImpl ruleImpl = null;
        
    /**
     * 执行规则
     * @param obj
     * @return
     */
    public Object execRule(Object obj){
            
        return execRule(obj , "MainRule.rp");
    }
        
    /**
     *
     * @param obj
     * @param rule
     * @return
     */
    public Object execRule(Object obj , String rule){
        //创建规则脚本引擎
        engineManager = new ScriptEngineManager();
        engine = engineManager.getEngineByName("js");
        //读取规则脚本
        ClassLoader classLoader = RuleInvoker.class.getClassLoader();
        inputStream = classLoader.getResourceAsStream(rule);
        reader = new InputStreamReader(inputStream);
        try {
            //执行规则脚本
            engine.eval(reader);
        } catch (ScriptException e) {
            e.printStackTrace();
        }
        finally{
            try {
                if(null != reader){
                    reader.close();
                }
                if(null != inputStream){
                    inputStream.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        invocable = (Invocable)engine;
        if(rule.endsWith(".rp")){
            ruleProcessImpl =  invocable.getInterface(RuleProcessImpl.class);
            rule = ruleProcessImpl.start(obj);
            return execRule(obj , rule);
        }
        else{
            ruleImpl =  invocable.getInterface(RuleImpl.class);
            return ruleImpl.start(obj);
        }
    }
        
}

obj参数为需要进行规则判断的BOM对象。

---

定义*.rp脚本为规则流，其他后缀的为规则脚本（推荐使用*.js），规则脚本使用js脚本语法。

规则和规则流要分别实现规则和规则流的接口

一、规则流的编写

MainRule.rp

function start(obj){
        //此处省略规则走向代码
        //.........
    return "com/awsle/rule/ARule.js";
}

二、规则编写

ARule.js

/**
 * A规则
 * @param obj
 * @returns
 */
function start(obj){
        
    if(obj.sex == '1'){
        obj.result='男人';
    }else if (obj.sex == '0'){
        obj.result='女人';
    }else{
        obj.result='人妖';
    }
    return obj;
}

将规则工程打包成jar导入到规则引擎工程里就可使用。