GOF23设计模式-创建型模式4-原型模式

我就是我 2021-12-02 01:40 291阅读 0赞

### 设计模式GOF23-原型模式 ###

*  思考
 *  原型模式
 *  原型模式实现
 *  克隆绵羊多利（浅拷贝）
 *  克隆绵羊多利（深拷贝）
 *  利用序列化和反序列化技术实现深克隆
 *  何时使用？
 *  测试new与clone创建对象效率

# 思考 #

克隆技术是怎么样一个过程？  
JavaScript语言中，继承怎么实现？

# 原型模式 #

*  通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
 *  java中的克隆技术，就是以某个对象为原型，复制出新的对象，显然，新的对象具有原型对象的特点。
 *  优势：效率高。（直接克隆，避免了重新执行构造过程步骤）
 *  克隆类似与new，但是不同于new。new创建新的对象属性采用的是默认值，克隆出的对象属性值完全和原型对象相同。并且克隆出的新对象改变不会影响原型对象。

# 原型模式实现 #

*  Cloneable接口和clone方法。
 *  Prototype模式中实现起来最困难的地方就是内存复制操作，所幸在Java中提供了clone方法替我们做了绝大部分事情。

# 克隆绵羊多利（浅拷贝） #

新建Sheep.java类，有属性name,生日birthday。实现Cloneable接口，重写Object类clone()方法。

/**
     * User：tumbler
     * Desc：原型模式--克隆羊多利
     */
    public class Sheep implements Cloneable{
        private String name;
        private Date birthday;
    
        public Sheep(String name, Date birthday) {
            this.name = name;
            this.birthday = birthday;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone(); //直接调用Object的克隆方法
        }
        //getter()/setter()
    }

编写客户端测试克隆：

/**
     * User：tumbler
     * Desc：原型模式--客户端测试类，测试克隆(浅克隆)
     */
    public class Client {
        public static void main(String[] args) throws Exception {
            Date date = new Date(1231231231231L);
            Sheep s1 = new Sheep("少利",date);
            Sheep s2 = (Sheep) s1.clone();
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s1.getName() + "----" + s1.getBirthday());
            System.out.println(s2.getName() + "----" + s2.getBirthday());
        }
    }

运行结果：

src.com.tumbler.prototype.Sheep@6d6f6e28
    src.com.tumbler.prototype.Sheep@135fbaa4
    少利----Tue Jan 06 16:40:31 CST 2009
    少利----Tue Jan 06 16:40:31 CST 2009

可以看出，此时的s2与s1的属性值完全相同，但是这只是浅克隆，她两共同指向日期date对象，当s1改变了date属性后，s2的date属性值也变了。我们对客户端代码进行修改：

public class Client {
        public static void main(String[] args) throws Exception {
            Date date = new Date(1231231231231L);
            Sheep s1 = new Sheep("少利",date);
            Sheep s2 = (Sheep) s1.clone();
            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s1.getName() + "----" + s1.getBirthday());
            System.out.println(s2.getName() + "----" + s2.getBirthday());
            //这里修改s2的name属性和date属性
            date.setTime(1299239231231L);
            s2.setName("多利");
            //再次打印s1、s2
            System.out.println(s1.getName() + "----" + s1.getBirthday());
            System.out.println(s2.getName() + "----" + s2.getBirthday());
        }
    }

结果：

src.com.tumbler.prototype.Sheep@6d6f6e28
    src.com.tumbler.prototype.Sheep@135fbaa4
    少利----Tue Jan 06 16:40:31 CST 2009
    少利----Tue Jan 06 16:40:31 CST 2009
    少利----Fri Mar 04 19:47:11 CST 2011
    多利----Fri Mar 04 19:47:11 CST 2011

可以看出，当s1的date属性改变后，s2的date属性也改变了，而name属性没变是因为String类已实现了深拷贝。  
此时的内存引用是这样的：  
![在这里插入图片描述][20190721142007495.png]  
那么，我们想深拷贝呢，需要像下面这样呢？各自指向自己的属性，应该怎么办？  
![在这里插入图片描述][20190721142301258.png]  
那就需要深拷贝，深拷贝就是将属性也拷贝一份

# 克隆绵羊多利（深拷贝） #

此时需要将Sheep类的clone方法需要修改：

@Override
        protected Object clone() throws CloneNotSupportedException {
            Object obj = super.clone(); //直接调用Object的克隆方法
            //添加以下代码实现深拷贝（deep clone）,把属性也进行克隆
            Sheep s = (Sheep) obj;
            s.birthday = (Date) this.birthday.clone();
            return obj;
        }

此时在运行客户端，s1date值改变后，S2的date值并没有改变，因为它是一个新对象。结果如下：

# 利用序列化和反序列化技术实现深克隆 #

上面我们使用Object类的clone方法实现了多利的深克隆，下面我们用序列化和反序列化实现深克隆，我们新建一个Sheep2.java类，clone方法内直接调用父类的clone方法，不用自己实现深克隆：

/**
     * User：tumbler
     * Desc：原型模式--克隆羊多利2
     */
    public class Sheep2 implements Cloneable, Serializable {
        private String name;
        private Date birthday;
        public Sheep2(String name, Date birthday) {
            this.name = name;
            this.birthday = birthday;
        }
        @Override
        protected Object clone() throws CloneNotSupportedException {
            Object obj = super.clone(); //直接调用Object的克隆方法
            return obj;
        }
        //getter()/setter()
    }

客户端使用序列化和反序列化实现拷贝：

/**
     * User：tumbler
     * Desc：原型模式--使用序列化和反序列化技术实现深克隆
     */
    public class Client2 {
        public static void main(String[] args) throws Exception {
            Date date = new Date(1231231231231L);
            Sheep2 s1 = new Sheep2("原型对象", date);
            System.out.println(s1.getName() + "----" + s1.getBirthday());
    
            //使用序列化和反序列化实现深拷贝
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(s1);
            byte[] bytes = bos.toByteArray();
    
            ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bis);
            Sheep2 s2 = (Sheep2) ois.readObject(); //获得一只新的羊，属性值与原型对象一样
            System.out.println(s2.getName() + "----" + s2.getBirthday());
    
            s2.setName("新对象羊");  //改变新对象的name
            date.setTime(1299239231231L); //将原型对象的date值改变后再次输出，拷贝出的新对象的值并未改变
            System.out.println(s1.getName() + "----" + s1.getBirthday());
            System.out.println(s2.getName() + "----" + s2.getBirthday());
        }
    }

同样实现了深拷贝，运行结果：

原型对象----Tue Jan 06 16:40:31 CST 2009
    原型对象----Tue Jan 06 16:40:31 CST 2009
    原型对象----Fri Mar 04 19:47:11 CST 2011
    新对象羊----Tue Jan 06 16:40:31 CST 2009

# 何时使用？ #

*  通过new产生一个新对象需要非常繁琐的数据准备或访问权限时，则可使用原型模式。
 *  开发中原型模式很少单独出现，一般是和工厂方法模式一起出现，通过克隆的方法创建一个对象，然后由工厂方法提供给调用者。
 *  Spring中的bean的创建实际就是两种：单例模式和原型模式（当然原型模式需要和工厂模式搭配起来）。

# 测试new与clone创建对象效率 #

/**
     * User：tumbler
     * Desc：原型模式--new与克隆创建对象效率测试
     *       如果短时间需要创建大量对象，并且new过程比较耗时，则可以考虑使用原型模式
     */
    public class Client3 {
        /**
         * 测试new耗时
         * @param size
         */
        public static void testNew(int size) {
            long start = System.currentTimeMillis();
            for (int i = 0; i < size; i++) {
                Laptop laptop = new Laptop();
            }
            long end = System.currentTimeMillis();
            System.out.println("new 方式花费时间：" + (end - start));
        }
        /**
         * 测试clone耗时
         * @param size
         */
        public static void testClone(int size) throws CloneNotSupportedException{
            long start = System.currentTimeMillis();
            Laptop laptop = new Laptop();
            for (int i = 0; i < size; i++) {
                Laptop temp = (Laptop) laptop.clone();
            }
            long end = System.currentTimeMillis();
            System.out.println("clone 方式花费时间：" + (end - start));
        }
        public static void main(String[] args) throws Exception{
            testNew(1000);
            testClone(1000);
        }
    }
    class Laptop implements Cloneable{
        public Laptop() {
            try {
                Thread.sleep(10);  // 模拟创建对象耗时过程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }

运行结果：

new 方式花费时间：10447
    clone 方式花费时间：10

[20190721142007495.png]: /images/20211201/a3180436797541f794520099d43e5ded.png
[20190721142301258.png]: /images/20211201/934251c9865e45b4a4298564f7e23e61.png