JAVA：深入理解原型模式构建可复用对象的关键技术

旧城等待， 2024-04-20 12:14 63阅读 0赞

请关注微信公众号：**拾荒的小海螺**

#### 1、简述 ####

在软件开发中，有时候我们需要创建许多相似但不完全相同的对象，这时候使用原型模式就显得非常有用。原型模式是一种创建型设计模式，它允许我们通过复制现有对象来创建新对象，而无需从头开始构建。本文将深入探讨 Java 中的原型模式，解释其原理、用法以及常见的应用场景。

![在这里插入图片描述][cf6898655ef749b5b42c9e3d5b058fe0.png]

#### 2、原理 ####

原型模式的核心思想是通过克隆（拷贝）现有对象来创建新的对象。这种克隆可以分为浅克隆和深克隆两种形式：

*  浅克隆（Shallow Clone）：只复制对象本身，而不复制对象的引用类型属性。即新对象和原对象共享引用类型属性。
 *  深克隆（Deep Clone）：复制对象本身以及对象的引用类型属性，创建全新的对象，新对象和原对象的引用类型属性不共享。

Java 中实现原型模式的方式主要有两种：通过实现 Cloneable 接口和通过序列化。

#### 3、浅拷贝 ####

Java 提供了 Cloneable 接口，该接口表示一个类支持被复制（克隆）。如果一个类实现了 Cloneable 接口，那么它就可以使用 clone() 方法进行对象的克隆。下面是一个简单的示例：

public class Prototype implements Cloneable {
        private String data;
        /**
         * 引用Teacher 对象
         */
        private Teacher teacher;
    
        public Prototype(String data) {
            this.data = data;
        }
    
        @Override
        public Prototype clone() throws CloneNotSupportedException {
            return (Prototype) super.clone();
        }
    
        public String getData() {
            return data;
        }
    
        public void setData(String data) {
            this.data = data;
        }
    
        public Teacher getTeacher() {
            return teacher;
        }
    
        public void setTeacher(Teacher teacher) {
            this.teacher = teacher;
        }
    }

引用的Teacher对象实例：

public class Teacher {
        private String data;
    
        public Teacher(String data) {
            this.data = data;
        }
    
        @Override
        public Prototype clone() throws CloneNotSupportedException {
            return (Prototype) super.clone();
        }
    
        public String getData() {
            return data;
        }
    
        public void setData(String data) {
            this.data = data;
        }
    }

通过使用main函数示例输出：

public class CloneMain {
        public static void main(String[] args) throws CloneNotSupportedException {
            Teacher teacher = new Teacher("Teacher Data");
            Prototype prototype = new Prototype("Original Data");
            teacher.setData("Teacher Data");
            prototype.setTeacher(teacher);
            
            Prototype clonedPrototype = prototype.clone();
            clonedPrototype.setData("Original Data1");
            clonedPrototype.getTeacher().setData("Teacher Data2");
    
            System.out.println("原来对象：" + prototype.getData()); // 输出：Original Data
            System.out.println("引用原来对象：" + prototype.getTeacher().getData()); // 输出：Teacher Data2
    
            System.out.println("拷贝对象：" + clonedPrototype.getData()); // 输出：Original Data1
            System.out.println("引用拷贝对象：" + clonedPrototype.getTeacher().getData()); // 输出：Teacher Data2
        }
    }

通过执行控制台输出结果：

原来对象：Original Data
    引用原来对象：Teacher Data2
    拷贝对象：Original Data1
    引用拷贝对象：Teacher Data2

观察以上运行结果，我们可以发现：在我们给Prototype 拷贝对象 修改老师的时候，Prototype 原型的老师也跟着被修改了。这就是浅拷贝带来的问题。

#### 4、深拷贝 ####

另一种实现深克隆的方法是通过序列化和反序列化。通过将对象写入输出流，然后再从输入流中读取对象，可以创建一个新的对象，这个过程中会创建对象的副本。下面是一个示例：

##### 4.1 使用序列化和反序列化 #####

通过将对象写入输出流，然后再从输入流中读取对象，可以创建一个新的对象，这个过程中会创建对象的副本。

import java.io.*;
    
    public class DeepPrototype implements Serializable {
        
        private String data;
        /**
         * 引用Teacher 对象
         */
        private Teacher teacher;
    
        public DeepPrototype(String data) {
        
            this.data = data;
        }
    
    
    
        public DeepPrototype deepClone() throws IOException, ClassNotFoundException {
        
            // 写入输出流
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
            objectOutputStream.writeObject(this);
    
            // 从输入流中读取对象
            ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
            ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
            return (DeepPrototype) objectInputStream.readObject();
        }
    
        public String getData() {
        
            return data;
        }
    
        public void setData(String data) {
        
            this.data = data;
        }
    
        public Teacher getTeacher() {
        
            return teacher;
        }
    
        public void setTeacher(Teacher teacher) {
        
            this.teacher = teacher;
        }
    }

引用的Teacher对象实例也要实现序列化Serializable：

public class Teacher implements Serializable {
        
        private String data;
    
        public Teacher(String data) {
        
            this.data = data;
        }
    
        @Override
        public Prototype clone() throws CloneNotSupportedException {
        
            return (Prototype) super.clone();
        }
    
        public String getData() {
        
            return data;
        }
    
        public void setData(String data) {
        
            this.data = data;
        }
    }

通过使用main函数示例输出：

public class CloneMain {
        
        public static void main(String[] args) throws CloneNotSupportedException, IOException, ClassNotFoundException {
        
            Teacher teacher = new Teacher("Teacher Data");
            DeepPrototype prototype = new DeepPrototype("Original Data");
            teacher.setData("Teacher Data");
            prototype.setTeacher(teacher);
    
            DeepPrototype clonedPrototype = prototype.deepClone();
            clonedPrototype.setData("Original Data1");
            clonedPrototype.getTeacher().setData("Teacher Data2");
    
            System.out.println("原来对象：" + prototype.getData()); // 输出：Original Data
            System.out.println("引用原来对象：" + prototype.getTeacher().getData()); // 输出：Teacher Data
    
            System.out.println("拷贝对象：" + clonedPrototype.getData()); // 输出：Original Data2
            System.out.println("引用拷贝对象：" + clonedPrototype.getTeacher().getData()); // 输出：Teacher Data2
        }
    }

通过执行控制台输出结果：

原来对象：Original Data
    引用原来对象：Teacher Data
    拷贝对象：Original Data1
    引用拷贝对象：Teacher Data2

##### 4.2 使用 JSON 序列化和反序列化 #####

将对象转换为 JSON 格式的字符串，然后再从字符串中反序列化出对象。这种方法需要使用一个 JSON 库，如 Jackson、Gson 等。以下是一个示例：

import com.fasterxml.jackson.databind.ObjectMapper;
    
    public class DeepCopyUtils {
        
        private static final ObjectMapper objectMapper = new ObjectMapper();
    
        public static <T> T deepCopy(T obj, Class<T> clazz) throws IOException {
        
            String json = objectMapper.writeValueAsString(obj);
            return objectMapper.readValue(json, clazz);
        }
    }

##### 4.3 使用 BeanUtils #####

Apache Commons BeanUtils 库提供了 BeanUtils.cloneBean() 方法，可以复制对象的属性到新对象中。这种方法需要确保对象的属性都是可序列化的。以下是一个示例：

import org.apache.commons.beanutils.BeanUtils;
    
    public class DeepCopyUtils {
        
        public static <T> T deepCopy(T obj) throws ReflectiveOperationException {
        
            return (T) BeanUtils.cloneBean(obj);
        }
    }

你可以使用 DeepCopyUtils.deepCopy() 方法来实现深拷贝。

#### 5、应用场景 ####

原型模式在开源框架中的应用也非常广泛。例如 Spring 中，@Service 默认都是单例的。用了私有全局变量，若不想影响下次注入或每次上下文获取 bean，就需要用到原型模式，我们可以通过以下注解来实现，@Scope(“prototype”)。

*  当对象的创建成本较高，但需要频繁创建相似对象时，可以使用原型模式。
 *  当需要避免构造函数重复调用，而又需要获得新对象时，可以使用原型模式。
 *  当对象的结构比较复杂，无法直接使用 new 关键字创建对象时，可以使用原型模式。

#### 6、总结 ####

原型模式是一种创建型设计模式，通过复制现有对象来创建新对象，能够有效地减少对象的创建成本，提高代码的可复用性和可维护性。在 Java 中，可以通过实现 Cloneable 接口或者序列化来实现原型模式。通过深入理解原型模式的原理和用法，我们可以更好地应用它解决实际的软件设计和开发问题。

[cf6898655ef749b5b42c9e3d5b058fe0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/075eef3553474653be969ddbe3a9a16c.png