类似策略模式 替代if else

@Data
public class RuleDto {

    private String address;
    private int age;

}

public interface BaseRule {
    /***
     * 执行方法
     * @param dto
     * @return
     */
    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;
    };

}

public class AddressRule extends AbstractRule{

    @Override
    protected <T> boolean executeRule(T t) {

        RuleDto dto = (RuleDto) t;


        if (dto.getAddress().startsWith("a")){
            return true;
        }
        return false;
    }

}

public class AgeRule extends AbstractRule{


    @Override
    protected <T> T convert(RuleDto dto) {

       return super.convert(dto);
    }

    @Override
    public boolean execute(RuleDto dto) {

        System.out.println("AgeRule rule ");

        if (dto.getAge() > 10){
            return true;
        }
        return false;

    }
}

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) {

        boolean allMatch = hashMap.entrySet().stream()
                .allMatch(entry -> {
                    Integer key = entry.getKey();
                    List<BaseRule> value = entry.getValue();

                    switch (key) {
                        case AND: {
                            // 如果是and关系 同步执行
                            if (!and(dto, value)) {
                                return false;
                            }
                            break;
                        }
                        case OR: {
                            // 如果是or关系 并行执行
                            if (!or(dto, value)) {
                                return false;
                            }
                            break;
                        }
                        default: {
                            break;
                        }
                    }
                    return true;
                });

        return allMatch;
    }


    private boolean and(RuleDto dto, List<BaseRule> ruleList) {
        // 只要有一个是返回false 的  就返回false
        boolean execute = ruleList.stream()
                .allMatch(baseRule -> baseRule.execute(dto));
        return execute;
    }


    private boolean or(RuleDto dto, List<BaseRule> ruleList) {
        // 只要有一个是返回true 的  就返回true
        boolean execute = ruleList.stream()
                .anyMatch(baseRule -> baseRule.execute(dto));
        return execute;
    }


}

public class T {

    public static void main(String[] args) {

        BaseRule ageRule = new AgeRule();
        BaseRule addressRule = new AddressRule();

        RuleDto ruleDto = new RuleDto();
        ruleDto.setAddress("abcd");
        ruleDto.setAge(12);

        boolean execute = RuleService.create()
                .and(Arrays.asList(addressRule))
                .or(Arrays.asList(ageRule))
                .execute(ruleDto);


        System.out.println(execute);


    }

}