23种设计模式笔记第三篇简单工厂模式、工厂方法模式以及抽象工厂模式

我会带着你远行 2023-09-29 11:40 14阅读 0赞

**目录**

工厂模式

简单工厂模式（静态工厂模式）Simple Factory

工厂方法模式Factory Method

抽象工厂模式Abstract Factory

简单工厂+配置文件解除耦合

小结

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

## 工厂模式 ##

**作用**：实现了创建者和调用者的分离，帮助我们实例化对象。

**核心本质**：用工厂代替new操作实例化对象

将选择实现类，创建对象统一管理和控制，从而将调用者跟我们的实现类解耦

工厂模式是一种典型的解耦模式

**满足的OOP七大原则：**

开闭原则

依赖倒转原则

迪米特法则（要权衡好）

**分类：**

简单工厂模式：用来生成同一等级结构中的任意产品（对于增加的新的产品，需要扩展已有代码）。不是23种设计模式中的，反而比较像是一种编程习惯

工厂方法模式：用来生成同一等级结构中的固定产品（支持增加任意产品）。

抽象工厂模式：围绕一个超级工厂创建其他工厂。

**适用场景**：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过new就可以完成创建的对象，无需使用工厂模式。当需要系统有比较好的扩展性时，可以考虑工厂模式，不同的产品用不同的实现工厂来组装。

实际上，创建型模式(Creational Pattern)对类的实例化过程进行了抽象，能够将软件模块中对象的创建和对象的使用分离。

创建型模式在创建什么(What)，由谁创建(Who)，何时创建(When)等方面都为软件设计者提供了尽可能大的灵活性。

## 简单工厂模式（静态工厂模式）Simple Factory  ##

就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

简单工厂模式中的角色有：工厂，产品，客户端。看下例：

首先我们可以看一下类图

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_20_color_FFFFFF_t_70_g_se_x_16][]

具体实现代码如下：

创建一个Car接口

public interface Car {
    	public void name();
    }

编写两个实现类

public class WuLing implements Car{
    	@Override
    	public void name() {
    		System.out.println("五菱宏光"); 
    	}
    }
    
    public class Tesla implements Car{
    	@Override
    	public void name() {
    		 System.out.println("特斯拉");
    	}  
    }

创建工厂类

public class CarFactory{
    	public static Car getCar(String car) {
    		if(car.equals("五菱")) {
    			return new WuLing();
    		}else if(car.equals("特斯拉")) {
    			return new Tesla();
    		}else {
    			return null;
    		}
    	}
    }

测试一下

public class Comsumer {
    	public static void main(String[] args){
    		Car car1 = CarFactory.getCar("五菱");
    		Car car2 = CarFactory.getCar("特斯拉");
    		car1.name();
    		car2.name();
    	}
    }

输出的结果：

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_13_color_FFFFFF_t_70_g_se_x_16][]

我无需再去关心车是怎么来的，我只需要提供一个名称，从工厂里面拿就行了。

我们能很清楚的感受到这个模式的弊端，如果我们现在想要新增一个Car接口的实现类，添加一个大众的车，就必须要去修改工厂中的getCar()方法，违背了开闭原则。

当然，我们可以修改工厂类中的方法，需要什么就获取什么，无需我们再去输入参数

public class CarFactory{
    	public static Car getWuLing(){
            return new WuLing();
    	}
        public static Car getTesla(){
            return new Tesla();
    	}
    }

其实这也是不满足我们的需求的，我们仍旧需要去修改代码，只是说不会像上一个方法要去代码逻辑中去修改。

简单工厂模式存在的问题：

违背了开闭原则

违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中

## 工厂方法模式**Factory Method** ##

工厂方法模式是对简单工厂模式进一步的解耦，这相当于是把原本会因为业务代码而庞大的简单工厂类，拆分成了一个个的工厂类，这样代码就不会都耦合在同一个类里了。

工厂方法模式和简单工厂模式虽然都是通过工厂来创建对象，他们之间最大的不同是——工厂方法模式在设计上完全完全符合“开闭原则”。

直接看例子：

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_20_color_FFFFFF_t_70_g_se_x_16 1][] 具体代码实现如下：

Car接口、Tesla类和WuLing类不变

创建车工厂接口

public interface CarFactory{
        public Car getCar();
    }

创建车工厂接口的实现类TeslaFactory工厂类和WuLingFactory类

public class TeslaFactory implements CarFactory{
        @Override
        public Car getCar(){
            return new Tesla();
        }
    }
    
    public class WuLingFactory implements CarFactory{
        @Override
        public Car getCar(){
            return new WuLing();
        }
    }

最后测试一下

public class Comsumer {
    	public static void main(String[] args){
    		Car car1 = new WuLingFactory.getCar();
    		Car car2 = new TeslaFactory.getCar();
    		car1.name();
    		car2.name();
    	}
    }

由于这里举的例子没有涉及到参数问题，所以我们的感觉不是很明显，试想一下，如果Tesla类或者WuLing类中有很多参数呢？这个方法对消费者来说就是友好的，我们无需去管车是怎么造的，它对应的工厂方法会去实例化它，我们只需要去调用工厂中的方法就可以了。

这里我认为狂神的流程图可能会更加清晰（加层）

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_14_color_FFFFFF_t_70_g_se_x_16][]

**在以下情况下可以使用工厂方法模式：**

一个类不知道它所需要的对象的类。

一个类通过其子类来指定创建哪个对象

**优点：**

一个调用者想创建一个对象，只要知道其名称就可以了。

扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

屏蔽产品的具体实现，调用者只关心产品的接口。

**缺点：**

每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

## 抽象工厂模式Abstract Factory ##

抽象工厂模式相对工厂方法模式来讲，就是工厂方法模式是针对一个产品系列，而抽象工厂模式是针对多个产品系列的。

**定义**︰抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们具体的类。抽象工厂模式是工厂的工厂

我个人认为就是再加一层的意思，当然，这只是我个人的观点。

在讲案例之前，我们需要知道产品族和产品等级两个概念：

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_20_color_FFFFFF_t_70_g_se_x_16 2][]

现在我们来看具体案例：

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_20_color_FFFFFF_t_70_g_se_x_16 3][]

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_20_color_FFFFFF_t_70_g_se_x_16 4][]

首先创建手机接口和路由器接口

//手机产品接口
    public interface IPhoneProduct {
    	void start();
    	void shutdown();
    	void callup();
    	void sendSMS();
    }

//路由器产品接口
    public interface IRouterProduct {
    	void start();
    	void shutdown();
    	void openWifi();
    	void setting();
    }

然后创建两个手机接口的实现类：小米手机和华为手机

//小米手机
    public class XiaoMiPhone implements IPhoneProduct{
    
    	@Override
    	public void start() {
    		System.out.println("开启小米手机");
    	}
    
    	@Override
    	public void shutdown() {
    		System.out.println("关闭小米手机");
    	}
    
    	@Override
    	public void callup() {
    		System.out.println("小米手机打电话");
    		
    	}
    
    	@Override
    	public void sendSMS() {
    		System.out.println("小米手机发短信");
    		
    	}
    
    }

//华为手机
    public class HuaWeiPhone implements IPhoneProduct{
    
    	@Override
    	public void start() {
    		System.out.println("开启华为手机");
    	}
    
    	@Override
    	public void shutdown() {
    		System.out.println("关闭华为手机");
    	}
    
    	@Override
    	public void callup() {
    		System.out.println("华为手机打电话");
    		
    	}
    
    	@Override
    	public void sendSMS() {
    		System.out.println("华为手机发短信");
    		
    	}
    
    }

创建两个路由器接口的实现类：小米路由器和华为路由器

//小米路由器
    public class XiaoMiRouter implements IRouterProduct {
    
    	@Override
    	public void start() {
    		System.out.println("启动小米路由器");
    	}
    
    	@Override
    	public void shutdown() {
    		System.out.println("关闭小米路由器");
    		
    	}
    
    	@Override
    	public void openWifi() {
    		System.out.println("小米路由器打开WiFi");
    	}
    
    	@Override
    	public void setting() {
    		System.out.println("小米路由器设置");
    	}
    
    }

//华为路由器
    public class HuaWeiRouter implements IRouterProduct {
    
    	@Override
    	public void start() {
    		System.out.println("启动华为路由器");
    	}
    
    	@Override
    	public void shutdown() {
    		System.out.println("关闭华为路由器");
    		
    	}
    
    	@Override
    	public void openWifi() {
    		System.out.println("华为路由器打开WiFi");
    	}
    
    	@Override
    	public void setting() {
    		System.out.println("华为路由器设置");
    	}
    
    }

编写一个抽象产品工厂来制造

//抽象产品工厂
    public interface IProductFactory {	
    	//生产手机
    	IPhoneProduct iphoneProduct();
    	//生产路由器
    	IRouterProduct irouterProduct();
    }

创建抽象产品工厂的实现类

//小米工厂
    public class XiaoMiFactory implements IProductFactory {
    
    	@Override
    	public IPhoneProduct iphoneProduct() {
    		return new XiaoMiPhone();
    	}
    
    	@Override
    	public IRouterProduct irouterProduct() {
    		return new XiaoMiRouter();
    	}
    }

//华为工厂
    public class HuaWeiFactory implements IProductFactory {
    
    	@Override
    	public IPhoneProduct iphoneProduct() {
    		return new HuaWeiPhone();
    	}
    
    	@Override
    	public IRouterProduct irouterProduct() {
    		return new HuaWeiRouter();
    	}
    
    }

编写客户端测试：

public class Client {
    	public static void main(String[] args) {
    		System.out.println("**********华为系列***********");
    		//华为工厂
    		HuaWeiFactory huaweiFactory = new HuaWeiFactory();
    		IPhoneProduct huaweiPhone = huaweiFactory.iphoneProduct();
    		huaweiPhone.start();
    		huaweiPhone.callup();
    	}
    }

运行结果：

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_7_color_FFFFFF_t_70_g_se_x_16][]

**适用场景：**客户端(应用层)不依赖于产品类实例如何被创建、实现等细节。强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码提供一个产品类的库，所有的产品以同样的接口出现，从而使得客户端不依赖于具体的实现

**优点:**

具体产品在应用层的代码隔离，无需关心创建的细节

将一个系列的产品统一到一起创建

**缺点:**

规定了所有可能被创建的产品集合，产品簇中扩展新的产品困难;

增加了系统的抽象性和理解难度

## 简单工厂+配置文件解除耦合 ##

Spring的ioc原理

可以通过工厂模式+配置文件的方式解除工厂对象和产品对象的耦合。在工厂类中加载配置文件中的全类名，并创建对象进行存储，客户端如果需要对象，直接进行获取即可。

第一步：定义配置文件，可以使用properties文件，用来存储全类名（也就是要生产的对象的类名）

第二步：在工厂类中加载配置文件中的全类名，并创建对象进行存储

1、定义容器对象用来存储要生产的对象

2、加载配置文件，只需要加载一次（静态成员变量用来存储创建的对象（键存储的是名称，值存储的是对应的对象））

2.1、创建properties对象

2.2、调用p对象中的Load方法进行配置文件的加载

2.3、从properties集合中获取全类名并创建对象

2.4、通过反射技术创建对象

2.5、将名称和对象存储到容器中

第三步：根据名称获取对象

## **小结** ##

**简单工厂模式：**虽然某种程度上不符合设计原则，但实际使用最多

**工厂方法模式：**不修改已有类的前提下，通过增加新的工厂类实现扩展

**抽象工厂模式：**不可以增加产品，可以增加产品族

（戏言：没有什么是加一层解决不了的）

最大优点：解耦。

学到最后，我们必须要清楚的知道一点，就是不要本末倒置了，我们学习设计模式是为了更好的设计软件，不要为了使用某种设计模式而去设计

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/e2eb962fbcd846239aaf2cb4b044e69e.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQSBwZXJzb24sQSBmb29s,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_13_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/6a86a52a2bed430889681d851d31d91f.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQSBwZXJzb24sQSBmb29s,size_13,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/a9fe2c2e6466467c8af2acda12c256de.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQSBwZXJzb24sQSBmb29s,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_14_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/91935c5933844e27a7122171d862b174.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQSBwZXJzb24sQSBmb29s,size_14,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/85cbd5563e1547d88814c78afd79d4da.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQSBwZXJzb24sQSBmb29s,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://img-blog.csdnimg.cn/97394843dfca425bbf491facb17b59eb.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQSBwZXJzb24sQSBmb29s,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_20_color_FFFFFF_t_70_g_se_x_16 4]: https://img-blog.csdnimg.cn/72968b25d14b4dbaab4bee161cb1645a.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQSBwZXJzb24sQSBmb29s,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQSBwZXJzb24sQSBmb29s_size_7_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/1b6ac60fa0b9412e87b159d0e2d3b6b8.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQSBwZXJzb24sQSBmb29s,size_7,color_FFFFFF,t_70,g_se,x_16