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多条件判断规则执行器内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！

黄山市民网：https://www.huangshanshimin.com/