bizruleengine.java

这个是使用java开发的一个平台

package com.exp.bizatom.auto.rule;

import java.util.StringTokenizer;
import java.util.Vector;

import com.exp.bizatom.auto.BizAutoAtomUtil;
import com.exp.bizatom.auto.FunctionStack;
import com.exp.fcl.util.NumberUtil;

/**
 * 业务规则计算引擎
 * <p>
 * Title: jstrd 基础技术平台
 * </p>
 * <p>
 * Description: jstrd 基础技术平台
 * </p>
 * <p>
 * Copyright: Copyright (c)  jstrd 2004-2008
 * </p>
 * <p>
 * Company: jstrd
 * </p>
 * 
 * @author zhanghf
 * @version 3.0.0.0
 */
public class BizRuleEngine {
    private static final String RULE_NOTNULL = "!=null";

    private static final String RULE_ISNULL = "=null";

    private static final String LOGIC_MOST = ">=";

    private static final String LOGIC_LEAST = "<=";

    private static final String LOGIC_MORE = ">";

    private static final String LOGIC_LESS = "<";

    private static final String LOGIC_NOTEQUAL = "!=";

    private static final String LOGIC_EQUAL = "=";

    private static final Vector opts = new Vector();

    protected FunctionStack stack;

    protected String rule;

    public BizRuleEngine(FunctionStack stack, String rule) {
        this.stack = stack;
        this.rule = rule;
    }

    protected String deleteQuotes(String strRule) {
        StringBuffer buf = new StringBuffer(strRule);
        int right2 = buf.lastIndexOf("(");
        while (right2 > -1) {
            int left = buf.indexOf(")", right2);
            if (left > right2) {
                String subRule = buf.substring(right2 + 1, left);
                buf.delete(right2, left + 1);
                if (check(subRule)) {
                    buf.insert(right2, "true");
                } else {
                    buf.insert(right2, "false");
                }
                right2 = buf.lastIndexOf("(");
            } else {
                break;
            }
        }
        return buf.toString();
    }

    public boolean check() {
        return this.check(this.deleteQuotes(this.rule));
    }

    protected boolean check(String subRule) {
        StringBuffer buf = new StringBuffer(subRule);
        String unionOpt = "&";
        int start = 0;
        int unionIndex = 0;
        unionIndex = buf.indexOf(unionOpt, start);
        if (unionIndex == -1) {
            unionOpt = "|";
            unionIndex = buf.indexOf(unionOpt, start);
        }
        if (unionIndex == -1) {
            return this.checkOpt(subRule);
        }
        while (unionIndex >= 0) {
            String strRule = buf.substring(start, unionIndex);
            if (!strRule.equalsIgnoreCase("true")
                    && !strRule.equalsIgnoreCase("false")) {
                boolean ret = this.checkOpt(strRule);
                buf.delete(start, unionIndex);
                if (ret) {
                    buf.insert(start, "true");
                } else {
                    buf.insert(start, "false");
                }
            }
            start = unionIndex + 1;
            unionIndex = buf.indexOf(unionOpt, start);
            if (unionIndex == -1) {
                unionOpt = "|";
                unionIndex = buf.indexOf(unionOpt, start);
            }
        }
        int len = buf.length();
        boolean ret = buf.toString().equalsIgnoreCase("true");
        StringTokenizer tokens = new StringTokenizer(buf.toString(), "&|", true);
        if (!tokens.hasMoreTokens()) {
            return ret;
        } else {
            String leftToken = tokens.nextToken();
            ret = this.checkOpt(leftToken);
        }
        while (tokens.hasMoreTokens()) {
            String opt = tokens.nextToken();
            if ("".equals(opt)) {
                return ret;
            } else {
                if (tokens.hasMoreTokens()) {
                    String rightToken = tokens.nextToken();
                    boolean rightValue = this.checkOpt(rightToken);
                    if ("&".equals(opt)) {
                        ret = ret && rightValue;
                    } else if ("|".equalsIgnoreCase(opt)) {
                        ret = ret || rightValue;
                    } else {
                        break;
                    }
                } else {
                    break;
                }
            }
        }
        return ret;
    }

    protected boolean checkOpt(String subRule) {
        if (!"".equals(subRule)) {
            if ("true".equalsIgnoreCase(subRule)) {
                return true;
            }
            if ("false".equalsIgnoreCase(subRule)) {
                return false;
            }
            if (subRule.endsWith(RULE_NOTNULL)) {
                Object target = this.getVariable(subRule.substring(0, subRule
                        .length()
                        - RULE_NOTNULL.length()));
                return target != null;
            }
            if (subRule.endsWith(RULE_ISNULL)) {
                Object target = this.getVariable(subRule.substring(0, subRule
                        .length()
                        - RULE_ISNULL.length()));
                return target == null;
            }
            int index = subRule.indexOf(LOGIC_MOST);
            if (index > 0) {
                String value1 = subRule.substring(0, index);
                String value2 = subRule.substring(index + LOGIC_MOST.length());
                double dValue1 = Double.valueOf(
                        (String) this.getVariable(value1)).doubleValue();
                double dValue2 = Double.valueOf(
                        (String) this.getVariable(value2)).doubleValue();
                return dValue1 >= dValue2;
            }
            index = subRule.indexOf(LOGIC_LEAST);
            if (index > 0) {
                String value1 = subRule.substring(0, index);
                String value2 = subRule.substring(index + LOGIC_LEAST.length());
                double dValue1 = Double.valueOf(
                        (String) this.getVariable(value1)).doubleValue();
                double dValue2 = Double.valueOf(
                        (String) this.getVariable(value2)).doubleValue();
                return dValue1 <= dValue2;
            }
            index = subRule.indexOf(LOGIC_MORE);
            if (index > 0) {
                String value1 = subRule.substring(0, index);
                String value2 = subRule.substring(index + LOGIC_MORE.length());
                double dValue1 = Double.valueOf(
                        (String) this.getVariable(value1)).doubleValue();
                double dValue2 = Double.valueOf(
                        (String) this.getVariable(value2)).doubleValue();
                return dValue1 > dValue2;
            }
            index = subRule.indexOf(LOGIC_LESS);
            if (index > 0) {
                String value1 = subRule.substring(0, index);
                String value2 = subRule.substring(index + LOGIC_LESS.length());
                double dValue1 = Double.valueOf(
                        (String) this.getVariable(value1)).doubleValue();
                double dValue2 = Double.valueOf(
                        (String) this.getVariable(value2)).doubleValue();
                return dValue1 < dValue2;
            }
            index = subRule.indexOf(LOGIC_NOTEQUAL);
            if (index > 0) {
                String value1 = subRule.substring(0, index);
                String value2 = subRule.substring(index
                        + LOGIC_NOTEQUAL.length());
                value1 = (String) this.getVariable(value1);
                value2 = (String) this.getVariable(value2);
                if (NumberUtil.isDigital(value1)
                        && NumberUtil.isDigital(value2)) {
                    double dValue1 = Double.valueOf(value1).doubleValue();
                    double dValue2 = Double.valueOf(value2).doubleValue();
                    return dValue1 != dValue2;
                } else {
                    if (value1 != null) {
                        return !value1.equals(value2);
                    } else if (value2 != null) {
                        return !value2.equals(value1);
                    } else {
                        return true;
                    }
                }
            }
            index = subRule.indexOf(LOGIC_EQUAL);
            if (index > 0) {
                String value1 = subRule.substring(0, index);
                String value2 = subRule.substring(index + LOGIC_EQUAL.length());
                value1 = (String) this.getVariable(value1);
                value2 = (String) this.getVariable(value2);
                if (NumberUtil.isDigital(value1)
                        && NumberUtil.isDigital(value2)) {
                    double dValue1 = Double.valueOf(value1).doubleValue();
                    double dValue2 = Double.valueOf(value2).doubleValue();
                    return dValue1 == dValue2;
                } else {
                    if (value1 != null) {
                        return value1.equals(value2);
                    } else if (value2 != null) {
                        return value2.equals(value1);
                    } else {
                        return true;
                    }
                }
            }
            throw new RuntimeException("规则表达式非法！");
        } else {
            return false;
        }
    }

    protected Object getVariable(String name) {
        if (name.startsWith("@")) {
            return name.substring(1);
        } else {
            if (this.stack != null) {
                return BizAutoAtomUtil.getRealValue(this.stack, name.trim());
            } else {
                return null;
            }
        }
    }
}