原型模式（Prototype）

 

原型模式：

1、定义：原型模式就是通过一个原型对象来表明要创建的对象类型，然后用复制这个对象的方法来创建更痛类型的对象。

2、原理：有两部分组成，抽象原型和具体原型。

3、使用时机：系统需要 创建吃的对象是动态加载的，而且产品具有一定层次时，可以考虑使用原型模式。

1>当要实例化的类是在运行时刻指定时，例如，通过动态装载；

2>或者为了避免创建一个与产品类层次平行的工厂类层次时；

3>或者当一个类的实例只能有几个不同状态组合中的一种时。

4>建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

4、效果：

1>可以再运行时刻增加和删除产品。

2>可以通过改变值来指定产品。

3>可以通过改变结构来指定新对象。

4>减少子类的构造

5>可以用类动态配置应用。

5、实现：

1>使用一个原型管理器

2>实现克隆操作（浅拷贝和深拷贝）

3>初始化克隆对象。

6、使用原型模式的意图：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

7、解决的问题：

比如有一个对象，在某一时刻该对象中已经包含了一些有效的值，此时可能会需要一个和该对象完全相同的新对象，并且此后对新对象的任何改动都不会影响到原来对象中的值，也就是说新对象与原来的对象是两个独立的对象，但新对象的初始值是由原来的对象确定的。

Clone：

赋值创建对象：

1>java中赋值创建对象是可以实现对象的重用的，但是新对象和原对象是同一个引用；如果修改其中的一个对象的值，则另外的一个对象也会发生改变。

2>使用clone方法会返回对象的一个拷贝，这样一来，如果修改一个对象的值，则另外的对象不会发生改变的。

原型模式UML图：

请注意，在 这边Cloneable并非指Java中的java.lang.Cloneable，而是指支持原型复制 的对象，必须实作之公开协议。

不 同的语言可能提供不同程 度支持之对象复制技术，以Java而言，java.lang.Object本身即定义有clone()方法，因此所有的对象 基本上 皆具自我复制之能力，不 过真正要让对象支持复制，则对象必须实作java.lang.Cloneable这个标示接口（Tag interface）。

原型模式浅拷贝与原型模式深度拷贝：

看看这样一个示例：有个类（DogClone）实现了Java的Cloneable接口，也实现了Object的clone（）方法，它持有另一个没有实现Cloneable接口并且没有复写Object的clone（）方法的引用（Dog）。如果Dog同时实现了clone（）方法也实现了Cloneable接口，在对DogClone做科隆操作的时候会不会影响dog的值呢？

 

package org.bestupon.prototype.copy;
/**
 * 同实现了克隆方法的类和实现克隆方法的类做比较
 * @author bestupon
 * 浅拷贝Dog
 */
public class Dog {
	/**
	 * 狗腿条数
	 */
	public int legCounts;

	public Dog(int legCounts) {
		this.legCounts = legCounts;
	}
	/**
	 * 改变狗的腿数量
	 */
	public void changeLegCounts(){
		this.legCounts *=2;
	}
	public String toString () {
		return Integer.toString(this.legCounts);
	}
}

 

 

package org.bestupon.prototype.clone;
/**
 * 该类是没有实现克隆方法的类和实现克隆方法的类做比较
 * @author bestupon
 * 深度拷贝用例
 */
public class Dog implements Cloneable{
	/**
	 * 狗腿条数
	 */
	public int legCounts;

	public Dog(int legCounts) {
		this.legCounts = legCounts;
	}
	/**
	 * 改变狗的腿数量
	 */
	public void changeLegCounts(){
		this.legCounts *=2;
	}
	
	@Override
	public Dog clone() throws CloneNotSupportedException {
		return (Dog)super.clone();
	}
	public String toString () {
		return Integer.toString(this.legCounts);
	}
}

 

 

package org.bestupon.prototype.copy;

public class DogClone implements Cloneable {
	/**
	 * 狗腿条数
	 */
	public int legCounts;
	/**
	 * 初始化一个狗
	 */
	Dog dog = new Dog(4);
	@Override
	protected DogClone clone() throws CloneNotSupportedException {
		return (DogClone)super.clone();
	}
	
}

 

 

 package org.bestupon.prototype.copy;
/** 浅拷贝
 * @author bestupon
 *
 */
public class Client {
	public static void main(String args []) throws CloneNotSupportedException {
		DogClone dogClone = new DogClone();
		dogClone.legCounts = 3;
		System.out.println("原来的克隆狗腿数量："+dogClone.legCounts);
		System.out.println("原来的普通狗腿的数量："+dogClone.dog);//Dog的toString方法返回的值。
		
		DogClone dogClone1 = (DogClone)dogClone.clone();
		dogClone1.legCounts=2 ;
		
		 Dog dog = dogClone1.dog;
		 dog.changeLegCounts();
		 System.out.println("克隆后原来狗腿数量："+dogClone.legCounts);
		 /**
		  * 出现的结果是：8
		  * 原因很简单就是dog是一个引用，改变一个对象的话，会改变另一个对象。
		  */
		 System.out.println("克隆后原来普通狗的数量："+ dogClone.dog);
		 System.out.println("克隆后克隆狗腿的数量："+ dogClone1.legCounts);
		 /**
		  *改变源：改变了自身dogClone.dog，影像了对象dogClone.dog 的值，
		  */
		 System.out.println("克隆后普通狗的数量："+ dogClone1.dog);
		
	}
}

 

两次运行结果：

没有实现Cloneable接口和clone()方法结果：

 

原来的克隆狗腿数量：3
原来的普通狗腿的数量：4
克隆后原来狗腿数量：3
克隆后原来普通狗的数量：8
克隆后克隆狗腿的数量：2
克隆后普通狗的数量：8

 

 

实现了Cloneable接口和clone()方法结果：

 

原来的克隆狗腿数量：3
原来的普通狗腿的数量：4
克隆后原来狗腿数量：3
克隆后原来普通狗的数量：4
克隆后克隆狗腿的数量：2
克隆后普通狗的数量：8

 同样的客户端为什么会有不同的结果呢？这就是所谓的浅拷贝和深拷贝的为题.

 

分析：

浅拷贝： DogClone类中的legCounts属性被科隆了，因为对科隆后的对象进行修改时，没有改变原来对象的值，其原因是实现了接口和方法，而DogClone，Dog对象 dog没有被科隆，而在修改科隆后的对象时，会改变原来对象的值。

如果要是都实现了接口和方法，就实现了深度科隆，不会影响远对象的值。

 

应用：

 不是所有的对象都是能实现深度科隆的，例如:StringBuffer就没有重载Clone（）方法，而且StringBuffer还是一个final类，所以其不能自动实现深度科隆。

在Spring中.深度科隆是应用广泛的。在实体模型上面有这样一个注解：@Component("lawsuitArchive") @scope("prototype")，表明在别的地方应用的时候，是引用其原型，同时Entity也要实现Cloneable接口和复写clone()方法。因为原型在初始化的时候就已经创建了一部分有价值的东西，减少容器的压力，而在别的地方，例如action中引用该对象的时候，直接可以使用@Resource(name="lawsuitArchive")引用对象，Spring会自动的装配好你想要的对象。

注：附件有直接可以运行的示例。点击下载

 

最近正在看大话设计模式这本书，感觉不错

希望以后多沟通！

LZ确定 你写的程序没问题吗？
  System.out.println("原来的普通狗腿的数量："+dogClone.dog);//Dog的toString方法返回的值。    这句话 都有错啊。。编译都不过

希望你在使用代码的时候,是不是有中文乱码的问题!还有编译级别的问题!检查检查!我使用的jdk1.6-upload 11.

可能不在同一个包下

看着LZ的原型模式，我写了个简单的Demo。但发现测试结果很奇怪，似乎并为实现深度拷贝？

BtripApplication.java

public class BtripApplication implements Cloneable{

   private int a;

public int getA() {
return a;
}

public void setA(int a) {
this.a = a;
}
  
public BtripApplication clone() throws CloneNotSupportedException {
return (BtripApplication)super.clone();
}


BtripRevisioin.java

public class BtripRevision implements Cloneable {

  private BtripApplication btripApplication;
 
  public BtripRevision(BtripApplication btripApplication){
  this.btripApplication =  btripApplication;
  }

public BtripApplication getBtripApplication() {
return btripApplication;
}
public void setBtripApplication(BtripApplication btripApplication) {
this.btripApplication = btripApplication;
}

public BtripRevision clone() throws CloneNotSupportedException {
return (BtripRevision)super.clone();
}


上述两个类都实现了Cloneable ，并重写了clone，我写的测试类如下：

public class TestBtripApplicationRevision {
  public static void main(String args[]) throws CloneNotSupportedException{
  BtripApplication b1 = new BtripApplication();
  b1.setA(1);
  BtripRevision b2 = new BtripRevision(b1);
  BtripRevision b3 =  b2.clone();
  //b3.getBtripApplication().setA(3);
  b1.setA(3);
  System.out.println("b2="+b2.getBtripApplication().getA());
  System.out.println("b3="+b3.getBtripApplication().getA());
  System.out.println("b2="+b2+"--------b3="+b3);
  }
}

测试结果：b2=3
         b3=3

为什么结果不是b2=1,b3=3??????求解

如果对于类BtripApplication通过super.clone方法是可以进行正确克隆的，因为是primitive 类型，所以可以实现正确克隆，并且不是“影子克隆”，但是对于后者由于BtripRevision中有“可变类”mutable class，所以需要进行状态重置，不能仅仅通过super.clone进行拷贝。所以...