设计模式之工厂模式（创建型）_工厂模式没有就创建-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_43013511/article/details/125453425

文章目录

一、为什么需要工厂模式

在面向对象编程中，继承是一个基本概念，它与多态共同构成了类的父子继承关系（Is-A关系）。Car 对象可以被当做 Vehicle 对象（交通工具）处理，Truck对象（卡车）也可以被当做 Vehicle 对象处理。

好处：
一方面，这种抽象方式使得同一段代码能为 Car 对象和 Truck 对象提供同样的处理操作，使代码更加简洁；；另一方面，如果要扩展 Vehicle 对象类型，比如 Bike 或者 Van，不需要修改代码，只需要添加新的类即可。

出现问题的背景：
在大多数情况下，最棘手的问题往往是对象的创建。在面向对象编程中，每个对象都使用特定类的构造器进行实例化操作，如下面代码所示：

Vehicel vehicle = new Car();

这段代码说明了 Vehicel 和 Car 两个类之间的依赖关系。这样的依赖关系使代码紧密耦合，在不更改的情况下很难拓展。举例来说，假设要用 Truck 替换 Car，就需要修改相应的代码：

Vehicel vehicle = new Truck();

两个问题：

类应该保持对拓展的开放和对修改的关闭（开闭原则）；
每个类应该只有一个发生变化的原因（单一指责原则）。

每增加新的类造成主要代码修改时会打破开闭原则，而主类除了其固有功能外还负责实例化 Vehicle 对象，这种行为将会打破单一职责原则。在这种情况下就需要一种更好的设计方案。

二、工厂模式是什么

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。这满足创建型模式中所要求的“创建与使用相分离”的特点。

按实际业务场景划分，工厂模式有 3 种不同的实现方式，分别是简单工厂模式、工厂方法模式和抽象工厂模式。

三、简单工厂模式

工厂模式用于实现逻辑的封装，并通过公共的接口提供对象的实例化服务，在添加新的类时只需要做少量的修改。

简单工厂的实现描述如图所示：
在这里插入图片描述
类 SimpleFactory 中包含实例化 ConcreteProduct1 和 ConcreteProduct2 的代码。当客户需要对象时，调用SimpleFactory的createProduct()方法，并提供参数指明所需对象的类型。SimpleFactory实例化相应的具体产品并返回，返回的产品对象被转换为基类类型。因此，无论是ConcreteProduct1还是ConcreteProduct2,客户能以相同的方式处理。

1、静态工厂模式

下面我们写一个简单的工厂类用来创建Vehicle实例。
我们创建一个抽象Vehicle 类和继承自它的三个具体类：Bike、Car和 Truck。工厂类（也叫静态工厂类）代码如下所示：

public class VehicleFactory{
    public enum VehicleType{
        Bike,Car,Truck;
    }
    public static Vehicle create(VehicleType type){
        if (type.equals(VehicleType.Bike)){
            return new Bike();
        }
        if (type.equals(VehicleType.Car)) {
            return new Car();
        }
        if (type.equals(VehicleType.Truck)) {
            return new Truck();
        }else{
            return null;
        } 
    }
}

工厂类逻辑非常简单，只负责Vehicle类的实例化，符合单一职责原则；用户只调用Vehicle接口，这样做可以减少耦合，符合依赖倒置原则；但是当增加一个新的 Vehicle类时，需要对VehicleFactory类进行修改，这样就打破了开闭原则。

我们可以改进这种简单工厂模式，使得注册的新类在使用时才被实例化，从而保证其对扩展开放，同时对修改闭合。

具体的实现方式有以下两种：

使用反射机制注册产品类对象和实例化。
注册产品对象并向每个产品添加newlnstance方法，该方法返回与自身类型相同的新实例。

2、使用反射机制进行类注册的简单工厂模式

为此，我们需要使用map对象来保存产品ID及其对应的类：

private Map<String, Class> registeredProducts = new HashMap<String,Class> ();

然后，增加一个注册新Vehicle类的方法：

public void registerVehicle(String vehicleId, Class vehicleclass){
    registeredProducts.put(vehicleId, vehicleclass);
}

构造方法如下所示：

public Vehicle createVehicle(String type) throws InstantiationException, IllegalAccessException {
    Class productclass = registeredProducts.get(type);
    return (Vehicle)productclass.newInstance();
}

全部代码如下：

public class VehicleFactory{
    
    //需要使用map对象来保存产品ID及其对应的类
    private Map<String, Class> registeredProducts = new HashMap<String,Class>();

    //增加一个注册新Vehicle类的方法
    public void registerVehicle(String vehicleId, Class vehicleclass){
        registeredProducts.put(vehicleId, vehicleclass);
    }

    //使用构造方法实例化对象
    public Vehicle createVehicle(String type) throws InstantiationException, IllegalAccessException {
        Class productclass = registeredProducts.get(type);
        return (Vehicle)productclass.newInstance();
    }
}

但在某些情况下，反射机制并不适用。比如，反射机制需要运行时权限，这在某些特定环境中是无法实现的。反射机制也会降低程序的运行效率，在对性能要求很高的场景下应该避免使用这种机制。

3、使用newInstance方法进行类注册的简单工厂模式

前面的代码中使用了反射机制来实现新Vehicle类的实例化。如果要避免使用反射机制，可以使用注册新Vehicle类的类似工厂类，不再将类添加到map对象中，而是将要注册的每种对象实例添加其中。每个产品类都能够创建自己的实例。
首先在Vehicle基类中添加一个抽象方法：

public abstract class Vehicle {
    abstract public Vehicle newlnstance();
}

对于每种产品，基类中声明为抽象的方法都要实现：

public class Car extends Vehicle{
    @Override
    public Vehicle newlnstance() {
        return new Car ();
    }
}

在工厂类中，更改map用于保存对象的ID及其对应的Vehicle对象：

private Map<String, Vehicle> registeredProducts = new HashMap<String,Vehicle>();

通过实例注册一种新的Vehicle类型：

public void registervehicle(String vehicleld, Vehicle vehicle) {
    registeredProducts.put(vehicleld, vehicle);
}

也要相应地改变createVehicle方法：

public Vehicle createVehicle(String vehicleld){
    return registeredProducts.get(vehicleld).newlnstance ();
}

整体代码：

public class VehicleFactory{

    //需要使用map对象来保存产品ID及其对应的类
    private Map<String, Vehicle> registeredProducts = new HashMap<String,Vehicle>();

    //增加一个注册新Vehicle类的方法
    public void registervehicle(String vehicleld, Vehicle vehicle) {
        registeredProducts.put(vehicleld, vehicle);
    }

    //实例化对象
    public Vehicle createVehicle(String vehicleld)
    {
        return registeredProducts.get(vehicleld).newlnstance ();
    }
}

四、工厂方法模式

工厂方法模式是在静态工厂模式上的改进。工厂类被抽象化，用于实例化特定产品类的代码被转移到实现抽象方法的子类中。这样不需要修改就可以扩展工厂类。工厂方法模式的实现如图2-3所示。
在这里插入图片描述
下面来看一些样例：假设有一个汽车工厂，目前只生产两种车型，小型跑车和大型家用车。在软件中，顾客可以自由决定买小型车或大型车。首先，我们需要创建一个Vehicle类和两个子类，子类分别为SportCar和SedanCar。

1、创建抽象工厂的子类

创建Vehicle类结构之后就可以创建抽象工厂类。要注意工厂类中并不包含任何创建新实例的代码：

public abstract class VehicleFactory
{
    //抽象创建实例的方法
    protected abstract Vehicle createVehicle(String item);

    //对外提供订单消费方法
    public Vehicle orderVehicle(String size, String color){
        Vehicle vehicle = createVehicle(size);
        vehicle.setcolor(color);
        return vehicle;
    }
}

为了增加汽车实例化的代码，我们创建了 VehicleFactory的子类，即CarFactory 类，并在CarFactory中实现从父类中调用的createVehicle抽象方法。实际上，Vehicle- Factory 类将Vehicle类的具体实例化操作委托给了它的子类：

public class CarFactory extends VehicleFactory
{
    @Override
    protected Vehicle createVehicle(String size)
    {
        if (size.equals ("small")){
            return new SportCar();
        } else if (size.equals("large")) {
            return new SedanCar();
        }else {
            return null;
        }
    }
}

在客户端，我们只需要创建工厂类并创建订单：

VehicleFactory carFactory = new CarFactory();
carFactory. orderVehicle ("large", "blue");

此时，我们意识到汽车工厂所带来的收益，是时候进一步拓展业务了。市场调查显示卡车的需求量很大，因此我们又建了一个卡车工厂 TruckFactory 扩大收益：

public class TruckFactory extends VehicleFactory
{
    @Override
    protected Vehicle createVehicle(String size){
        if ("small".equals(size)){
            return new SmallTruck();
        }else if ("large".equals(size)){
            return new LargeTruck();
        }else {
            return null;
        }
    }
}

我们使用如下代码来下订单：

VehicleFactory truckFactory = new TruckFactory();
truckFactory.ordervehicle ("large", "blue");

2、匿名具体工厂模式

继续在前面的代码中添加一个BikeFactory，使得顾客可以选择购买小型或大型自行车。这里不用创建单独的类文件，只需直接在客户端代码中简单地创建一个匿名类来对VehicleFactory类进行扩展即可：

VehicleFactory bikeFactory = new VehicleFactory()
{
    @Override
    protected Vehicle createVehicle(String size)
    {
        if ("small".equals(size)) {
            return new MountainBike();
        }else if ("large".equals(size)) {
            return new CityBike();
        }else {
            return null;
        }
    }
};
bikeFactory.ordervehicle("large", "blue");

3、总结

简单工厂和工厂方法模式的不同在于前者生成产生产品的行为封装在一个方法中，根据参数的类型进行实例化，同时不存在抽象接口，将实例化交给唯一的工厂处理。

而后者则增加了抽象工厂，通过实现不同的工厂方法来创建不同的产品，一个方法通常对应一个产品，将实例化交给抽象工厂的子类去做，这种方式相较于前者扩展性更高，在需求增加时完全符合开闭原则和依赖倒置原则。

五、抽象工厂模式

抽象工厂模式是工厂方法模式的扩展版本。它不再是创建单一类型的对象，而是创建一系列相关联的对象。如果说工厂方法模式中只包含一个抽象产品类，那么抽象工厂模式则包含多个抽象产品类。

工厂方法类中只有一个抽象方法，在不同的具体工厂类中分别实现抽象产品的实例化，而抽象工厂类中，每个抽象产品都有一个实例化方法。

如果我们采用抽象工厂模式并将它应用于包含单个对象的簇，那么就得到了工厂方法模式。工厂方法模式只是抽象工厂模式的一种特例。

抽象工厂设计模式的实现如图所示：
在这里插入图片描述
抽象工厂模式由以下类组成：

AbstractFactory （抽象工厂类）：抽象类，用于声明创建不同类型产品的方法。它针对不同的抽象产品类都有对应的创建方法。
ConcreteFactory （具体工厂类）：具体类，用于实现抽象工厂基类中声明的方法。针对每个系列的产品都有一个对应的具体工厂类。
AbstracProduct （抽象产品类）：对象所需的基本接口或类。一簇相关的产品类由来自不同层级的相似产品类组成。Product A1和ProductBl来自第一个类簇，由ConcreteFactory1实例化。ProductA2和ProductB2来自第二个类簇,由 ConcreteFactory2 实例化。

举个例子，抽象工厂类是名义上的工厂，不管这个工厂的作用是什么，都可以称之为工厂，继承于这个抽象工厂类。具体工厂类可以理解成有小米工厂、华为工厂等。而抽象产品类是指手机、电脑、家电等，这些都可以被小米和华为的工厂生产，小米生产出来的手机、电脑、家电是小米品牌，华为生产出来的手机、电脑、家电是华为品牌。

六、优缺点

优点：
1、一个调用者想创建一个对象，只要知道其名称就可以了。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3、屏蔽产品的具体实现，调用者只关心产品的接口。

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

七、使用场景

1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
3、设计一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口。

八、个人理解

工厂模式的实现方式和原理都不难理解和掌握。但是，在学习完之后，发现网上给的例子，根本体现不了工厂模式的作用。先不说存在有的例子本身就是错误的，主要是例子中的代码太简单，可以说没必要用工厂模式，只不过是为了说明实现方式和原理。所以，会产生一种错觉：还不如直接new 一个对象来的方便，有效。

的确，设计模式本身就有其适用的场景，并不是滥用的，否则还不如不用。

现在，我记录一下在翻阅一些资料后，自己的理解。

首先，工厂模式是为了解耦：把对象的创建和使用的过程分开。就是Class A 想调用 Class B ，那么A只是调用B的方法，而至于B的实例化，就交给工厂类。

其次，工厂模式可以降低代码重复。如果创建对象B的过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。我们可以这些创建对象B的代码放到工厂里统一管理。既减少了重复代码，也方便以后对B的创建过程的修改维护。（当然，我个人觉得也可以把这些创建过程的代码放到类的构造函数里，同样可以降低重复率，而且构造函数本身的作用也是初始化对象。不过，这样也会导致构造函数过于复杂，做的事太多，不符合java 的设计原则。）

由于创建过程都由工厂统一管理，所以发生业务逻辑变化，不需要找到所有需要创建B的地方去逐个修正，只需要在工厂里修改即可，降低维护成本。同理，想把所有调用B的地方改成B的子类B1，只需要在对应生产B的工厂中或者工厂的方法中修改其生产的对象为B1即可，而不需要找到所有的new B（）改为new B1()。

另外，因为工厂管理了对象的创建逻辑，使用者并不需要知道具体的创建过程，只管使用即可，减少了使用者因为创建逻辑导致的错误。

举个例子：

一个数据库工厂：可以返回一个数据库实例，可以是mysql，oracle等。

这个工厂就可以把数据库连接需要的用户名，地址，密码等封装好，直接返回对应的数据库对象就好。不需要调用者自己初始化，减少了写错密码等等这些错误。调用者只负责使用，不需要管怎么去创建、初始化对象。

还有，如果一个类有多个构造方法（构造的重写），我们也可以将它抽出来，放到工厂中，一个构造方法对应一个工厂方法并命名一个友好的名字，这样我们就不再只是根据参数的不同来判断，而是可以根据工厂的方法名来直观判断将要创建的对象的特点。这对于使用者来说，体验比较好。