在项目的开发中，我们经常会遇到需要创建复杂对象的场景，例如一个参数繁多的类的构造函数。这时如果我们不使用任何设计模式进行开发，项目将变得十分复杂，面对常常变动的需求，我们可能需要一个一个修改参数，并在任何引用该类的地方都做一次修改，最后只会变得乱成一团无法维护。那么该如何解决这个问题呢？

答案是使用工厂模式。在需要创建复杂对象，并频繁使用时，我们就可以选择工厂模式。

工厂模式的三种实现形式 #

工厂模式有三种实现形式

- 简单工厂（静态工厂）
- 工厂方法（本节核心）
- 抽象工厂

> 注：简单工厂并不算在GoF 23种设计模式中

本节，我们将深入理解工厂方法模式及其应用。

简单工厂（静态工厂） #

在介绍工厂方法模式之前，我先对简单工厂进行介绍。在简单工厂模式中，创建实例的方法通常为静态方法，因此简单工厂模式又被成为静态工厂方法。简单工厂只有一个具体的工厂类，专门用于生产特定专一的产品，在需要生产多种产品时，需要将多个产品定义到同一个工厂中进行生产。简单工厂名副其实，十分简单。这样的好处就是产品创建方便，客户直接提需求，工厂直接实现，不需要经过任何产品线。但问题也来了，在需要大量创建不同产品时，简单工厂就会变得“不堪重负”。回归到软件中，简单工厂会增加系统的复杂性，在多个产品的情况下，单个类职责过重，软件将变得难以维护。每增加一个产品就要增加一个工厂类，违背了“开闭原则”。

 简单工厂的示例 

我们有苹果树和梨树和一家工厂，这家工厂要负责将水果树上的所有水果都摘下来。

`java

package com.yeliheng.factory.simplefactory;

public class Main {
    public static void main(String[] args) {
        Apple apple = (Apple) SimpleFactory.make(0);
        Banana banana = (Banana) SimpleFactory.make(1);
        apple.show();
        banana.show();
    }

    //水果产品
    public interface Fruit {
        void show();
    }

    //具体产品
    static class Apple implements Fruit {
        public void show() {
            System.out.println("苹果树上长苹果...");
        }
    }

    //具体产品
    static class Banana implements Fruit {
        public void show() {
            System.out.println("香蕉树上长香蕉...");
        }
    }

    //工厂生产
    static class SimpleFactory {
        public static Fruit make(int kind) {
            switch (kind) {
                case 0:
                    return new Apple();
                case 1:
                    return new Banana();
            }
            return null;
        }
    }
}

`

通过代码示例我们可以看到每生产一种具体的水果，就要定义一个新的静态产品类让水果能被工厂生产。工厂类的代码将会随着产品的增加越来越复杂。

为了解决这个问题，工厂方法（Factory Method）模式出现了。

工厂方法 #

工厂方法模式在简单工厂模式的基础上进一步抽象，可以使系统拓展新的具体类时，原来的工厂代码不必修改，满足开闭原则。拓展新的需求，创建新产品，只需要在原来的基础上增加一个工厂类，这样就可以有多个工厂为我们服务。并且上层应用只需了解抽象的产品类，无需对其他类进行拓展。这也同时满足了迪米特法则、依赖倒置原则和里氏替换原则。但工厂方法模式同样存在缺点。它将会让工厂类数目繁多，降低系统代码的可读性。并且在抽象产品中，只能产出一种具体产品。（这个问题可以使用抽象工厂解决，下节介绍）。

工厂方法模式由以下结构组成：

- 抽象工厂（AbstractFactory）：提供了产品的抽象类或接口。
- 具体工厂（ConcreteFactory）：具体的创建类，实现具体生产产品的方法。
- 抽象产品（Product）：产品的抽象创建类。
- 具体产品（ConcreteProduct）：将抽象产品进行实现。

 实际应用场景 

- 日志工厂
- 文件存储
...

 示例 

我们来实现一个日志工厂，该日志工厂具有以下三个功能：
1. 打印日志到控制台
2. 打印日志到文件

我们按照上文所述的结构一一实现工厂方法：

1. 抽象产品

Logger.java

`java

package com.yeliheng.factory.factorymethod;

/
 * 日志产品的抽象
 */
public interface Logger {
    //日志级别
    void debug();

    void info();

    void warning();

    void error();

}

`

我们在抽象产品中定义了四个产品接口，可对应四种不同级别的日志。

2. 抽象工厂

LoggerFactory.java

`java

package com.yeliheng.factory.factorymethod;

public interface LoggerFactory {
    Logger getLogger();
}

`

在抽象工厂中，我们去使用Logger，定义一个getLogger()方法来便于待会具体工厂获取Logger实例。

3. 具体产品

我们实现两个具体产品类，一个是输出到控制台的产品类，一个是输出到文件的产品类。这里为了代码的简洁，就不详细地写出输出到文件的逻辑，仅使用输出进行简单举例。

ConsoleLogger.java

`java
package com.yeliheng.factory.factorymethod;

public class ConsoleLogger implements Logger{
    @Override
    public void debug() {

    }

    @Override
    public void info() {
        System.out.println("[INFO] 这条日志被输出到[控制台]");
    }

    @Override
    public void warning() {

    }

    @Override
    public void error() {

    }
}
`

FileLogger.java

`java
package com.yeliheng.factory.factorymethod;

public class FileLogger implements Logger{
    @Override
    public void debug() {

    }

    @Override
    public void info() {
        System.out.println("[INFO] 这条日志被输出到[文件]");
    }

    @Override
    public void warning() {

    }

    @Override
    public void error() {

    }
}

`

4. 实现具体的工厂

ConsoleLoggerFactory.java

`java
package com.yeliheng.factory.factorymethod;

/
 * 具体工厂
 */
public class ConsoleLoggerFactory implements LoggerFactory{
    @Override
    public Logger getLogger() {
        return new ConsoleLogger();
    }
}
`

我们重写了实现了抽象工厂：LoggerFactory，并重写了getLogger方法，让其返回一个ConsoleLogger实例。

FileLoggerFactory.java

`java

package com.yeliheng.factory.factorymethod;

public class FileLoggerFactory implements LoggerFactory{
    @Override
    public Logger getLogger() {
        return new FileLogger();
    }
}

`

原理相同。

5. 最后，我们可以开始使用我们通过工厂方法模式创建的日志工厂了。

Main.java

`java
package com.yeliheng.factory.factorymethod;

public class Main {
    public static void main(String[] args) {
        //输出到控制台
        LoggerFactory consoleLoggerFactory = new ConsoleLoggerFactory();
        Logger logger1 = consoleLoggerFactory.getLogger();
        logger1.info();
        //输出到文件
        LoggerFactory fileLoggerFactory = new FileLoggerFactory();
        Logger logger2 = fileLoggerFactory.getLogger();
        logger2.info();

    }
}

`
可以看到最终输出如下：

!output.png

细心的你可能会发现，这个写法与slf4j日志库的写法十分相似。没错，查看slf4j源码可以发现，其使用了大量工厂模式实现强大的日志框架。

小结 #

到此，我们使用工厂方法模式完成了一个简单的日志工厂，下节我们将使用抽象方法模式继续完善本节的例子。

源码参考：Github

在项目中，如何做到对象的创建与使用分离？本文将以Java为例，带你重温GoF设计模式之工厂方法模式，并深入理解工厂方法模式及其应用场景。

Java设计模式再相识 (三)——工厂方法(Factory Method)模式

当你的系统存在相同或者相似对象需要创建，你可能会想到使用new 对象名() 来创建。但如果你的系统存在大量相同对象需要创建时，这样做会显得效率低下，并且代码将杂乱无章，你需要在构造函数中使用大量类名来进行实例化。这时，我们可以采用原型模式来进行优化，提高执行效率。例如复印机只需要简单的配置就可以复印出大量材料，这就是典型的原型模式的体现。

原型模式介绍 #

原型(Prototype)：用一个已经创建的“原型对象”进行复制，得出与原型相同或者相似的新对象。原型模式和上节的单例模式同样属于创建型模式。它很少单独使用，经常与其他设计模式配合使用（例如：它可以与Command命令模式配合使用，便于复制Command模式中出现的命令）。但作为基础，我们也必须掌握原型模式。

应用场景 #

我相信你最关心什么时候需要用到原型模式，这里我列举出几种可以使用原型模式的场景供你参考：

- 相同或相似对象繁多，无法将他们整合到唯一一个类中。
- 一个类调用了另外一个类，两个类之间存在耦合，你想把他们解耦，在不修改另一个类的情况下改变职责。
- 难以根据类来生成实例时。

 举例 

下面我们来根据一个实际的例子实现原型模式。

例子：假设你有一台打印机，它可以为你打印大量的文件，并且支持各种纸张的样式。现在，你需要让它为你打印大量A4和A3版本的Hello,World。请使用原型模式实现它。

首先我们定义打印机原型：

Printer.java

`java
package com.yeliheng.prototype;

/
 * 打印机原型
 */
public class Printer implements Cloneable {

    private String paperType; //纸张类型

    private String content; //打印内容

    public Printer(String paperType, String content) {
        this.paperType = paperType;
        this.content = content;
        System.out.println("打印机准备就绪！");
    }

    public String getPaperType() {
        return paperType;
    }

    public void setPaperType(String paperType) {
        this.paperType = paperType;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public void display() {
        System.out.println(" 纸张类型: " + paperType + " \n 打印内容: " + content);
    }

    @Override
    public Printer clone() {
        try {
            return (Printer) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}
`

Printer原型的实现代码很简单，我们具体来关注对Cloneable接口的实现。在Printer类中，我们实现了java.lang包提供的Cloneable接口，并重写了clone()方法，在clone()方法内，我们试图捕获CloneNotSupportedException异常。这是因为我们必须保证被复制的对象必须实现java.lang.Clonable接口，否则对象将无法被克隆。细心的你可能会发现Cloneable接口中并没有clone()方法的相关定义。这是因为clone()方法被定义在java.lang.Object中，而Object类是所有Java类的父类。因此所有Java类都继承了clone()方法。像Cloneable接口很容易让人误认为Cloneable接口中声明了clone()方法，其实这是错误的。Clone接口中什么都没有，它只是起到告诉程序可以调用clone方法的作用。

写完了打印机原型，我们现在就开始让它工作，让它为我们复制出不同纸张类型的Hello,World。

Main.java

`java

package com.yeliheng.prototype;

/
 * 原型模式
 */
public class Main {
    public static void main(String[] args) {

        Printer obj1 = new Printer("A4","Hello,World");
        obj1.display();

        Printer obj2 = (Printer) obj1.clone(); //克隆！
        obj2.setPaperType("A3");
        obj2.display();
    }
}

`

我们先用传统的方式实例化了Printer类，让它打印一张A4的Hello,World。然后我们用克隆的方式：obj1.clone()，让它打印出一张A3的相同内容的纸。最后的输出结果如下：

!输出结果

这时，我们就实现了一个原型模式。本例中的克隆方式称为浅克隆。

>请注意：Cloneable接口破坏了单例模式，如果是单例类，又实现了Cloneable接口，那么该类就可以调用clone方法创建另外的实例，因此破坏了单例模式。

浅克隆 #

浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型，浅克隆只会将实例的引用复制。例如，当字段中保存的是数组时，如果使用clone()方法进行克隆，则只会将数组的引用复制，并不会复制数组内的元素。浅克隆默认使用super.clone()来实现。

深克隆 #

深克隆：创建一个新的对象，属性中引用的其他对象也将被克隆，不再指向原对象地址，即在内存中开辟新的空间。

如果你需要更复杂的功能，例如复制所有非基本类型的引用和值，则需要以下步骤：

1. 创建实例对象：通过clone()方法创建原型类的实例，这个步骤与浅克隆相同。
2. 克隆引用的成员：调用原型类对象成员的clone()方法，创建新的成员对象，将新的成员对象赋值给克隆出的原型模式的对象。（类似于递归调用）
3. 返回新对象：返回clone()创建的原型对象。

思考：你可以尝试着实现一个包含数组对象的深克隆。

总结 #

本文仅举一个简单的例子展现原型模式，在实际开发中，原型模式需要根据具体情况决定是否使用，例如上文描述的几种应用场景。熟练掌握原型模式，在后面需要与其他设计模式一起使用时，你就能够轻松驾驭。

源码参考：GitHub

当你的系统存在大量相同对象需要创建，使用原型模式能够为你高效地创建对象。本文将以Java为例，带你重温GoF设计模式之原型模式，并深入理解原型模式以及应用场景。

Java设计模式再相识 (二)——原型模式

> 当你想在一个庞大的工程中，确保整个程序只存在一个唯一的实例，并且保证在任何情况下，新的实例都不会被创建，这时候，单例模式将是你的不二之选。

我们在使用Windows操作系统时，是否曾注意到任务管理器，回收站等系统应用始终只能打开一个窗口，这就是单例模式的类比。接下来，我们将动手实现一个单例模式的程序。在开始之前，我们先来熟悉单例模式的基本概念。

基础篇 #

 介绍 

单例（Singleton）模式的定义：一个类只允许拥有一个实例。

单例模式通常有两种实现形式：饿汉式，懒汉式。在基础篇中，我将详细介绍饿汉式单例模式。

何为饿汉式？顾名思义，就是在类加载时就创建一个单例，这样能够保证在调用getInstance()方法之前这个单例就已经存在。

现在，就让我们来编写代码模拟实现一个Windows任务管理器，让它只能存在一个。

 示例-模拟任务管理器 

我们新建一个名为Singleton.java的文件，代码内容如下: 

Singleton.java

`java
package com.yeliheng.singleton;

public class Singleton {
    private static final Singleton singleton = new Singleton();

    private Singleton() {
        System.out.println("任务管理器已打开！");
    }

    public static Singleton getInstance() {
        return singleton;
    }
}

`

在Singleton类中，我们定义了static字段的成员变量singleton，并将其初始化为Singleton类的实例。然后我们定义了一个私有构造函数Singleton，打印提示。使用private修饰符可以防止从Singleton类以外的代码调用构造函数，从而单例模式将失去意义。

接着我们定义getInstance()方法，就可以让外部程序以只读的方式获取到Singleton类的唯一实例。(通常情况下，我们采用getInstance作为方法名。)

Main.java

`java

package com.yeliheng.singleton;

public class Main {

    public static void main(String[] args) {

        Singleton obj1 = Singleton.getInstance();

        Singleton obj2 = Singleton.getInstance();

        if(obj1.equals(obj2)) {
            System.out.println("obj1和obj2是同一个实例，任务管理器只能创建一个！");
        }
    }
}

`
在Main函数中，我们定义obj1和obj2两个变量，这两个变量都去创建两次Singleton实例。然后我们使用if语句来判断，这两个实例是否是同一个实例。代码十分简单，我们一起来看看运行结果。

运行结果如下：

!QQ20220210-214108@2x.png

显而易见，两个实例是同一个实例，我们的Singleton只被创建了一次。

饿汉式单例我们就介绍到这里，接下来，我们开始介绍懒汉式单例。

进阶篇 #

 懒汉式单例 

懒汉式单例在类加载时不会生成单例，只有当第一次调用getInstance()方法时才去创建这个单例。代码如下: 

`java
package com.yeliheng.singleton;

public class LazySingleton {
    
    private static LazySingleton lazySingleton = null; //创建一个空的懒汉式单例

    private LazySingleton() {

    }
    
    public static LazySingleton getInstance() {
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

`

在这个例子中，代码与前面的大同小异，就是在初始化lazySingleton变量时，没有像饿汉式单例那样立即实例化，而是指定一个null，当需要获取Instance实例时，再进行实例化。这样做，可以在大型计算场景中，节省内存，按需加载。

不知道聪明的你有没有注意到这样做的问题。在上面这个代码中，存在线程安全问题。在多线程程序的条件下，会出现LazySingleton还未创建完成的情况下，另一个线程又去访问调用LazySignleton，造成实例被创建多次的情况，这样它就不再是一个单例模式了。我们现在对程序进行改进：

`java

package com.yeliheng.singleton;

public class LazySingleton {

    private static volatile LazySingleton lazySingleton = null; //创建一个空的懒汉式单例

    private LazySingleton() {

    }

    public static synchronized LazySingleton getInstance() {
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

`
没错，只需要在变量出增加volatile关键字，并在静态成员方法处增加一个同步锁，就可以完美解决这个问题，保证线程安全。这样，全局程序将不可能出现多个实例。

 总结 

单例模式是设计模式中常用的模式之一。单例模式的形式常分为饿汉式和懒汉式。饿汉式的优点是创建起来简单，并且天然线程安全。缺点是在大量单例存在时，将造成资源浪费。懒汉式的优点是性能较好，按需加载对象，能够让内存空间被较佳利用。缺点是创建相对于饿汉式复杂，在多线程的场景下，对多线程不熟悉或稍不注意容易出现线程安全问题。

源码参考：GitHub

本文将以Java为例，带你重温GoF设计模式之单例模式，并深入理解单例模式的创建方法以及应用场景。

标签：设计模式

Java设计模式再相识 (三)——工厂方法(Factory Method)模式

Java设计模式再相识 (二)——原型模式

Java设计模式再相识 (一)——单例模式