设计模式——规则树模型结构

规则树模型结构分析 - 通过场景剖析其应用思路,并掌握工程实践中如何使用它。



写在前面

通过规则树模型结构可以更优雅地编写我们在项目中构建大量ifelse逻辑的场景,并且越是随着树型逻辑分支的迭代增多,规则树结构下多人协同维护的优势更加明显。


一、场景设置

当完成某些业务或功能的流程设计后,如果需要选择使用设计模式来实现流程时,常常遇到选型的问题。因为很多时候我们的流程既不是纯粹的链表也不是严格的树,介于树或者列表之间。例如
订单场景:在虚拟机申请的订单业务中,有许多必要的检查、资源分配、实施、通知等等流程,以及后期在多云厂商的环境下不同场景会有不同的实现。申请流程如下图大部分情况是链式结构,但同时存在随时拓展分支的可能性,例如检查失败节点、资源分配失败节点、实施中断节点等等异常节点。
在这里插入图片描述
配额场景:又或者是在某一个具体的领域中,例如配额领域中,同样有许多必要的检查、分配、扣减、返还等等流程,以及在不同来源不同类型资源下会有不同的扣减、超额等等策略。
在这里插入图片描述
在这些场景中,我们可能会快速判断出适合选择使用模版模式、工厂模式、策略模式等等设计模式…
但是可能会在责任链或者是规则树模式中间纠结一阵。
那么不妨试一试本文介绍的这套基于规则树模型结构实现流程驱动的模版。


二、通用模版

这套模版是基于规则树的思想而产生,但是节点驱动的方式由配置转变为了由代码控制,并且具有范式设计,可以更加泛化地应用在各种场景。先介绍三个核心部件:

策略映射器

/**
 * 策略映射器
 * T 入参类型
 * D 上下文参数
 * R 返参类型
 */
public interface StrategyMapper<T, D, R> {

	// 获取待执行策略
    StrategyHandler<T, D, R> get(T requestParameter, D dynamicContext) throws Exception;

}

受理策略处理

/**
 * 受理策略处理
 * T 入参类型
 * D 上下文参数
 * R 返参类型
 */
public interface StrategyHandler<T, D, R> {

    StrategyHandler DEFAULT = (T, D) -> null;

    R apply(T requestParameter, D dynamicContext) throws Exception;

}

策略路由抽象类

/**
 * 策略路由抽象类
 */
public abstract class AbstractStrategyRouter<T, D, R> implements StrategyMapper<T, D, R>, StrategyHandler<T, D, R> {

    @Getter
    @Setter
    protected StrategyHandler<T, D, R> defaultStrategyHandler = DEFAULT;

    public R router(T requestParameter, D dynamicContext) throws Exception {
        StrategyHandler<T, D, R> strategyHandler = get(requestParameter, dynamicContext);
        if(null != strategyHandler) return strategyHandler.apply(requestParameter, dynamicContext);
        return defaultStrategyHandler.apply(requestParameter, dynamicContext);
    }

}

三、使用实例

本文以申请创建资源的简化场景为例,实现如下业务流程:
在这里插入图片描述

抽象的订单模块支撑类

/**
 * 抽象的订单模块支撑类
 */
public abstract class AbstractOrderSupport<OrderEntity, DynamicContext, ResourceReturnEntity> extends AbstractStrategyRouter<OrderEntity, DefaultOrderStrategyFactory.DynamicContext, ResourceReturnEntity> {

    @Resource
    protected IOrderRepository repository;

}

根节点——初步的参数校验

@Slf4j
@Service
public class RootNode extends AbstractOrderSupport<OrderEntity, DefaultOrderStrategyFactory.DynamicContext, ResourceReturnEntity> {

    @Resource
    private QuotaAllocationNode quotaAllocationNode;

    @Override
    public ResourceReturnEntity apply(OrderEntity requestParameter, DefaultOrderStrategyFactory.DynamicContext dynamicContext) throws Exception {
        log.info("云主机申请服务-RootNode userId:{} requestParameter:{}", requestParameter.getUserId(), JSON.toJSONString(requestParameter));
        // TODO 实现业务逻辑
        // 例如 校验逻辑 - 参数判断
        if (StringUtils.isBlank(requestParameter.getUserId())) {
            throw new AppException(ResponseCode.ILLEGAL_PARAMETER.getCode(), ResponseCode.ILLEGAL_PARAMETER.getInfo());
        }
        return router(requestParameter, dynamicContext);
    }

    @Override
    public StrategyHandler<OrderEntity, DefaultOrderStrategyFactory.DynamicContext, ResourceReturnEntity> get(OrderEntity requestParameter, DefaultOrderStrategyFactory.DynamicContext dynamicContext) throws Exception {
        return quotaAllocationNode;
    }

}

配额分配节点

@Slf4j
@Service
public class QuotaAllocationNode extends AbstractOrderSupport<OrderEntity, DefaultOrderStrategyFactory.DynamicContext, ResourceReturnEntity> {

    @Resource
    private IpAllocationNode ipAllocationNode;

    @Override
    public ResourceReturnEntity apply(OrderEntity requestParameter, DefaultOrderStrategyFactory.DynamicContext dynamicContext) throws Exception {
        log.info("配额分配服务-QuotaAllocationNode userId:{} requestParameter:{}", requestParameter.getUserId(), JSON.toJSONString(requestParameter));

        // 判断是否超额
        checkExcess();
        // 额度预占用
        doQuotaAllocation();

        return router(requestParameter, dynamicContext);
    }

    @Override
    public StrategyHandler<OrderEntity, DefaultOrderStrategyFactory.DynamicContext, ResourceReturnEntity> get(OrderEntity requestParameter, DefaultOrderStrategyFactory.DynamicContext dynamicContext) throws Exception {
        return ipAllocationNode;
    }
}

IP分配节点

@Slf4j
@Service
public class IpAllocationNode extends AbstractOrderSupport<OrderEntity, DefaultOrderStrategyFactory.DynamicContext, ResourceReturnEntity> {

    @Resource
    private ResourceCreationNode resourceCreateNode;

    @Override
    public ResourceReturnEntity apply(OrderEntity requestParameter, DefaultOrderStrategyFactory.DynamicContext dynamicContext) throws Exception {
        log.info("IP分配服务-IpAllocationNode userId:{} requestParameter:{}", requestParameter.getUserId(), JSON.toJSONString(requestParameter));
        
        // IP占用
        doIpAllocation();

        return router(requestParameter, dynamicContext);
    }

    @Override
    public StrategyHandler<OrderEntity, DefaultOrderStrategyFactory.DynamicContext, ResourceReturnEntity> get(OrderEntity requestParameter, DefaultOrderStrategyFactory.DynamicContext dynamicContext) throws Exception {
        return resourceCreateNode;
    }
}

资源创建节点

@Slf4j
@Service
public class ResourceCreationNode extends AbstractOrderSupport<OrderEntity, DefaultOrderStrategyFactory.DynamicContext, ResourceReturnEntity> {

    @Resource
    private QuotaReleaseNode quotaReleaseNode;
    @Resource
    private QuotaConsumptionNode quotaConsumptionNode;

    @Override
    public ResourceReturnEntity apply(OrderEntity requestParameter, DefaultOrderStrategyFactory.DynamicContext dynamicContext) throws Exception {
        log.info("资源创建服务-ResourceCreationNode userId:{} requestParameter:{}", requestParameter.getUserId(), JSON.toJSONString(requestParameter));

        // 获取上下文数据 - 创建虚拟机配置
        ResourceApplicationVO resourceApplicationVO = dynamicContext.getResourceApplicationVO();
        if (null == resourceApplicationVO) {
            log.info("上下文缺失 {}", JSON.toJSONString(dynamicContext));
            throw new AppException(ResponseCode.E0001.getCode(), ResponseCode.E0001.getInfo());
        }
        
        // 创建资源
        doResourceApplication(resourceApplicationVO);
        
        return router(requestParameter, dynamicContext);
    }

    @Override
    public StrategyHandler<OrderEntity, DefaultOrderStrategyFactory.DynamicContext, ResourceReturnEntity> get(OrderEntity requestParameter, DefaultOrderStrategyFactory.DynamicContext dynamicContext) throws Exception {
        // 资源创建异常的,走配额释放节点
        if (false == dynamicContext.getResourceApplicationResult()) {
            return quotaReleaseNode;
        }
        // 正常创建的则走配额消费节点
        return quotaConsumptionNode;
    }

}

配额、IP的释放和消费节点(行为方式类似,代码省略)


四、优化——支持异步场景模版

在实际的一些复杂场景中,为了提高接口响应率,资源数据的加载可以前置进行,亦或者是可以同时进行,衍生出一些需要异步加载策略的场景需求。本节将介绍由此衍生出的适用异步场景的通用模版。

支持异步资源加载策略的路由抽象类

/**
 * 支持异步资源加载策略的路由抽象类
 */
public abstract class AbstractMultiThreadStrategyRouter<T, D, R> implements StrategyMapper<T, D, R>, StrategyHandler<T, D, R> {

    @Getter
    @Setter
    protected StrategyHandler<T, D, R> defaultStrategyHandler = DEFAULT;

    public R router(T requestParameter, D dynamicContext) throws Exception {
        StrategyHandler<T, D, R> strategyHandler = get(requestParameter, dynamicContext);
        if(null != strategyHandler) return strategyHandler.apply(requestParameter, dynamicContext);
        return defaultStrategyHandler.apply(requestParameter, dynamicContext);
    }

    @Override
    public R apply(T requestParameter, D dynamicContext) throws Exception {
        // 异步加载数据
        multiThread(requestParameter, dynamicContext);
        // 业务流程受理
        return doApply(requestParameter, dynamicContext);
    }

    /**
     * 异步加载数据
     */
    protected abstract void multiThread(T requestParameter, D dynamicContext) throws ExecutionException, InterruptedException, TimeoutException;

    /**
     * 业务流程受理
     */
    protected abstract R doApply(T requestParameter, D dynamicContext) throws Exception;

}

支持异步资源加载策略的抽象订单模块支撑类

/**
 * 支持异步资源加载策略的抽象订单模块支撑类
 */
public abstract class AbstractMultiOrderSupport<OrderEntity, DynamicContext, ResourceReturnEntity> extends AbstractMultiThreadStrategyRouter<OrderEntity, DefaultOrderStrategyFactory.DynamicContext, ResourceReturnEntity> {

    protected long timeout = 500;
    @Resource
    protected IOrderRepository repository;

    @Override
    protected void multiThread(OrderEntity requestParameter, DefaultOrderStrategyFactory.DynamicContext dynamicContext) throws ExecutionException, InterruptedException, TimeoutException {
        // 缺省的方法
    }

}

改造配额分配节点,使用异步方式处理数据

@Slf4j
@Service
public class MultiQuotaAllocationNode extends AbstractMultiOrderSupport<OrderEntity, DefaultOrderStrategyFactory.DynamicContext, ResourceReturnEntity> {

    @Resource
    private ThreadPoolExecutor threadPoolExecutor;
    @Resource
    private IpAllocationNode ipAllocationNode;


    @Override
    protected void multiThread(OrderEntity requestParameter, DefaultOrderStrategyFactory.DynamicContext dynamicContext) throws ExecutionException, InterruptedException, TimeoutException {
        // 判断是否超额
        checkExcess();
        
        // 异步处理配额分配数据 - 放在 Task 中去实现
        QuotaAllocationThreadTask quotaAllocationThreadTask = new QuotaAllocationThreadTask(requestParameter, repository);
        FutureTask<QuotaAllocationVO> quotaVOFutureTask = new FutureTask<>(quotaAllocationThreadTask);
        threadPoolExecutor.execute(quotaVOFutureTask);

        // 写入上下文 - 实际上对于一些复杂的场景,就可以在下N个节点获取结果,这样前置处理数据,可以提高接口响应效率
        dynamicContext.setQuotaAllocationVO(quotaVOFutureTask.get(timeout, TimeUnit.MINUTES));

        log.info("配额分配服务-QuotaAllocationNode userId:{} 异步线程加载数据「QuotaAllocationVO」完成", requestParameter.getUserId());
    }

    @Override
    public ResourceReturnEntity doApply(OrderEntity requestParameter, DefaultOrderStrategyFactory.DynamicContext dynamicContext) throws Exception {
        log.info("配额分配服务-QuotaAllocationNode userId:{} requestParameter:{}", requestParameter.getUserId(), JSON.toJSONString(requestParameter));
        // 假设有其他同步的业务逻辑可以在此处实现
        
        return router(requestParameter, dynamicContext);
    }

    @Override
    public StrategyHandler<OrderEntity, DefaultOrderStrategyFactory.DynamicContext, ResourceReturnEntity> get(OrderEntity requestParameter, DefaultOrderStrategyFactory.DynamicContext dynamicContext) throws Exception {
        return ipAllocationNode;
    }

}

总结

这套模板的的优势就是简单灵活,充分理解这套模板的核心思路之后,根据不同的场景需求可以编排封装出更加适用的抽象类模版。再结合常用的设计模式三板斧可以优化地解决90%的复杂业务场景,例如本文中资源创建节点可以用工厂模式去支持不同云厂商不同的创建逻辑,配额节点可以使用策略模式去支持不同的超额策略,配额校验的执行链可以使用责任链的方式去执行,当然也同样可以使用本文介绍的规则树模型去驱动。

更多推荐