Spring5设计模式 - 原型模式

快来打我* 2022-10-25 04:43 100阅读 0赞

# 设计模式 - 原型模式 #

### \--------目录直通车------- ###

*  设计模式 - 原型模式
 *   *  一、浅克隆
     *  二、深克隆
     *  三、克隆破坏单例模式

--------------------

原型模式是指原型实例指定创建对象的种类，并复制这些原型这些原型创建新的对象。

主要适用于：

（1）大量的Getter和Setter 赋值的场景

（2）类初始化消耗资源较多。

（3）使用 new 生成一个对象需要非常繁琐的过程（数据准备、访问权限）。

（4）构造函数比较复杂。

（5）在循环体中产生大量对象。

在 Spring 中，原型模式应用得非常广泛，例如 scope=“prototype” ，我们经常用的 JSON.parseObject() 也是一种原型模式。分为浅克隆和深克隆两种。

## 一、浅克隆 ##

浅克隆：**完整复制值类型数据，没有复制引用对象**（也就是说所有的引用对象仍然**指向原来**对象的**地址**）。

一个标准的原型模式代码应该是这样设计的：先创建原型 Prototype 接口、创建需要克隆的类ConcretePrototypeA、创建克隆的客户端，通过客户端来实现克隆。

Prototype接口

public interface Prototype { 
        Prototype clone();
    }

ConcretePrototypeA 需要克隆的类

public class ConcretePrototypeA implements Prototype { 
        private String name;
        private int age;
        private List<String> hobbies;
    
        public void setHobbies(List<String> hobbies) { 
            this.hobbies = hobbies;
        }
    
        @Override
        public Prototype clone() { 
            ConcretePrototypeA concretePrototype = new ConcretePrototypeA();
            concretePrototype.setAge(this.age);
            concretePrototype.setName(this.name);
            concretePrototype.setHobbies(this.hobbies);
            return concretePrototype;
        }
    	// 省略Getter、Setter方法
    }

Client 客户端类

public class Client { 
        private Prototype prototype;
    
        public Client(Prototype prototype) { 
            this.prototype = prototype;
        }
    
        public Prototype startClone(Prototype concretePrototype) { 
            return (Prototype) concretePrototype.clone();
        }
    }

Test 测试类

public class PrototypeTest { 
        public static void main(String[] args) { 
            ConcretePrototypeA concretePrototype = new ConcretePrototypeA();
            concretePrototype.setAge(18);
            concretePrototype.setName("prototype");
            List<String> hobbies = new ArrayList<>();
            concretePrototype.setHobbies(hobbies);
    
            Client client = new Client(concretePrototype);
            ConcretePrototypeA concretePrototypeClone = (ConcretePrototypeA) client.startClone(concretePrototype);
    
            System.out.println(concretePrototypeClone);
            // 结果为 true，说明引用地址相同
            System.out.println(concretePrototypeClone.getHobbies() == concretePrototype.getHobbies());
        }
    }

## 二、深克隆 ##

这里举一个房子和房子的主人的案例，房子有面积大小、楼层等属性、房主有姓名、电话等属性。

房子类（包含这个房子的主人、面积、楼层属性）

public class House implements Serializable { 
        // 楼层
        String floor;
        // 住房面积
        int area;
        // 租金
        double price;
        // 房主
        HouseOwner owner;
    
        public House() { 
        }
    
        public House(String roomId, int area, double price, HouseOwner owner) { 
            this.floor = roomId;
            this.area = area;
            this.price = price;
            this.owner = owner;
        }
    }

房主类

public class HouseOwner implements Serializable { 
        // 电话
        int phone;
        // 姓名
        String name;
    
        public HouseOwner() { 
        }
    
        public HouseOwner(int phone, String name) { 
            this.phone = phone;
            this.name = name;
        }
    }

Test测试类

public class HouseCloneTest { 
        public static void main(String[] args) throws IOException, ClassNotFoundException { 
            HouseOwner MrDJun = new HouseOwner(1, "MrDJun");
    
            House h1 = new House("1302", 78, 2900, MrDJun);
    
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("clone.obj"));
            oos.writeObject(h1);
            oos.close();
    
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("clone.obj"));
            House h2 = (House) ois.readObject();
    
            System.out.println(h1);
            System.out.println(h1.owner == h2.owner);
            ois.close();
        }
    }

## 三、克隆破坏单例模式 ##

如果我们克隆的对象是单例对象，那么就意味着深克隆会破坏单例模式。实际上防止克隆破坏单例模式的解决思路很简单：禁止克隆即可。

两种方式：

1、 不实现 Cloneable 接口；

2、重写 clone() 方法，在 clone() 方法中返回单例对象；

@Override
    protected Object clone() throws CloneNotSupportedException { 
        return INSTANCE;
    }