文档开发者中心
我的

代码实现探索系列--工厂模式的应用

工厂模式的应用

背景

在实际开发中,下面这种情况往往是遇到最多的场景:根据某个标记信息,走不同的实现分支逻辑。典型的如,根据订单的类型:普通订单、批量订单,分别走不同的分支实现。我遇到的实际需求是,第三方触发规则,规则中有定义不同的执行动作,需要根据动作编码来执行对应的逻辑。 以下根据实际需求,简化需求如下,当前有三个不同的类型需要对应处理:

  • Type = 1,执行逻辑1;

  • Type = 2,执行逻辑2;

  • Type = 3,执行逻辑3;


实现方案分析

下面是三种不同的实现,这三种实现的抽象度、设计原则的遵从度各不相同,所带来的问题也各不相同。下面就分别来看下不同的实现并进行分析。


方案1 使用 if else

这种方案是最简单的,也是最容易直接想到的。直接在代码中硬编码,使用if else来判断Type的值,根据不同的值走不同的分支处理。


-Java 代码
01public class Processer {
02    /**
03     * 业务需求,按照不同的分类有不同的处理过程
04      * @param flagType
05      * @throws Exception
06     */
07     public void handling(int flagType) throws Exception {
08        if (flagType == 1){
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();
17        } else {
18            throw new Exception('Error Type!');
19        }
20    }
21}

优点: 

简单直接,直接在代码里判断类型,使用if else走不同的分支逻辑。 分支逻辑很清楚,在调测阶段,直接根据条件判断出走的哪个分支逻辑。

缺点:

外部的类(Processer)直接依赖具体的Handler实现类。这里例子中,每个handler的处理都是一个doing方法封装了。但是,实际实现中,由于没有抽象的思维,往往不同的handler提供的方法也是不同的。

不利于后续的扩展,当新增了一个类型后,需要修改if else的代码,新增一个else分支处理。同时,新增一个Handler类用来实现对应的逻辑。

例如,当Type新增了一个值:4时。


-Java 代码
01public void handling(int flagType) throws Exception {
02    if (flagType == 1){
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();
11    }
12    // 修改此处的代码,增加Type=4的判断和相应的逻辑处理
13    else if (flagType == 4) {
14        TypeFourHandler typeFourHandler = new TypeFourHandler();
15        typeFourHandler.doing();
16    }
17    else {
18        throw new Exception('Error Type!');
19    }
20}

方案2 使用工厂模式

在方案1的基础上,根据不同类型处理类的实现,封装一个接口。采用依赖倒置原则,让外部执行依赖这个接口。同时,在构建一个工厂类,在工厂类中负责创建具体的执行类。

工厂方法的实现有两种方法,方法1使用if else来判断。


-Java 代码
01// TypeHandlerFactory代码片段,根据Type的值返回实现类
02public static ITypeHandler getTypeHandler(int typeFlag) {
03    if (typeFlag == 1) {
04        return new TypeOneHandlerImpl();
05  } else if (typeFlag == 2) {
06        return new TypeTwoHandlerImpl();
07  } else if (typeFlag == 3) {
08        return new TypeThreeHandlerImpl();
09  }
10    return null;
11}



方法2,构建一个Map,使用Type作为Key,具体的实现类作为Value,根据Type获取对应的实现类。


-Java 代码
01// TypeHandlerFactory代码片段,使用Type作为key获取实现类
02public static ITypeHandler getTypeHander2(int typeFlag) {
03    // 以下初始化代码,应该使用单例模式
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);
11
12 return (ITypeHandler) typeHandlerMap.get(typeFlag);
13}



看到这儿,会发现工厂模式和直接使用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 代码
01// HandlerFactory的代码
02// 使用Component,告知IoC框架进行自动注入
03@Component
04public class HandlerFactory {
05  // 借助IoC框架Spring实现自动注入,这里使用的是ITypeHandler这个接口
06  @Autowired
07  private Map<String , ITypeHandler> handlerMap;
08
09 public ITypeHandler getHandlerByName(String name){
10        return handlerMap.get(name);
11  }
12}
-Java 代码
1// ITypeHandler接口定义
2public interface ITypeHandler {
3    public void doing();
4}
-Java 代码
1// 类型=1的处理实现类
2// 借助Spring框架,会自动注入到Handler的handlerMap中,并使用'1'作为key值
3@Component('1')
4public class TypeOneHandlerImpl implements ITypeHandler {
5    @Override
6  public void doing() {
7        System.out.println('Doing type one!');
8  }
9}
-Java 代码
1@Component('2')
2public class TypeTwoHandlerImpl implements ITypeHandler {
3    @Override
4  public void doing() {
5        System.out.println('Doing type two!');
6  }
7}

在Business侧的实现将会是:


-Java 代码
1public void doBusiness() {
2  HandlerFactory hf = applicationContext.getBean(HandlerFactory.class);
3  hf.getHandlerByName('2').doing();
4}

当需要新增一个实现类时,只需要继承ITypeHandler实现一个对应的实现类。如下所示:


-Java 代码
1@Component('4')
2public class TypeFourHandlerImpl implements ITypeHandler {
3    @Override
4  public void doing() {
5        System.out.println('Doing type four!');
6  }
7}


Spring框架会自动将这个实现类注入到工厂类的handlerMap中,无需在使用显式的代码来处理。

这样做的优点是,对于扩展来说,只需要新增实现类,其他的完全都不需要关注和变更。从而符合以下设计原则: 开闭原则,对于扩展新的实现,只需要新增实现类。 职责单一原则,每个类的职责是单一的,边界是明确的。 * 依赖倒置原则,Business处理完全不依赖于具体实现类,只要接口稳定,就可以不断扩展。

不过,这需要IoC框架支持。在没有引入IoC框架时,可以考虑直接利用java的反射机制。

总结

如果类型变化的可能性不大,也就是说类型相对稳定,那么使用方案1也是可以的。因为被依赖的实现已经预见是稳定的,并不会发生变动。例如,在使用java开发时,我们都会依赖jdk提供的各种基础类,如String。如果要按照设计原则来看,String是一个具体的实现。不应该依赖它,但是它相对来说是稳定的。依赖它也不会带来太大的问题。相反,如果再去抽象一个interface,反而会导致开发效率的下降。 在功能实现和开发代码时,并一定要完全遵守各种设计原则。设计原则只是为了让我们可以在遇到某个问题的时候,帮助我们提升效率。

方案3应该是最好的一种实现方案了,当业务变化导致类型不断地变化,为了适配这种情况,提升开发效率,使用方案3就是最好的解决办法。但是,也会带来复杂度提升等问题,包括内存管理(如果使用反射)等方面的问题。

我认为,好的代码就是要能够适应当前开发的需求,不做过度的设计,在刚刚好的情况下,使用最优的方案解决问题。


BY:HW-LT

点赞
收藏
回复
1
分享
举报
浏览804 编辑于2019-10-10 02:05未知归属地
全部评论
最多点赞
最新发布
最早发布

赞同作者的话,好的代码就是要能够适应当前开发的需求,不做过度的设计,在刚刚好的情况下,使用最优的方案解决问题。

1楼回复于2019-10-10 09:28 未知归属地
写回答
新增插入模板功能
一键使用模板,快速填写内容,轻松发帖~
知道了
  • 为了保障您的信息安全,请勿上传您的敏感个人信息(如您的密码等信息)和您的敏感资产信息(如关键源代码、签名私钥、调试安装包、业务日志等信息),且您需自行承担由此产生的信息泄露等安全风险。
  • 如您发布的内容为转载内容,请注明内容来源。

我要发帖子

目录 收起
工厂模式的应用
实现方案分析
总结
了解社区公约,与您携手共创和谐专业的开发者社区。