Java设计模式 - 原型模式

简介

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。

克隆

原型模式对某个对象进行克隆，在最原始的古老方法就是通过new出实例，使用与之相同的参数，但是每次创建新的对象时候需要重新获取一下属性，效率不佳。 例子如下：

①、古老办法

本次使用lombok，省的还需要写get，set，toString；坐标导入如下：

<dependencies> <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.24</version> </dependency> </dependencies> 

实体类，使用lombok的@Data注解

package com.lyd.demo.entity; import lombok.Data; /**
 * @Author: lyd
 * @Description:
 * @Date: 2022-08-25
 */ @Data public class Car { private String type; private String color; public Car(String type, String color) { this.type = type; this.color = color;
    }
}

使用古老办法，使用new一个一个赋值，很明显有些缺点，每次都需要调用对象去获取属性

package com.lyd.demo.ancient; import com.lyd.demo.entity.Car; /**
 * @Author: lyd
 * @Description:
 * @Date: 2022-08-25
 */ public class Test { public static void main(String[] args) {
        Car car = new Car("奔驰", "black"); // 复制更多对象 Car c1 = new Car(car.getType(), car.getColor());
        Car c2 = new Car(car.getType(), car.getColor());
        Car c3 = new Car(car.getType(), car.getColor());
        System.out.println("car: " + car + " hashcode: " + car.hashCode());
        System.out.println("c1: " + c1 + " hashcode: " + c1.hashCode());
        System.out.println("c2: " + c2 + " hashcode: " + c2.hashCode());
        System.out.println("c3: " + c3 + " hashcode: " + c3.hashCode());
    }
}

运行结果：可见虽然是复制成功了，但是效率明显很低。

②、原型模式

用原型实例指定创建对象的种类，通过拷贝实例创建新的对象。 例子如下代码： 需要让car实现Cloneable并且实现clone方法。

package com.lyd.demo.entity; import lombok.Data; /**
 * @Author: lyd
 * @Description:
 * @Date: 2022-08-25
 */ @Data public class Car implements Cloneable { private String type; private String color; public Car(String type, String color) { this.type = type; this.color = color;
    } // 克隆实例 @Override protected Object clone() throws CloneNotSupportedException {
        Car car = null;
        car = (Car) super.clone(); return car;
    }
}

测试：

package com.lyd.demo.entity; /**
 * @Author: lyd
 * @Description:
 * @Date: 2022-08-25
 */ public class PrototypeTest { public static void main(String[] args) throws CloneNotSupportedException {
        Car car = new Car("红旗", "red");
        Car c1 = (Car) car.clone();
        Car c2 = (Car) car.clone();
        Car c3 = (Car) car.clone();
        System.out.println("car: " + car + " hashcode: " + car.hashCode());
        System.out.println("c1: " + c1 + " hashcode: " + c1.hashCode());
        System.out.println("c2: " + c2 + " hashcode: " + c2.hashCode());
        System.out.println("c3: " + c3 + " hashcode: " + c3.hashCode());
    }
}

定义一个原型类，声明出克隆自己的接口。克隆的时候只要调用clone方法就可以实现对象克隆。

浅拷贝

对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性复制一份给新的对象。因为是两份不同的数据，所以对其中一的对象的成员变量值进行修改，不会影响另一个对象拷贝得到的数据。 对于数据类型是引用类型的成员变量，比如说成员变量是某个数组，某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用指（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。

在Car类中加一个属性

public Car NewEnergy;

编写测试浅拷贝类

package com.lyd.demo.entity; /**
 * @Author: lyd
 * @Description: 浅拷贝
 * @Date: 2022-08-25
 */ public class ShallowCopyTest { public static void main(String[] args) throws CloneNotSupportedException {
        Car car = new Car("红旗", "red");
        car.NewEnergy = new Car("奔驰", "blue"); // 克隆 Car c1 = (Car) car.clone();
        Car c2 = (Car) car.clone();
        Car c3 = (Car) car.clone();
        System.out.println("car: " + car + " hashcode: " + car.hashCode() + " NewEnergy: " + car.NewEnergy + " hashcode: " + car.NewEnergy.hashCode());
        System.out.println("c1: " + c1 + " hashcode: " + c1.hashCode() + " NewEnergy: " + c1.NewEnergy + " hashcode: " + c1.NewEnergy.hashCode());
        System.out.println("c2: " + c2 + " hashcode: " + c2.hashCode() + " NewEnergy: " + c2.NewEnergy + " hashcode: " + c2.NewEnergy.hashCode());
        System.out.println("c3: " + c3 + " hashcode: " + c3.hashCode() + " NewEnergy: " + c3.NewEnergy + " hashcode: " + c3.NewEnergy.hashCode());
    }
}

可见，如果是基本数据类型，那就会传递值，将值赋给新的对象；对于对象，则只是进行引用传递。这种就是浅拷贝。这样会导致只要修改其中一个变量，就会导致所有都修改，例如 c2.NewEnergy.setColor("red"); 之后在打印一次数据。

深拷贝

深拷贝复制变量值，对于引用数据，则递归至基本类型后，再复制。深拷贝后的对象与原来的对象是完全隔离的，互不影响，对一个对象的修改并不会影响另一个对象。深拷贝相比于浅拷贝速度较慢并且花销较大。 重新定义两个实体类，其中一个只有基本数据类型，另一个包含引用数据类型

方式一：通过重写clone()方法

Car: 在克隆的时候直接调用super.clone()来完成对基本数据类型的克隆，通过引用数据类的clone方法在进行类型强制装换即可。

package com.lyd.demo.deep; import lombok.Data; import java.io.Serializable; /**
 * @Author: lyd
 * @Description: 汽车类
 * @Date: 2022-08-25
 */ @Data public class Car implements Cloneable, Serializable { private String type; private String color; public NewEnergy newEnergy; // 引用数据类型 public Car(String type, String color) { this.type = type; this.color = color;
    } // 克隆实例 @Override protected Object clone() throws CloneNotSupportedException {
        Object object = null; // 完成基本数据的装换 object = super.clone(); // 对引用数据类型的属性，单独处理 Car car = (Car) object;
        car.newEnergy = (NewEnergy) newEnergy.clone(); return car;
    }
}

NewEnergy：

package com.lyd.demo.deep; import lombok.Data; import java.io.Serializable; /**
 * @Author: lyd
 * @Description: 新能源类
 * @Date: 2022-08-25
 */ @Data public class NewEnergy implements Serializable, Cloneable { private String type; private String color; public NewEnergy(String type, String color) { this.type = type; this.color = color;
    } /**
     * 该类都是基本数据类型，直接返回即可
     * @return * @throws CloneNotSupportedException
     */ @Override protected Object clone() throws CloneNotSupportedException { return super.clone();
    }
}

测试:

package com.lyd.demo.deep; /**
 * @Author: lyd
 * @Description: 深拷贝
 * @Date: 2022-08-25
 */ public class DeepCopyTest { public static void main(String[] args) throws CloneNotSupportedException {
        Car car = new Car("路虎", "green");
        car.newEnergy = new NewEnergy("路虎新能源", "blue");
        Car c1 = (Car) car.clone();
        Car c2 = (Car) car.clone();
        System.out.println("car: " + car + " hashcode: " + car.hashCode() + " NewEnergy: " + car.newEnergy + " hashcode: " + car.newEnergy.hashCode());
        System.out.println("c1: " + c1 + " hashcode: " + c1.hashCode() + " NewEnergy: " + c1.newEnergy + " hashcode: " + c1.newEnergy.hashCode());
        System.out.println("c2: " + c2 + " hashcode: " + c2.hashCode() + " NewEnergy: " + c2.newEnergy + " hashcode: " + c2.newEnergy.hashCode());
        System.out.println("==============================================================================================================================");
        c1.newEnergy.setColor("red"); // 修改 System.out.println("car: " + car + " hashcode: " + car.hashCode() + " NewEnergy: " + car.newEnergy + " hashcode: " + car.newEnergy.hashCode());
        System.out.println("c1: " + c1 + " hashcode: " + c1.hashCode() + " NewEnergy: " + c1.newEnergy + " hashcode: " + c1.newEnergy.hashCode());
        System.out.println("c2: " + c2 + " hashcode: " + c2.hashCode() + " NewEnergy: " + c2.newEnergy + " hashcode: " + c2.newEnergy.hashCode());
    }
}

可见，不但完成了把引用对象进行拷贝，修改c1的属性时，不会影响其他的对象，这就是深拷贝

方式二：通过对象序列化

通过对象流的方式将对象进行序列化之后在进行反序列化完成深拷贝。这样的效果会更好。 只要在Car类中添加一个deepClone方法

// 方式二：实现序列化 public Object deepClone() { // 创建流对象 ByteArrayOutputStream bos = null;
    ObjectOutputStream oos = null;
    ByteArrayInputStream bis = null;
    ObjectInputStream ois = null; try { // 序列化 bos = new ByteArrayOutputStream();
        oos = new ObjectOutputStream(bos);
        oos.writeObject(this); // 把当前对象以对象流的方式输出 //反序列 bis = new ByteArrayInputStream(bos.toByteArray());
        ois = new ObjectInputStream(bis);
        Car car = (Car) ois.readObject(); return car;
    } catch (Exception e) {
        e.printStackTrace(); return null;
    } finally { // 关闭流 try {
            ois.close();
            bis.close();
            oos.close();
            bos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

测试：只要调用deepClone方法就可以

Car c1 = (Car) car.deepClone();
Car c2 = (Car) car.deepClone();

💓小建议：

理解设计模式不是一件简单的事情，需要不断的学习和动手去练习，才能理解。只有掌握好设计模式，才能够真正的理解SpringAOP和Mybatis的底层原理。各位读者可以和我一样，动手敲一敲代码，甚至用不同的例子来做，通过debug一步一步调试，还有就是多看看别人的例子。能够有助于理解！