drools脚本常用语法记录

drools脚本常用语法--------------------------------------------CjwSelfUnderstand
以代码块创建的方法函数为准：

public class DroolsFunction {

  

      /**
         * 判断是否包含
         * @param str
         * @param dest
         * @return
         */
        public static boolean contains(String str, String dest){
            String[] d = dest.split(",");
            for(String s : d){
                if(str.contains(s)){
                    return true;
                }
            }
            return false;
        }
    
        /**
         * list是否包含
         * @param strList
         * @param dest
         * @return
         */
        public static boolean contains(List<String> strList, String dest){
            String[] d = dest.split(",");
            for(String str : strList){
                for(String s : d){
                    if(str.contains(s)){
                        return true;
                    }
                }
            }
            return false;
        }
    
    
        /**
         * 判断不包含
         * @param str
         * @param dest
         * @return
         */
        public static boolean notContains(String str, String dest){
            String[] d = dest.split(",");
            for(String s : d){
                if(str.contains(s)){
                    return false;
                }
            }
            return true;
        }
    
        /**
         * list中不包含
         * @param strList
         * @param dest
         * @return
         */
        public static boolean notContains(List<String> strList, String dest){
            String[] d = dest.split(",");
            for(String str : strList){
                for(String s : d){
                    if(str.contains(s)){
                        return false;
                    }
                }
            }
            return true;
        }
    
        public static boolean onlyEqual(List list, String code){
            if(list == null){
                return false;
            }
            for(Object str : list){
                if(str instanceof String && !str.equals(code)){
                    return false;
                }
            }
            return true;
        }
    
        public static boolean onlyEqualString(List<String> list, String code){
            if(list == null){
                return false;
            }
            for(Object str : list){
                if(str instanceof String && !str.equals(code)){
                    return true;
                }
            }
            return false;
        }
    
        public static boolean onlyEqualStr(List<String> list, String code){
            if(list == null){
                return false;
            }
            List<String> codeList = new ArrayList<>(Arrays.asList(code.split(",")));
            for(Object str : list){
                if(str instanceof String && !codeList.contains(str)){
                    return false;
                }
            }
            return true;
        }
    
        public static Integer containEqualStrCount(List<String> list, String code){
            Integer count = 0;
            if(list == null){
                return 0;
            }
            List<String> codeList = new ArrayList<>(Arrays.asList(code.split(",")));
            for(String str : list){
                if(codeList.contains(str)){
                    count ++;
                }
            }
            return count;
        }
    
        public static Integer containEqualCount(List<String> list, String code){
            Integer count = 0;
            if(list == null){
                return 0;
            }
            for(String str : list){
                if(str.equals(code)){
                    count ++;
                }
            }
            return count;
        }
    
        public static double getRate(Integer blackCount, Integer allCount) {
            if (blackCount == null || blackCount == 0 || allCount == 0 || allCount == null) {
                return 0;
            }
            return new BigDecimal(blackCount).divide(new BigDecimal(allCount), 3, BigDecimal.ROUND_CEILING).doubleValue();
        }
    
        public static boolean startWith(String str, String pre) {
            if(str.startsWith(pre)){
                return true;
            }
            return false;
        }
    
        /**
         * 等于任意一个
         *
         * @param source 源数据
         * @param vars   判断被包含数据
         * @return
         */
        public static boolean equalsAny(String source, String... vars) {
            if (source != null && source.trim().length() > 0 && vars != null && vars.length > 0) {
                for (String var : vars) {
                    if (source.equals(var)) {
                        return true;
                    }
                }
            }
            return false;
        }
    
        /**
         * 包含任意一个
         *
         * @param source 源数据
         * @param vars   判断被包含数据
         * @return
         */
        public static boolean containsAny(String source, String... vars) {
            if (source != null && source.trim().length() > 0 && vars != null && vars.length > 0) {
                for (String var : vars) {
                    if (source.contains(var)) {
                        return true;
                    }
                }
            }
            return false;
        }
    
        /**
         * 以任意一个字符串为前缀
         *
         * @param source 源数据
         * @param vars   判断被包含数据
         * @return
         */
        public static boolean startWithAny(String source, String... vars) {
            if (source != null && source.trim().length() > 0 && vars != null && vars.length > 0) {
                for (String var : vars) {
                    if (source.startsWith(var)) {
                        return true;
                    }
                }
            }
            return false;
        }
    
        /**
         * 包含任意一个
         *
         * @param sources 源数据
         * @param vars    判断被包含数据
         * @return
         */
        public static boolean containsAny(Collection<String> sources, String... vars) {
            if (sources != null && sources.size() > 0 && vars != null && vars.length > 0) {
                for (String var : vars) {
                    if (sources.contains(var)) {
                        return true;
                    }
                }
            }
            return false;
        }
    
        /**
         * 模糊匹配任意一个
         *
         * @param sources 源数据
         * @param vars    判断被包含数据
         * @return
         */
        public static boolean likeAny(Collection<String> sources, String... vars) {
            if (sources != null && sources.size() > 0 && vars != null && vars.length > 0) {
                for (String var : vars) {
                    for (String source : sources) {
                        if (source.contains(var)) {
                            return true;
                        }
                    }
                }
            }
            return false;
        }
    
        /**
         * 包含所有
         *
         * @param sources 源数据
         * @param vars    判断被包含数据
         * @return
         */
        public static boolean containsAll(Collection<String> sources, String... vars) {
            if (sources != null && sources.size() > 0 && vars != null && vars.length > 0) {
                return sources.containsAll(Arrays.asList(vars));
            }
            return false;
        }
    
        private final static Pattern NUMERIC = Pattern.compile("^[-+]?[\\d]+[.]?[\\d]*$");
    
        public static boolean isNumeric(String str) {
            return NUMERIC.matcher(str).matches();
        }
    }

1.数值在某个区间内
%s是占位符，age是元数据（读取到报告里解析出来的数据变成模型的元数据
），元数据的数值在sql中映射最后放在drools代码块中执行，得到最终决策。
类似写法：
rule “XXXX” no-loop when info : %s(age < 20 || age > 50) then ruleSet.addResult(“XXXX”, “规则名”, “决策1”); end
【意思大致就是对应报告里解析出来的age在小于20或大于50的年龄，给予决策1】

2.包含某个String串的内容就是命中规则
rule “XXXX” no-loop when info : %s(DroolsFunction.containsAny(identityAddress, “地名1”, “地名2”, “地名3”, “地名3”, “地名4”, “地名5”, “地名6”, “地名7”)) then ruleSet.addResult(“XXXX”, “命中某风险地区”, “决策2”); end
【意思大致是身份证或者是手机登录地区或者是类似三方报告里抓取到的地点名在以上任一地名内的，就是命中，给予决策2】

3.包含以某个内容开头
rule “XXXX” no-loop when info : %s(DroolsFunction.startWithAny(identityNation, “XXX”, “XXX”, “XXX”)) then ruleSet.addResult(“XXXX”, “命中少数民族”, “决策3”); end
【元数据对象属性中以上述其种之一的内容开头的命中规则，给予决策3】

4.true||false命中规则
rule “XXXX” no-loop when info : %s(Boolean.TRUE.equals(hitBlackListFromYeadun)) then ruleSet.addResult(“XXXX”, “命中某某黑名单”, “决策4”); end
【元数据结果是否是命中，如果是命中直接给予决策4】

5.两个元数据合并成一个规则，其中一个通过就是通过
rule “r_B9001” no-loop
when
$r1 : com.cash.risk.center.core.rule.command.domain.metadata.SlooptechMetadata(Boolean.TRUE.equals(notApprovedOfSlooptech));
$r2 : com.cash.risk.center.core.rule.command.domain.metadata.IceCreditMetadata(iceCreditScore != null && iceCreditScore <= 650)
then
ruleSet.addResult(“XXXX”, “风控模型拒绝”, “p2”); end

上面的，分数为605<=650（命中规则为拒），但是另一个命中项是false，结果还是通过，就说所说的“多个命中项判断其中一个是通过，整条规则就是通过”。