Java多条件判断场景中规则执行器的设计

业务场景

近日在公司领到一个小需求，需要对之前已有的试用用户申请规则进行拓展。我们的场景大概如下所示:

if (是否海外用户) {
 return false;
}

if (刷单用户) {
  return false;
}

if (未付费用户 && 不再服务时段) {
  return false
}

if (转介绍用户 || 付费用户 || 内推用户) {
  return true;
}

按照上述的条件我们可以得出的结论是：

• 咱们的的主要流程主要是基于 and 或者 or 的关系。
• 如果有一个不匹配的话，其实咱们后续的流程是不用执行的，就是需要具备一个短路的功能。
• 对于目前的现状来说，我如果在原有的基础上来该，只要稍微注意一下解决需求不是很大的问题，但是说后面可维护性非常差。

后面进过权衡过后，我还是决定将这个部分进行重构一下。

规则执行器

针对这个需求，我首先梳理了一下咱们规则执行器大概的设计， 然后我设计了一个 v1 版本和大家一起分享一下，如果大家也有这样的 case 可以给我分享留言，下面部分主要是设计和实现的流程和 code .

规则执行器的设计

对于规则的抽象并实现规则

// 业务数据
@data
public class ruledto {
  private string address;
 private int age;
}

// 规则抽象
public interface baserule {

    boolean execute(ruledto dto);
}

// 规则模板
public abstract class abstractrule implements baserule {

    protected <t> t convert(ruledto dto) {
        return (t) dto;
    }

    @override
    public boolean execute(ruledto dto) {
        return executerule(convert(dto));
    }
  
    protected <t> boolean executerule(t t) {
        return true;
    }
}

// 具体规则- 例子1
public class addressrule extends abstractrule {

    @override
    public boolean execute(ruledto dto) {
        system.out.println("addressrule invoke!");
        if (dto.getaddress().startswith(match_address_start)) {
            return true;
        }
        return false;
    }
}

// 具体规则- 例子2
public class nationalityrule extends abstractrule {

    @override
    protected <t> t convert(ruledto dto) {
        nationalityruledto nationalityruledto = new nationalityruledto();
        if (dto.getaddress().startswith(match_address_start)) {
            nationalityruledto.setnationality(match_nationality_start);
        }
        return (t) nationalityruledto;
    }


    @override
    protected <t> boolean executerule(t t) {
        system.out.println("nationalityrule invoke!");
        nationalityruledto nationalityruledto = (nationalityruledto) t;
        if (nationalityruledto.getnationality().startswith(match_nationality_start)) {
            return true;
        }
        return false;
    }
}

// 常量定义
public class ruleconstant {
    public static final string match_address_start= "北京";
    public static final string match_nationality_start= "中国";
}

执行器构建

public class ruleservice {

    private map<integer, list<baserule>> hashmap = new hashmap<>();
    private static final int and = 1;
    private static final int or = 0;

    public static ruleservice create() {
        return new ruleservice();
    }


    public ruleservice and(list<baserule> rulelist) {
        hashmap.put(and, rulelist);
        return this;
    }

    public ruleservice or(list<baserule> rulelist) {
        hashmap.put(or, rulelist);
        return this;
    }

    public boolean execute(ruledto dto) {
        for (map.entry<integer, list<baserule>> item : hashmap.entryset()) {
            list<baserule> rulelist = item.getvalue();
            switch (item.getkey()) {
                case and:
                    // 如果是 and 关系，同步执行
                    system.out.println("execute key = " + 1);
                    if (!and(dto, rulelist)) {
                        return false;
                    }
                    break;
                case or:
                    // 如果是 or 关系，并行执行
                    system.out.println("execute key = " + 0);
                    if (!or(dto, rulelist)) {
                        return false;
                    }
                    break;
                default:
                    break;
            }
        }
        return true;
    }

    private boolean and(ruledto dto, list<baserule> rulelist) {
        for (baserule rule : rulelist) {
            boolean execute = rule.execute(dto);
            if (!execute) {
                // and 关系匹配失败一次，返回 false
                return false;
            }
        }
        // and 关系全部匹配成功，返回 true
        return true;
    }

    private boolean or(ruledto dto, list<baserule> rulelist) {
        for (baserule rule : rulelist) {
            boolean execute = rule.execute(dto);
            if (execute) {
                // or 关系匹配到一个就返回 true
                return true;
            }
        }
        // or 关系一个都匹配不到就返回 false
        return false;
    }
}

执行器的调用

public class ruleservicetest {

    @org.junit.test
    public void execute() {
        //规则执行器
        //优点：比较简单，每个规则可以独立，将规则，数据，执行器拆分出来，调用方比较规整
        //缺点：数据依赖公共传输对象 dto

        //1. 定义规则  init rule
        agerule agerule = new agerule();
        namerule namerule = new namerule();
        nationalityrule nationalityrule = new nationalityrule();
        addressrule addressrule = new addressrule();
        subjectrule subjectrule = new subjectrule();

        //2. 构造需要的数据 create dto
        ruledto dto = new ruledto();
        dto.setage(5);
        dto.setname("张三");
        dto.setaddress("北京");
        dto.setsubject("数学");;

        //3. 通过以链式调用构建和执行 rule execute
        boolean ruleresult = ruleservice
                .create()
                .and(arrays.aslist(nationalityrule, namerule, addressrule))
                .or(arrays.aslist(agerule, subjectrule))
                .execute(dto);
        system.out.println("this student rule execute result :" + ruleresult);
    }
}

总结

规则执行器的优点和缺点

优点：

比较简单，每个规则可以独立，将规则，数据，执行器拆分出来，调用方比较规整；
我在 rule 模板类中定义 convert 方法做参数的转换这样可以能够，为特定 rule 需要的场景数据提供拓展。

缺点：上下 rule 有数据依赖性，如果直接修改公共传输对象 dto 这样设计不是很合理，建议提前构建数据。

到此这篇关于java多条件判断场景中规则执行器的设计的文章就介绍到这了,更多相关java多条件判断规则执行器 内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！