【设计模式】10.创建型模式-原型模式(Prototype)

亦凉 2023-10-05 23:28 19阅读 0赞

一、描述：

将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。

二、特点：

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。

三、优点：

(1)Java自带的原型模式基于内存二进制流的复制，在性能上比直接new一个对象更加优秀。

(2)可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份，并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用(例如恢复到历史某一状态)，可辅助实现撤销操作。

四、应用：

Object的clone方法，实体类实现Cloneable接口类,重写clone()方法，clone方法有浅拷贝和深拷贝两种：

(1)浅拷贝：只拷贝当前主类的对象，建立一个新的复制对象，但是新的复制对象中的子对象依旧引用之前的主类的子对象地址。(注意：测试clone方法的结果，不能用@Data注解，因为@Data注解重写了hashCode方法，相同属性相同值的情况下，hashCode值一致。)

public class User implements Cloneable {
        private String name;
        private String sex;
        private Integer age;
        private School school;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public School getSchool() {
            return school;
        }
    
        public void setSchool(School school) {
            this.school = school;
        }
    
        @Override
        protected User clone() throws CloneNotSupportedException {
            return (User) super.clone();
        }
    
        public static class School implements Cloneable {
            private String name;
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            @Override
            protected Object clone() throws CloneNotSupportedException {
                return super.clone();
            }
        }
    }

测试：

@Slf4j
    public class MainTest {
        public static void main(String[] args) throws CloneNotSupportedException {
            User user = new User();
            user.setName("张三");
            user.setAge(18);
            User.School school = new User.School();
            school.setName("华师小学");
            user.setSchool(school);
    
            User user2 = user.clone();
            log.info("user:{}",JSON.toJSONString(user));
            log.info("user2:{}",JSON.toJSONString(user2));
            log.info("user-hashCode:{},user2-hashCode:{},isEquals:{}", user.hashCode(), user2.hashCode(), user.hashCode() == user2.hashCode());
            log.info("user-school-hashCode:{},user2-school-hashCode:{}, isEquals:{}", user.getSchool().hashCode(), user2.getSchool().hashCode(), user.getSchool().hashCode() == user2.getSchool().hashCode());
        }
    }

运行结果：

user:{"age":18,"name":"张三","school":{"name":"华师小学"}}
    user2:{"age":18,"name":"张三","school":{"name":"华师小学"}}
    user-hashCode:662736689,user2-hashCode:1320677379,isEquals:false
    user-school-hashCode:852687460,user2-school-hashCode:852687460, isEquals:true

从结果可以看出来，主对象在克隆之后，hashCode值变化，说明为克隆主对象又重新开辟了内存存储。但是克隆子对象school的hashCode值仍然为原来的hashCode，说明克隆后的user2对象中的school仍然引用的user的school对象地址。这就是浅拷贝。

浅拷贝的util方法有：

BeanUtil.copyProperties(user, user2);

(2)深拷贝：比浅拷贝更进一步，子对象也都重新开辟了新的内存存储，重写clone方法：

/**
     * User
     *
     * @author zhouxy
     * @date 2022/5/24
     **/
    public class User implements Cloneable {
        private String name;
        private String sex;
        private Integer age;
        private School school;
    
        //getter、setter方法
    　　......
    
        @Override
        protected User clone() throws CloneNotSupportedException {
            User copyUser = (User) super.clone();
    　　　　//重写school的clone方法
            School school = copyUser.getSchool().clone();
            copyUser.setSchool(school);
            return copyUser;
        }
    
        public static class School implements Cloneable {
            private String name;
    
    　　　　　//getter、setter方法
            .....
    
            @Override
            protected School clone() throws CloneNotSupportedException {
                return (School) super.clone();
            }
        }
    }

测试代码仍然和浅拷贝的测试代码一致，直接显示测试结果：

school的对象的hashCode也发生了变化。