深入探讨原型模式：灵活复制对象，提升代码效率与可维护性

引言

在软件开发中，经常会遇到需要创建对象的情况。有时候，我们希望创建一个新的对象，但又不想通过传统的构造方法来创建，而是希望通过复制一个现有对象的方式来创建新的对象。这时，原型模式就能派上用场了。原型模式是一种创建型设计模式，它通过复制现有对象来创建新对象，从而提高了代码的效率和可维护性。

本篇文章将深入探讨原型模式的原理、应用场景以及在实际项目中的使用方法。

一、理解原型模式

原型模式属于创建型设计模式，其核心思想是通过复制现有对象来创建新的对象，而不是通过传统的构造方法。在原型模式中，原型对象是被复制的对象，而新对象是根据原型对象创建的副本。这种方式既避免了直接使用构造方法创建对象的繁琐过程，又可以保证新对象的属性与原型对象一致。

二、原型模式的应用场景

原型模式适用于以下几种场景：

对象的创建过程比较复杂，但又希望保持对象的属性一致。
需要避免使用复杂的构造方法来创建对象。
需要动态地生成对象，而不是静态地使用类的构造方法。

在实际项目中，原型模式通常用于以下几种情况：

在大量对象需要创建，且创建过程相对复杂时，使用原型模式可以提高代码效率。
当需要创建的对象属性与现有对象相似或相同，但需要稍作修改时，可以通过复制原型对象并修改部分属性来创建新对象。

三、原型模式的实现方式

原型模式的实现方式主要有两种：浅拷贝和深拷贝。

浅拷贝：浅拷贝是指复制对象时，只复制对象本身及其基本数据类型的属性，而不会复制对象所引用的其他对象。即使原型对象中包含了引用类型的属性，复制后的新对象与原对象仍会共享同一个引用类型的属性。
深拷贝：深拷贝是指复制对象时，不仅复制对象本身及其基本数据类型的属性，还会递归复制对象所引用的其他对象。这样，即使原型对象中包含了引用类型的属性，复制后的新对象与原对象不会共享同一个引用类型的属性。

在实现原型模式时，需要根据具体的需求选择合适的拷贝方式，以确保复制出的新对象能够满足业务需求。

四、原型模式的代码示例

先来看下相关 UML 图：

下面通过一个简单的示例来演示原型模式的代码实现：

package com.markus.desgin.mode.creational.prototype;

/**
 * @Author: zhangchenglong06
 * @Date: 2024/3/7
 * @Description:
 */
public abstract class Car implements Cloneable {

  private String carName;
  private String carType;

  abstract void drive();

  public String getCarName() {
    return carName;
  }

  public void setCarName(String carName) {
    this.carName = carName;
  }

  public String getCarType() {
    return carType;
  }

  public void setCarType(String carType) {
    this.carType = carType;
  }

  @Override
  public Object clone() {
    try {
      return super.clone();
    } catch (CloneNotSupportedException e) {
      e.printStackTrace();
    }
    return null;
  }
}

package com.markus.desgin.mode.creational.prototype;

/**
 * @Author: zhangchenglong06
 * @Date: 2024/3/7
 * @Description:
 */
public class XiaoMiSuvCar extends Car {
  @Override
  void drive() {
    String message = "carName: " + this.getCarName() + ", carType: " + this.getCarType();
    System.out.println(message + " 已启动");
  }
}

package com.markus.desgin.mode.creational.prototype;

/**
 * @Author: zhangchenglong06
 * @Date: 2024/3/7
 * @Description:
 */
public class BydSuvCar extends Car {
  @Override
  void drive() {
    String message = "carName: " + this.getCarName() + ", carType: " + this.getCarType();
    System.out.println(message + " 已启动");
  }
}

package com.markus.desgin.mode.creational.prototype;

import java.util.HashMap;

/**
 * @Author: zhangchenglong06
 * @Date: 2024/3/7
 * @Description:
 */
public class CarCache {
  private static HashMap<String, Car> carMap = new HashMap<String, Car>();

  static {
    XiaoMiSuvCar xiaoMiSuvCar = new XiaoMiSuvCar();
    xiaoMiSuvCar.setCarType("SUV");
    xiaoMiSuvCar.setCarName("XiaoMi");
    carMap.put("Xiaomi", xiaoMiSuvCar);

    BydSuvCar bydSuvCar = new BydSuvCar();
    bydSuvCar.setCarType("SUV");
    bydSuvCar.setCarName("BYD");
    carMap.put("BYD", bydSuvCar);
  }

  public static Car getCar(String key) {
    Car car = carMap.get(key);
    return (Car) car.clone();
  }
}

package com.markus.desgin.mode.creational.prototype;

/**
 * @Author: zhangchenglong06
 * @Date: 2024/3/7
 * @Description:
 */
public class PrototypePatternDemo {
  public static void main(String[] args) {
    Car car = CarCache.getCar("Xiaomi");
    car.drive();

    car = CarCache.getCar("BYD");
    car.drive();

    Car car2 = CarCache.getCar("BYD");
    System.out.println("car == car2 : " + (car == car2));
  }
}

在上面的示例中，我们通过实现Cloneable接口并重写clone()方法，实现了原型对象的浅拷贝。

五、原型模式在 Spring 的应用

我们知道在 Spring 框架中 Bean 的作用域除了单例模式，还有原型模式。

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {

	/**
	 * Scope identifier for the standard singleton scope: {@value}.
	 * <p>Custom scopes can be added via {@code registerScope}.
	 * @see #registerScope
	 */
	String SCOPE_SINGLETON = "singleton";

	/**
	 * Scope identifier for the standard prototype scope: {@value}.
	 * <p>Custom scopes can be added via {@code registerScope}.
	 * @see #registerScope
	 */
	String SCOPE_PROTOTYPE = "prototype";
}

在 Spring 框架中，原型模式和我们本篇说的原型模式实现有所不同。Spring 中创建 Bean 实例是通过反射重复创建。

六、设计模式百宝箱

在本节，我们继续填充我们的百宝箱：

面向对象基础
- 抽象
- 封装
- 多态
- 继承
面向对象原则
- 依赖抽象，不要依赖具体类
- 针对接口编程，不针对具体实现编程
- 类应该对扩展开放，对修改关闭
- 为交互对象之间的松耦合设计而努力
面向对象设计模式
- 简单工厂模式：定义了一个创建对象的接口，将创建对象的内容从客户端抽离出来
- 抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类
- 原型模式：通过复制现有对象来创建新对象，提高代码效率和可维护性