新来的"大神"用策略模式把if else给"优化"了，技术总监说：能不能想好了再改？-阿里云开发者社区

本文来自作者投稿，原作者：上帝爱吃苹果

目前在魔都，贝壳找房是我的雇主，平时关注一些 java 领域相关的技术，希望你们能在这篇文章中找到些有用的东西。个人水平有限，如果文章有错误还请指出，在留言区一起交流。

我想大家肯定都或多或少的看过各种“策略模式”的讲解、布道等等，这篇文章就是来好好“澄清”一下策略模式，并尝试回答以下的问题：

1. 策略模式是如何优化业务逻辑代码结构的？

2. 杀鸡焉用宰牛刀？就是几个if else场景我需要用到策略模式？！

3. 有没有什么更好的代码结构来实现策略模式的吗？

策略模式是如何优化业务逻辑代码结构的？

要回答这个问题，我们还得先扒一扒策略模式的定义，从定义着手来理解它

策略模式的教科书定义

它的定义很精简：一个类的行为或其算法可以在运行时更改。我们把它降维到代码层面，用人话翻译一下就是，运行时我给你这个类的方法传不同的“key”，你这个方法会执行不同的业务逻辑。细品一下，这不就是 if else 干的事吗？

策略模式优化了什么？

其实策略模式的核心思想和 if else如出一辙，根据不同的key动态的找到不同的业务逻辑，那它就只是如此吗？

实际上，我们口中的策略模式其实就是在代码结构上调整，用接口+实现类+分派逻辑来使代码结构可维护性好点。

一般教科书上讲解到接口与实现类就结束了，其他博客上会带上提及分派逻辑。这里就不啰嗦了。

小结一下，即使用了策略模式，你该写的业务逻辑照常写，到逻辑分派的时候，还是变相的if else。而它的优化点是抽象了出了接口，将业务逻辑封装成一个一个的实现类，任意地替换。在复杂场景（业务逻辑较多）时比直接 if else 来的好维护些。

杀鸡焉用宰牛刀？就是几个if else场景我需要用到策略模式？！

我想小伙伴们经常有这样的不满，我的业务逻辑就3 4 行，你给我整一大堆类定义？有必要这么麻烦吗？我看具体的业务逻辑还需要去不同的类中，简单点行不行。

其实我们所不满的就是策略模式带来的缺点：

1、策略类会增多

2、业务逻辑分散到各个实现类中，而且没有一个地方可以俯视整个业务逻辑

针对传统策略模式的缺点，在这分享一个实现思路，这个思路已经帮我们团队解决了多个复杂if else的业务场景，理解上比较容易，代码上需要用到Java8的特性——利用Map与函数式接口来实现。

直接show代码结构：为了简单演示一个思路，代码用String 类型来模拟一个业务BO

其中：

getCheckResult() 为传统的做法
getCheckResultSuper()则事先在Map中定义好了“判断条件”与“业务逻辑”的映射关系,具体讲解请看代码注释

/**

某个业务服务类
*/

@Service public class BizService {

/**
 * 传统的 if else 解决方法
 * 当每个业务逻辑有 3 4 行时，用传统的策略模式不值得，直接的if else又显得不易读
 */
public String getCheckResult(String order) {
    if ("校验1".equals(order)) {
        return "执行业务逻辑1";
    } else if ("校验2".equals(order)) {
        return "执行业务逻辑2";
    }else if ("校验3".equals(order)) {
        return "执行业务逻辑3";
    }else if ("校验4".equals(order)) {
        return "执行业务逻辑4";
    }else if ("校验5".equals(order)) {
        return "执行业务逻辑5";
    }else if ("校验6".equals(order)) {
        return "执行业务逻辑6";
    }else if ("校验7".equals(order)) {
        return "执行业务逻辑7";
    }else if ("校验8".equals(order)) {
        return "执行业务逻辑8";
    }else if ("校验9".equals(order)) {
        return "执行业务逻辑9";
    }
    return "不在处理的逻辑中返回业务错误";
}

/**
 * 业务逻辑分派Map
 * Function为函数式接口，下面代码中 Function&lt;String, String&gt; 的含义是接收一个Stirng类型的变量，返回一个String类型的结果
 */
private Map&lt;String, Function&lt;String, String&gt;&gt; checkResultDispatcher = new HashMap&lt;&gt;();

/**
 * 初始化 业务逻辑分派Map 其中value 存放的是 lambda表达式
 */
@PostConstruct
public void checkResultDispatcherInit() {
    checkResultDispatcher.put("校验1", order -&gt; String.format("对%s执行业务逻辑1", order));
    checkResultDispatcher.put("校验2", order -&gt; String.format("对%s执行业务逻辑2", order));
    checkResultDispatcher.put("校验3", order -&gt; String.format("对%s执行业务逻辑3", order));
    checkResultDispatcher.put("校验4", order -&gt; String.format("对%s执行业务逻辑4", order));
    checkResultDispatcher.put("校验5", order -&gt; String.format("对%s执行业务逻辑5", order));
    checkResultDispatcher.put("校验6", order -&gt; String.format("对%s执行业务逻辑6", order));
    checkResultDispatcher.put("校验7", order -&gt; String.format("对%s执行业务逻辑7", order));
    checkResultDispatcher.put("校验8", order -&gt; String.format("对%s执行业务逻辑8", order));
    checkResultDispatcher.put("校验9", order -&gt; String.format("对%s执行业务逻辑9", order));
}

public String getCheckResultSuper(String order) {
    //从逻辑分派Dispatcher中获得业务逻辑代码，result变量是一段lambda表达式
    Function&lt;String, String&gt; result = checkResultDispatcher.get(order);
    if (result != null) {
        //执行这段表达式获得String类型的结果
        return result.apply(order);
    }
    return "不在处理的逻辑中返回业务错误";
}

}

通过http调用一下看看效果：

/**
 * 模拟一次http调用
 */
@RestController
public class BizController {

    @Autowired
    private BizService bizService;

    @PostMapping("/v1/biz/testSuper")
    public String test2(String order) {
        return bizService.getCheckResultSuper(order);
    }
}

这是个简单的demo演示，之后会举一些复杂的场景案例。

鲁迅曾说过，“每解决一个问题，就会因出更多的问题”。我们一起来看看这样的实现有什么好处，会带来什么问题。

好处很直观：

在一段代码里直观的看到"判断条件"与业务逻辑的映射关系
不需要单独定义接口与实现类，直接使用现有的函数式接口（什么？不知道函数式接口？快去了解），而实现类直接就是业务代码本身。

不好的点：

需要团队成员对lambda表达式有所了解(什么？Java14都出来了还有没用上Java8新特性的小伙伴？)

接下来我举几个在业务中经常遇到的if else场景，并用Map+函数式接口的方式来解决它

在真实业务场景问题的解决思路

有的小伙伴会说，我的判断条件有多个啊，而且很复杂，你之前举个例子只有单个判断逻辑，而我有多个判断逻辑该怎么办呢？

很好解决：写一个判断逻辑的方法，Map的key由方法计算出

/**

某个业务服务类
*/

@Service public class BizService {

private Map&lt;String, Function&lt;String, String&gt;&gt; checkResultDispatcherMuti = new HashMap&lt;&gt;();

/**
 * 初始化 业务逻辑分派Map 其中value 存放的是 lambda表达式
 */
@PostConstruct
public void checkResultDispatcherMuitInit() {
    checkResultDispatcherMuti.put("key_订单1", order -&gt; String.format("对%s执行业务逻辑1", order));
    checkResultDispatcherMuti.put("key_订单1_订单2", order -&gt; String.format("对%s执行业务逻辑2", order));
    checkResultDispatcherMuti.put("key_订单1_订单2_订单3", order -&gt; String.format("对%s执行业务逻辑3", order));
}

public String getCheckResultMuti(String order, int level) {
    //写一段生成key的逻辑：
    String ley = getDispatcherKey(order, level);

    Function&lt;String, String&gt; result = checkResultDispatcherMuti.get(ley);
    if (result != null) {
        //执行这段表达式获得String类型的结果
        return result.apply(order);
    }
    return "不在处理的逻辑中返回业务错误";
}

/**
 * 判断条件方法
 */
private String getDispatcherKey(String order, int level) {
    StringBuilder key = new StringBuilder("key");
    for (int i = 1; i &lt;= level; i++) {
        key.append("_" + order + i);
    }
    return key.toString();
}

}

用http模拟一下：

/**
 * 模拟一次http调用
 */
@RestController
public class BizController {

    @Autowired
    private BizService bizService;

    @PostMapping("/v1/biz/testMuti")
    public String test1(String order, Integer level) {
        return bizService.getCheckResultMuti(order, level);
    }
}

只要设计好你的key的生成规则就好。

还有小伙伴会问：我的业务逻辑有很多很多行，在checkResultDispatcherMuitInit()方法的Map中直接写不会很长吗？

直接写当然长了，我们可以抽象出一个service服务专门放业务逻辑，然后在定义中调用它就好了：

提供一个业务逻辑单元：

/**

提供业务逻辑单元
*/

@Service public class BizUnitService {

public String bizOne(String order) {
    return order + "各种花式操作1";
}
public String bizTwo(String order) {
    return order + "各种花式操作2";
}
public String bizThree(String order) {
    return order + "各种花式操作3";
}

}

/**

某个业务服务类
*/

@Service public class BizService {

@Autowired
private BizUnitService bizUnitService;

private Map&lt;String, Function&lt;String, String&gt;&gt; checkResultDispatcherComX = new HashMap&lt;&gt;();

/**
 * 初始化 业务逻辑分派Map 其中value 存放的是 lambda表达式
 */
@PostConstruct
public void checkResultDispatcherComXInit() {
    checkResultDispatcherComX.put("key_订单1", order -&gt; bizUnitService.bizOne(order));
    checkResultDispatcherComX.put("key_订单1_订单2", order -&gt; bizUnitService.bizTwo(order));
    checkResultDispatcherComX.put("key_订单1_订单2_订单3", order -&gt; bizUnitService.bizThree(order));
}

public String getCheckResultComX(String order, int level) {
    //写一段生成key的逻辑：
    String ley = getDispatcherComXKey(order, level);

    Function&lt;String, String&gt; result = checkResultDispatcherComX.get(ley);
    if (result != null) {
        //执行这段表达式获得String类型的结果
        return result.apply(order);
    }
    return "不在处理的逻辑中返回业务错误";
}

/**
 * 判断条件方法
 */
private String getDispatcherComXKey(String order, int level) {
    StringBuilder key = new StringBuilder("key");
    for (int i = 1; i &lt;= level; i++) {
        key.append("_" + order + i);
    }
    return key.toString();
}

}

调用结果：

总结

最后，我们一起尝试回答以下几个问题：

1. 策略模式是如何优化业务逻辑代码结构的？

抽象了出了接口，将业务逻辑封装成一个一个的实现类，任意地替换。在复杂场景（业务逻辑较多）时比直接 if else 来的好维护些。

2. 杀鸡焉用宰牛刀？就是几个if else场景我需要用到策略模式？！

我们所不满的其实就是传统接口实现的缺点： 1、策略类会很多。 2、业务逻辑分散到各个实现类中，而且没有一个地方可以俯览整个业务逻辑

3. 有没有什么更好的代码结构来实现策略模式的吗？

针对传统策略模式的缺点，分享了利用Map与函数式接口来实现的思路。

新来的"大神"用策略模式把if else给"优化"了，技术总监说：能不能想好了再改？

策略模式是如何优化业务逻辑代码结构的？

策略模式的教科书定义

策略模式优化了什么？

杀鸡焉用宰牛刀？就是几个if else场景我需要用到策略模式？！

在真实业务场景问题的解决思路

总结

Java技术进阶

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

新来的"大神"用策略模式把if else给"优化"了，技术总监说：能不能想好了再改？

策略模式是如何优化业务逻辑代码结构的？

策略模式的教科书定义

策略模式优化了什么？

杀鸡焉用宰牛刀？就是几个if else场景我需要用到策略模式？！

在真实业务场景问题的解决思路

总结

Java技术进阶

热门文章

最新文章

相关课程

相关电子书