字节二面：如何用策略模式，优化你代码里的的if-else？

曾经终败给现在 2022-10-05 11:56 110阅读 0赞

> 有情怀，有干货，微信搜索【**三太子敖丙**】关注这个有一点点东西的程序员。
> 
> 本文 **GitHub** [https://github.com/JavaFamily][https_github.com_JavaFamily] 已收录，有一线大厂面试完整考点、资料以及我的系列文章。

最近有一个学妹在跟我沟通如何有效的去避免代码中一长串的**if else**判断或者**switch**条件判断？针对更多的回答就是合理的去使用设计来规避这个问题。

在设计模式中，可以使用**工厂模式**或者**策略模式**来处理这类问题，之前已经分享了工厂模式，感兴趣的同学可以去复习一下。

设计模式系列往期文章：

*  [单例模式][Link 1]
 *  [工厂模式][Link 2]
 *  [流程引擎][Link 3]
 *  [建造者模式][Link 4]
 *  [原型模式][Link 5]
 *  [责任链模式][Link 6]
 *  [观察者模式][Link 7]

那么工厂模式和策略模式有什么区别呢？

>  *  工厂模式是属于创建型设计模式，主要用来针对不同类型创建不同的对象，达到解偶类对象。
>  *  策略模式是属于行为型设计模式，主要是针对不同的策略做出对应行为，达到行为解偶

本次就来具体聊聊**策略模式**它是如何做到行为解耦

## 大纲 ##

![19127596eac99ef0e588c5c9d3609ef7.png][]

## 定义 ##

什么是策略模式？它的原理实现是怎么样的？

> 定义一系列算法，封装每个算法，并使他们可以互换，不同的策略可以让算法独立于使用它们的客户而变化。 以上定义来自设计模式之美

感觉有点抽象？那就来看一张结构图吧

![874977cb436b8fa44e9b1e0bc62b4c30.png][]

>  *  Strategy（抽象策略）：抽象策略类，并且定义策略执行入口
>  *  ConcreteStrategy（具体策略）：实现抽象策略，实现algorithm方法
>  *  Context（环境）：运行特定的策略类。

这么看结构其实还是不复杂的，而且跟状态模式类似。

那么这个代码怎么实现？

举个例子，汽车大家肯定都不陌生，愿大家早日完成汽车梦，汽车的不同档(concreteStrategy）就好比不同的策略，驾驶者选择几档则汽车按几档的速度前进，整个选择权在驾驶者（context）手中。

public interface GearStrategy { 
    
        // 定义策略执行方法
        void algorithm(String param);
    }

首先还是先定义抽象策略

> 这里是用接口的形式，还有一种方式可以用抽象方法**abstract**来写也是一样的。具体就看大家自己选择了。
> 
>     public abstract class GearStrategyAbstract { 
>      // 定义策略执行方法
>      abstract void algorithm(String param);
>     }

public class GearStrategyOne implements GearStrategy { 
    
        @Override
        public void algorithm(String param) { 
            System.out.println("当前档位" + param);
        }
    }

其次定义具体档位策略，实现algorithm方法。

public class Context { 
    		// 缓存所有的策略，当前是无状态的，可以共享策略类对象
        private static final Map<String, GearStrategy> strategies = new HashMap<>();
    
        // 第一种写法
        static { 
            strategies.put("one", new GearStrategyOne());
        }
    
        public static GearStrategy getStrategy(String type) { 
            if (type == null || type.isEmpty()) { 
                throw new IllegalArgumentException("type should not be empty.");
            }
            return strategies.get(type);
        }
    
        // 第二种写法
        public static GearStrategy getStrategySecond(String type) { 
            if (type == null || type.isEmpty()) { 
                throw new IllegalArgumentException("type should not be empty.");
            }
            if (type.equals("one")) { 
                return new GearStrategyOne();
            }
            return null;
        }
    
    
        public static void main(String[] args) { 
            // 测试结果
            GearStrategy strategyOne = Context.getStrategy("one");
            strategyOne.algorithm("1档");
             // 结果：当前档位1档
            GearStrategy strategyTwo = Context.getStrategySecond("one");
            strategyTwo.algorithm("1档");
            // 结果：当前档位1档
        }
    
    }

最后就是实现运行时环境（Context），你可以定义成StrategyFactory，但都是一个意思。

在main方法里面的测试demo，可以看到通过不同的type类型，可以实现不同的策略，这就是策略模式主要思想。

在Context里面定义了两种写法：

>  *  第一种是维护了一个strategies的Map容器。用这种方式就需要判断每种策略是否可以共享使用，它只是作为算法的实现。
>  *  第二种是直接通过有状态的类，每次根据类型new一个新的策略类对象。这个就需要根据实际业务场景去做的判断。

### 框架的应用 ###

策略模式在框架中也在一个很常见的地方体现出来了，而且大家肯定都有使用过。

那就是JDK中的线程池**ThreadPoolExecutor**

![a5481ee7ff55ca7a67f35cb9dccc3c72.png][]

首先都是类似于这样定义一个线程池，里面实现线程池的异常策略。

这个线程池的异常策略就是用的策略模式的思想。

![78bf9284c4c6f0eee1d1673e068bcea8.png][]

在源码中有RejectedExecutionHandler这个抽象异常策略接口，同时它也有四种拒绝策略。关系图如下：

![dfd6718576cfb1acd5a40d56a19e9c7f.png][]

![595b61beba6c5d0cd3e70a7cc91b36fd.png][]

这就是在框架中的体现了，根据自己的业务场景，合理的选择线程池的异常策略。

### 业务改造举例 ###

在真实的业务场景中策略模式也还是应用很多的。

在社交电商中分享商品是一个很重要的环节，假设现在要我们实现一个分享图片功能，比如当前有 单商品、多商品、下单、会场、邀请、小程序链接等等多种分享场景。

![8c3b44882c4d2f94b0cf4f09def30dfa.png][]

针对上线这个流程图先用if else语句做一个普通业务代码判断，就像下面的这中方式：

public class SingleItemShare { 
        // 单商品
        public void algorithm(String param) { 
            System.out.println("当前分享图片是" + param);
        }
    }
    public class MultiItemShare { 
        // 多商品
        public void algorithm(String param) { 
            System.out.println("当前分享图片是" + param);
        }
    }
    public class OrderItemShare { 
        // 下单
        public void algorithm(String param) { 
            System.out.println("当前分享图片是" + param);
        }
    }
    public class ShareFactory { 
    
        public static void main(String[] args) throws Exception { 
            Integer shareType = 1;
           // 测试业务逻辑
            if (shareType.equals(ShareType.SINGLE.getCode())) { 
                SingleItemShare singleItemShare = new SingleItemShare();
                singleItemShare.algorithm("单商品");
            } else if (shareType.equals(ShareType.MULTI.getCode())) { 
                MultiItemShare multiItemShare = new MultiItemShare();
                multiItemShare.algorithm("多商品");
            } else if (shareType.equals(ShareType.ORDER.getCode())) { 
                OrderItemShare orderItemShare = new OrderItemShare();
                orderItemShare.algorithm("下单");
            } else { 
                throw new Exception("未知分享类型");
            }
            // .....省略更多分享场景
        }
    
        enum ShareType { 
            SINGLE(1, "单商品"),
            MULTI(2, "多商品"),
            ORDER(3, "下单");
            /** * 场景对应的编码 */
            private Integer code;
            /** * 业务场景描述 */
            private String desc;
            ShareType(Integer code, String desc) { 
                this.code = code;
                this.desc = desc;
            }
            public Integer getCode() { 
                return code;
            }
           // 省略 get set 方法
        }
    }

这里大家可以看到每新加一种分享类型，就需要加一次if else 判断，当如果有十几种场景的时候那代码整体就会非常的长，看起来给人的感觉也不是很舒服。

接下来就看看如何用策略模式进行重构：

public interface ShareStrategy { 
        // 定义分享策略执行方法
        void shareAlgorithm(String param);
    }
    
    public class OrderItemShare implements ShareStrategy { 
        @Override
        public void shareAlgorithm(String param) { 
            System.out.println("当前分享图片是" + param);
        }
    }
    
    // 省略 MultiItemShare以及SingleItemShare策略
    
    // 分享工厂
    public class ShareFactory { 
    		// 定义策略枚举
        enum ShareType { 
            SINGLE("single", "单商品"),
            MULTI("multi", "多商品"),
            ORDER("order", "下单");
            // 场景对应的编码
            private String code;
           
            // 业务场景描述
            private String desc;
            ShareType(String code, String desc) { 
                this.code = code;
                this.desc = desc;
            }
            public String getCode() { 
                return code;
            }
           // 省略 get set 方法
        }
    		// 定义策略map缓存
        private static final Map<String, ShareStrategy> shareStrategies = new       HashMap<>();
        static { 
            shareStrategies.put("order", new OrderItemShare());
            shareStrategies.put("single", new SingleItemShare());
            shareStrategies.put("multi", new MultiItemShare());
        }
        // 获取指定策略
        public static ShareStrategy getShareStrategy(String type) { 
            if (type == null || type.isEmpty()) { 
                throw new IllegalArgumentException("type should not be empty.");
            }
            return shareStrategies.get(type);
        }
    	
        public static void main(String[] args) { 
            // 测试demo
            String shareType = "order";
            ShareStrategy shareStrategy = ShareFactory.getShareStrategy(shareType);
            shareStrategy.shareAlgorithm("order");
            // 输出结果：当前分享图片是order
        }
    }

这里策略模式就已经改造完了。在client请求端，根本看不到那么多的if else判断，只需要传入对应的策略方式即可，这里我们维护了一个策略缓存map，在直接调用的ShareFactory获取策略的时候就直接是从换种获取策略类对象。

这就已经达到了行为解偶的思想。同时也避免了长串的if else 判断。

优点：

>  *  算法策略可以自由实现切换
>  *  扩展性好，加一个策略，只需要增加一个类

缺点：

>  *  策略类数量多
>  *  需要维护一个策略枚举，让别人知道你当前具有哪些策略

## 总结 ##

以上就讲完了策略模式，整体看上去其实还是比较简单的，还是那句话学习设计模式我们还是要学习每种设计模式的思想，任何一种设计模式存在即合理。当然也不要因为设计模式而设计代码，那样反而得不偿失。

--------------------

**敖丙把自己的面试文章整理成了一本电子书，共 1630页！**

**干货满满，字字精髓。目录如下，还有我复习时总结的面试题以及简历模板，现在免费送给大家。**

![9a3daa9b6b50144cb4872985437ff964.png][]

链接:[https://pan.baidu.com/s/1ZQEKJBgtYle3v-1LimcSwg][https_pan.baidu.com_s_1ZQEKJBgtYle3v-1LimcSwg] 密码:`wjk6`

我是敖丙，**你知道的越多，你不知道的越多**，感谢各位人才的：**点赞**、**收藏**和**评论**，我们下期见！

--------------------

> 文章持续更新，可以微信搜一搜「 **三太子敖丙** 」第一时间阅读，回复【**资料**】有我准备的一线大厂面试资料和简历模板，本文 **GitHub** [https://github.com/JavaFamily][https_github.com_JavaFamily] 已经收录，有大厂面试完整考点，欢迎Star。

[https_github.com_JavaFamily]: https://github.com/AobingJava/JavaFamily
[Link 1]: https://mp.weixin.qq.com/s/dW0L-PoBeTFHhD29HJO0BQ
[Link 2]: https://mp.weixin.qq.com/s/j42vn-A_rdWZP3aixXB8Ag
[Link 3]: https://mp.weixin.qq.com/s/b8xa3o4fKDme2438oJTakw
[Link 4]: https://mp.weixin.qq.com/s/h7iEyxgN34FPn191S8qUpA
[Link 5]: https://mp.weixin.qq.com/s/fORmbucHuPVMS2z3q-mV3A
[Link 6]: https://mp.weixin.qq.com/s/l9EdvpAMukIDOgaN7x3b4w
[Link 7]: https://mp.weixin.qq.com/s/_hVGgJxefoVXFHFNXC-U6A
[19127596eac99ef0e588c5c9d3609ef7.png]: /images/20221005/9c9b8e810bd84134999e01c51eee1dce.png
[874977cb436b8fa44e9b1e0bc62b4c30.png]: /images/20221005/f135acc4eafc4c69b09997cba4496ea3.png
[a5481ee7ff55ca7a67f35cb9dccc3c72.png]: /images/20221005/88f947aa7bd640ea9562257be0841111.png
[78bf9284c4c6f0eee1d1673e068bcea8.png]: /images/20221005/e6f7e898108e4da6a7bbc8b7c0f63462.png
[dfd6718576cfb1acd5a40d56a19e9c7f.png]: /images/20221005/20ecb259adb341df80fd8673f71db9ee.png
[595b61beba6c5d0cd3e70a7cc91b36fd.png]: /images/20221005/53c52225f8764273b696a629b577134b.png
[8c3b44882c4d2f94b0cf4f09def30dfa.png]: /images/20221005/7ad6791492b4426c86b3571102e491cd.png
[9a3daa9b6b50144cb4872985437ff964.png]: /images/20221005/02d1029148ae40f6b9ff5cff540ad16d.png
[https_pan.baidu.com_s_1ZQEKJBgtYle3v-1LimcSwg]: https://pan.baidu.com/s/1ZQEKJBgtYle3v-1LimcSwg