编程知识 cdmana.com

java设计模式之原型模式

原型模式的定义:

  原型模式指原型实例指定创建对象的种类,并且通过复制这些原型创建新的对象,属于创建型设计模式。原型模式的核心在于复制原型对象。

以系统中已存在的一个对象原型,直接基于内存二进制流进行复制,不需要再经历耗时的对象初始化过程,性能将大大提升。

原型模式的应用场景:

  • 创建对象成本大,需要优化资源。
  • 创建一个对象需要繁琐的数据准备或权限访问,需要提高性能或提高安全性。
  • 系统中大量使用该类对象,且各个调用者都需要给它的属性重新赋值。

分析JDK浅克隆API带来的问题:

  在java提供的API中,不需要手动创建抽象原型接口,java内置了Cloneable抽象原型接口,自定义的类型只需要实现该接口并重写Object.clone方法即可完成

对本类的复制。

  通过查看JDK的源码发现,其实Cloneable是一个空接口。java之所以提供Cloneable接口,只是为了在运行时通知java虚拟机可以安全的在该类上使用clone

方法。如果没有实现Cloneable接口,调用clone()方法会抛出CloneNotSupportedException异常。

 

 如果使用clone()方法,需要满足以下条件:

  1. 对于任何对象o,都有o.clone() != o,也就是说克隆产生的对象和原对象不是同一个对象。
  2. 对于任何对象o,都有o.clone().getClass() == o.getClass(),也就是说克隆产生的对象和原对象类型相同。
  3. 对于任何对象o,应该有o.clone().equals(o)成立,为什么这样不是绝对的呢,因为如果在不重写hashcode和equals的情况下,是不能保证两个对象equals相等的。

那么在java中浅克隆会带来什么问题呢,看下面的例子:

创建一个User类,并重写clone方法:

package com.liuyi.designmode.creational.prototype;

import lombok.Data;

import java.util.List;

/**
 * @ClassName User
 * @description:
 * @author:liuyi
 * @Date:2020/11/11 20:55
 */
@Data
public class User implements Cloneable{
    private Integer id;

    private String name;

    private List<String> phoneList;

    /* *
     * @Author liuyi
     * @Description //TODO 重写浅克隆方法
     * @Date 2020/11/11 21:11 
     * @Param []
     * @return com.liuyi.designmode.creational.prototype.User
     **/
    @Override
    protected User clone(){
        try {
            return (User) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}

创建一个对象,然后克隆一个对象,再修改对应的属性值:

package com.liuyi.designmode.creational.prototype;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @ClassName PrototypeTest
 * @description:
 * @author:liuyi
 * @Date:2020/11/11 21:04
 */
public class PrototypeTest {
    public static void main(String[] args) {
        //创建对象
        User user = new User();
        user.setId(1);
        user.setName("刘一");
        List<String> PhoneList = new ArrayList<>();
        PhoneList.add("1457697");
        PhoneList.add("545452");
        PhoneList.add("5155445645");
        user.setPhoneList(PhoneList);
        //打印之前的对象信息
        System.out.println(user);
        //克隆对象
        User clone = user.clone();
        //修改id为2
        clone.setId(2);
        //删除list对象的一个值
        clone.getPhoneList().remove(1);
        //分别打印
        System.out.println(user);
        System.out.println(clone);

    }
}

我们来看执行结果:

 

 可以看到,我对克隆之后的值进行修改,基础数据类型id改变了,没有影响原对象,但是改变引用类型List,则原对象的值也发生了改变。这就叫浅拷贝,这也是

浅克隆最致命的问题。那么怎么解决这个问题呢,使用深克隆可以解决该问题。

使用序列化实现深克隆:

  在上面的基础上添加一个deepClone()方法,代码如下:

 /* *
     * @Author liuyi
     * @Description 深克隆
     * @Date 2020/11/11 21:40 
     * @Param []
     * @return com.liuyi.designmode.creational.prototype.User
     **/
    public User deepClone(){
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (User)ois.readObject();
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

把clone方法修改为deepClone方法的结果如下:

 

 这次修改克隆对象没有影响到原对象,达到了我们的目的。

原型模式的优点:

  • java自带的原型模式基于内存二进制流的复制,在性能上比直接new一个对象更佳。
  • 可以使用深克隆方式保存对象的状态,以便在需要的时候使用,例如恢复的历史某个状态,可辅助实现撤销操作。

原型模式的缺点:

  • 需要对每个类都重写clone方法才能实现。
  • clone位于类的内部,如需要修改,则需要修改代码,违背开闭原则。
  • 当实现深克隆时候,需要编写复杂的代码,且当对象存在多重嵌套是,需要每一层对象都实现深克隆,实现起来比较麻烦。

 

版权声明
本文为[负重前行的小牛]所创,转载请带上原文链接,感谢
https://www.cnblogs.com/liu-yi/p/13961208.html

Scroll to Top