3.原型模式

原型模式

一、克隆羊问题

​ 现在有一只羊tom，姓名为tom，年龄为1，颜色为白色，编写程序创建和tom羊属性完全相同的10只羊。

二、传统方式

1.代码实现

public class Client {

    public static void main(String[] args) {
        //传统的方法
        Sheep sheep = new Sheep("tom", 1, "白色");
        Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep4 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep5 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        System.out.println(sheep);
        System.out.println(sheep2);
        System.out.println(sheep3);
        System.out.println(sheep4);
        System.out.println(sheep5);
    }
}

2.传统方式的优缺点

1）优点是比较好理解，简单易操作。
2）在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低。
3）总是需要重新初始化对象，而不是动态地获得对象运行时的状态，不够灵活

三、原型模式（Prototype）

​ 思路：Java中Object类是所有类的根类，Object类提供了一个clone（）方法，该方法可以将一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个接口Cloneable，该接口表示该类能够复制且具有复制的能力

• 代码实现

  public class Sheep implements Cloneable {
  	private String name;
  	private int age;
  	private String color;
  	private String address = "蒙古羊";
  	public Sheep friend; //是对象, 克隆是会如何处理
  	public Sheep(String name, int age, String color) {
  		super();
  		this.name = name;
  		this.age = age;
  		this.color = color;
  	}
  	public String getName() {
  		return name;
  	}
  	public void setName(String name) {
  		this.name = name;
  	}
  	public int getAge() {
  		return age;
  	}
  	public void setAge(int age) {
  		this.age = age;
  	}
  	public String getColor() {
  		return color;
  	}
  	public void setColor(String color) {
  		this.color = color;
  	}
  
  	@Override
  	public String toString() {
  		return "Sheep [name=" + name + ", age=" + age + ", color=" + color + ", address=" + address + "]";
  	}
  	//克隆该实例，使用默认的clone方法来完成
  	@Override
  	protected Object clone()  {
  		Sheep sheep = null;
  		try {
  			sheep = (Sheep)super.clone();
  		} catch (Exception e) {
  			System.out.println(e.getMessage());
  		}
  		return sheep;
  	}
  }
  

四、原型模式在Spring框架中的源码分析

1）Spring中原型bean的创建，就是原型模式的应用

五、浅拷贝和深拷贝

1.浅拷贝的介绍

1）基本数据类型，浅拷贝会直接进行值传递

2）引用数据类型，如数组、对象等，浅拷贝会进行引用传递。这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。

3）浅拷贝是使用默认的clone()方法来实现

2.深拷贝的基本介绍

1）基本数据类型，值传递

2）为引用数据类型的成员变量申请存储空间，复制一份相同的出来，修改复制出来的对象不会影响其他的对象

3）深拷贝实现方式1：重写clone方法实现

4）深拷贝实现方式2：通过对象序列化实现深拷贝（推荐）

3.深拷贝应用实例

1）重写clone方法实现深拷贝（多层引用对象时比较麻烦）

2）对象序列化实现（推荐）

/**
 * 深拷贝
 */
public class DeepProtoType implements Serializable, Cloneable{
	
	public String name; //String 属性
	public DeepCloneableTarget deepCloneableTarget;// 引用类型
	public DeepProtoType() {
		super();
	}

	//深拷贝 - 方式 1 使用clone 方法
	@Override
	protected Object clone() throws CloneNotSupportedException {
		Object deep = null;
		//这里完成对基本数据类型(属性)和String的克隆
		deep = super.clone(); 
		//对引用类型的属性，进行单独处理
		DeepProtoType deepProtoType = (DeepProtoType)deep;
		deepProtoType.deepCloneableTarget  = (DeepCloneableTarget)deepCloneableTarget.clone();
		
		return deepProtoType;
	}
	
	//深拷贝 - 方式2 通过对象的序列化实现 (推荐)
	
	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);
			DeepProtoType copyObj = (DeepProtoType)ois.readObject();
			
			return copyObj;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		} finally {
			//关闭流
			try {
				bos.close();
				oos.close();
				bis.close();
				ois.close();
			} catch (Exception e2) {
				System.out.println(e2.getMessage());
			}
		}
	}
}

六、原型模式的注意事项和细节

1）创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，提高效率

2）不用重新初始化对象，而是动态的获得对象运行时的状态

3）如果原始对象发生变化（增加或者减少属性），其他克隆对象也会发生相应的变化，无需修改代码。