程序员必知！原型模式的实战应用与案例分析

原型模式（Prototype Pattern）是一种创建型设计模式，它允许通过复制（或克隆）一个已有对象的方式来创建新对象，而无需重新实例化。这种模式的核心思想是利用已有的对象作为原型，通过对其进行复制来生成新的对象。

定义

原型模式是一个巧妙的工具，它可以帮助我们解决在编程过程中的一些头疼问题，想象一下你每次需要一个对象时都得从零开始创建，这就像每次要画一幅画都得从头开始准备颜料和画布一样。如果对象的创建涉及到大量的数据加载或复杂的初始化工作，这就会非常耗时。原型模式就像是一个预先准备好的模板，让我们可以直接复制一个已经存在的对象，而不是每次都重新制作。有些对象的构造函数特别复杂，参数多得让人眼花缭乱，使用原型模式，我们就不再需要调用这样的构造函数，而是直接复制一个已经配置好的对象，这样，对象的创建过程就变得更加简单和直观了。有时候我们还需要根据程序运行时的不同情况来生成不同的对象，原型模式允许我们在复制对象之前对其进行修改，这样就可以轻松地根据需要生成具有不同状态的对象了。

代码案例

1、范例代码演示

假设我们有一个ComplexObject类，它代表一个复杂的数据对象，每次创建时都需要从数据库或外部资源中加载大量数据，如以下代码：

import java.util.ArrayList;  
import java.util.List;  
  
public class ComplexObject {  
    private List<Data> dataList = new ArrayList<>();  
  
    public ComplexObject() {  
        // 模拟从数据库或外部资源中加载大量数据  
        System.out.println("Loading data...");  
        for (int i = 0; i < 10000; i++) {  
            dataList.add(new Data()); // 假设Data是一个简单的数据类  
        }  
        System.out.println("Data loaded.");  
    }  
  
    // 为了展示，添加一个简单的获取数据的方法  
    public List<Data> getData() {  
        return dataList;  
    }  
  
    // 假设Data是一个简单的内部类，用于存储数据  
    public static class Data {  
        private String value;  
  
        public Data() {  
            value = "Some data"; // 在实际应用中，这里可能是从数据库或其他来源获取的数据  
        }  
  
        @Override  
        public String toString() {  
            return value;  
        }  
    }  
}

现在，如果我们想创建多个ComplexObject实例，每次都会执行大量的数据加载操作，如下代码：

public class Main {  
    public static void main(String[] args) {  
        // 创建第一个ComplexObject实例，加载数据  
        ComplexObject obj1 = new ComplexObject();  
        System.out.println("Object 1 created.");  
  
        // 创建第二个ComplexObject实例，再次加载数据  
        ComplexObject obj2 = new ComplexObject();  
        System.out.println("Object 2 created.");  
    }  
}

当运行上述代码时，会看到以下输出，如下代码：

Loading data...  
Data loaded.  
Object 1 created.  
Loading data...  // 注意这里，我们又重新加载了数据，即使obj1已经加载过一遍了。  
Data loaded.  
Object 2 created.

如上，每次创建ComplexObject实例时都会重新加载数据，频繁创建这种对象，会造成资源浪费和性能下降，但是通过原型模式，我们可以避免这种不必要的重复加载，从而提高应用程序的性能和效率。

2、正例代码演示

使用原型模式，我们可以通过复制已有的对象来创建新的对象，而无需每次都重新加载数据或执行复杂的初始化操作，如下代码，展示了如何使用原型模式来优化对象创建的过程：

首先，我们修改ComplexObject类，让它实现Cloneable接口并重写clone()方法。clone()方法将返回一个与原始对象具有相同状态的新对象，而不会重新加载数据。

import java.util.ArrayList;  
import java.util.List;  
  
public class ComplexObject implements Cloneable {  
    private List<Data> dataList = new ArrayList<>();  
  
    public ComplexObject() {  
        // 模拟从数据库或外部资源中加载大量数据  
        System.out.println("Loading data...");  
        for (int i = 0; i < 10000; i++) {  
            dataList.add(new Data()); // 假设Data是一个简单的数据类  
        }  
        System.out.println("Data loaded.");  
    }  
  
    // 实现Cloneable接口的clone方法，用于创建对象的副本  
    @Override  
    public ComplexObject clone() {  
        try {  
            return (ComplexObject) super.clone(); // 调用Object类的clone方法进行浅复制  
        } catch (CloneNotSupportedException e) {  
            e.printStackTrace(); // 在正常情况下，CloneNotSupportedException不会发生  
            return null;  
        }  
    }  
  
    // 为了展示，添加一个简单的获取数据的方法  
    public List<Data> getData() {  
        return dataList;  
    }  
  
    // 假设Data是一个简单的内部类，用于存储数据  
    public static class Data {  
        private String value;  
  
        public Data() {  
            value = "Some data"; // 在实际应用中，这里可能是从数据库或其他来源获取的数据  
        }  
  
        @Override  
        public String toString() {  
            return value;  
        }  
    }  
}

接下来，我们可以在客户端代码中使用clone()方法来创建ComplexObject的实例，而无需每次都重新加载数据：

public class Main {  
    public static void main(String[] args) {  
        // 创建第一个ComplexObject实例，加载数据  
        ComplexObject original = new ComplexObject();  
        System.out.println("Original object created.");  
  
        // 使用clone()方法创建第二个ComplexObject实例，无需重新加载数据  
        ComplexObject copy1 = original.clone();  
        System.out.println("Copy 1 created.");  
  
        // 使用clone()方法创建第三个ComplexObject实例，同样无需重新加载数据  
        ComplexObject copy2 = original.clone();  
        System.out.println("Copy 2 created.");  
    }  
}

当运行上述代码时，您会看到以下输出：

Loading data...  // 只有在这里加载了一次数据。之后都是通过复制来创建新对象。  
Data loaded.  
Original object created.  // 创建了原始对象。  
Copy 1 created.  // 通过复制原始对象创建了第一个副本。  
Copy 2 created.  // 通过复制原始对象创建了第二个副本。```java  
这样，通过使用原型模式，我们避免了不必要的重复数据加载，提高了对象创建的效率和性能。在实际应用中，原型模式特别适用于创建成本较高或需要动态生成对象的场景。

核心总结

原型模式是一种创建对象的设计模式，它通过复制现有的对象来创建新的对象。

在原型模式中，我们创建一个原型对象，并通过复制这个原型对象来创建新的对象，原型对象通常是一个通用的对象，它包含了对象的基本属性和方法，在创建新对象时，我们只需要复制原型对象，并根据需要修改新对象的属性即可。

原型模式的主要优点是可以提高对象创建的效率，尤其是在需要创建大量相似对象的情况下。此外，原型模式还可以减少对象创建的开销，因为我们不需要每次都创建一个新的对象。原型模式的缺点是可能会导致代码可读性降低，因为我们需要在代码中处理对象的复制过程。

在 Java 中，我们可以使用原型模式来实现对象的复制。例如，我们可以使用 Java 的 clone 方法来复制对象。需要注意的是，在使用 clone 方法时，我们需要确保被复制的对象是可复制的，并且需要处理深拷贝和浅拷贝的问题。