java 原型模式（Prototype Pattern）

原型模式

　　用于创建重复的对象，同时又能保证性能。就是从一个对象中再创建另一个可定制的对象，不需要知道任何创建的细节，属于创建型模式，提供了一种创建对象的最佳方式。

　　原型模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如：一个对象需要在高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

　　原理：原型模式的核心在于拷贝原型对象。以系统中已存在的一个对象为原型，直接基于内存二进制流进行拷贝，无需再进行耗时的对象初始化过程（不调用构造函数），性能提升很多。当对象的构建过程比较耗时，可以利用当前系统中已经存在的对象作为原型，对其进行克隆（一般是基于二进制流的复制），躲避初始化过程，使得新对象的创建时间大大减少。

　　原型模式主要包含三个角色：

　　客户（client）：客户类剔除创建对象的请求。

　　抽象原型（prototype）：规定拷贝接口。

　　具体原型（concreate prototype）：被拷贝对象。

　　注：对不听过new关键字，而是通过对象拷贝来实现创建对象的模式就称为原型模式。

原型模式应用场景

　　1.类初始化消耗资源过多；

　　2.new产生的一个对象需要非常繁琐的过程（数据准备、访问权限等）；

　　3.构造函数比较复杂；

　　4.循环体中产生大量对象；

　　在spring中，原型模式应该非常广泛。例如scope="prototype"，在我们经常用的JSON.parseObject()也是一种原型模式。

原型模式的通用写法

先创建原型接口

public interface IPrototype<T> {
    T clone();
}

创建克隆对象 ConcretePrototype

public class ConcretePrototype implements IPrototype {
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    @Override
    public ConcretePrototype clone() {
        ConcretePrototype concretePrototype = new ConcretePrototype();
        concretePrototype.setAge(this.age);
        concretePrototype.setName(this.name);
        return concretePrototype;
    }

    @Override
    public String toString() {
        return "ConcretePrototype{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

测试代码

public class Client {
    public static void main(String[] args) {
        //创建原型对象
        ConcretePrototype prototype = new ConcretePrototype();
        prototype.setAge(18);
        prototype.setName("java");
        System.out.println(prototype);
        //拷贝原型对象
        ConcretePrototype cloneType = prototype.clone();
        System.out.println(cloneType);
    }
}

在实际编码中，JDK 已经帮我们实现了一个API，我们只需要实现Cloneable接口即可

浅克隆

@Data
public class ConcretePrototype implements Cloneable {
    private int age;
    private String name;
    private List<String> hobbies;
    @Override
    public ConcretePrototype clone() {
        try {
            return (ConcretePrototype)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
      ......
}

这种克隆属于浅克隆，只是完整复制了值类型数据，没有复制应用对象

使用序列化实现深度克隆

在上面的基础上我们继续改造，增加一个deepClone()方法

@Data
public class ConcretePrototype implements Cloneable,Serializable {
    private int age;
    private String name;
    private List<String> hobbies;
    @Override
    public ConcretePrototype clone() {
        try {
            return (ConcretePrototype)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }

    public ConcretePrototype deepCloneHobbies(){
        try {
            ConcretePrototype result = (ConcretePrototype)super.clone();
            result.hobbies = (List)((ArrayList)result.hobbies).clone();
            return result;
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }

    public ConcretePrototype 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 (ConcretePrototype)ois.readObject();
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }
    ......
}

运行deepCloneHobbies() 也能得到期望结果，但是这属于硬编码，如果对象中声明有各种集合类型，每种情况都要单独处理。因此深克隆的写法，一般是直接序列化来操作

克隆破坏单例模式

如果我们克隆的目标对象是单例对象，那意味着深克隆会破坏单例。实际上防止克隆破坏单例解决思路非常简单，禁止深克隆即可。要么我们单例类不实现Cloneable接口；要么我们重写clone()方法，在clone方法中返回单例对象即可。

@Override








public ConcretePrototype clone() {
   return instance;
}

原型模式优缺点

优点：

性能优良，java自带的原型模式是基于内存二进制的拷贝，比直接new一个对象性能提升了很多。
可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份并将其保存起来，简化了创建对象的过程，以便早需要的时候使用（例如恢复到历史某一状态），可辅助实现撤销操作。
缺点：

需要为每一个类配置一个克隆方法。
克隆方法位于类的内部，当对一有的类进行改造的时候，需要修改代码，违反了开闭原则。
在实现深克隆时需要编写较为复杂的代码，而且当对象之间存在多重嵌套引用时，为了实现深克隆，每一层对应的类都必须支持深克隆，实现起来比较麻烦。因此深拷贝、浅拷贝需要运用得当。

原文链接：https://blog.csdn.net/weixin_44412111/article/details/119322023

深拷贝和浅拷贝的区别：

　　深拷贝（shallow copy）：创建一个新对象，新对象的基本数据类型成员的值会被复制，而引用类型数据成员仍然指向原始对象所指向的内存地址。也就是说，浅拷贝只是复制了对象的“顶层“，对于引用类型的成员，实际上复制的是引用，而不是引用所指的对象。

　　浅拷贝（deep copy）：创建一个新对象，不仅复制基本数据类型成员的值，对于引用数据类型的成员，也会为其创建新的对象，并复制其内容，使得新对象和原始对象完全独立，修改其中一个对象引用的类型成员不会影响到另外一个对象。

什么是基本数据类型（primitive type）：

　　4类8种：

　　整型：byte、short、int、long

　　浮点型：float、double

　　字符型：char

　　布尔型：boolean

什么是引用类型数据(reference type)：

　　类：class、string

　　数组：array [ ]

　　接口：interface

　　枚举：enum

　　注解：annotation

　　记录：record

posted @ 2025-07-21 16:36 krt-wanyi 阅读(29) 评论(0) 收藏举报

刷新页面返回顶部

krt-wanyi