【设计模式】第二章：工厂模式详解及应用案例

短命女 2024-04-03 11:21 63阅读 0赞

## 系列文章 ##

[【设计模式】七大设计原则][Link 1]  
[【设计模式】第一章：单例模式][Link 2]  
[【设计模式】第二章：工厂模式][Link 3]  
[【设计模式】第三章：建造者模式][Link 4]  
[【设计模式】第四章：原型模式][Link 5]  
[【设计模式】第五章：适配器模式][Link 6]  
[【设计模式】第六章：装饰器模式][Link 7]  
[【设计模式】第七章：代理模式][Link 8]  
[【设计模式】第八章：桥接模式][Link 9]  
[【设计模式】第九章：外观模式 / 门面模式][Link 10]  
[【设计模式】第十章：组合模式][Link 11]  
[【设计模式】第十一章：享元模式][Link 12]  
[【设计模式】第十二章：观察者模式][Link 13]  
[【设计模式】第十三章：模板方法模式][Link 14]  
[【设计模式】第十四章：策略模式][Link 15]  
[【设计模式】第十五章：责任链模式][Link 16]  
[【设计模式】第十六章：迭代器模式][Link 17]  
[【设计模式】第十七章：状态模式][Link 18]  
[【设计模式】第十八章：备忘录模式][Link 19]  
[【设计模式】第十九章：访问者模式][Link 20]  
[【设计模式】第二十章：解释器模式][Link 21]  
[【设计模式】第二十一章：命令模式][Link 22]  
[【设计模式】第二十二章：中介者模式][Link 23]

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

#### 文章目录 ####

*  系列文章
 *  一、定义
 *  二、实现方式
 *   *  1. 简单工厂模式
     *   *  （1）角色分类
         *  （2）应用案例
         *  （3）优缺点
         *  （4）小结
     *  2. 工厂方法模式
     *   *  （1）角色分类
         *  （2）应用案例
         *  （3）优缺点
         *  （4）小结
     *  3. 抽象工厂模式
     *   *  （1）角色分类
         *  （2）应用案例
         *  （3）优缺点
         *  （4）小结
 *  三、应用场景
 *  四、总结
 *  推荐

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

## 一、定义 ##

> 摘自百度百科：  
> 工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。

工厂模式为我们提供了一种创建对象的最佳方式，最大的特点是我们在创建对象的时候不会对客户端暴露创建逻辑，通过一个共同的接口去指向新创建的对象。

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

## 二、实现方式 ##

工厂模式是一种比较统概的说法，实现方式共分为以下几种：

*  **简单工厂模式**
 *  **工厂方法模式**
 *  **抽象工厂模式**

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

> 简单工厂模式又叫做`静态工厂模式`，它是由一个工厂来决定创建出哪一种产品的实例。

#### （1）角色分类 ####

**具体工厂**

它`负责实现创建实例的内部逻辑`，创建方法由外部调用，创建不同的产品

**抽象产品**

它是所有产品的父类，它`负责来描述所有实例的共有的公共接口`

**具体产品**

它是具体被创建的产品，`所有被创建的对象都是这个角色下具体某个具体类的实例`

#### （2）应用案例 ####

> 例如：你肚子饿了，于是你便来到了一家面馆（具体工厂），然后面馆中有各种各样的面（抽象产品），然后可以根据自己的口味来下单合适的面（具体产品）

**抽象产品**：

/**
     * 抽象产品
     */
    public interface Noodles {
        
    	/**
    	 * 做面
    	 */
    	void cook();
    }

**具体产品**

/**
     * 拉面
     */
    public class Ramen implements Noodles {
        
    	@Override
    	public void cook(){
        
    		System.out.println("正在制作拉面...");
    	}
    }

/**
     * 汤面
     */
    public class SoupNoodles implements Noodles {
        
    	@Override
    	public void cook(){
        
    		System.out.println("正在制作汤面...");
    	}
    }

/**
     * 炒面
     */
    public class StirFriedNoodles implements Noodles {
        
    	@Override
    	public void cook(){
        
    		System.out.println("正在制作炒面...");
    	}
    }

**具体工厂**

/**
     * 具体工厂
     */
    public class CookFactory {
        
    	
    	/**
    	 * 做面
    	 * @param type 面条类型
    	 */
    	public static Noodles cookNoodles(String type) {
        
    		switch (type) {
        
    			case "Ramen":
    				return new Ramen();
    			case "SoupNoodles":
    				return new SoupNoodles();
    			case "StirFriedNoodles":
    				return new StirFriedNoodles();
    			default :
    				return null;
    		}
    	}
    }

**测试类**

public class Test {
        
    	public static void main(String[] args){
        
    		CookFactory factory = new CookFactory();
    		
    		Ramen ramen = factory.cookNoodles("Ramen");
    		ramen.cook();
    		SoupNoodles soupNoodles = factory.cookNoodles("SoupNoodles");
    		soupNoodles.cook();
    		StirFriedNoodles stirFriedNoodles = factory.cookNoodles("StirFriedNoodles");
    		stirFriedNoodles.cook();
    	}
    }

![测试结果][563ed0e1cc944bdfaa3cb30cfcbc9271.png]

#### （3）优缺点 ####

**优点：**

*  将对象的创建与使用隔离开，使用时不必关心对象是如何创建的，并实现了`解耦`
 *  将实例的初始化放到工厂中实现，`代码更易维护，并且更贴近面向对象/接口开发原则`

**缺点：**

*  `过于依赖工厂`，所有的实例都在该工厂中创建，若该工厂出现异常，则涉及工厂的地方都会出现异常
 *  `违反开闭原则`，每次想要新增产品时都需要修改工厂的逻辑，`不便于新增`

#### （4）小结 ####

简单工厂可以理解为：`通过一个抽象产品，从而派生出其他的具体产品。再通过一个工厂来完成具体产品的创建。`

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

工厂方法模式又称为工厂模式，是我们最常用的一种工厂模式，我们通过`定义一个工厂的父类，该父类中包含一个创建对象的共有方法，再由其子类去创建具体对象。`

#### （1）角色分类 ####

**抽象工厂**

负责描述工厂的公共接口

**具体工厂**

实现了抽象工厂中的抽象方法，负责对象的创建

**抽象产品**

负责描述产品的公共接口，描述了产品的主要特性或功能

**具体产品**

实现了抽象产品中的接口，用于被工厂创建

#### （2）应用案例 ####

> 比如：你感到肚子饿了想要吃面，这时你来到小吃街（抽象工厂），里面有许多家餐馆，每种餐馆只做一种面（抽象产品），那么你想要去你最喜欢的面馆中（具体工厂）去下单喜欢吃的面条（具体产品）

**抽象产品**

public abstract class Noodles {
        
    	public abstract void eat();
    }

**具体产品**

public class Ramen extends Noodles {
        
    	
    	@Override
    	public void eat() {
        
    		System.out.println("我要吃拉面...");
    	}
    }

public class SoupNoodles extends Noodles {
        
    	
    	@Override
    	public void eat() {
        
    		System.out.println("我要吃汤面...");
    	}
    }

public class StirFriedNoodles extends Noodles {
        
    	
    	@Override
    	public void eat() {
        
    		System.out.println("我要吃炒面...")
    	}
    }

**抽象工厂**

public abstract class NoodlesFactory {
        
    
    	public abstract Noodles getNoodles();
    }

**具体工厂**

/**
     * 拉面
     */
    public class RestaurantA extends NoodlesFactory {
        
    
    	@Override
    	public Noodles getNoodles(){
        
    		return new Ramen();
    	}
    }

/**
     * 汤面
     */
    public class RestaurantB extends NoodlesFactory {
        
    	
    	@Override
    	public Noodles getNoodles() {
        
    		return new SoupNoodles();
    	}
    }

/**
     * 炒面
     */
    public class RestaurantC extends NoodlesFactory {
        
    	
    	@Override
    	public Noodles getNoodles() {
        
    		return new StirFriedNoodles();
    	}
    }

**测试类**

public class Test {
        
    	public static void main(String[] args){
        
    		FactoryA factoryA = new FactoryA();
    		factoryA.getNoodles().eat();
    		
    		FactoryB factoryB = new FactoryB();
    		factoryB.getNoodles().eat();
    		
    		FactoryC factoryC = new FactoryC();
    		factoryC.getNoodles().eat();
    	}
    }

![运行结果][715eb1ff05ee43e589601cc6ab972968.png]

#### （3）优缺点 ####

**优点**：

*  `符合开闭原则，且可扩展度高`，新增加功能只需要增加具体产品和工厂子类即可
 *  `符合单一职责原则`，每个工厂子类只负责对应的产品

**缺点**：

*  增加了系统复杂度，因为一个工厂只创建一种具体产品，那么类的数量会增加
 *  系统会变得更加抽象，不便于理解

#### （4）小结 ####

工厂方法模式可以理解为：`通过一个父类工厂来派生出其他的具体工厂，再通过一个抽象产品派生出其他的具体产品，由对应的具体工厂来创建，且每个具体工厂只负责创建一种具体产品`。

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

抽象工厂模式其实就是升级版的工厂方法模式，它是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。  
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

#### （1）角色分类 ####

**抽象工厂**

负责描述工厂的公共接口

**具体工厂**

负责创建实例，供外部调用

**抽象产品族**

负责描述抽象产品的公共接口

**抽象产品**

负责描述具体产品的公共接口

**具体产品**

具体产品，由工厂创建

#### （2）应用案例 ####

> 例如：你肚子感到饿了，你想去吃点东西，于是你来到了小吃街（抽象工厂），这条街有各种各样的食物（抽象产品族），比如主食、小吃等（抽象产品），于是你来到了其中的一家餐馆（具体工厂），里面有汉堡、薯条、炸鸡等食物（具体产品）

**抽象产品族**

public abstract class Food {
        
    	public abstract void description();
    }

**抽象产品**

public abstract class StapleFood extends Food {
        
    }

public abstract class Snacks extends Food {
        
    }

**具体产品**

/**
     * 米饭
     */
    public class Rice extends StapleFood {
        
    	@Override
    	public void description() {
        
    		System.out.println("米饭")
    	}
    }

/**
     * 面条
     */
    public class Noodles extends StapleFood {
        
    	@Override
    	public void description() {
        
    		System.out.println("面条");
    	}
    }

/**
     * 汉堡
     */
    public class Hamburger extends Snacks {
        
    	@Override
    	public void description() {
        
    		System.out.println("汉堡");
    	}
    }

/**
     * 薯条
     */
    public class Chips extends Snacks {
        
    	@Override
    	public void description() {
        
    		System.out.println("薯条");
    	}
    }

**抽象工厂**

public abstract class FoodFactory {
        
    	/**
    	 * 下单主食
    	 */
    	public abstract Food getStapleFood();
    
    	/**
    	 * 下单小吃
    	 */
    	 public abstract Food getSnacks();
    }

**具体工厂**

public class StapleFoodFactory extends FoodFactory {
        
    	@Override
    	public Food getStapleFood() {
        
    		//下单米饭
    		return new Rice();
    	}
    
    	@Override
    	public Food getSnacks() {
        
    		//下单汉堡
    		return new Hamburger();
    	}
    }

public class SnacksFactory extends FoodFactory {
        
    	@Override
    	public Food getStapleFood() {
        
    		//下单面条
    		return new Noodles();
    	}
    
    	@Override
    	public Food getSnacks() {
        
    		//下单薯条
    		return new Chips();
    	}
    }

**测试类**

public class Test {
        
    	public static void main(String[] args) {
        
    		StapleFoodFactory stapleFactory = new StapleFoodFactory();
    		stapleFactory.getStapleFood().description();
    		stapleFactory.getSnacks().description();
    
    		System.out.println("----------分割线----------");
    
    		SnacksFactory snacksFactory = new SnacksFactory();
    		snacksFactory.getStapleFood().description();
    		snacksFactory.getSnacks().description();
    	}
    }

![在这里插入图片描述][76759b97460647eba9c297a6e67018b9.png]

#### （3）优缺点 ####

**优点：**

*  `符合开闭原则`
 *  `降低耦合`
 *  当一个产品族中的多个对象被设计成一起工作时，它能`保证客户端始终只使用同一个产品族中的对象`。

**缺点：**

*  扩展比较麻烦，当需要增加某个产品族的产品时，不仅要在抽象产品中增加代码，还要在具体产品中增加代码

#### （4）小结 ####

抽象工厂我们可以理解为：`首先由抽象工厂派生出多个具体工厂，抽象产品族派生出多个抽象产品，再由抽象产品派生出多个具体产品，由具体工厂来创建具体产品，且同一个具体工厂可以创建多个具体产品`

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

## 三、应用场景 ##

> 以下部分内容摘自菜鸟教程

**意图：** 定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。  
**主要解决：** 主要解决接口选择的问题。  
**何时使用：** 我们明确地计划不同条件下创建不同实例时。  
**如何解决：** 让其子类实现工厂接口，返回的也是一个抽象的产品。  
**关键代码：** 创建过程在其子类执行。  
**应用实例：**  
您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。  
Hibernate 换数据库只需换方言和驱动就可以。  
**优点：**  
一个调用者想创建一个对象，只要知道其名称就可以了。  
扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。  
屏蔽产品的具体实现，调用者只关心产品的接口。  
**缺点：** 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。  
**使用场景：**  
日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。  
数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。  
设计一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口。  
注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

## 四、总结 ##

工厂模式共有三种实现方式：`简单工厂模式`、`工厂方法模式`和`抽象工厂模式`，每种模式都有不同的应用场景和优缺点，大家可以根据自身的应用场景来选择不同的实现方式来实现。

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

## 推荐 ##

关注博客和公众号获取最新文章

[Bummon’s Blog][Bummon_s Blog] ｜ [Bummon’s Home][Bummon_s Home] ｜ [公众号][Link 24]

[Link 1]: https://blog.csdn.net/HackAzrael/article/details/127247474
[Link 2]: https://blog.csdn.net/HackAzrael/article/details/127257678
[Link 3]: https://blog.csdn.net/HackAzrael/article/details/127263017
[Link 4]: https://blog.csdn.net/HackAzrael/article/details/127281056
[Link 5]: https://blog.csdn.net/HackAzrael/article/details/131191740
[Link 6]: https://blog.csdn.net/HackAzrael/article/details/130830533
[Link 7]: https://blog.csdn.net/HackAzrael/article/details/131527873
[Link 8]: https://blog.csdn.net/HackAzrael/article/details/131527943
[Link 9]: https://blog.csdn.net/HackAzrael/article/details/131528074
[Link 10]: https://blog.csdn.net/HackAzrael/article/details/131528365
[Link 11]: https://blog.csdn.net/HackAzrael/article/details/131528404
[Link 12]: https://blog.csdn.net/HackAzrael/article/details/131528468
[Link 13]: https://blog.csdn.net/HackAzrael/article/details/131528589
[Link 14]: https://blog.csdn.net/HackAzrael/article/details/131529402
[Link 15]: https://blog.csdn.net/HackAzrael/article/details/131529479
[Link 16]: https://blog.csdn.net/HackAzrael/article/details/131529548
[Link 17]: https://blog.csdn.net/HackAzrael/article/details/131529642
[Link 18]: https://blog.csdn.net/HackAzrael/article/details/131554457
[Link 19]: https://blog.csdn.net/HackAzrael/article/details/131554575
[Link 20]: https://blog.csdn.net/HackAzrael/article/details/131554702
[Link 21]: https://blog.csdn.net/HackAzrael/article/details/131554803
[Link 22]: https://blog.csdn.net/HackAzrael/article/details/131554865
[Link 23]: https://blog.csdn.net/HackAzrael/article/details/131554931
[563ed0e1cc944bdfaa3cb30cfcbc9271.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/fcadd427340d4ce79ceb53767ef963ce.png
[715eb1ff05ee43e589601cc6ab972968.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/fda2ec6db32a4e27abb90d3fa2b75890.png
[76759b97460647eba9c297a6e67018b9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/3e4a2b8c808d4aaba78858eaae8fcdf1.png
[Bummon_s Blog]: https://blog.bummon.com/
[Bummon_s Home]: https://www.bummon.com/
[Link 24]: https://www.bummon.com/wechat/