引言

在业务操作中，我们经常会遇到根据关键字来执行相应的方法，返回结果。
模拟一个执行方法类：

@Data
public class Action {

    /**
     * 方法名
     */
    String method;

    /**
     * 方法参数
     */
    String param;

    public Action (String method, String param) {
        this.method = method;
        this.param = param;
    }
}

模拟一个执行方法生成器：

public class ActionBuilder {

    public static List<Action> generateActionList() {
        List<Action> actionList = new ArrayList<>();
        Action[] methodArray = {new Action("subCentreNum", "head_str%middle_str%tail_str|9|19"),
                                new Action("subCentreStr", "head_str%middle_str%tail_str|%|%"),
                                new Action("subStartNum","head_str%tail_str|9"),
                                new Action("subStartStr","head_str%tail_str|%"),
                                new Action("params","xpath=tesfdfdsfadfdsf")};
        actionList = Arrays.asList(methodArray);
        return actionList;
    }
}

传统的做法是使用 if-else 分支判断关键字，根据不同的条件执行不同的业务逻辑。

List<Action> actionList = ActionBuilder.generateActionList();
for (Action action: actionList) {
      if (action.getMethod().equals("params")) {
            System.out.println("执行 params 方法");
            System.out.println("返回 params 方法结果");
      } else if (action.getMethod().equals("subCenterNum")) {
            System.out.println("执行 subCenterNum 方法");
            System.out.println("返回 subCenterNum 方法结果");
      } else if (action.getMethod().equals("subCenterStr")) {
            System.out.println("执行 subCenterStr 方法");
            System.out.println("返回 subCenterStr 方法结果");
      } else if (action.getMethod().equals("subStartNum")) {
            System.out.println("执行 subStartNum 方法");
            System.out.println("返回 subStartNum 方法结果");
      } else if (action.getMethod().equals("subStartStr")) {
            System.out.println("执行 subStartStr 方法");
            System.out.println("返回 subStartStr 方法结果");
      }
      // ......可能还有好多个 else if，未来还可能增加新的 else if 的判断
  }

就上面的例子，当方法关键字越来越多的时候，分支 else-if 就会越来越多，每增加一个新的方法类型，就需要修改或添加 if-else 分支，违反了开闭原则（对扩展开放，对修改关闭）。

策略模式+ 注解 + 反射

Java 的设计模式中有一个策略模式，它的目的是封装一系列的算法，它们具有共性，可以相互替换，也就是说让算法独立于使用它的客户端而独立变化，客户端仅仅依赖于策略接口。
上述场景中，我们可以把 if-else 分支的业务逻辑抽取为各种策略，在具体的实现类上增加注解，再通过 Java 反射获取到对应的类，代码如下：

策略接口：

public interface IMethodHandleStrategy {

    String handleMethod(String params);
}

策略接口实现，也就是具体的处理者

@Action(name="params")
public class ParamsMethod implements IMethodHandleStrategy {

    @Override
    public String handleMethod(String params) {
        System.out.println("paramsMethod 执行结果是："+SubStringUtil.params(params));
        return SubStringUtil.params(params);
    }
}


@Action(name="subcentrenum")
public class SubCenterNumMethod implements IMethodHandleStrategy {

    @Override
    public String handleMethod(String params) {
        String[] paramArray = SubStringUtil.splitParams(params, 3);
        String result = SubStringUtil.subStringByNum(paramArray[0], paramArray[1], paramArray[2]);
        System.out.println("SubCenterNumMethod 执行结果是："+result);
        return result;
    }
}


@Action(name="subcentrestr")
public class SubCenterStrMethod implements IMethodHandleStrategy {

    @Override
    public String handleMethod(String params) {
        String[] paramArray = SubStringUtil.splitParams(params, 3);
        String result = SubStringUtil.subStringByStr(paramArray[0], paramArray[1], paramArray[2]);
        System.out.println("SubCenterStrMethod 执行结果是："+result);
        return result;
    }
}


@Action(name="substartnum")
public class SubStartNumMethod implements IMethodHandleStrategy {

    @Override
    public String handleMethod(String params) {
        String[] paramArray = SubStringUtil.splitParams(params, 2);
        String result = SubStringUtil.subStringByNum(paramArray[0], paramArray[1], null);
        System.out.println("SubStartNumMethod 执行结果是："+result);
        return result;
    }
}


@Action(name="substartstr")
public class SubStartStrMethod implements IMethodHandleStrategy {

    @Override
    public String handleMethod(String params) {
        String[] paramArray = SubStringUtil.splitParams(params, 2);
        String result = SubStringUtil.subStringByStr(paramArray[0], paramArray[1], null);
        System.out.println("SubStartStrMethod 执行结果是："+result);
        return result;
    }
}

自定义的注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface Action {
    String name() default "";
}

策略上下文（策略接口的持有者）

public class MethodStrategyContext {

    private static Map<String, Class> allActions;
    private static final String PACKAGE_NAME = "com.stf.core";

    static  {
        Reflections reflections = new Reflections(PACKAGE_NAME);
        Set<Class<?>> annotationClasses = reflections.getTypesAnnotatedWith(Action.class);
        allActions = new ConcurrentHashMap<>();
        for (Class<?> classObject: annotationClasses) {
            Action action = classObject.getAnnotation(Action.class);
            allActions.put(action.name(), classObject);
        }
        allActions = Collections.unmodifiableMap(allActions);
    }

    private IMethodHandleStrategy methodHandleStrategy;

    /**
     * 设置策略接口
     */
    public MethodStrategyContext(String name) {
        if (allActions.containsKey(name)) {
            log.info("Created Action name is {}", name);
            try {
                methodHandleStrategy = (IMethodHandleStrategy)allActions.get(name).newInstance();
            } catch (InstantiationException | IllegalAccessException e) {
                log.error("Instantiate Action failed", e);
            }
        } else {
            log.warn("Specified Action name {} does not exist", name);
        }
    }

    public String handleMethod(String params, String actionKeyword) {
        if (methodHandleStrategy != null) {
            return methodHandleStrategy.handleMethod(params);
        } else {
            log.warn("未检索到对应动作关键字，请检查关键字：{}", actionKeyword);
        }
        return null;
    }
}

上述代码中，先获取指定包路径下的所有带 Action 注解的类，放到 map 里面，再根据传递的参数 name 获取到 map 中对应的类，通过 Java 反射得到该对象，再执行对象的方法。

具体调用

public static void main(String[] args) {
        // 模拟生成 actionList
        List<Action> actionList = ActionBuilder.generateActionList();

        for (Action action: actionList) {
            // 获取并设置策略
            String method = action.getMethod();
            if (StringUtils.isNotBlank(method)) {
                // 策略上下文
                MethodStrategyContext methodStrategyContext = new MethodStrategyContext(method.toLowerCase());
                // 执行策略
                methodStrategyContext.handleMethod(action.getParam(), method);
            }
        }
    }

执行结果：

11:57:04.825 [main] INFO com.stf.core.MethodStrategyContext - Created Action name is subcentrenum
SubCenterNumMethod 执行结果是：middle_str
11:57:04.828 [main] INFO com.stf.core.MethodStrategyContext - Created Action name is subcentrestr
SubCenterStrMethod 执行结果是：middle_str
11:57:04.829 [main] INFO com.stf.core.MethodStrategyContext - Created Action name is substartnum
SubStartNumMethod 执行结果是：tail_str
11:57:04.829 [main] INFO com.stf.core.MethodStrategyContext - Created Action name is substartstr
SubStartStrMethod 执行结果是：tail_str
11:57:04.829 [main] INFO com.stf.core.MethodStrategyContext - Created Action name is params
paramsMethod 执行结果是：xpath=tesfdfdsfadfdsf

总结

通过策略模式+注解+Java 反射的改造，我们已经消除了 if-else 的结构，每当新来一种方法类型时，只需要添加新的策略处理类即可，保证了程序符合开闭原则。