23种设计模式之原型模式

港控/mmm° 2022-10-01 07:59 294阅读 0赞

**23种设计模式总篇：[chenmingyu.top/design/][chenmingyu.top_design]**

#### 原型模式 ####

原型模式属于创建型设计模式

\*\*定义：\*\*用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象

原型模式通过克隆一个已经存在的对象实例来返回新的实例，而不是通过new去创建对象，多用于创建复杂的或者耗时的实例，因为这种情况下，复制一个已经存在的实例使程序运行更高效；

java中复制对象是通过重写`clone()`实现的，原型类需要实现`Cloneable`接口，否则报`CloneNotSupportedException`异常

##### 模式类图 #####

**角色**

1.  抽象原型：Prototype，可以为接口或者抽象类，实现了`Cloneable`接口，重写了`clone()`方法，子类只需实现或集成即可拥有克隆功能
2.  具体原型：PrototypeA，PrototypeB，实现/集成了Prototype接口的类，拥有克隆方法
3.  工厂模式：原型模式常和工厂模式一起使用，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者

#### 优点 ####

1.  性能优良，比new一个对象性能好很多
2.  不受对象构造函数的约束

#### 模式代码实现 ####

**源码地址：[github.com/mingyuHub/d…][github.com_mingyuHub_d]**

以获取笔对象为例子，结合工厂模式讲解如何使用原型模式，涉及的类：`Pen`（抽象类），`Pencil`（铅笔），`CarbonPen`（碳素笔），`PenFactory`（工厂类）

##### 抽象原型 #####

抽象类，实现了`Cloneable`接口，重写了`clone()`方法

/** * @author: chenmingyu * @date: 2019/2/28 09:54 * @description: 抽象原型角色 */
    @Data
    public abstract class Pen implements Cloneable{
    
        private String name;
    
        public Pen(String name) {
            this.name = name;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    复制代码

##### 具体原型 #####

`Pencil`，继承`Pen`

/** * @author: chenmingyu * @date: 2019/2/28 11:27 * @description: 铅笔 */
    public class Pencil extends Pen{
    
        public Pencil(String name) {
            super(name);
        }
    }
    复制代码

`CarbonPen`，继承了\`Pen

/** * @author: chenmingyu * @date: 2019/2/28 11:29 * @description: 碳素笔 */
    public class CarbonPen extends Pen{
    
        public CarbonPen(String name) {
            super(name);
        }
    }
    复制代码

##### 工厂类 #####

简单工厂实现

/** * @author: chenmingyu * @date: 2019/2/28 11:32 * @description: 笔生产工厂 */
    public class PenFactory {
    
        /** * 原型类容器 */
        private static Map<String, Pen> penMap = new Hashtable<>();
    
        /** * 初始化 */
        public static void init() {
            Pen carbonPen = new CarbonPen("碳素笔");
            penMap.put(CarbonPen.class.getName(),carbonPen);
            Pen pencil = new Pencil("铅笔");
            penMap.put(Pencil.class.getName(),pencil);
        }
    
        /** * 通过复制获取实例 * @param className * @return * @throws CloneNotSupportedException */
        public static Pen getPen(Class className) throws CloneNotSupportedException{
            Pen cachedShape = penMap.get(className.getName());
            return (Pen) cachedShape.clone();
        }
    
    }
    复制代码

##### 验证 #####

public static void main(String[] args){
            PenFactory.init();
            IntStream.range(0,2).forEach(i->{
                try {
                    System.out.println(PenFactory.getPen(CarbonPen.class).getClass());
                    System.out.println(PenFactory.getPen(Pencil.class).getClass());
                    System.out.println(" ... ");
                }catch (CloneNotSupportedException e){
                    e.printStackTrace();
                }
            });
        }
    复制代码

输出

class com.example.design.prototype.CarbonPen class com.example.design.prototype.Pencil ... class com.example.design.prototype.CarbonPen class com.example.design.prototype.Pencil ... 复制代码

#### 浅拷贝和深拷贝 ####

浅拷贝：将一个对象复制后，基本类型会被重新创建，引用类型的对象会把引用拷贝过去，实际上还是指向的同一个对象

深拷贝：将一个对象复制后，基本类型和引用类型的对象都会被重新创建

##### 浅拷贝 #####

举个例子

/** * @author: chenmingyu * @date: 2019/2/28 14:53 * @description: 克隆 */
    @Data
    public class Clone implements Cloneable{
    
        private CloneA CloneA;
    
        public Clone() {
            this.CloneA = new CloneA();
        }
    
        @Override
        protected Clone clone() throws CloneNotSupportedException {
            return (Clone) super.clone();
        }
    
        class CloneA{
        }
    }
    复制代码

验证

public static void main(String[] args) throws CloneNotSupportedException{
    
        Clone clone = new Clone();
        Clone clone1 = clone.clone();
        System.out.println(clone == clone1);
        System.out.println(clone.getCloneA() == clone1.getCloneA());
    }
    复制代码

输出

false    
    true
    复制代码

所以clone()方法是执行的浅拷贝，这个需要在写代码的时候注意一下，浅拷贝是否可以满足需求

##### 深拷贝 #####

深拷贝的实现方案主要有两种

1.  引用类型也使用clone()，进行clone的时候，对引用类型在调用一次clone()方法
2.  使用序列化，将对象序列化后在反序列化回来，得到新的对象实例

使用序列化实现以下

/** * @author: chenmingyu * @date: 2019/2/28 14:53 * @description: 浅克隆 */
    @Data
    public class Clone implements Cloneable ,Serializable {
    
        private CloneA CloneA;
    
        public Clone() {
            this.CloneA = new CloneA();
        }
    
        @Override
        protected Clone clone() throws CloneNotSupportedException {
            return (Clone) super.clone();
        }
    
        /** * 深拷贝 * @return * @throws CloneNotSupportedException */
        protected Clone deepClone() throws CloneNotSupportedException {
            Clone clone = null;
            try{
                ByteArrayOutputStream baos=new ByteArrayOutputStream();
                ObjectOutputStream oos=new ObjectOutputStream(baos);
                oos.writeObject(this);
                oos.close();
                ByteArrayInputStream bais=new ByteArrayInputStream(baos.toByteArray());
                ObjectInputStream ois=new ObjectInputStream(bais);
                //生成新的对象实例
                clone=(Clone)ois.readObject();
                ois.close();
            }catch (Exception e){
                e.printStackTrace();
            }
            return clone;
        }
    
        class CloneA implements Serializable{
        }
    }
    复制代码

验证

public static void main(String[] args) throws CloneNotSupportedException{
     
        Clone clone = new Clone();
        Clone clone1 = clone.deepClone();
        System.out.println(clone == clone1);
        System.out.println(clone.getCloneA() == clone1.getCloneA());
    }
    复制代码

输出

false    
    false
    复制代码

在使用原型模式的时候一定要理解什么是浅拷贝和深拷贝，才可以放心的使用原型模式，并且一般都会和工厂模式一起使用

#### 相关阅读 ####

**创建型设计模式**

**关注于如何创建对象**

1.  [**23种设计模式之单例模式**][23]
    
    保证在程序运行期间一个类只有一个实例，并提供一个全局访问点
2.  [**23种设计模式之工厂模式**][23 1]
    
    用工厂方法代替new操作，让子类去决定实例化哪个类，工厂方法将一个类的实例化延迟到子类
3.  [**23种设计模式之抽象工厂**][23 2]
    
    抽象工厂模式属于创建型模式，是对工厂方法模式的扩展，抽象工厂比工厂模式更为抽象，工厂方法模式针对产品等级结构，而抽象工厂针对产品族
4.  [**23种设计模式之建造者模式**][23 3]
    
    通过克隆一个已经存在的对象实例来返回新的实例，而不是通过new去创建对象
5.  [**23种设计模式之原型模式**][23 4]
    
    通过克隆一个已经存在的对象实例来返回新的实例，而不是通过new去创建对象

**结构型设计模式**

**关注于类和对象之间的关系**

1.  [**23种设计模式之适配器模式**][23 5]
    
    组合两个不相干类，在两个不兼容的接口之间提供一个混合接口，使其兼容适配
2.  [**23种设计模式之桥接模式**][23 6]
    
    将抽象部分与它的实现部分分离，使它们都可以独立地变化。桥接模式将系统各维度抽象出来，各维度独立变化，之后可通过聚合，将各维度组合起来，减少它们之间耦合
3.  [**23种设计模式之组合模式**][23 7]
    
    用来描述部分与整体的关系，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，所以组合模式的使用场景就是出现树形结构的地方。
4.  [**23种设计模式之装饰器模式**][23 8]
    
    装饰器模式可以为一个现有的类增加新功能，又不改变其结构，要求装饰类和被装饰类实现同一个接口，装饰类持有被装饰类的实例
5.  [**23种设计模式之外观模式**][23 9]
    
    外观模式是为了解决类与类之家的责任关系和依赖关系的，通过提供一个Facade类来隐藏这些复杂的类之间关系的调用，并提供一个接口，供外部调用，利用这种方式进行类之间的解耦
6.  [**23种设计模式之代理模式**][23 10]
    
    代理模式就是在操作原对象的时候，多出来一个代理类，用来对原对象的访问进行控制和替代原对象进行一些操作
7.  [**23种设计模式之代理享元模式**][23 11]
    
    运用共享技术有效地支持大量细粒度对象的复用，主要用来减少对象的创建，用来减少内存和提高性能，比较常见的连接池，缓冲池这类的池技术都是享元模式

**行为型设计模式**

**关注于对象之间的通信**

1.  [**23种设计模式之模板方法模式**][23 12]
    
    在父类（抽象类）中定义好算法的流程，提供抽象方法，针对不同的实现交由不同的子类去实现，通过这种方式将公共代码提取出来封装在父类中，然后父类去控制行为，子类负责实现
2.  [**23种设计模式之策略模式**][23 13]
    
    在系统中提供一组策略，并将每个策略封装成类，使他们可以相互转换，具体策略的选择由客户端决定
3.  [**23种设计模式之观察者模式**][23 14]
    
    定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新
4.  [**23种设计模式之迭代器模式**][23 15]
    
    迭代器模式就是为解决遍历元素而诞生的，它提供一种方法访问一个容器对象中各个元素，而又不需暴露该对象的内部细节
5.  [**23种设计模式之责任链模式**][23 16]
    
    使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止
6.  [**23种设计模式之命令模式**][23 17]
    
    将一个请求封装成一个对象，从而让你使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能，用来降低类之间解耦
7.  [**23种设计模式之备忘录模式**][23 18]
    
    在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态，其实就是在某个时刻备份了对象的状态，在更改对象状态后，可以通过备份将对象还原成备份时刻的状态
8.  [**23种设计模式之状态模式**][23 19]
    
    允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类，对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为
9.  [**23种设计模式之访问者模式**][23 20]
    
    封装一些作用于某种数据结构中的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作，访问者模式就是将数据结构与数据操作相分离
10. [**23种设计模式之中介者模式**][23 21]
    
    用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互
11. [**23种设计模式之解释器模式**][23 22]
    
    给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子

转载于:https://juejin.im/post/5c7790de6fb9a049c15fe6e4

[chenmingyu.top_design]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign%2F
[github.com_mingyuHub_d]: https://link.juejin.im?target=https%3A%2F%2Fgithub.com%2FmingyuHub%2Fdesign-patterns
[23]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-singleton%2F
[23 1]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-factory-method%2F
[23 2]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-abstract-factory%2F
[23 3]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-builder%2F
[23 4]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-phototype%2F
[23 5]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-adapter%2F
[23 6]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-bridge%2F
[23 7]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-composite%2F
[23 8]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-decorator%2F
[23 9]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-facade%2F
[23 10]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-proxy%2F
[23 11]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-flyweight%2F
[23 12]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-template-method%2F
[23 13]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-strategy%2F
[23 14]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-observer%2F
[23 15]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-iterator%2F
[23 16]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-chain%2F
[23 17]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-command%2F
[23 18]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-memento%2F
[23 19]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-state%2F
[23 20]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-visitor%2F
[23 21]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-mediator%2F
[23 22]: https://link.juejin.im?target=https%3A%2F%2Fchenmingyu.top%2Fdesign-interpreter%2F