一起学设计模式 - 创建型设计模式之工厂模式

短命女 2022-11-05 01:59 313阅读 0赞

### 文章目录 ###

*  一起学设计模式 - 创建型设计模式之工厂模式
 *   *  1.工厂模式是什么？
     *  2.简单工厂模式
     *  3.工厂方法模式
     *  4.抽象工厂模式

# 一起学设计模式 - 创建型设计模式之工厂模式 #

## 1.工厂模式是什么？ ##

>  工厂模式想必大家也不陌生，但是真的对所有的工厂模式的实现都理解了吗？工厂模式提供了一种创建对象的最佳方式，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。  
>    
>  比如我们大家都是搞IT的，我们现在需要一台电脑。我们不用去考虑电脑如何组装；并且我们可以根据喜好选择各种类型的电脑，比如游戏本、商务本、超薄本。这些我们直接去电脑城就可以购买，而电脑城在这里的角色就是工厂。  
>    
>  并且除了各种类型的电脑，还有各种各样品牌的区别，比如外星人、苹果、戴尔、联想、华硕。  
>    
>  而在我们业务开发中比较常见的就是支付模块，支付都有一个统一下单、支付、退款的接口，具体的支付实现可以是支付宝、微信、银行卡等各种方式。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70]  
>  工厂模式也有三种不同的实现方式：
> 
> 1.  `简单工厂模式`：通过传入相关类型匹配返回对应的类；实现简单但方式单一，可扩展性差。
> 2.  `工厂方法模式`：通过实现类实现响应的方法来决定返回的结果；可扩展性强。
> 3.  `抽象工厂模式`：基于简单工厂模式和工厂方法模式的扩展，可更细化产品。  
>      
> 
>  这三种方式后面我都会一一举例，和大家分享我的理解。这里我们先看看一般哪些场景下可能可以使用到工厂模式。
> 
> 1.  `解耦`：分离职责，将复杂对象的创建和使用过程分开。
> 2.  `复用代码`：降低维护成本，如果对象创建复杂且多处需用到，则可以考虑使用工厂模式统一创建，修改时只需修改工厂类即可。

## 2.简单工厂模式 ##

>  简单工厂模式又称静态工厂方法，根据不同参数返回不同类的实例，专门提供一个工厂类来负责创建其他类的实例。而被创建的实例通常都会有共同的父类。  
>    
>  简单工厂模式主要由三部分组成：
> 
> 1.  `Factory`：工厂类，简单工厂模式的核心，主要负责实现创建实例。
> 2.  `IProduct`：抽象产品类，简单工厂模式所创建的所有对象的父类，描述所有实例所共有的公共接口。
> 3.  `Product`：具体产品类，是简单工厂模式的创建目标。  
>      
> 
>  而整个实现也十分简单，这里我们来看一下大概需要如何实现。

**创建抽象产品类**

>  创建抽象产品类，里面有产品的抽象方法，由具体的产品类去实现。这里我们定义了一个电脑统一接口。

/** * 电脑产品 接口 */
    public interface IComputer { 
    
        /** * 玩游戏 */
        void playGame();
    
        /** * 编程 */
        void programming();
    
    }

**创建具体产品类**

>  创建具体产品类，继承了他们的父类，并实现具体方法。这里我们定义了两个品牌电脑产品并且实现了统一接口。

public class DellComputer implements IComputer { 
    
        @Override
        public void playGame() { 
            System.out.println("DellComputer playGame");
        }
    
        @Override
        public void programming() { 
            System.out.println("DellComputer programming");
        }
    }

public class AppleComputer implements IComputer{ 
    
        @Override
        public void playGame() { 
            System.out.println("AppleComputer playGame");
        }
    
        @Override
        public void programming() { 
            System.out.println("AppleComputer programming");
        }
    }

**创建工厂类**

>  创建工厂类，提供了一个静态方法`createComputer`方法来生产电脑产品，只需要传入我们需要的品牌类型即可。

/** * 电脑工厂 */
    public class ComputerFactory { 
    
        public static IComputer createComputer(String type){ 
            if ("DELL".equals(type)){ 
                return new DellComputer();
            } else if("APPLE".equals(type)){ 
                return new AppleComputer();
            }
            return null;
        }
    
        public static void main(String[] args) { 
            IComputer dell = ComputerFactory.createComputer("DELL");
            dell.playGame();
            dell.programming();
        }
    }

>  整个结构关系如下图，其实实现过程还是十分简单的。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 1]  
>  这里我们可以大概总结下简单工厂模式的优缺点。
> 
> 1.  `优点`：将对象的创建和对象本身业务处理分离可以降低系统的耦合度，使得两者修改起来都相对容易。
> 2.  `缺点`：工厂类的职责相对过重，增加新的产品需要修改工厂类的判断逻辑，这一点与开闭原则是相违背。并且会增加系统中类的个数，在一定程度上增加了系统的复杂度和理解难度，不利于系统的扩展和维护。

## 3.工厂方法模式 ##

>  工厂方法模式是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。  
>    
>  通过工厂父类定义负责创建产品的公共接口，通过子类来确定所需要创建的类型。相比简单工厂而言，此种方法具有更多的可扩展性和复用性，同时也增强了代码的可读性。  
>    
>  将类的实例化（具体产品的创建）延迟到工厂类的子类（具体工厂）中完成，即由子类来决定应该实例化哪一个类。  
>    
>  而工厂方法的组成在简单工厂上多一层。
> 
> 1.  `IProduct`：抽象产品类，描述所有实例所共有的公共接口。
> 2.  `Product`：具体产品类，实现抽象产品类的接口，工厂类创建对象，如果有多个需要定义多个。
> 3.  `IFactory`：抽象工厂类，描述具体工厂的公共接口。
> 4.  `Factory`：具体工厂类，实现创建产品类对象，实现抽象工厂类的接口，如果有多个需要定义多个。  
>      
> 
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 2]  
>  这里先把整个关系图给大家放出来，梳理清楚关系后咱们看代码。  
>    
>  创建抽象产品类和创建具体产品这两步和简单工厂一样，这里主要在于工厂类的创建思路。

**抽象工厂**

/** * 电脑工厂 */
    public interface ComputerFactory { 
    
        IComputer createComputer();
    }

**具体工厂**

public class AppleComputerFactory implements ComputerFactory { 
        @Override
        public IComputer createComputer() { 
            return new AppleComputer();
        }
    }

public class DellComputerFactory implements ComputerFactory { 
    
        @Override
        public IComputer createComputer() { 
            return new DellComputer();
        }
    
        public static void main(String[] args) { 
            ComputerFactory computerFactory = new DellComputerFactory();
            IComputer computer = computerFactory.createComputer();
            computer.playGame();
            computer.programming();
        }
    }

>  这里比较可以发现，工厂方法模式将创建具体产品的权利交给了具体的工厂，这种方式的优缺点我们也大概分析一下。
> 
> 1.  `优点`：  
>      符合开闭原则，增加一个产品类，只需要实现其他具体的产品类和具体的工厂类；  
>      符合单一职责原则，每个工厂只负责生产对应的产品；使用者只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。
> 2.  `缺点`：增加一个产品，需要实现对应的具体工厂类和具体产品类；每个产品需要有对应的具体工厂和具体产品类。

## 4.抽象工厂模式 ##

>  抽象工厂模式是基于上述两种模式的拓展，是工厂方法模式的升级版，当需要创建的产品有多个产品线时使用抽象工厂模式是比较好的选择。在Spring框架中抽象工厂模式其实就是应用得最为广泛的一种设计模式。  
>    
>  工厂方法模式引入工厂等级结构，解决了简单工厂模式中工厂类职责过重的问题。但是工厂方法模式中每个工厂只创建一类具体类的对象，后续发展可能会导致工厂类过多，因此将一些相关的具体类组成一个“具体类族”，由同一个工厂来统一生产，强调的是一系列相关的产品对象。  
>    
>  抽象工厂模式相比上面的结构化要复杂很多，如果对于工厂模式熟悉的同学在维护的时候会发现十分清爽；但其实如果不熟悉的话也增加了不少阅读和理解难度。不过既然我们要一起学设计模式，那当然就要彻底理解，这里可能需要大家集中注意力去思考理解。  
>    
>  最开始学习理解这种模式的时候我始终站在从上往下的角度去设计，但是后来发现这种思路其实是错误的，因为如果完全自上而下的话那其实就没有明白为何要使用这种模式。这里我会尽可能细进行阶段化拆分开让大家跟清晰理解这种模式。

>  我们以现实场景为例，这样不会过于抽象；但既然是抽象工厂模式，抽象的思想也就不能完全抛弃。  
>    
>  假如现在`苹果`和`戴尔`两个厂商要生产电子产品，那么他们都会建立自己的`生产线`，那么不管生产什么电子产品我们假定生产的整体流程都是一致的，主要包含`生产CPU`、`生产内存`和`组装`。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 3]  
>  根据上面这份依赖关系，我们首先需要定义一个生产线的统一接口，里面统一规范生产线所需进行的步骤。

**生产线统一标准**

/** * 生产线 */
    public interface ProductionLine { 
    
        /** * 生产CPU */
        void produceCpu();
    
        /** * 生产内存 */
        void produceMemory();
    
        /** * 组装 */
        Product assemble();
    }

>  接下来我们依次实现苹果手机、苹果电脑、戴尔电脑各自的生产线实现类。

**苹果手机生产线**

/** * 苹果手机生产线 */
    public class AppleIphoneProductionLine implements ProductionLine { 
    
        @Override
        public void produceCpu() { 
            System.out.println("AppleIphoneProductionLine produceCpu");
        }
    
        @Override
        public void produceMemory() { 
            System.out.println("AppleIphoneProductionLine produceMemory");
        }
    
        @Override
        public Product assemble() { 
            System.out.println("AppleIphoneProductionLine assemble");
            return new ApplePhone().setName("苹果手机");
        }
    }

**苹果电脑生产线**

/** * 苹果电脑生产线 */
    public class AppleComputerProductionLine implements ProductionLine { 
    
        @Override
        public void produceCpu() { 
            System.out.println("AppleComputerProductionLine produceCpu");
        }
    
        @Override
        public void produceMemory() { 
            System.out.println("AppleComputerProductionLine produceMemory");
        }
    
        @Override
        public Product assemble() { 
            System.out.println("AppleComputerProductionLine assemble");
            return new AppleComputer().setName("苹果电脑");
        }
    }

**戴尔电脑生产线**

/** * 戴尔电脑生产线 */
    public class DellComputerProductionLine implements ProductionLine { 
    
        @Override
        public void produceCpu() { 
            System.out.println("DellComputerProductionLine produceCpu");
        }
    
        @Override
        public void produceMemory() { 
            System.out.println("DellComputerProductionLine produceMemory");
        }
    
        @Override
        public Product assemble() { 
            System.out.println("DellComputerProductionLine assemble");
            return new DellComputer().setName("戴尔电脑");
        }
    }

>  这里面涉及了具体生产的产品，内容很简单，大概的结构图如下，大家稍微有点印象就可以了，这个不是抽象工厂的核心。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 4]  
>  电脑和手机生产完成后，我们就需要把他卖出去了，不然这样我们就是自个闹着玩。这里我们就需要依靠专卖店了，但是苹果和戴尔都有自个的专卖店，不过专卖店的功能都差不多，这里我们定义一个专卖店的统一功能接口，然后苹果和戴尔根据这套规范按照自己的方法去销售就好了。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 5]

**专卖店统一标准**

/** * 专卖店(产品族工厂的产品) */
    public interface ExclusiveAgency { 
    
        /** * 销售 */
        void sell(Product product);
    
        /** * 回收 */
        void recycle();
    
        /** * 修理 */
        void fix();
    }

**苹果专卖店**

/** * 苹果专卖店 */
    public class AppleExclusiveAgency implements ExclusiveAgency{ 
    
        @Override
        public void sell(Product product) { 
            System.out.println("AppleExclusiveAgency sell" + product.getName());
        }
    
        @Override
        public void recycle() { 
            System.out.println("AppleExclusiveAgency recycle");
        }
    
        @Override
        public void fix() { 
            System.out.println("AppleExclusiveAgency fix");
        }
    }

**戴尔专卖店**

/** * 戴尔专卖店 */
    public class DellExclusiveAgency implements ExclusiveAgency { 
    
        @Override
        public void sell(Product product) { 
            System.out.println("DellExclusiveAgency sell" + product.getName());
        }
    
        @Override
        public void recycle() { 
            System.out.println("DellExclusiveAgency recycle");
        }
    
        @Override
        public void fix() { 
            System.out.println("DellExclusiveAgency fix");
        }
    }

>  好了，一切就绪。按照以前我们的思路，我们只需要通过获取不同的生产线，然后再去不同的专卖店销售产品就可以了。那么抽象工厂模式使这种抽象升华了一下。  
>    
>  我们知道无论是苹果还是戴尔想要完成整个流程，都避免不了先去获取自己的流水线生产出产品后，再去获取自己的专卖店销售自己的产品。那么获取流水线和获取专卖店这两个也可以抽象成一层标准。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 6]

**公司统一工厂类**

/** * 公司工厂类 */
    public interface CompanyFactory { 
    
        /** * 获取生产线 * @return */
        ProductionLine createProductionLine(String type);
    
        /** * 获取专卖店 * @return */
        ExclusiveAgency createExclusiveAgency();
    }

**苹果公司**

/** * 苹果公司工厂类 */
    public class AppleCompanyFactory implements CompanyFactory { 
    
        @Override
        public ProductionLine createProductionLine(String type) { 
            if ("Mobile".equals(type)) { 
                return new AppleIphoneProductionLine();
            }
            return new AppleComputerProductionLine();
        }
    
        @Override
        public ExclusiveAgency createExclusiveAgency() { 
            return new AppleExclusiveAgency();
        }
    }

>  苹果公司除了电脑还生产手机，所以在获取生产线时还可以灵活去匹配。

**戴尔公司**

/** * 戴尔公司工厂类 */
    public class DellCompanyFactory implements CompanyFactory { 
    
        @Override
        public ProductionLine createProductionLine(String type) { 
            return new DellComputerProductionLine();
        }
    
        @Override
        public ExclusiveAgency createExclusiveAgency() { 
            return new DellExclusiveAgency();
        }
    }

>  到这里就真的一切都大功告成了，最后完成我们工厂类终极生产者。

/** * 超级工厂生产者 */
    public class FactoryProducer { 
    
        public static CompanyFactory getFactory(String type) { 
            if ("APPLE".equals(type)) { 
                return new AppleCompanyFactory();
            } else if ("DELL".equals(type)) { 
                return new DellCompanyFactory();
            }
            return null;
        }
    }

>  我们只需要通过标识就可以获取到整个公司的完整业务体系了。

public static void main(String[] args) { 
            CompanyFactory appleCompanyFactory = FactoryProducer.getFactory("APPLE");
            // 获取生产线 生产具体产品
            ProductionLine pcProductionLine = appleCompanyFactory.createProductionLine("PC");
            pcProductionLine.produceCpu();
            pcProductionLine.produceMemory();
            Product product = pcProductionLine.assemble();
    
            // 获取专卖店 销售产品
            ExclusiveAgency appleExclusiveAgency = appleCompanyFactory.createExclusiveAgency();
            appleExclusiveAgency.sell(product);
            appleExclusiveAgency.fix();
            appleExclusiveAgency.recycle();
    
    
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 7]

>  最后再奉上这张整体结构体，大家可以再顺着思路理一理；整个过程比较抽象，还是需要一定时间消化消化的。而当抽象工厂模式中每一个具体工厂类只创建一个产品对象，抽象工厂模式退化成工厂方法模式。  
>    
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 8]  
>  这里同样总结一下抽象工厂模式的优缺点。
> 
> 1.  `优点`：当一个产品族中的多个对象被设计成一起工作时，它能保证使用方始终只使用同一个产品族中的对象；`产品等级结构`扩展容易，如果需要增加多一个产品等级，比如公司品牌工厂升级又接入了更多类似联想、华硕的品牌厂商，只需要增加新的工厂类和产品类即可，只需要新增一套公司的逻辑然后在超级工厂类中接入无需修改原有抽象代码。
> 2.  `缺点`：`产品族`扩展困难，要增加一个系列的某一产品，比如除了`流水线`和`专卖店`还需要新增一个`体验店`，甚至需要改动所有抽象的工厂和抽象产品里的代码，不是很符合开闭原则；并且增加了系统的抽象性和理解难度。  
>      
> 
>  工厂模式大概就是上面这些内容了，如果是刚接触的话其实要完全理解还是有一定难度的。希望我的分享能给大家带来帮助，一起进步，谢谢！

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

>  源码地址：[【设计模式博客源码】][Link 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70]: /images/20221023/3506ef4095444bc3b5f6a538079a107f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 1]: /images/20221023/51e8fb10ad764677958e650239608e14.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 2]: /images/20221023/effce985ff344341b506816efb562052.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 3]: /images/20221023/fe8854f2542c4605b8089cbc5d77c31a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 4]: /images/20221023/4646dc7f26c74b65aba3a4d372b0345e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 5]: /images/20221023/12adfb858a5b4d5199b5539f29501c13.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 6]: /images/20221023/ffc4b757c089417d83ef7b061535e9dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 7]: /images/20221023/b3548bca3ea04750b4d7652c0c14dbac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM5ODU2NjQ_size_16_color_FFFFFF_t_70 8]: /images/20221023/b15c99d57cf243429324f24055436d7f.png
[Link 1]: https://gitee.com/onethree/design-pattern