关于工作流的简单代码分析

class JudgeFactory {
    public static Judge generateJudge(String judgeName) {
        if ("EqualJudge".equals(judgeName)) {//不同类型的数据(date int string )比较  要做成多态  新增Judge的实现类
            return new EqualJudge();
        } else if ("ContainJudge".equals(judgeName)) {
            return new ContainJudge();
        } else {
            return new BelongJudge();
        }
    }
}

interface Judge {
    boolean run(Condition condition);
}

class GTJudge implements Judge{//数字的大小比较器

    @Override
    public boolean run(Condition condition) {
        boolean flag = (int)condition.getSource() >(int)condition.getTarget();
        return flag;
    }
}
class GTJudgeDate implements Judge{//日期的大小比较器

    @Override
    public boolean run(Condition condition) {//重写日期的比较
        
        return false;
    }
}


class EqualJudge implements Judge {

    @Override
    public boolean run(Condition condition) {//字段  数字  日期
        //等于  不等于判断
        boolean flag = condition.getTarget().equals(condition.getSource());
        condition.setFlag(flag);
        return flag;
    }
}

class ContainJudge implements Judge {

    @Override
    public boolean run(Condition condition) {//部门树这种  定义一个基类
        //包含  不包含
        List list = (List) condition.getSource();//按逻辑查出一个list  此处简写

        boolean flag = list.contains(condition.getTarget());
        condition.setFlag(flag);
        return flag;
    }
}

class BelongJudge implements Judge {

    @Override
    public boolean run(Condition condition) {//部门树这种  定义一个基类
        //包含  不包含
        List list = (List) condition.getTarget();//按逻辑查出一个list  此处简写

        boolean flag = list.contains(condition.getSource());
        condition.setFlag(flag);
        return flag;
    }
}


class Order {//工单

}


class Workflow {//工作流的表

    private List<Handler> handlerList;//在数据库中存入 处理节点的ID集合
}



class Handler {//控制工单流向  数据库对应储存为 节点表

    private String successNextCode;
    private String failNextCode;
    private String code;//当前处理节点的代码
    private ConditionGroup group;//从数据库的 处理节点表 拿出group 的Json字符串

    public String handle(Order Order) {

        boolean result = group.compute(Order);//计算最终的  yes  no
        if (result) {
            update(Order);//项目中只是改变了处理人，其他的没有说明
            return successNextCode;//yes 时在数据库record表里存入下一个 调用的Handler的code
        }
        return failNextCode;//no 时 从数据库找出 处理节点表 找出 下一个调用的Handler  的code
    }

    //满足要求将工单内容更改
    private void update(Order Order) {
        //将处理动作 记录 到record
    }

    public String getSuccessNextCode() {
        return successNextCode;
    }

    public void setSuccessNextCode(String successNextCode) {
        this.successNextCode = successNextCode;
    }

    public String getFailNextCode() {
        return failNextCode;
    }

    public void setFailNextCode(String failNextCode) {
        this.failNextCode = failNextCode;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public ConditionGroup getGroup() {
        return group;
    }

    public void setGroup(ConditionGroup group) {
        this.group = group;
    }
}


class WorkflowRecord {
    private int handlerId;

    public int getHandlerId() {
        return handlerId;
    }

    public void setHandlerId(int handlerId) {
        this.handlerId = handlerId;
    }
}

class WorkflowService {//工作流服务
    public void runWorkflow(int orderNumber) {
        Order order = getOrder(orderNumber);
        WorkflowRecord record = getWorkflowRecord(orderNumber);
        Handler handler = getWorkflowNode(record.getHandlerId());
        handler.handle(order);
    }

    private Handler getWorkflowNode(int handlerId) {
        return null;//从数据库拿出handler
    }

    private WorkflowRecord getWorkflowRecord(int orderNumber) {
        return null;//从数据库拿出record
    }

    private Order getOrder(int id) {//从数据库拿出order
        return null;
    }
}

class ConditionGroup {

    private boolean yesOrNo;

    public List<Condition> orList;

    public List<Condition> andList;

    public boolean computeAnd(Order dto) {
        for (int i = 0; i < andList.size(); i++) {
            Condition condition = andList.get(i);
            Object source = condition.getSourceFromOrderByFieldName(dto);
            condition.setSource(source);
            Judge judge = JudgeFactory.generateJudge(condition.getJudgeName());//通过名称调用judge
            judge.run(condition);
        }
        int count = (int) andList.stream().filter(x -> x.getFlag()).count();

        return count == andList.size();
    }

    public boolean compute(Order dto) {
        return yesOrNo ? (computeAnd(dto) && computeAnd(dto)) : computeOr(dto) || computeAnd(dto);
    }

    private boolean computeOr(Order dto) {
        for (int i = 0; i < andList.size(); i++) {
            Condition condition = andList.get(i);
            Object source = condition.getSourceFromOrderByFieldName(dto);
            condition.setSource(source);
            Judge judge = JudgeFactory.generateJudge(condition.getJudgeName());//通过名称调用judge

            judge.run(condition);
        }
        int count = (int) andList.stream().filter(x -> !x.getFlag()).count();

        return count != 0;
    }

    public boolean isYesOrNo() {
        return yesOrNo;
    }

    public void setYesOrNo(boolean yesOrNo) {
        this.yesOrNo = yesOrNo;
    }

    public List<Condition> getOrList() {
        return orList;
    }

    public void setOrList(List<Condition> orList) {
        this.orList = orList;
    }

    public List<Condition> getAndList() {
        return andList;
    }

    public void setAndList(List<Condition> andList) {
        this.andList = andList;
    }


}

class Condition {
    private Object target;//存在数据库
    private Object source;//order设置
    private Boolean flag;//计算结果
    private String judgeName;//判断器的名称  
    private String fieldName;//order中的字段名称

    public String getFieldName() {
        return fieldName;
    }

    public void setFieldName(String fieldName) {
        this.fieldName = fieldName;
    }

    public String getJudgeName() {
        return judgeName;
    }

    public void setJudgeName(String judgeName) {
        this.judgeName = judgeName;
    }

    public Boolean getFlag() {
        return flag;
    }

    public void setFlag(Boolean flag) {
        this.flag = flag;
    }


    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    public Object getSource() {
        return source;
    }

    public void setSource(Object source) {
        this.source = source;
    }

    public Object getSourceFromOrderByFieldName(Order dto) {
        Map<String, Object> map = Util.objectToMap(dto);
        return map.get(fieldName);
    }


}

class Util {
    public static Map<String, Object> objectToMap(Object obj) {
        Map<String, Object> map = new HashMap<>();
        try {
            Class<?> clazz = obj.getClass();
            for (Field field : clazz.getDeclaredFields()) {
                field.setAccessible(true);
                String fieldName = field.getName();
                Object value = field.get(obj);
                map.put(fieldName, value);
            }
        } catch (Exception e) {

        }
        return map;
    }
}