文章目录
策略模式 + 工厂方法
策略模式 + 工厂方法是解决 if…else 用得非常多的方案
- 把条件模块抽象为一个公共的接口,策略接口
public interface ActionService {
void doAction();
}
- 根据每个逻辑,定义出自己具体的策略实现类,如下:
public class ActionService1 implements ActionService{
public void doAction() {
//do something
}
}
public class ActionService2 implements ActionService{
public void doAction() {
//do something
}
}
// 省略其他策略
- 工厂类,统一调度,用来管理这些策略,如下:
public class ActionServiceFactory {
private ActionServiceFactory(){
}
private static class SingletonHolder{
private static ActionServiceFactory instance=new ActionServiceFactory();
}
public static ActionServiceFactory getInstance(){
return SingletonHolder.instance;
}
private static final Map<String,ActionService> ACTION_SERVICE_MAP = new HashMap<String, ActionService>();
static {
ACTION_SERVICE_MAP.put("action1",new ActionService1());
ACTION_SERVICE_MAP.put("action2",new ActionService2());
ACTION_SERVICE_MAP.put("action3",new ActionService3());
ACTION_SERVICE_MAP.put("action4",new ActionService4());
ACTION_SERVICE_MAP.put("action5",new ActionService5());
}
public static ActionService getActionService(String actionCode) {
ActionService actionService = ACTION_SERVICE_MAP.get(actionCode);
if (actionService == null) {
throw new RuntimeException("非法 actionCode");
}
return actionService;
}
public void doAction(String actionCode) {
getActionService(actionCode).doAction();
}
}
单例模式实现工厂类。
- 使用
ActionServiceFactory.getInstance().doAction("action1");
这种优化方式也是很优雅的,特别适合分支较多,逻辑较为复杂的代码块,这种方式将分支逻辑与业务代码解耦了,是一种很不错的方案。
责任链模式
责任链我们可以看做是一个单链表的数据结构,一个对象一个对象地过滤条件,符合的就执行,然后结束,不符合的就传递到下一个节点,如果每个对象都无法处理,一般都有一个最终的节点来统一处理。
- 定义责任链处理请求节点
public abstract class ActionHandler {
// 后继节点
protected ActionHandler successor;
/**
* 处理请求
* @param actionCode
*/
public void handler(String actionCode) {
doHandler(actionCode);
}
// 设置后继节点
protected ActionHandler setSuccessor(ActionHandler successor) {
this.successor = successor;
return this;
}
// 处理请求
public abstract void doHandler(String actionCode);
}
- 定义首尾节点,用于一些异常情况的处理
// 首节点,判断 actionCode 是否为空
public class HeadHandler extends ActionHandler{
@Override
public void doHandler(String actionCode) {
if (StringUtils.isBlank(actionCode)) {
throw new RuntimeException("actionCode 不能为空");
}
successor.doHandler(actionCode);
}
}
// 尾节点,直接抛出异常,因为到了尾节点说明当前 code 没有处理
public class TailHandler extends ActionHandler{
@Override
public void doHandler(String actionCode) {
throw new RuntimeException("当前 code[" + actionCode + "] 没有具体的 Handler 处理");
}
}
- 定义各个节点具体的实现节点
public class ActionHandler1 extends ActionHandler{
@Override
public void doHandler(String actionCode) {
if ("action1".equals(actionCode)) {
doAction1();
} else {
// 传递到下一个节点
successor.doHandler(actionCode);
}
}
}
public class ActionHandler2 extends ActionHandler{
@Override
public void doHandler(String actionCode) {
if ("action2".equals(actionCode)) {
doAction2();
} else {
// 传递到下一个节点
successor.doHandler(actionCode);
}
}
}
// 省略其他节点
- 定义工厂,来构建一条完整的责任链,并负责调度
public class ActionHandlerFactory {
private ActionHandler headHandler;
private ActionHandlerFactory(){
headHandler = new HeadHandler();
ActionHandler actionHandler1 = new ActionHandler1();
ActionHandler actionHandler2 = new ActionHandler2();
ActionHandler actionHandler3 = new ActionHandler3();
ActionHandler actionHandler4 = new ActionHandler4();
ActionHandler actionHandler5 = new ActionHandler5();
ActionHandler tailHandler = new TailHandler();
// 构建一条完整的责任链
headHandler.setSuccessor(actionHandler1).setSuccessor(actionHandler2).setSuccessor(actionHandler3).
setSuccessor(actionHandler4).setSuccessor(actionHandler5).setSuccessor(tailHandler);
}
private static class SingletonHolder{
private static ActionHandlerFactory instance=new ActionHandlerFactory();
}
public static ActionHandlerFactory getInstance(){
return SingletonHolder.instance;
}
public void doAction(String actionCode) {
headHandler.doHandler(actionCode);
}
}
- 使用
ActionHandlerFactory.getInstance().doAction("action1");