工厂模式的应用
背景
在实际开发中,下面这种情况往往是遇到最多的场景:根据某个标记信息,走不同的实现分支逻辑。典型的如,根据订单的类型:普通订单、批量订单,分别走不同的分支实现。我遇到的实际需求是,第三方触发规则,规则中有定义不同的执行动作,需要根据动作编码来执行对应的逻辑。 以下根据实际需求,简化需求如下,当前有三个不同的类型需要对应处理:
Type = 1,执行逻辑1;
Type = 2,执行逻辑2;
Type = 3,执行逻辑3;
实现方案分析
下面是三种不同的实现,这三种实现的抽象度、设计原则的遵从度各不相同,所带来的问题也各不相同。下面就分别来看下不同的实现并进行分析。
方案1 使用 if else
这种方案是最简单的,也是最容易直接想到的。直接在代码中硬编码,使用if else来判断Type的值,根据不同的值走不同的分支处理。
-Java 代码01 | public class Processer { |
03 | * 业务需求,按照不同的分类有不同的处理过程 |
07 | public void handling(int flagType) throws Exception { |
09 | TypeOneHandler typeOneHandler = new TypeOneHandler(); |
10 | typeOneHandler.doing(); |
11 | } else if (flagType == 2) { |
12 | TypeTwoHandler typeTwoHandler = new TypeTwoHandler(); |
13 | typeTwoHandler.doing(); |
14 | } else if (flagType == 3) { |
15 | TypeThreeHandler typeThreeHandler = new TypeThreeHandler(); |
16 | typeThreeHandler.doing(); |
18 | throw new Exception('Error Type!'); |
优点:
简单直接,直接在代码里判断类型,使用if else走不同的分支逻辑。 分支逻辑很清楚,在调测阶段,直接根据条件判断出走的哪个分支逻辑。
缺点:
外部的类(Processer)直接依赖具体的Handler实现类。这里例子中,每个handler的处理都是一个doing方法封装了。但是,实际实现中,由于没有抽象的思维,往往不同的handler提供的方法也是不同的。
不利于后续的扩展,当新增了一个类型后,需要修改if else的代码,新增一个else分支处理。同时,新增一个Handler类用来实现对应的逻辑。
例如,当Type新增了一个值:4时。
-Java 代码01 | public void handling(int flagType) throws Exception { |
03 | TypeOneHandler typeOneHandler = new TypeOneHandler(); |
04 | typeOneHandler.doing(); |
05 | } else if (flagType == 2) { |
06 | TypeTwoHandler typeTwoHandler = new TypeTwoHandler(); |
07 | typeTwoHandler.doing(); |
08 | } else if (flagType == 3) { |
09 | TypeThreeHandler typeThreeHandler = new TypeThreeHandler(); |
10 | typeThreeHandler.doing(); |
13 | else if (flagType == 4) { |
14 | TypeFourHandler typeFourHandler = new TypeFourHandler(); |
15 | typeFourHandler.doing(); |
18 | throw new Exception('Error Type!'); |
方案2 使用工厂模式
在方案1的基础上,根据不同类型处理类的实现,封装一个接口。采用依赖倒置原则,让外部执行依赖这个接口。同时,在构建一个工厂类,在工厂类中负责创建具体的执行类。
工厂方法的实现有两种方法,方法1使用if else来判断。
-Java 代码02 | public static ITypeHandler getTypeHandler(int typeFlag) { |
04 | return new TypeOneHandlerImpl(); |
05 | } else if (typeFlag == 2) { |
06 | return new TypeTwoHandlerImpl(); |
07 | } else if (typeFlag == 3) { |
08 | return new TypeThreeHandlerImpl(); |
方法2,构建一个Map,使用Type作为Key,具体的实现类作为Value,根据Type获取对应的实现类。
-Java 代码02 | public static ITypeHandler getTypeHander2(int typeFlag) { |
04 | TypeOneHandlerImpl typeOneHandler = new TypeOneHandlerImpl(); |
05 | TypeTwoHandlerImpl typeTwoHandler = new TypeTwoHandlerImpl(); |
06 | TypeThreeHandlerImpl typeThreeHandler = new TypeThreeHandlerImpl(); |
07 | HashMap typeHandlerMap = new HashMap(); |
08 | typeHandlerMap.put(1,typeOneHandler); |
09 | typeHandlerMap.put(2,typeTwoHandler); |
10 | typeHandlerMap.put(3,typeThreeHandler); |
12 | return (ITypeHandler) typeHandlerMap.get(typeFlag); |
看到这儿,会发现工厂模式和直接使用if else的方式差别感觉并不大。工厂中构建实现类的两种方法,方法1就是if else的实现。方法2使用了map,相对来说会好一些。但是仍然没有解决方案1的缺点,而且还多增加了一个Factory实现类。只带来了下面两个好处: 根据设计原则:功能职责单一原则。if else和实现类的处理的实现分在两个实现类实现,每个实现类的职责单一。 外部依赖抽象的接口,不依赖具体的实现类,这部分是可以稳定的,除非接口发生变更。
方案3 借助IoC框架实现工厂方法
在方案2的基础上,期望能够去掉if else,同时可以适应扩展,使得整个实现符合开闭原则:对扩展开放,对修改封闭。目标就是,如果Type的值新增,只需要定义一个对应的扩展实现类,由框架自动完成实现类构造。 借助Spring这样的IoC框架,可以实现自动注入。我们可以将实现类自动注入到Factory中的一个Map中,并借助Type为Key值,从而使用一个稳定的map.get(type)的方法返回对应的实现类。
-Java 代码04 | public class HandlerFactory { |
07 | private Map<String , ITypeHandler> handlerMap; |
09 | public ITypeHandler getHandlerByName(String name){ |
10 | return handlerMap.get(name); |
-Java 代码2 | public interface ITypeHandler { |
-Java 代码4 | public class TypeOneHandlerImpl implements ITypeHandler { |
7 | System.out.println('Doing type one!'); |
-Java 代码2 | public class TypeTwoHandlerImpl implements ITypeHandler { |
5 | System.out.println('Doing type two!'); |
-Java 代码1 | public void doBusiness() { |
2 | HandlerFactory hf = applicationContext.getBean(HandlerFactory.class); |
3 | hf.getHandlerByName('2').doing(); |
当需要新增一个实现类时,只需要继承ITypeHandler实现一个对应的实现类。如下所示:
-Java 代码2 | public class TypeFourHandlerImpl implements ITypeHandler { |
5 | System.out.println('Doing type four!'); |
Spring框架会自动将这个实现类注入到工厂类的handlerMap中,无需在使用显式的代码来处理。
这样做的优点是,对于扩展来说,只需要新增实现类,其他的完全都不需要关注和变更。从而符合以下设计原则: 开闭原则,对于扩展新的实现,只需要新增实现类。 职责单一原则,每个类的职责是单一的,边界是明确的。 * 依赖倒置原则,Business处理完全不依赖于具体实现类,只要接口稳定,就可以不断扩展。
不过,这需要IoC框架支持。在没有引入IoC框架时,可以考虑直接利用java的反射机制。
总结
如果类型变化的可能性不大,也就是说类型相对稳定,那么使用方案1也是可以的。因为被依赖的实现已经预见是稳定的,并不会发生变动。例如,在使用java开发时,我们都会依赖jdk提供的各种基础类,如String。如果要按照设计原则来看,String是一个具体的实现。不应该依赖它,但是它相对来说是稳定的。依赖它也不会带来太大的问题。相反,如果再去抽象一个interface,反而会导致开发效率的下降。 在功能实现和开发代码时,并一定要完全遵守各种设计原则。设计原则只是为了让我们可以在遇到某个问题的时候,帮助我们提升效率。
方案3应该是最好的一种实现方案了,当业务变化导致类型不断地变化,为了适配这种情况,提升开发效率,使用方案3就是最好的解决办法。但是,也会带来复杂度提升等问题,包括内存管理(如果使用反射)等方面的问题。
我认为,好的代码就是要能够适应当前开发的需求,不做过度的设计,在刚刚好的情况下,使用最优的方案解决问题。
BY:HW-LT