1.什么是工厂模式
它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。实现了创建者和调用者分离，工厂模式分为简单工厂、工厂方法、抽象工厂模式
2.工厂模式好处
工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。
- 利用工厂模式可以降低程序的耦合性，为后期的维护修改提供了很大的便利。
将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。
3.为什么要学习工厂设计模式
不知道你们面试题问到过源码没有，你知道Spring的源码吗，MyBatis的源码吗，等等等 如果你想学习很多框架的源码，或者你想自己开发自己的框架，就必须先掌握设计模式（工厂设计模式用的是非常非常广泛的）
4.Spring开发中的工厂设计模式
1.Spring IOC
看过Spring源码就知道，在Spring IOC容器创建bean的过程是使用了工厂设计模式
- Spring中无论是通过xml配置还是通过配置类还是注解进行创建bean，大部分都是通过简单工厂来进行创建的。
当容器拿到了beanName和class类型后，动态的通过反射创建具体的某个对象，最后将创建的对象放到Map中。
2.为什么Spring IOC要使用工厂设计模式创建Bean呢
在实际开发中，如果我们A对象调用B，B调用C，C调用D的话我们程序的耦合性就会变高。（耦合大致分为类与类之间的依赖，方法与方法之间的依赖。）
- 在很久以前的三层架构编程时，都是控制层调用业务层，业务层调用数据访问层时，都是是直接new对象，耦合性大大提升，代码重复量很高，对象满天飞
为了避免这种情况，Spring使用工厂模式编程，写一个工厂，由工厂创建Bean，以后我们如果要对象就直接管工厂要就可以，剩下的事情不归我们管了。Spring IOC容器的工厂中有个静态的Map集合，是为了让工厂符合单例设计模式，即每个对象只生产一次，生产出对象后就存入到Map集合中，保证了实例不会重复影响程序效率。
5.工厂模式分类
工厂模式分为简单工厂、工厂方法、抽象工厂模式
- 简单工厂 ：用来生产同一等级结构中的任意产品。（不支持拓展增加产品）
- 工厂方法 ：用来生产同一等级结构中的固定产品。（支持拓展增加产品）
抽象工厂 ：用来生产不同产品族的全部产品。（不支持拓展增加产品；支持增加产品族）
我下面来使用代码演示一下：5.1 简单工厂模式
什么是简单工厂模式
简单工厂模式相当于是一个工厂中有各种产品，创建在一个类中，客户无需知道具体产品的名称，只需要知道产品类所对应的参数即可。但是工厂的职责过重，而且当类型过多时不利于系统的扩展维护。
代码演示：
- 创建一种产品类型，产品类型是车
```java
/**
- 一类产品类型，产品类型是车 */ public interface Car { void run(); }
2. 创建一种产品：宝马， 类型是车```java/*** 一种产品：宝马， 类型是车*/public class Bmw implements Car{@Overridepublic void run() {System.out.println("我是宝马");}}
- 创建工另外一种产品（奥迪）
```java
/**
- 一种产品：奥迪， 类型是车 */ public class AoDi implements Car{ @Override public void run() { System.out.println(“我是奥迪”); } }
4. 创建核心工厂类，由他决定具体调用哪产品```java/*** 这是一个工厂，这个厂是用来造车的*/public class CarFactory {/*** 可以造多个不同的产品，但是产品的类型是车* @param name 指定生产的产品名称* @return 返回该类型产品 （多态）*/public static Car createCar(String name) {if (name == null || "".equals(name)) {return null;}if ("奥迪".equals(name)) {return new AoDi();}if ("宝马".equals(name)) {return new Bmw();}return null;}}
演示创建工厂的具体实例
/*** 客户端，我想要什么类型的汽车，你来给我创建*/public class Client {public static void main(String[] args) {//告诉汽车厂，我想要一辆车，类型是宝马Car bmw = CarFactory.createCar("宝马");//给了我一辆宝马，我开走了bmw.run();//告诉汽车厂，我想要一辆车，类型是奥迪Car aoDi = CarFactory.createCar("奥迪");//给了我一辆奥迪，我开走了aoDi.run();//告诉你的汽车厂，我想要一辆车，类型是迈凯伦Car mkl = CarFactory.createCar("迈凯伦");if (mkl == null) {//对不起，我们厂造不了迈凯伦}}}
单工厂的优点/缺点
- 优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
缺点：很明显工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则
小结：
在简单工厂模式里面 屏蔽了产品创建细节，我们只需要提供需要的具体产品名称，工厂会给我们创建一个该类型的对象(多态)。我们对汽车这一产品类型进行了抽象，使用时只需要调用该类型的特征方法(产品类型声明的run方法)即可。
5.2 工厂方法模式
什么是工厂方法模式
工厂方法模式Factory Method，又称多态性工厂模式。在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节
代码演示：
创建工厂
/** * 一类产品类型，产品类型是车 */ public interface Car { void run(); }创建工厂方法调用接口（所有的产品需要new出来必须继承他来实现方法） ```java /**
一类工厂类型，工厂类型是造车 */ public interface CarFactory {
/**
- 你会有多个工厂，一个厂造一种类型的汽车，可以造多个类型的汽车
- @return */ Car createCar(); }
3. 创建工厂的产品（奥迪）
```java
/**
* 一种产品：奥迪， 类型是车
*/
public class AoDi implements Car{
@Override
public void run() {
System.out.println("我是奥迪");
}
}
创建工厂另外一种产品（宝马）
/** * 一种产品：宝马， 类型是车 */ public class Bmw implements Car{ @Override public void run() { System.out.println("我是宝马"); } }创建工厂方法调用接口的实例（奥迪） ```java /**
- 奥迪工厂类型，工厂类型是造车，造奥迪车的工厂 */ public class AoDiFactory implements CarFactory{ @Override public Car createCar() { return new AoDi(); } }
6. 创建工厂方法调用接口的实例（宝马）
```java
/**
* 宝马工厂类型，工厂类型是造车，造宝马车的工厂
*/
public class BmwFactory implements CarFactory{
@Override
public Car createCar() {
return new Bmw();
}
}
演示创建工厂的具体实例
/** * 客户端，我想要什么类型的汽车，你来给我创建 */ public class Client { public static void main(String[] args) { //我想要奥迪汽车，我找到了你们公司造奥迪的汽车厂，他来造车 Car aoDi = new AoDiFactory().createCar(); //造好车，我开走了 aoDi.run(); //我想要宝马汽车，我找到了你们公司造宝马的汽车厂，他来造车 Car bmw = new BmwFactory().createCar(); //造好车，我开走了 bmw.run(); //我想要迈凯伦，可惜找不到造迈凯伦的汽车厂，无法购买迈凯伦 } }小结：
和简单工厂一样的是只能创建指定类型的产品，但是对简单工厂中创建实例的具体方法进行下放，由具体的实现工厂实现。
5.3 抽象工厂模式
什么是抽象工厂模式
- 抽象工厂简单地说是工厂的工厂，抽象工厂可以创建具体工厂，由具体工厂来产生具体产品。
代码演示：
创建第一个产品类型，及实现类
/** * 一类产品类型，产品类型是车 */ public interface Car { void run(); }/** * 一种产品：奥迪， 类型是车 */ public class AoDi implements Car { @Override public void run() { System.out.println("我是奥迪"); } }/** * 一种产品：宝马， 类型是车 */ public class Bmw implements Car { @Override public void run() { System.out.println("我是宝马"); } }创建第二个产品类型，及实现类
/** * 一类产品类型，产品类型是引擎 */ public interface Engine { void run(); }/** * 一种产品：V3发动机， 类型是引擎 */ public class V3Engine implements Engine { @Override public void run() { System.out.println("我是 2.0T V3 发动机"); } }/** * 一种产品：V5发动机， 类型是引擎 */ public class V5Engine implements Engine { @Override public void run() { System.out.println("我是 3.0T V5 发动机"); } }创建一个总工厂，及实现类（由总工厂的实现类决定调用那个工厂的那个实例）
public interface TotalFactory { Car createCar(); Engine createEngine(); }public class AoDiV5Factory implements TotalFactory{ @Override public Car createCar() { return new AoDi(); } @Override public Engine createEngine() { return new V5Engine(); } }```java public class BmwV3Factory implements TotalFactory{ @Override public Car createCar() {
return new Bmw();}
@Override public Engine createEngine() {
return new V3Engine();} }
4. 运行测试
```java
/**
* 客户端，我想要什么类型的汽车（引擎），你来给我创建
*/
public class Client {
//创建和使用汽车和引擎
public static void createCarAndEngine(TotalFactory totalFactory){
//我不知道是什么类型工厂，但我知道这个类型的工厂都可以创建引擎
Engine engine = totalFactory.createEngine();
//我不知道是什么类型工厂，但我知道这个类型的工厂都可以创建汽车
Car car = totalFactory.createCar();
//我不知道是什么类型的汽车，但是我知道他们都可以运行(run)
car.run();
//我不知道是什么类型的引擎，但是我知道他们都可以运行(run)
engine.run();
}
public static void main(String[] args) {
//我想要一辆车，类型是宝马V3(搭载V3引擎),我不知道具体实现
TotalFactory bmwV3Factory = new BmwV3Factory();
//我只知道我需要一辆车和一个引擎
createCarAndEngine(bmwV3Factory);
//我想要一辆车，类型是奥迪V5(搭载V5引擎),我不知道具体实现
TotalFactory aoDiV5Factory = new AoDiV5Factory();
//我只知道我需要一辆车和一个引擎
createCarAndEngine(aoDiV5Factory);
}
}
小结：
抽象工厂模式对工厂进行了抽象，可以创建具体的工厂来实现产品的创建。是工厂的工厂。
总结：
简单工厂模式类似我有一个工厂，这个工厂可以制造一种类型的不同产品（制造方法都在一个工厂里面）；
工厂方法模式类似我有一堆工厂，每个工厂可以制造一种类型的一种产品（制造方法分布在每个工厂中）；
抽象方法模式类似我有一个公司，我可以建造多个不同的工厂，每个工厂制造一种产品；
若有收获，就点个赞吧
0 人点赞
