引言
在业务操作中，我们经常会遇到根据关键字来执行相应的方法，返回结果。
模拟一个执行方法类：
@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 的结构，每当新来一种方法类型时，只需要添加新的策略处理类即可，保证了程序符合开闭原则。
网友评论