策略模式

public abstract class AbstractExecutor<T> {

    /**
     * 执行业务逻辑
     */
    public void doExecute(T t) {
        try {
            // 初始化
            this.init(t);

            // 执行逻辑
            this.process(t);
        } finally {

            // 使用结束移除
            this.finish();
        }
    }

    /**
     * 处理过程
     * @param t 处理参数
     */
    protected abstract void process(T t);

    /**
     * 初始化
     * @param t 处理参数
     */
    protected abstract void init(T t);

    /**
     * 结束
     */
    protected abstract void finish();
}

public class SaveAbstractExecutor extends AbstractExecutor<SaveParam> {

    protected static ThreadLocal<Entity> threadLocal = new ThreadLocal<>();

    @Override
    protected void process(SaveParam saveParam) {

        log.info("保存入参：{}", JSONObject.toJSONString(saveParam));

    }

    @Override
    protected void init(EvaluationSaveParam param) {
        

    }

　　/**
     * 保存
     *
     * @param param 入参
     * @return
     */
    protected void save(SaveParam param) {


    }protected void checkParam(SaveParam param) {
        Validator.getInstance().notNull(param.getRate());
    }

    @Override
    protected void finish() {
        evaluationThreadLocal.remove();
    }
}

public class SaveExecutorRegister {

    /**
     * 执行器容器
     */
    private final static Map<EventEnum, SaveAbstractExecutor> EXECUTOR_MAP = Maps.newHashMap();

    /**
     * 注册
     *
     * @param eventEnum 事件
     * @param executor 执行器
     */
    public static void register(EventEnum eventEnum, saveAbstractExecutor executor) {
        EXECUTOR_MAP.put(eventEnum, executor);
    }

    /**
     * 查找执行器
     *
     * @param eventEnum 评论事件
     * @return 返回执行器
     */
    public static saveAbstractExecutor findByType(EventEnum eventEnum) {
        return EXECUTOR_MAP.get(eventEnum);
    }
}

public class ExampleExecutor extends SaveAbstractExecutor{

    public ExampleExecutor() {
        SaveExecutorRegister.register(EventEnum.EXAMPLE, this);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    protected void process(SaveParam param) {

        super.process(param);

        super.checkParam(param);

       
    }
}

SaveExecutorRegister.findByType(eventEnum).doExecute(param);