原型模式

使用原型模式来复制一个对象，从而克隆出多个与原型对象一模一样的对象。

在某些系统中，有些对象的创建过程很昂贵很复杂，而且有时候需要频繁创建。

可以用原型模式解决。

 

原型模式(Prototype Pattern)：原型模式是一种对象创建型模式，用原型实例，指定创建对象的种类，并且通过复制这些原型，创建新的对象。

 

在原型模式结构中定义了一个抽象原型类，所有的Java类都继承自java.lang.Object，而Object类提供一个clone()方法，可以将一个Java对象复制一份。因此在Java中可以直接使用Object提供的clone()方法来实现对象的克隆（浅拷贝），Java语言中的原型模式实现很简单。

能够实现克隆的Java类必须实现一个标识接口Cloneable，表示这个Java类支持复制。如果一个类没有实现这个接口但是调用了clone()方法，Java编译器将抛出一个CloneNotSupportedException异常。 

 

浅拷贝是指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量，引用变量地址），而不拷贝对象包含的引用指向的对象。

深拷贝不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象。

 

若不对clone()方法进行改写，则调用此方法得到的对象即为浅拷贝（Object的clone为浅拷贝）。

深拷贝方法，就是将对象串行化。

 

package com.ez;

import java.io.Serializable;

/**
 * 浅拷贝，通过Object提供的clone方法，就可以实现浅拷贝。
 * 对象必须继承Cloneable接口。
 * @author 窗外赏雪（EZ编程网）
 */
public class People implements Cloneable,Serializable{
	private static final long serialVersionUID = -4084944705840672303L;
	private int age;
	private String name;
	
	public People(int age,String name) {
		this.age=age;
		this.name=name;
	}
	
	public int getAge() {
		return age;
	}
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public void setName(String name) {
		this.name = name;
	}
	/**
	 * 子类默认实现方式：覆盖重写父类的方法，默认使用super.xxx
	 * 所以在子类中，可以调用父类的方法。
	 */
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
	
	public static void main(String[] args) {
		People p0=new People(15,"李四");
		System.out.println("age:"+p0.getAge()+",name:"+p0.getName());;
		try {
			People p1=(People)p0.clone();
			System.out.println("age:"+p1.getAge()+",name:"+p1.getName());
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
	}
}

 

package com.ez;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OptionalDataException;
import java.io.Serializable;
/**
 * 深拷贝和浅拷贝的区别
 * @author 窗外赏雪（EZ编程网）
 */
public class Student implements Serializable,Cloneable{

	/**
	 * 反序列化的时候，需要对照这个ID，如果不匹配就反序列化异常。
	 */
	private static final long serialVersionUID = 3457679362463213165L;

	private String name;// 常量对象。
    private int age;
    private People people;// 学生1和学生2的引用值都是一样的。
 
    Student(String name, int age, People p) {
        this.name = name;
        this.age = age;
        this.people = p;
    }
 
    public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	public People getPeople() {
		return people;
	}

	public Object deepClone() throws IOException, OptionalDataException,
            ClassNotFoundException {
        // 将对象写到流里
        ByteArrayOutputStream bo = new ByteArrayOutputStream();
        ObjectOutputStream oo = new ObjectOutputStream(bo);
        oo.writeObject(this);
        // 从流里读出来
        ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
        ObjectInputStream oi = new ObjectInputStream(bi);
        return (oi.readObject());
    }
    
    public static void main(String[] args) throws CloneNotSupportedException, OptionalDataException, ClassNotFoundException, IOException {
		People p0=new People(18, "窗外赏雪");
		Student stu=new Student("李四", 15, p0);
		//浅拷贝只拷贝p0的引用
		Student stu1=(Student)stu.clone();
		System.out.println("age:"+stu1.getAge()+",name:"+stu1.getName());
		stu1.getPeople().setAge(111);
		stu1.getPeople().setName("大刀关羽");
		System.out.println("======"+p0.getAge()+p0.getName()+"======");
		
		//深拷贝会拷贝p0的真实对象
		Student stu2=(Student)stu.deepClone();
		System.out.println("age:"+stu2.getAge()+",name:"+stu2.getName());
		stu2.getPeople().setAge(222);
		stu2.getPeople().setName("小刀关胜");
		System.out.println("======"+p0.getAge()+p0.getName()+"======");
	}
}

 

原型模式的优点

当创建新的对象实例较为复杂时，使用原型模式可以简化对象的创建过程。（通过一个已有实例可以提高新实例的创建效率）

 

原型模式应用：

Struts2中为了保证线程的安全性，Action对象的创建使用了原型模式，访问一个已经存在的Action对象时将通过克隆的方式创建出一个新的对象，从而保证其中定义的变量无须进行加锁实现同步，每一个Action中都有自己的成员变量，避免Struts1因使用单例模式而导致的并发和同步问题。

 

Spring中，用户也可以采用原型模式来创建新的bean实例，从而实现每次获取的是通过克隆生成的新实例，对其进行修改时对原有实例对象不造成任何影响。