原型模式(Prototype Pattern):使用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。原型模式是一种对象创建型模式。
原型模式的工作原理很简单:将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝自己来实现创建过程。
原型模式是一种“另类”的创建型模式,创建克隆对象的工厂就是原型类自身,工厂方法由克隆方法来实现。
需要注意的是通过克隆方法所创建的对象是全新的对象,它们在内存中拥有新的地址,通常对克隆所产生的对象进行修改对原型对象不会造成任何影响,每一个克隆对象都是相互独立的。通过不同的方式修改可以得到一系列相似但不完全相同的对象。
原型模式的核心在于如何实现克隆方法。
学过Java语言的人都知道,所有的Java类都继承自 java.lang.Object。事实上,Object 类提供一个 clone() 方法,可以将一个Java对象复制一份。因此在Java中可以直接使用 Object 提供的 clone() 方法来实现对象的克隆,Java语言中的原型模式实现很简单。
需要注意的是能够实现克隆的Java类必须实现一个 标识接口 Cloneable,表示这个Java类支持被复制。如果一个类没有实现这个接口但是调用了clone()方法,Java编译器将抛出一个 CloneNotSupportedException 异常。
具体原型类:
//实现Cloneable接口 @Data public class Sheep implements Cloneable { private String name; private Integer age; //重写Object的clone方法 @Override protected Object clone() throws CloneNotSupportedException { Sheep sheep=null; sheep=(Sheep)super.clone(); return sheep; } }
客户端创建并克隆原型对象:
//创建原型对象 Sheep sheep=new Sheep(); sheep.setAge(3); sheep.setName("肖恩"); //克隆 Sheep sheep1 = sheep.clone(); Sheep sheep2=sheep.clone(); System.out.println(sheep1); System.out.println(sheep2); System.out.println(sheep1==sheep2);
克隆出来的对象,它们的内存地址均不同,说明不是同一个对象,克隆成功,克隆仅仅通过调用 super.clone() 即可。
看一眼 Object#clone 方法
protected native Object clone() throws CloneNotSupportedException;
这是一个 native 关键字修饰的方法
一般而言,Java语言中的clone()方法满足:
在派生类中覆盖基类的 clone() 方法,并声明为public;
在派生类的 clone() 方法中,调用 super.clone();
派生类需实现Cloneable接口。
此时,Object类相当于抽象原型类,所有实现了Cloneable接口的类相当于具体原型类。
pig类:
@Data @AllArgsConstructor @NoArgsConstructor public class Pig { String name; Integer age; }
sheep类:
//实现Cloneable接口 @Data public class Sheep implements Cloneable { private String name; private Integer age; private Pig pig; //重写Object的clone方法 @Override protected Sheep clone() throws CloneNotSupportedException { Sheep sheep=null; sheep=(Sheep)super.clone(); return sheep; } }
客户端进行克隆:
public class test { @Test public void test() throws CloneNotSupportedException { //创建原型对象 Sheep sheep=new Sheep(); sheep.setAge(3); sheep.setName("肖恩"); sheep.setPig(new Pig("大忽悠",3)); //克隆 Sheep sheep1 = sheep.clone(); Sheep sheep2=sheep.clone(); System.out.println(sheep1); System.out.println(sheep2); System.out.println(sheep1==sheep2); System.out.println("=============================="); System.out.println(sheep1.getPig()==sheep2.getPig()); } }
这里对Sheep类里面的引用类型Pig的克隆方式只是简单的地址拷贝,即浅拷贝操作
浅克隆:
深克隆:
Pig类首先需要实现克隆即可,并重写clone方法:
@Data @AllArgsConstructor @NoArgsConstructor public class Pig implements Cloneable { String name; Integer age; @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } }
sheep类:
//实现Cloneable接口 @Data public class Sheep implements Cloneable { private String name; private Integer age; private Pig pig; //重写Object的clone方法 @Override protected Sheep clone() throws CloneNotSupportedException { Sheep sheep=null; sheep=(Sheep)super.clone(); sheep.pig=(Pig)sheep.pig.clone(); return sheep; } }
对象可以序列化的前提是实现了Serializable接口,这里Sheep和Pig都需要实现该接口
pig类:
@Data @AllArgsConstructor @NoArgsConstructor public class Pig implements Serializable { String name; Integer age; }
sheep类:
//实现Cloneable接口 @Data public class Sheep implements Serializable { private String name; private Integer age; private Pig pig; //序列化方式完成深拷贝 public Sheep deepClone() throws IOException, ClassNotFoundException { //先将要序列化的对象写入流中 ByteArrayOutputStream baot=new ByteArrayOutputStream(); //ObjectOutputStream构造函数的参数是,将对象流写入到哪里 ObjectOutputStream oot=new ObjectOutputStream(baot); oot.writeObject(this); //将序列化的对象从流中读取出来 ByteArrayInputStream bait=new ByteArrayInputStream(baot.toByteArray()); ObjectInputStream oit=new ObjectInputStream(bait); return (Sheep) oit.readObject(); } }
饿汉式单例模式如下:
public class HungrySingleton implements Serializable, Cloneable { private final static HungrySingleton hungrySingleton; static { hungrySingleton = new HungrySingleton(); } private HungrySingleton() {} public static HungrySingleton getInstance() { return hungrySingleton; } private Object readResolve() { return hungrySingleton; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } }
使用反射获取对象,测试如下
public class Test { public static void main(String[] args) throws CloneNotSupportedException, NoSuchMethodException, InvocationTargetException, IllegalAccessException { HungrySingleton hungrySingleton = HungrySingleton.getInstance(); Method method = hungrySingleton.getClass().getDeclaredMethod("clone"); method.setAccessible(true); HungrySingleton cloneHungrySingleton = (HungrySingleton) method.invoke(hungrySingleton); System.out.println(hungrySingleton); System.out.println(cloneHungrySingleton); } }
输出
com.designpattern.HungrySingleton@34c45dca
com.designpattern.HungrySingleton@52cc8049
可以看到,通过原型模式,我们把单例模式给破坏了,现在有两个对象了
为了防止单例模式被破坏,我们可以:不实现 Cloneable 接口;或者把 clone 方法改为如下
@Override protected Object clone() throws CloneNotSupportedException { return getInstance(); }
原型模式的主要优点如下:
原型模式的主要缺点如下:
在Spring中,用户也可以采用原型模式来创建新的Bean实例,从而实现每次获取的是通过克隆生成的新实例,对其进行修改时对原有实例对象不造成任何影响。
这里的原型模式,也就是常说的Spring中的多实例模式,Spring中还有大家熟知的单实例模式,即Sigleton
本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注的更多内容!