【Java】【设计模式 Design Pattern】原型模式 Prototype
原型模式 Prototype
1) 原型模式(Prototype模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象
2) 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节
3) 工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即 对象.clone()
4) 形象的理解：孙大圣拔出猴毛， 变出其它孙大圣
克隆羊问题
package DP; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; /** * @author ArkD42 * @file Jdbc * @create 2020 - 05 - 01 - 9:12 */ @Data @AllArgsConstructor @NoArgsConstructor public class Sheep { private String name; private int age; private String color; }
在客户类使用
import org.junit.Test; /** * @author ArkD42 * @file Jdbc * @create 2020 - 05 - 01 - 9:13 */ public class Client { @Test public void prototype(){ Sheep dolly = new Sheep("多利",10,"灰色"); // 复制 Sheep newDolly1 = new Sheep(dolly.getName(),dolly.getAge(),dolly.getColor()); Sheep newDolly2 = new Sheep(dolly.getName(),dolly.getAge(),dolly.getColor()); Sheep newDolly3 = new Sheep(dolly.getName(),dolly.getAge(),dolly.getColor()); Sheep newDolly4 = new Sheep(dolly.getName(),dolly.getAge(),dolly.getColor()); Sheep newDolly5 = new Sheep(dolly.getName(),dolly.getAge(),dolly.getColor()); Sheep newDolly6 = new Sheep(dolly.getName(),dolly.getAge(),dolly.getColor()); Sheep newDolly7 = new Sheep(dolly.getName(),dolly.getAge(),dolly.getColor()); } }
1) 优点是比较好理解，简单易操作。
2) 在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低
3) 总是需要重新初始化对象，而不是动态地获得对象运行时的状态, 不够灵活
4) 改进的思路分析
思路：Java中Object类是所有类的根类，Object类提供了一个clone()方法，该方法可以
将一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个接口Cloneable，
该接口表示该类能够复制且具有复制的能力 => 原型模式
使用原型模式处理：
实现可克隆的接口，重写克隆方法（不重写好像也没什么问题....）
@Data @AllArgsConstructor @NoArgsConstructor public class Sheep implements Cloneable{ private String name; private int age; private String color; @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } }
在客户端调取
public class Client { @Test public void prototype() throws CloneNotSupportedException { Sheep dolly = new Sheep("多利",10,"灰色"); Sheep clone1 = (Sheep)dolly.clone(); Sheep clone2 = (Sheep)dolly.clone(); Sheep clone3 = (Sheep)dolly.clone(); Sheep clone4 = (Sheep)dolly.clone(); } }
深入讨论-浅拷贝和深拷贝
1)对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该【属性值】复制一份给新的对象。
2)对于数据类型是引用数据类型的成员变量，
比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行【引用传递】
也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该员变量都指向同一个实例。
在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值
3)前面我们克隆羊就是浅拷贝
4)浅拷贝是使用默认的 clone()方法来实现sheep = (Sheep) super.clone();
我们在Sheep设置一个自己的实例属性
package DP; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; /** * @author ArkD42 * @file Jdbc * @create 2020 - 05 - 01 - 9:12 */ @Data @AllArgsConstructor @NoArgsConstructor public class Sheep implements Cloneable{ private String name; private int age; private String color; private Sheep friend; //设置一个实例属性 @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } }
在客户端调用克隆查看对象
public class Client { @Test public void prototype() throws CloneNotSupportedException { Sheep dolly = new Sheep(); dolly.setName("多利"); dolly.setAge(10); dolly.setColor("灰色"); dolly.setFriend(new Sheep()); Sheep clone1 = (Sheep)dolly.clone(); Sheep clone2 = (Sheep)dolly.clone(); Sheep clone3 = (Sheep)dolly.clone(); Sheep clone4 = (Sheep)dolly.clone(); System.out.println(clone1 +" "+ clone1.getFriend().hashCode()); System.out.println(clone2 +" "+ clone2.getFriend().hashCode()); System.out.println(clone3 +" "+ clone3.getFriend().hashCode()); System.out.println(clone4 +" "+ clone4.getFriend().hashCode()); } }
我们可以发现这个实例属性克隆的结果是一样
这种情况就被称为是浅拷贝
深拷贝基本介绍
1)复制对象的所有基本数据类型的成员变量值
2)为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝
3)深拷贝实现方式1：重写clone方法来实现深拷贝
4)深拷贝实现方式2：通过对象序列化实现深拷贝(推荐)
注意演示的深拷贝不能再组合自己为实例，否则拷贝嵌套将会空指针异常
使用一个新的类作为拷贝组合类
@Data @NoArgsConstructor @AllArgsConstructor public class Goat implements Cloneable{ private String name; private int age; @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } }
还是一样的浅拷贝问题‘
我们对Sheep类实例的克隆方法进行修改
@Override protected Object clone() throws CloneNotSupportedException { Sheep sheep = (Sheep) super.clone(); sheep.friend = (Goat) friend.clone(); // 对组合的实例也进行克隆 return sheep; }
结果就不一样了
注意Lombok的@Data注解，该注解会改写hasCode方法，无法查看深拷贝的效果，不要使用此注解！！！
使用序列化实现深拷贝
注意！本类和组合的属性类都需要实现序列化接口
我们定义一个深拷贝方法
public Object deepClone(){ ByteArrayOutputStream outStream1 = null; ObjectOutputStream outStream2 = null; ByteArrayInputStream inStream1 = null; ObjectInputStream inStream2 = null; try{ outStream1 = new ByteArrayOutputStream(); outStream2 = new ObjectOutputStream(outStream1); outStream2.writeObject(this); // 反序列化 inStream1 = new ByteArrayInputStream(outStream1.toByteArray()); inStream2 = new ObjectInputStream(inStream1); Sheep object = (Sheep)inStream2.readObject(); return object; } catch (Exception e){ e.printStackTrace(); return null; } finally { try { outStream1.close(); outStream2.close(); inStream1.close(); inStream2.close(); } catch (Exception e){ e.printStackTrace(); } } }
客户类测试
public class Client { @Test public void prototype() throws CloneNotSupportedException { Sheep dolly = new Sheep(); dolly.setName("多利"); dolly.setAge(10); dolly.setColor("灰色"); dolly.setFriend(new Goat("山羊",22)); Sheep o1 = (Sheep)dolly.deepClone(); Sheep o2 = (Sheep)dolly.deepClone(); Sheep o3 = (Sheep)dolly.deepClone(); Sheep o4 = (Sheep)dolly.deepClone(); System.out.println(o1 + " "+o1.getFriend().hashCode()); System.out.println(o2 + " "+o2.getFriend().hashCode()); System.out.println(o3 + " "+o3.getFriend().hashCode()); System.out.println(o4 + " "+o4.getFriend().hashCode()); } }
打印结果
原型模式
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。
这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。
当直接创建对象的代价比较大时，则采用这种模式。
例如，一个对象需要在一个高代价的数据库操作之后被创建。
我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。
介绍
意图：
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
主要解决：
在运行期建立和删除原型。
何时使用：
1、当一个系统应该独立于它的产品创建，构成和表示时。
2、当要实例化的类是在运行时刻指定时，例如，通过动态装载。
3、为了避免创建一个与产品类层次平行的工厂类层次时。
4、当一个类的实例只能有几个不同状态组合中的一种时。
建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。
如何解决：
利用已有的一个原型对象，快速地生成和原型对象一样的实例。
关键代码：
1、实现克隆操作，在 JAVA 继承 Cloneable，重写 clone()，在 .NET 中可以使用 Object 类的 MemberwiseClone() 方法来实现对象的浅拷贝或通过序列化的方式来实现深拷贝。
2、原型模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它同样要求这些"易变类"拥有稳定的接口。
应用实例：
1、细胞分裂。 2、JAVA 中的 Object clone() 方法。
优点：
1、性能提高。 2、逃避构造函数的约束。
缺点：
1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。
2、必须实现 Cloneable 接口。
使用场景：
1、资源优化场景。 2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
3、性能和安全要求的场景。 4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
5、一个对象多个修改者的场景。
6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。
原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。
注意事项：
与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。
浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。
原型模式的注意事项和细节
1) 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率
2) 不用重新初始化对象，而是动态地获得对象运行时的状态
3) 如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，无需修改代码
4) 在实现深克隆的时候可能需要比较复杂的代码
5) 缺点：需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了ocp原则，这点请同学们注意.
浙公网安备 33010602011771号