设计模式-原型(prototype)

 一、概念

　　用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

二、模式动机

　　当已有一个对像，暂且称之为原型对象，需要一个新的对像，该对像和已有的原型对像具有相同的类型，且里面的属性大部分相同，或者只有个别不同时，这时就可以用原型模式，克隆原型对像，产生一个新的对像，并对新的对像属性进行适当的修改，已适应系统需求。比如新生产的同一批次同一型号的笔记本电脑，如果每个电脑都是一个实例对像，这些电脑配置都是相同的，唯一不同可能是序列号不同，如何实例化所有的电脑，这时就可以用一个原型电脑，去克隆出所有的电脑，只需对克隆出来的新电脑设置正确的序列号就可以了。

三、模式的结构

　　

　　角色分析：

　　　　1.IPrototype:声明一个克隆自身的接口

　　　　2.ConcretePrototype(ConcretePrototypeA,ConcretePrototypeA): 实现了IPrototype接口， 这些类真正实现了克隆自身的功能

　　　　3.Client:让一个原型对象克隆自身产生一个新的对象。

　　

样例代码：

package prototype;

/**
 * 声明一个克隆自身的接口，所有实现该接口的类实例，都可以克隆自身产生一个新的对象
* @ClassName: IPrototype
* @author beteman6988
* @date 2017年10月23日 下午9:47:35
*
 */
public interface IPrototype {

    /**
     * 实现克隆自身的接口方法
    * @Title: clone
    * @param @return
    * @return IPrototype
    * @throws
     */
    public IPrototype clone();

}

package prototype;

/**
 * 实现了克隆接口的具体实现对象
* @ClassName: ConcretePrototype
* @author beteman6988
* @date 2017年10月23日 下午9:51:13
*
 */
public class ConcretePrototypeA implements IPrototype {

    /**
     * 实现克隆功能的具本方法
     */
    @Override
    public IPrototype clone() {
        //最简单的方式就是new 一个新对像，并一一将自已的属性值复制到新的对像里面
        IPrototype cloneObj=new ConcretePrototypeA();
        //将本对像的属性值赋于新的对像
        //如   cloneObj.setProperty(this.propety); 等
        return cloneObj;
    }

}

package prototype;

/**
 * 实现了克隆接口的具体实现对象
* @ClassName: ConcretePrototype
* @author beteman6988
* @date 2017年10月23日 下午9:51:13
*
 */
public class ConcretePrototypeB implements IPrototype {

    /**
     * 实现克隆功能的具本方法
     */
    @Override
    public IPrototype clone() {
        //最简单的方式就是new 一个新对像，并一一将自已的属性值复制到新的对像里面
        IPrototype cloneObj=new ConcretePrototypeB();
        //将本对像的属性值赋于新的对像
        //如   cloneObj.setProperty(this.propety); 等
        return cloneObj;
    }

}

package prototype;

/**
 * 客户端程序，从已有实例克隆出一个新的对象
* @ClassName: Client
* @author beteman6988
* @date 2017年10月23日 下午10:06:18
*
 */
public class Client {
    private IPrototype instance=new ConcretePrototypeA();

    private void operation() {
        //从已有实例 instance 克隆出一个新的对象 cloneObj
        IPrototype  cloneObj=instance.clone();
    }

}

　

　关于浅度克隆、深度克隆及java对该原型模式的支持

　　1.浅度克隆与深度克隆：在讲原型模式是，浅度克隆与深度克隆是逃不开的话题，上面的示例都是浅度克隆，那么什么是浅度克隆和深度克隆呢？

　　　　浅度克隆：只负责按值传递的数据，如基本数据类型和String  ,如果是引用，则原型对像和克隆出的对像指的是同一个引用地址。

　　　  深度克隆：除了浅度克隆要克隆的值外，引用对像也会被克隆，克隆出的对像和原型对像中的引用是不同的，指上不同的地址空间。

　　2. java对浅度克隆的支持：java.lang.Object.clone()方法，该方法为protected native方法，表明继承于他的类都可以调用该方法，又由于java中的所有类都继承于java.lang.Object，所以说java中的所有类都可以以super.clone()的方式调用java.lang.Object.clone()方法。当子类通过调用java.lang.Object.clone()方法实现克隆时，子类必须实现Cloneable标识接口，该标识接口的作用就是在运行时通知java虚拟机可以安全的在这个类上使用clone()方法，通过该方法得到一个对像的克隆，如下图所示：

　　　　　　　　　　　　

　　代码如下：

　　

package prototype.cloneable;

/**
 * 声明一个克隆自身的接口，所有实现该接口的类实例，都可以克隆自身产生一个新的对象
* @ClassName: IPrototype
* @author beteman6988
* @date 2017年10月23日 下午9:47:35
*
 */
public interface IPrototype extends Cloneable {

    /**
     * 实现克隆自身的接口方法
    * @Title: clone
    * @param @return
    * @return IPrototype
    * @throws
     */
    public IPrototype clone();

}

package prototype.cloneable;
/**
 * 实现了克隆接口的具体实现对象
* @ClassName: ConcretePrototype
* @author beteman6988
* @date 2017年10月23日 下午9:51:13
*
 */
public class ConcretePrototypeA implements IPrototype {

    /**
     * 实现克隆功能的具本方法
     */
    @Override
    public IPrototype clone() {

        try {
            return     (IPrototype)super.clone();

        } catch ( Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
    }
}

package prototype.cloneable;

/**
 * 客户端程序  跟据已有实例，克隆出一个新的实例
* @ClassName: Client
* @author beteman6988
* @date 2017年10月23日 下午11:37:18
*
 */
public class Client {
    private IPrototype instance=new ConcretePrototypeA();
    public void option() {
        IPrototype p=instance.clone();
    }

}

　　　　3.java对深度克隆的支持：在java里面利用串行化Serilization可以实现深度克隆，他要求原型类及原型类里面的引用类都需要实现Serializable标识接口，他的实现思想是通过将原型对像写到流里面，然后再从流里读出来重建对像。还是基于上面的例子，如下图：

　　　　　　

package prototype;

import java.io.Serializable;

public class A  implements Serializable {

}

package prototype;

import java.io.Serializable;

/**
 * 声明一个克隆自身的接口，所有实现该接口的类实例，都可以克隆自身产生一个新的对象
* @ClassName: IPrototype
* @author beteman6988
* @date 2017年10月23日 下午9:47:35
*
 */
public interface IPrototype extends Serializable {

    /**
     * 实现克隆自身的接口方法
    * @Title: clone
    * @param @return
    * @return IPrototype
    * @throws
     */
    public IPrototype clone();

}

package prototype;

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

/**
 * 实现了克隆接口的具体实现对象
* @ClassName: ConcretePrototype
* @author beteman6988
* @date 2017年10月23日 下午9:51:13
*
 */
public class ConcretePrototypeA implements IPrototype {

    private A a =new A();

    /**
     * 实现克隆功能的具本方法
     */
    @Override
    public IPrototype clone() {

        try {
            //将对像写入流中
            ByteArrayOutputStream bo=new ByteArrayOutputStream();
            ObjectOutputStream oo=new ObjectOutputStream(bo);
            oo.writeObject(this);

            //将对像从流中读出
            ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
            ObjectInputStream oi=new ObjectInputStream(bi);
            return (IPrototype)oi.readObject();

        } catch ( Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
    }
}

package prototype;

/**
 * 客户端程序
* @ClassName: Client
* @author beteman6988
* @date 2017年10月23日 下午11:37:18
*
 */
public class Client {

    public static void main(String[] args) {
        IPrototype prototype=new ConcretePrototypeA();
        IPrototype copy= prototype.clone();
    }
}

通过调试见下图，可以看出copy对象及内部的a 引用对象与原型对象是不同的对象，如下图示:

　　　　　　　　

　　　　4.java通过逐级浅克隆实现深度克隆:通过java.lang.Object.clone()对java对像及内部的引用逐级克隆也是可以实现的，难点只是无法确定克隆的层次，因为引用里面还有可能有引用，引用的层次无法确定。　

四、模式样例

　　现实生活中复印机和细胞分裂就是很贴切的例子，当我们将一份文件放到复印机中，复印机可以将原件自身复印(克隆)出另一份文件，两份文件内容相同，但是是不同的两个实体。如下图所示：

　　　　　　　　　　　　　　　

　　

package prototype;

/**
 * 具有复印功能的接口
* @ClassName: CopyAble
* @author beteman6988
* @date 2017年10月23日 下午11:19:45
*
 */
public interface CopyAble {

    public CopyAble copy();

}

/**
 * 可以复制的一张纸
* @ClassName: Paper
* @author beteman6988
* @date 2017年10月23日 下午11:28:57
*
 */
public class Paper implements CopyAble {

    private String header;  //文件头
    private String content; //文件内容
    private String footer;  //文件尾

    /**
     * 复制出内容一样的一张纸
     */
    @Override
    public CopyAble copy() {
        Paper anotherPaper=new Paper();
        anotherPaper.setHeader(this.header);
        anotherPaper.setContent(this.content);
        anotherPaper.setFooter(this.footer);
        return anotherPaper;
    }

    public String getHeader() {
        return header;
    }

    public void setHeader(String header) {
        this.header = header;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getFooter() {
        return footer;
    }

    public void setFooter(String footer) {
        this.footer = footer;
    }

}

/**
 * 可以复制的一张纸
* @ClassName: Paper
* @author beteman6988
* @date 2017年10月23日 下午11:28:57
*
 */
public class Paper implements CopyAble {

    private String header;  //文件头
    private String content; //文件内容
    private String footer;  //文件尾

    /**
     * 复制出内容一样的一张纸
     */
    @Override
    public CopyAble copy() {
        Paper anotherPaper=new Paper();
        anotherPaper.setHeader(this.header);
        anotherPaper.setContent(this.content);
        anotherPaper.setFooter(this.footer);
        return anotherPaper;
    }

    public String getHeader() {
        return header;
    }

    public void setHeader(String header) {
        this.header = header;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getFooter() {
        return footer;
    }

    public void setFooter(String footer) {
        this.footer = footer;
    }

}

/**
 * 可复制的一张照片
* @ClassName: Picture
* @author beteman6988
* @date 2017年10月23日 下午11:30:51
*
 */
public class Picture implements CopyAble {

    private String data; //照片内容

    /**
     * 复制出内容一模一样的一张照片
     */
    @Override
    public CopyAble copy() {
        // TODO Auto-generated method stub
        return null;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

}

package prototype;

/**
 * 复印机类，可以复印一切可以复印的东西（即实现CopyAble的实现类）
* @ClassName: CopyMachine
* @author beteman6988
* @date 2017年10月23日 下午11:34:35
*
 */
public class CopyMachine {

    /**
     * 对传入的可复制对像进行复制
    * @Title: runCopy
    * @param @param source
    * @param @return
    * @return CopyAble
    * @throws
     */
    public CopyAble runCopy(CopyAble source) {
        return source.copy();
    }

}

package prototype;

/**
 * 客户端程序  使用复印机，对现有的可复制资料进行复制
* @ClassName: Client
* @author beteman6988
* @date 2017年10月23日 下午11:37:18
*
 */
public class Client {

    public static void main(String[] args) {

         CopyMachine machine=new CopyMachine();

         Paper aPaper=new Paper();
         aPaper.setHeader("文件头内空");
         aPaper.setContent("文件内容");
         aPaper.setFooter("文件尾内容");

         Paper anotherPaper= (Paper) machine.runCopy(aPaper); //复印机复印出另一文件
         System.out.println(anotherPaper.getHeader());
         System.out.println(anotherPaper.getContent());
         System.out.println(anotherPaper.getFooter());
　　　

　　　　　　System.out.println(aPaper==anotherPaper);
　　　　　　System.out.println(aPaper.getClass()==anotherPaper.getClass());

    }

}

运行结果如下：

文件头内空
文件内容
文件尾内容
false
true

　

五、模式的约束

　　对于第三方客户提供的实现类，这种类往往无权进行修改，这时如何实现对该类实例的克隆，是相当麻烦，这时可以借助一些通用性比较好的工具类来完成，如apache 的org.apache.commons.beanutils.BeanUtils.copyProperties(Object dest, Object orig)

　　对于克隆出的新对象和原对象之间需满足以下条件约束

　　1 对于任何对象  x.clone()!=x  克隆对像和原对象不是同一个对像  ，该条件必须满足

　　2. x.clone().getClass()=x.getClass() ，克隆对像和原对像的类型必须相同

　　3.x.clone().equals(x)  , 可选

　　

六、模式的变体与扩展

　　在实际的开发中，对于需要单独实现克隆的情况相对较少，经常使用的是一些写好的通用工具类，如apache 的org.apache.commons.beanutils.BeanUtils.copyProperties(Object dest, Object orig) ，其实现原理是通过java的反射机制来实现的，拿来就可以直接使用。

七、与其它模式的关系

　　如抽像工厂模式或工厂方法模式，这些模式关注点是要产生什么样的对像，对于如何产生这样的对像，适当的情况下就可以结合原型模式，如通过已有的对像产生想要的对像。

八、模式优缺点

　　优点：对客户隐藏具体的实现类型，原型模式的客户端只知道原型接口的类型，并不知道具体的实现类型，从而减少了客户端对这些具体实现类的依赖。

缺点：在实现深度克隆时比较麻烦，对于对像里面有引用，引用里面可能还有引用，每个引用层级的类都必须正确实现clone()方法才能让所有层级的对像正确的实现克隆。