Java与模式(阎宏著)之原型模式读书笔记

本文链接：https://blog.csdn.net/jack0511/article/details/3582562

什么是原型模式？

原始模型模式属于对象的创建模式 [GOF95]。通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的办法创建出更多同类型的对象。这就是原始模型模式的用意。

什么情况下使用原型模式？

如果一个系统的产品类是动态加载的，而且产品类具有一定的等级结构。这个时候如果采用工厂模式，工厂类就不得不具有一个相应的等级结构。而产品的类的等级结构一旦变化，工厂类的等级结构也必然随之改变，这种情况下采用工厂模式就有不方便的地方。

这时如果采取原型模式，给每个产品类配备一个clone()方法(大多数时候只需要给产品类等级结构的根类配备一个克隆方法)，便可以避免使用工厂模式所带来的具有固定等级结构的工厂类。

还有，大规模的创建同类对象时，用clone()的方法效率要比工厂的new效率高。

Java对象的复制

1.实现标识接口Cloneable，通知java虚拟机可以安全的在这个类上使用clone()方法。

2.重写clone()方法

java的所有类都是通过继承Object类得到的，而Object类提供了

protected Object clone()

方法来支持对象的复制。子类可以重写这个方法，定制适用于自己的clone()方法。对象被复制的时候，如果这个对象包含了指向其它对象的引用，那么引用也会被复制一份。

探讨两种写法：

第一种写法是阎宏书上一开始的例子，这种写法还是使用构造方法new了一个对象出来，然后将一些构造上的特殊性隔离出来。这种写法其实不实现Cloneable接口也不会报异常。因为它没有使用超类Object的clone()方法。

第二种写法是调用Object类的clone()方法实现自身的复制，并且需要显式的抛出一个CloneNotSupportedException异常。使用这种写法这个类本身必须实现Cloneable()接口。因为这种复制是java虚拟机调用native方法来实现，这样效率比之前一种要高。

原型模式有两种表现形式：简单形式和登记形式.

登记形式就是将对象放进原型管理器进行管理，一般是一个集合对象

登记形式代码示例：（在原来的代码例子上有所修改）

IProduct.java
package example.prototype;

import java.io.IOException;

public interface IProduct extends Cloneable {
   public Object clone(boolean isDeepClone) throws IOException, CloneNotSupportedException, ClassNotFoundException;
}

ConcreteProductPrototype.java

package example.prototype;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ConcreteProductPrototype implements IProduct {
  private int price=0;
  private String name;
  public ConcreteProductPrototype(String name,int price){
	  this.price=price;
	  this.name=name;
  }
  public String toString(){
	  return "Product："+name+" Price:"+price;
  }
	
  public synchronized Object clone(boolean isDeepClone) throws IOException, CloneNotSupportedException, ClassNotFoundException{
	  IProduct temp=null;
	if(!isDeepClone){  
		temp=(IProduct)(super.clone());  
	}
	if(isDeepClone){
		temp = deepClone();
	}
	return temp;
  }

private IProduct deepClone() throws IOException,
			ClassNotFoundException {
		IProduct temp;
		ByteArrayOutputStream bo=new ByteArrayOutputStream();
		ObjectOutputStream oo=new ObjectOutputStream(bo);
		oo.writeObject(this);
		ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
		ObjectInputStream oi=new ObjectInputStream(bi);
		temp=(IProduct)oi.readObject();
		return temp;
	}
}

PrototypeManager.java

package example.prototype;

import java.util.HashMap;
import java.util.Map;
import java.util.Vector;

public class PrototypeManager {
    private PrototypeManager(){}
    private static PrototypeManager pm=new PrototypeManager();
	
    public static PrototypeManager getInstance(){
    	return pm;
    }
    private Map objects=new HashMap();
    
    public void register(String clsname,IProduct concreteProductPrototype){
    	objects.put(clsname,concreteProductPrototype);
    }
    public IProduct getPrototype(String clsname){
    	IProduct product=null;
    	if(objects.containsKey(clsname)){
    		product=(IProduct)objects.get(clsname);
    	}
    	return product;
    }
    public IProduct unregister(String clsname){
    	return (IProduct)objects.remove(clsname);
    }
    public int getSize(){
    	return objects.size();
    }
}

深克隆与浅克隆

对象克隆有深克隆与浅克隆之分。

当复制一个对象时，如果此对象包含了对其它对象的引用，那么将被引用的对象也复制一份，并且让原来对被包含的对象的引用指向新的复制后的对象，此种复制的方式叫做深克隆；反之，如果仅仅只将被包含的对象的引用复制一份，而被包含的对象本身并没有复制，就是浅克隆。

实现深克隆的方法有两种：

方法一.序列化与反序列化

利用序列化(Serialization)来做深克隆。序列化(或者叫串行化)是把对象写到流里的过程，把对象从流中读出来的过程叫做反序列化(Deserialization) ，或者叫做并行化。这里需要说明的是，写到流里面的对象是一个拷贝，而原对象仍然存在于JVM里面。

Java中深克隆一个对象，可以实现Serializable接口，然后把对象的拷贝写到流里，再从流里读回来，就可以重建对象。

代码示例：

注意：不是所有的对象或对象内部引用到的对象都是可序列化的，不可序列化的对象需要设成transient，排除在深克隆之外。比如Thread对象或Socket对象是不能简单克隆或共享的，需要设成transient,例如：

public class MyClass implements Serializable {
public transient Thread t;
private String customerID;
private int total;
}

方法二、自己实现所有被引用的类的clone()方法，在被克隆的类的clone()方法里调用

public   class   ObjectForDeepClone   implements   Cloneable{
		private   int   i   =   0;
		private   ReferencedObject   rf  =  null; 
		public   void   setNum(int   i)   {
            this.i   =   i; 
        } 
		public   void   setReferencedObject(ReferencedObject   rf){
			this.rf   =   rf; 
		} 
		public   int   getNumber(){ 
			return   this.i; 
		}
		public   ReferencedObject   getReferencedObject(){ 
			  return   this.rf;
	    } 
		public   Object   clone()   throws   CloneNotSupportedException   { //  重写Object的clone
		ObjectForDeepClone cloneObject=(ObjectForDeepClone)super.clone();    																	
			if(rf!=null)
			{
				ReferencedObject rfClone=(ReferencedObject)rf.clone(); // 调用引用对象的clone方法
				cloneObject.setReferencedObject(rfClone);
			} 
			return   cloneObject; 
		} 
	}

public   class   ReferencedObject   implements   Cloneable{
	  private   int   i   =   0; 
	  public   ReferencedObject(int   i)   { 
         this.i   =   i;
      } 
	  public   void   doubleValue(){
         this.i   =   2*this.i; 
      } 
	  public   int   getNumber(){
			return   this.i;
	  }
	 public   Object   clone()   throws   CloneNotSupportedException   //   重写clone的方法
	  { 
		 return   (ReferencedObject)super.clone();
	  }
   }

另外书中提到用序列化的方式深克隆的时候，如果有对象相互引用的情况，会无限递归克隆出现异常，经实验是可以正常克隆的，如下构造两个类ChildA,ChildB,在Father类中使构造两个对象ca,cb，使其相互引用，然后克隆Father f对象，

ChildA.java
import java.io.Serializable;
public class ChildA implements Serializable{
    private ChildB b=null;
	public ChildA() {
		
	}
	
    public void print(){
    	System.out.println("ChildA is create@"+"a中的b is:"+b);
    }

public ChildB getB() {
		return b;
	}

public void setB(ChildB b) {
		this.b = b;
	}
}

ChildB.java
import java.io.Serializable;

public class ChildB implements Serializable{
    ChildA a=null;
	public ChildB() {
		
	}
	public void print(){
    	System.out.println("ChildB is create@"+ "b中的a is:"+a);
    }
	public ChildA getA() {
		return a;
	}
	public void setA(ChildA a) {
		this.a = a;
	}
	
}

Father.java

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

import example.prototype.IProduct;

public class Father implements Serializable,Cloneable{
   public Father(){}
   private ChildA a=null;
   private ChildB b=null;
   public static void main(String[] args) throws CloneNotSupportedException, IOException, ClassNotFoundException{
	   //构造含有两个空引用的f对象
	   Father f=new Father();
	   System.out.println("now f is:"+f);
       //构造含空引用b的ca,但ChildA对象确实已经存在了
	   ChildA ca=new ChildA();
	   ca.print();
	   //构造含空引用的a的cb,但ChildB对象确实已经存在了
	   ChildB cb=new ChildB();
	   cb.print();
	   //把两个含空引用的ca,cb对象，赋给f的引用
	   f.setA(ca);
	   f.setB(cb);
	   f.print();//f的a,b引用不为空了
	
	   //而f包含的a,b对象各自又引用到的a,b还是空的
	   System.out.println("now f.a.b is:"+f.getA().getB());
	   System.out.println("now f.b.a is:"+f.getB().getA());
       System.out.println("--------------------------------------");	   
	   //现在把ca,cb互相关联起来
	   ca.setB(cb);  
       cb.setA(ca);
       //可以看到现在所用的引用都不为空
       System.out.println("now f is:"+f+",f还是那个f");
	   System.out.println("now f.a.b is:"+f.getA().getB());
	   System.out.println("now f.b.a is:"+f.getB().getA());
	   System.out.println("--------------------------------------");
	   Father cf=f.deepClone();
	   System.out.println("Clone is Ok");
	   System.out.println("now cf is:"+cf);
	   System.out.println("now cf.a.b is:"+cf.getA().getB());
	   System.out.println("now cf.b.a is:"+cf.getB().getA());
	   System.out.println("弄不懂了，循环的克隆还真能成功？？？");
   }
   public void print(){
		System.out.println("Father is create@"+"f中的a is: "+a+"；f中的b is: "+b);
   }
   private Father deepClone() throws IOException,
	 ClassNotFoundException {
	 Father temp=null;   
	 ByteArrayOutputStream bo=new ByteArrayOutputStream();
	 ObjectOutputStream oo=new ObjectOutputStream(bo);
	 oo.writeObject(this);
	 ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
	 ObjectInputStream oi=new ObjectInputStream(bi);
	 temp=(Father)oi.readObject();
	 return temp;
	}

public ChildA getA() {
	return a;
}

public void setA(ChildA a) {
	this.a = a;
}

public ChildB getB() {
	return b;
}

public void setB(ChildB b) {
	this.b = b;
}
   
}

后来查询相关资料，这么说的：

在递归遍历过程中，对同一对象的引用如果出现多次，序列化过程并不会重复写入多个，具体的做法如下：
    ·保存到磁盘的所有对象都获得一个序列号（1、2、3等）
    ·当要保存一个对象时，先检查该对象是否已经被保存了
    ·如果以前保存过，只需写入“与已经保存的具有序列号x的对象相同”标记；否则，保存它的所有数据