白话梳理创建型设计模式：单例、原型，构建

在23种设计模式中，创建型的设计模式有了5种，分别为：单例、原型、建造、工厂方法和抽象工厂。

今天要温习的是前三个

单例

关于单例的实现方式，先不讲，聊聊为什么需要单例？单例的优点是什么，有哪些地方使用了单例？

单例用通俗的话讲，即在某个作用域内，不管如何操作，某个类的实例只能是同一个，创建的这种类实例称为单例模式。

为什么需要单例？

• 一种情况是有些实例没理由重新创建或者丢弃它，它需要一直存在着，同时，在内存里面只有一个实例，可以减少内存开销，频繁的创建和销毁实例需要考虑GC等其他的的问题，比如常见的一些工厂类实例，只是希望通过他来生成一些实例，没必多个实例存在，没必要创建销毁，而且多次重建，编码角度考虑，是很坏的编码，比如一些ORM框架中生成SqlSession的SqlSessionFactory实例，一般使用单例模式或者静态单例模式,粗了减少加载配置的同时，考虑数据库连接数性能问题。
• 二是某些实例，希望它在整个生命周期内是不可变得，全局唯一的。不管在什么情况下，它的构成能够被严格的控制，可以始终保证他是共享且安全的。同时使用单例可以避免那些存储唯一实例的全局变量污染命名空间。比如Java中某个类对应的class实例，都是单例模式，一个Class实例用于描述一个类加载到内存中的数据，只描述一个类，即一个类只有一个Class实例。同时它没有构造函数，不能主动实例化，而是在类在加载时由java虚拟机通过类加载器中的defineClass自动构造的。

如何实现单例

对于单例，本质的问题是如何保证只能被实例化一次，所以不管如何实现都需要构造函数私有化.或者没有构造函数由JVM自动构造

最简单的实现是饿汉式单例 ,singleton作为类变量并且直接得到了初始化，即类中所有的变量都会被初始化 singleton作为类变量在初始化的过程中会被收集进()方法中，虽然这样能够百分之百的保证同步，但是因为不是懒加载，singleton被加载后可能很长一段时间不被使用，即实例所开辟的空间会存在很长时间,内存角度考虑，不是好的实现。

private Singleton(){ }  
private  static final Singleton singleton = new Singleton();  
public static  Singleton getInstance(){  
    return singleton;  
  }

所以为了实现懒加载，有了懒汉式单例模式,虽然懒汉式可以保证懒加载，但是线程不安全, 当有两个线程访问时，不能保证单例的唯一性

private Singleton(){ }  
private static  Singleton singleton =null;  
public static  Singleton getInstance(){  
if (singleton == null) {  
            singleton = new Singleton();  
}  
            return singleton;  
}

为了保证线程安全，有了懒汉式+同步方法,即能保证懒加载，又可以保证singleton实例的唯一性，但是synchronizeed关键字的排他性导致getInstance()方法只能在同一时间被一个线程访问。性能低下。

private Singleton(){ }  
private static  Singleton singleton =null;  
public static synchronized Singleton getInstance(){  
    if (singleton == null) {  
        singleton = new Singleton();  
    }  
    return singleton;  
}

这个时候，有人对懒汉式+同步方法做了改进，双重校验锁单例(Double-Check)+Volatile ，当有两个线程发现singleton为null时，只有一个线程可以进入到同步代码块里。即满足了懒加载，又保证了线程的唯一性,不加volition的缺点，有时候可能会报NPE，(JVM运行指令重排序),有可能实例实例的变量未完成实例化其他线程去获取到singleton变量。未完成初始化的实例调用其方法会抛出空指针异常。

private Singleton(){ }  

private  static volatile Singleton singleton = null;  
public static Singleton getInstance() {  

if (singleton == null){  
    synchronized (Singleton.class){  
        if (singleton ==null){  
            singleton = new Singleton();  
        }  
    }  
}  
return singleton2;  
}

有人觉得这样写好麻烦，有些有没有简单的写法，当然有，静态内部类单例，静态内部类的单例模式在Singleton类初始化时并不会创建Singleton实例，在静态内部类中定义了singleton实例。当给静态内部类被主动创建时则会创建Singleton静态变量，是最好的单例模式之一,；类似于静态工厂，将类的创建延迟到静态内部类，外部类的初始化不会实例化静态内部类的静态变量。

private Singleton(){ }  

private  static class Singtetons{  
private static  Singleton SINGLETON = new Singleton();  
   /* static {  
     final Singleton SINGLETON = new Singleton();  
}*/  

}  
public static  Singleton getInstance(){  
return Singtetons.SINGLETON;  
}

当然还有其他的一些写法，比如基于枚举的单例等，感兴趣小伙伴可以去了解下

原型

为什么需要原型？

原型模式，用通俗的话讲，即在原有实例的基础上创建多个新的实例,减少多实例和复杂实例创建的内存消耗。

原型模式和享元模式有些类似，都是尝试重用现有的同类实例，但是他们本质是不相同的，原型模式对现有实例的再加工，比如JS里的原型设计，原型链，或者克隆当前实例；而享元模式是对现有实例的重复使用，比如Java里的整形池、字符串池(String Pool),另一个角度，原型是创建型设计模式，而享元是结构型设计模式。

所以可以这样理解记忆，如果希望重用现有实例，再加工或者直接克隆，属于实例创建是原型模式，如果直接使用，属于结构型享元模式。

原型模式一般用于克隆生成实例，会结合工厂模式使用，换一种角度考虑，其实和一种叫写时复制(copy-on-write)的技术特别类似，在容器、虚拟化技术中都有应用。

在容器技术中，应用级别考虑，内核共用本身就是一种原型设计，同时一个运行的容器分为镜像层和容器层，这里的镜像层可以理解为原型层，在对容器层的数据进行修改时，如果是update会把文件复制到容器层update，如果是新增会在容器层新增，如果删除，会屏蔽镜像层的文件。如果读取，会在由容器层到镜像层自上而下的查找。

在虚拟化技术中，如果系统级别考虑，硬件资源共享本身也是一种原型设计，同时OpenStack 利用其 Glance组件，把虚机的分为原始后端盘和增量前端盘，这里的原始后端盘即可以理解为原型盘，一个标准系统镜像，在创建的虚机里。当修改系统文件的时候，会复制原始的文件到增量盘修改。创建的文件只在增量盘创建

原型设计有许多和抽象工厂和建造者一样的效果:它隐藏了具体的实例类,因此减少了实例的数目。可以在运行时刻增加和删除实例，通过改变结构、改变值来指向新的实例。减少了子类的构造，也减少复杂实例的重复构建。

如何实现原型？

整体上讲，原型设计模式的应用有两种：

• 第一种是通过改变结构、改变值来指向新的实例，把实例中公共的部分作为原型，比如Js实例中的一些事件函数，这种情况下，可以减少对同类实例中相同部分的创建，减少内存开销，比如JS的原型设计
• 另一种情况是复杂实例的克隆，这种情况一般用于实例构建需要依赖外部数据，涉及第三方数据，比如数据库，IO读取等情况，构建相对复杂耗时，所以把整个实例作为原型，重写克隆方法实现对实例的克隆

这里那JS原生的原型模式Demo来看下。

    // 在原型基础上的新实例  
function Person() {  
     this.sex = 'man';   
  }  
// 原型实例     
Person.prototype = {  
      name: 'Nicholas',  
      age: 29,  
      job: "Software Engineer",  
      sayName : function () {  
          console.log(this.name)  
      }  
  }  
  var person1 = new Person();   
  person1.name = 'liruilong';  
  console.log(person1)  
   
  var person2 = new Person();  
  console.log(person2)  
  console.log(person1.sayName == person2.sayName);//true

Person.prototype指向原型，而Person本身即为原型扩展后的实例。通对name的赋值也可以看到，修改属性会直接覆盖原型的值。

[object Object] {  
  age: 29,  
  job: "Software Engineer",  
  name: "liruilong",  
  sayName: function () {  
          window.runnerWindow.proxyConsole.log(this.name)  
      },  
  sex: "man"  
}  
[object Object] {  
  age: 29,  
  job: "Software Engineer",  
  name: "Nicholas",  
 sayName: function () {  
          window.runnerWindow.proxyConsole.log(this.name)  
      },  
  sex: "man"  
}  
true

关于重写克隆方法的原型设计模式利用，可以通过深度遍历，或者序列化的方式实现，感兴趣小伙伴可以下去了解下

建造者

为什么需要建造者

建造者设计模式也被称为为生成器模式，个人觉得，这是编码中使用最多的一个设计模式了，用通俗的话讲，即使用多个简单的实例一步一步构建成一个复杂的实例，为什么需要建造者，通过建造者，可以将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

通过一个最简单的建造者设计模式应用体会下，比如一个Bean的生成,涉及的属性较多，构造函数很不方便，可以使用建造者设计模式，通setter 方法对属性赋值，返回一个this的方式(区别于传统的setter方法)，每个setter 方法的调用即是一次构建,返回的是不同的实例(属性不同)。

public Bulider setD(int d) {  
        this.d = d;  
        return this;  
}

复杂一点的，比如 Java 中 SpringBoot 系列安全组件 SpringSecurity配置的生成，即通过建造者的设计模式构建了一个配置类，可以有选择通过构建的方式配置鉴权,授权，比如表单验证等，以及各种事件的处理器。关于配置的Demo感兴趣小伙伴可以了解下。

开发中，需要生成一些复杂多变的东西，比如doc，excel等，设计策略较多，利用策略模式往往会有重叠的部分，就可以使用建造者模式来实现。比如这是一个生产中生成复杂Excel的Demo：https://liruilong.blog.csdn.net/article/details/113191009

如何实现建造者

这个一个通过建造者设计模式生成实例的Demo。这样写的好处:

• 一是相比传统的先使用构造函数生成实例，然后通过setter 方法一个个赋值来讲，他是一个整体，即整个构建过程是一个链式调用，传统的构造方式，构造过程被分配到了个多个setter方法调用中，在构造过程中 Bean 可能处于一种不一致的状态，真的出现这种情况往往很难调试

• 另一种情况，这样的写法，可以把一个Bean定义为不可变得，而使用传统的形式则很难实现。

  package com.liruilong.common.demo;  
  
  /**  
  * @Auther Liruilong  
  * @Date 2020/8/4 12:34  
  * @Description:  
  */  
  public class Demo {  
  private final int a;  
  private final int d;  
  private Demo(Bulider bulider) {  
  a = bulider.a;  
  d = bulider.d;  
    }  
  public static class Bulider {  
    private int a;  
    private int d;  
    public Bulider(int a) {  
        this.a = a;  
    }  
    public Demo build() {  
        return new Demo(this);  
    }  
    public Bulider setA(int a) {  
        this.a = a;  
        return this;  
    }  
    public Bulider setD(int d) {  
        this.d = d;  
        return this;  
    }  
    }  
  
  public static void main(String[] args) {  
    Demo build = new Demo.Bulider(3).setD(4).build();  
    }  
  
  }
  

嗯，创建型前三个设计模式就和小伙伴们分享到这里，之前有时间会陆续分享剩下的2个，生活加油