基于策略模式的可插拔设计2

针对上篇最后提出的不足，改进如下

1. ModuleManager增加spareStrategyName表示备用策略,BaseStrategy去掉spare的相关方法。改动较为简单，代码略。
2. 增加SingleAPIModuleStrategy类为简单的单一api接口做进一步的封装
   SingleAPIModuleStrategy代码如下

public abstract class SingleAPIModuleStrategy extends BaseStrategy {

    protected SupplyAPI api;

    protected JSONObject apiResponse;

    public SingleAPIModuleStrategy(Report report, SupplyAPIRepository supplyAPIRepository, APISearchRepository apiSearchRepository) {
        super(report, supplyAPIRepository, apiSearchRepository);
        setAPI();
    }

    protected abstract void setAPI();

    @Override
    public boolean isAPIActive() {
        return api.isActive() && isParameterComplete();
    }

    protected abstract boolean isParameterComplete();

    @Override
    public boolean isContainsAPI(Map<String, JSONObject> pool) {
        return pool.containsKey(api.getCode());
    }

    @Override
    public boolean isAPIUnfinished(Map<String, JSONObject> pool) {
        return EMPTY_JSON.equals(pool.get(api.getCode()));
    }

    @Override
    public void tryPutEmptyAPI(Map<String, JSONObject> pool) {
        if (!pool.containsKey(api.getCode())) {
            pool.put(api.getCode(), EMPTY_JSON);
        }
    }

    @Override
    public void removeEmptyAPI(Map<String, JSONObject> pool) {
        pool.remove(api.getCode());
    }

    @Override
    public void putAPIResponseIntoPool(Map<String, JSONObject> pool) {
        if (apiResponse != null && !EMPTY_JSON.equals(apiResponse)) {
            pool.put(api.getCode(), apiResponse);
        }
    }
}

对应的FraudModuleStrategy例子如下

public class FraudModuleStrategy extends SingleAPIModuleStrategy {

    private static final Logger logger = LoggerFactory.getLogger(FraudModuleStrategy.class);

    private final static long API_ID = 17L;

    public FraudModuleStrategy(Report report, SupplyAPIRepository supplyAPIRepository, APISearchRepository apiSearchRepository) {
        super(report, supplyAPIRepository, apiSearchRepository);
    }

    @Override
    protected void setAPI() {
        super.api = supplyAPIRepository.findOne(API_ID);
    }

    @Override
    protected boolean isParameterComplete() {
        return super.report.getCustomerName() != null && super.report.getCustomerIdCard() != null
                && super.report.getCustomerMobile() != null;
    }

    @Override
    public boolean fetchData(Map<String, JSONObject> pool) {
        JSONObject cacheData = pool.get(api.getCode());
        if (cacheData != null && !EMPTY_JSON.equals(cacheData)) {
            super.apiResponse = cacheData;
            return true;
        }
        API api = new API();
        api.setSupplyAPI(super.api);
        api.getParameters().put("name", super.report.getCustomerName());
        api.getParameters().put("idCard", super.report.getCustomerIdCard());
        api.getParameters().put("mobile", super.report.getCustomerMobile());
        if (!StringUtils.isEmpty(report.getCustomerBankCard())) {
            api.getParameters().put("bankCardNo", super.report.getCustomerBankCard());
        }

        cacheData = getCache(api);
        if (cacheData != null) {
            logger.info("缓存查询" + super.api.getCode());
        } else {
            logger.info("即时查询" + super.api.getCode());
            XinShuCallable xinShuCallable = new XinShuCallable(api.getSupplyAPI(), new HashMap<>(), api.getParameters(),
                    "");
            cacheData = xinShuCallable.call();
            logger.info(super.api.getCode() + " response:" + cacheData);
            if (cacheData != null && "0000".equals(cacheData.getString("rc"))) {
                putCache(api, cacheData);
            }
        }
        if (cacheData == null) {
            return false;
        } else {
            super.apiResponse = cacheData;
            return true;
        }
    }

    @Override
    public BaseModule analyseData() {
        //分析及封装操作，省略
    }

    @Override
    public void setModuleIntoReport(BaseModule module, Integer displayOrder) {
        module.setDisplaySort(displayOrder);
        report.setFraudModule((FraudModule) module);
    }
}

改动后，最主要的变化是主策略和备用策略通过修改ModuleManager类的反射字段也实现了可插拔。同时，如果有同一模块多中策略的话，其实可以参考链表的形式，实现策略的无限增加。但鉴于实际情况，本次就只到两个策略就结束了。