设计模式原则 ~单例模式

什么是设计模式

• 设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

  设计模式分类

  

• 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

• 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

• 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

  设计模式的六大原则

  

  开放封闭原则（Open Close Principle）

• 原则思想：尽量通过扩展软件实体来解决需求变化，而不是通过修改已有的代码来完成变化

• 描述：一个软件产品在生命周期内，都会发生变化，既然变化是一个既定的事实，我们就应该在设计的时候尽量适应这些变化，以提高项目的稳定性和灵活性。

• 优点：单一原则告诉我们，每个类都有自己负责的职责，里氏替换原则不能破坏继承关系的体系。

  里氏代换原则（Liskov Substitution Principle）

• 原则思想：使用的基类可以在任何地方使用继承的子类，完美的替换基类。

• 大概意思是：子类可以扩展父类的功能，但不能改变父类原有的功能。子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法，子类中可以增加自己特有的方法。

• 优点：增加程序的健壮性，即使增加了子类，原有的子类还可以继续运行，互不影响。

  依赖倒转原则（Dependence Inversion Principle）

• 依赖倒置原则的核心思想是面向接口编程.

• 依赖倒转原则要求我们在程序代码中传递参数时或在关联关系中，尽量引用层次高的抽象层类，

• 这个是开放封闭原则的基础，具体内容是：对接口编程，依赖于抽象而不依赖于具体。

  接口隔离原则（Interface Segregation Principle）

• 这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

• 例如：支付类的接口和订单类的接口，需要把这俩个类别的接口变成俩个隔离的接口

  迪米特法则（最少知道原则）（Demeter Principle）

• 原则思想：一个对象应当对其他对象有尽可能少地了解，简称类间解耦

• 大概意思就是一个类尽量减少自己对其他对象的依赖，原则是低耦合，高内聚，只有使各个模块之间的耦合尽量的低，才能提高代码的复用率。

• 优点：低耦合，高内聚。

  单一职责原则（Principle of single responsibility）

• 原则思想：一个方法只负责一件事情。

• 描述：单一职责原则很简单，一个方法 一个类只负责一个职责，各个职责的程序改动，不影响其它程序。 这是常识，几乎所有程序员都会遵循这个原则。

• 优点：降低类和类的耦合，提高可读性，增加可维护性和可拓展性，降低可变性的风险。

  单例模式

  1.什么是单例

• 保证一个类只有一个实例，并且提供一个访问该全局访问点

  2.那些地方用到了单例模式

1. 网站的计数器，一般也是采用单例模式实现，否则难以同步。
2. 应用程序的日志应用，一般都是单例模式实现，只有一个实例去操作才好，否则内容不好追加显示。
3. 多线程的线程池的设计一般也是采用单例模式，因为线程池要方便对池中的线程进行控制
4. Windows的（任务管理器）就是很典型的单例模式，他不能打开俩个

5. windows的（回收站）也是典型的单例应用。在整个系统运行过程中，回收站只维护一个实例。

   3.单例优缺点

   优点：

6. 在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就防止其它对象对自己的实例化，确保所有的对象都访问一个实例

7. 单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。
8. 提供了对唯一实例的受控访问。
9. 由于在系统内存中只存在一个对象，因此可以节约系统资源，当需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。
10. 允许可变数目的实例。
11. 避免对共享资源的多重占用。

缺点：

1. 不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。
2. 由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。
3. 单例类的职责过重，在一定程度上违背了“单一职责原则”。

4. 滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

   4.单例模式使用注意事项：

5. 使用时不能用反射模式创建单例，否则会实例化一个新的对象

6. 使用懒单例模式时注意线程安全问题

7. 饿单例模式和懒单例模式构造方法都是私有的，因而是不能被继承的，有些单例模式可以被继承（如登记式模式）

   5.单例防止反射漏洞攻击

   private static boolean flag = false;
   private Singleton() {
      if (flag == false) {
          flag = !flag;
      } else {
          throw new RuntimeException("单例模式被侵犯！");
      }
   }
   public static void main(String[] args) {
   }

   6.如何选择单例创建方式

• 如果不需要延迟加载单例，可以使用枚举或者饿汉式，相对来说枚举性好于饿汉式。 如果需要延迟加载，可以使用静态内部类或者懒汉式，相对来说静态内部类好于懒韩式。 最好使用饿汉式。

  7.单例创建方式

  （主要使用懒汉和饿汉式）

1. 饿汉式:类初始化时,会立即加载该对象，线程天生安全,调用效率高。
2. 懒汉式: 类初始化时,不会初始化该对象,真正需要使用的时候才会创建该对象,具备懒加载功能。
3. 静态内部方式:结合了懒汉式和饿汉式各自的优点，真正需要对象的时候才会加载，加载类是线程安全的。
4. 枚举单例: 使用枚举实现单例模式 优点:实现简单、调用效率高，枚举本身就是单例，由jvm从根本上提供保障!避免通过反射和反序列化的漏洞， 缺点没有延迟加载。

5. 双重检测锁方式 (因为JVM本质重排序的原因，可能会初始化多次，不推荐使用)

   1.饿汉式

6. 饿汉式:类初始化时,会立即加载该对象，线程天生安全,调用效率高。

   /**
   * 饿汉式:
   */
   public class Singleton02 {
    //类初始化时,会立即加载该对象，线程天生安全,调用效率高。
    private static Singleton02 singleton = new Singleton02();
    private Singleton02() {
        System.out.println("Singleton02 : 私有构造函数");
    }
    public static boolean hasInit() {
        return singleton != null;
    }
    public static Singleton02 getInstance() {
        return singleton;
    }
   }

7. 测试

   public static class Test2 {
    public static void main(String[] args) {
        System.out.println(Singleton02.hasInit());
        System.out.println("饿汉模式 getInstance之前已经初始化完成");
        Singleton02 instance = Singleton02.getInstance();
        Singleton02 instance1 = Singleton02.getInstance();
        System.out.println(instance == instance1);
    }
   }

8. 结果

   Singleton02 : 私有构造函数
   true
   饿汉模式 getInstance之前已经初始化完成
   true

   2.懒汉式

9. 懒汉式: 类初始化时,不会初始化该对象,真正需要使用的时候才会创建该对象,具备懒加载功能。 ```java /**

   • 懒汉式 */ public class Singleton03 { //类初始化时，不会初始化该对象，真正需要使用的时候才会创建该对象。 private static Singleton03 singleton;

private Singleton03() {
    System.out.println("Singleton03 : 私有构造函数");
}
public static boolean hasInit(){
    return singleton != null;
}
public synchronized static Singleton03 getInstance() {
    if (singleton == null) {
        singleton = new Singleton03();
    }
    return singleton;
}

}

2. 测试
```java
public static class Test3 {
    public static void main(String[] args) {
        System.out.println(Singleton03.hasInit());
        System.out.println("懒汉模式 getInstance之前还未初始化");
        Singleton03 instance = Singleton03.getInstance();
        Singleton03 instance1 = Singleton03.getInstance();
        System.out.println(instance == instance1);
    }
}

1. 结果

   false
   懒汉模式 getInstance之前还未初始化
   Singleton03 : 私有构造函数
   true
   

   3.静态内部类

2. 静态内部方式:结合了懒汉式和饿汉式各自的优点，真正需要对象的时候才会加载，加载类是线程安全的。

   /**
   * 静态内部类
   */
   public class Singleton04 {
   
    private Singleton04() {
        System.out.println("Singleton04 : 私有构造函数");
    }
   
    public static class SingletonClassInstance {
        private static final Singleton04 singleton = new Singleton04();
    }
   
    public static boolean hasInit() {
        return SingletonClassInstance.singleton != null;
    }
   
    public static Singleton04 getInstance() {
        return SingletonClassInstance.singleton;
    }
   }
   

3. 测试

   public static class Test4 {
    public static void main(String[] args) {
        //只要调用Singleton04任何静态方法，或者创建该对象，静态内部类都会初始化
        //System.out.println(Singleton04.hasInit());
        System.out.println("静态内部类 getInstance之前还未初始化");
        Singleton04 instance = Singleton04.getInstance();
        Singleton04 instance1 = Singleton04.getInstance();
        System.out.println(instance == instance1);
    }
   }
   

4. 结果

   静态内部类 getInstance之前还未初始化
   Singleton04 : 私有构造函数
   true
   

   4.枚举单例式

5. 枚举单例: 使用枚举实现单例模式 优点:实现简单、调用效率高，枚举本身就是单例，由jvm从根本上提供保障!避免通过反射和反序列化的漏洞， 缺点没有延迟加载。

   /**
   * 枚举单例模式
   */
   public class Singleton05 {
   
    public static Singleton05 getInstance() {
        return SingletonEnum.INSTANCE.getInstance();
    }
   
    public static boolean hasInit() {
        return SingletonEnum.INSTANCE.singleton != null;
    }
   
    private static enum SingletonEnum {
        //注意: 这里只写一个枚举
        INSTANCE;
   
        //每个枚举实例拥有一个独立的
        private final Singleton05 singleton;
   
        SingletonEnum() {
            System.out.println("枚举私有构造函数");
            singleton = new Singleton05();
        }
   
        public Singleton05 getInstance() {
            return singleton;
        }
    }
   }
   

6. 测试

   public static class Test5 {
    public static void main(String[] args) {
        System.out.println(Singleton05.hasInit());
        System.out.println("枚举单例模式 getInstance之前已经初始化完成");
        Singleton05 instance = Singleton05.getInstance();
        Singleton05 instance1 = Singleton05.getInstance();
        System.out.println(instance == instance1);
    }
   }
   

7. 结果

   枚举私有构造函数
   true
   枚举单例模式 getInstance之前已经初始化完成
   true
   

   5.双重检测锁方式

8. 双重检测锁方式 (因为JVM本质重排序的原因，可能会初始化多次，不推荐使用) ```java /**

   • 双重检测锁方式 (因为JVM本质重排序的原因，可能会初始化多次，不推荐使用)

   • 是对懒汉式的优化 */ public class Singleton06 {

     private static Singleton06 singleton;

     private Singleton06() { System.out.println(“Singleton06 双重检测锁私有构造函数”); }

     public static Singleton06 getInstance() { if (singleton == null) {

        synchronized (Singleton06.class) {
            if (singleton == null) {
                singleton = new Singleton06();
            }
        }
     

     } return singleton; }

     public static boolean hasInit() { return singleton != null; } }

2. 测试
```java
public static class Test6 {
    public static void main(String[] args) {
        System.out.println(Singleton06.hasInit());
        System.out.println("双重检测锁模式 getInstance之前还未初始化");
        Singleton06 instance = Singleton06.getInstance();
        Singleton06 instance1 = Singleton06.getInstance();
        System.out.println(instance == instance1);
    }
}

1. 结果

   false
   双重检测锁模式 getInstance之前还未初始化
   Singleton06 双重检测锁私有构造函数
   true