一、设计模式

1、什么是设计模式

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

2、为什么要学习设计模式

看懂源代码: 如果你不懂设计模式去看Jdk、Spring、SpringMVC、IO 等等等等的源码，你会很迷茫，你会寸步难行
看看前辈的代码:你去个公司难道都是新项目让你接手? 很有可能是接盘的，前辈的开发难道不用设计模式?
编写自己的理想中的好代码: 我个人反正是这样的，对于我自己开发的项目我会很认真，我对他比对我女朋友还好，把项目当成自己的儿子一样

3、设计模式分类

创建型模式，共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式原型模式。
结构型模式，共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式
行为型模式，共十一种:策略模式、模板方法模式、观察者模式、迭代子模式责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

4、设计模式的六大原则

4.1、开放封闭原则(Open Close Principle)

原则思想: 尽量通过扩展软件实体来解决需求变化，而不是通过修改已有的代码来完成变化
描述: 一个软件产品在生命周期内，都会发生变化，既然变化是一个既定的事实我们就应该在设计的时候尽量适应这些变化，以提高项目的稳定性和灵活性
优点: 单一原则告诉我们，每个类都有自己负责的职责，里氏替换原则不能破坏继承关系的体系。

4.2、里氏代换原则 (Liskov Substitution Principle)

原则思想: 使用的基类可以在任何地方使用继承的子类，完美的替换基类
大概意思是: 子类可以扩展父类的功能，但不能改变父类原有的功能。子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法，子类中可以增加自己特有的方法。
优点: 增加程序的健壮性，即使增加了子类，原有的子类还可以继续运行，互不影响。

4.3、依赖倒转原则 (Dependence Inversion Principle)

依赖倒置原则的核心思想是面向接口编程
依赖倒转原则要求我们在程序代码中传递参数时或在关联关系中，尽量引用层次高的抽象层类
这个是开放封闭原则的基础，具体内容是: 对接口编程，依赖于抽象而不依赖于具体。

4.4、接口隔离原则(Interface Segregation Principle)

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

4.5、迪米特法则(最少知道原则)(Demeter Principle)

原则思想:一个对象应当对其他对象有尽可能少地了解，简称类间解耦
大概意思就是一个类尽量减少自己对其他对象的依赖，原则是低耦合，高内聚只有使各个模块之间的耦合尽量的低，才能提高代码的复用率
优点: 低耦合，高内聚。

4.6、单一职责原则(Principle of single responsibility)

原则思想: 一个方法只负责一件事情。
描述: 单一职责原则很简单，一个方法一个类只负责一个职责，各个职责的程序改动，不影响其它程序。这是常识，几乎所有程序员都会遵循这个原则。
优点: 降低类和类的耦合，提高可读性，增加可维护性和可拓展性，降低可变性的风险。

二、单例模式

1、什么是单例

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

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

网站的计数器，一般也是采用单例模式实现，否则难以同步
应用程序的日志应用，一般都是单例模式实现，只有一个实例去操作才好否则内容不好追加显示。
多线程的线程池的设计一般也是采用单例模式，因为线程池要方便对池中的线程进行控制
Windows 的 (任务管理器) 就是很典型的单例模式，他不能打开俩个
windows 的 (回收站) 也是典型的单例应用。在整个系统运行过程中，回收站只维护一个实例。

3、单例优缺点

优点:

在单例模式中，活动的单例只有一个实例，对单例类的所有实例化得到的都是相同的一个实例。这样就防止其它对象对自己的实例化，确保所有的对象都访问一个实例。
单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。
提供了对唯一实例的受控访问。
由于在系统内存中只存在一个对象，因此可以节约系统资源，当需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。
允许可变数目的实例。
避免对共享资源的多重占用。

缺点：

不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。
由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。
单例类的职责过重，在一定程度上违背了“单一职责原则”。
滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出;如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

4、单例模式使用注意事项

使用时不能用反射模式创建单例，否则会实例化一个新的对象。
使用懒单例模式时注意线程安全问题。
饿单例模式和懒单例模式构造方法都是私有的，因而是不能被继承的，有些单例模式可以被继承 (如登记式模式)。

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、单例创建方式

(主要使用懒汉和懒汉式)

饿汉式:类初始化时，会立即加载该对象，线程天生安全，调用效率高。
懒汉式: 类初始化时，不会初始化该对象，真正需要使用的时候才会创建该对象具备懒加载功能。
静态内部方式:结合了懒汉式和饿汉式各自的优点，真正需要对象的时候才会加载，加载类是线程安全的。
枚举单例: 使用枚举实现单例模式优点:实现简单、调用效率高，枚举本身就是单例，由ivm 从根本上提供保障!避免通过反射和反序列化的漏洞，缺点没有延迟加载。
双重检测锁方式 (因为 JVM 本质重排序的原因，可能会初始化多次，不推荐用)

7.1、饿汉式

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

package com.lijie;

//饿汉式
public class Demo1 {

    // 类初始化时,会立即加载该对象，线程安全,调用效率高
    private static Demo1 demo1 = new Demo1();

    private Demo1(){
        System.out.println("私有 Demo1 造参数初始化");
    }

    public static Demo1 getInstance(){
        return demo1;
    }

    public static void main(String[] args){
        Demo1 s1 = Demo1.getInstance();
        Demo1 s2 = Demo1.getInstance();
        System.out.println(s1 == s2);
    }
}

7.2、懒汉式

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

package com.lijie:

//懒汉式
public class Demo2{

    //类初始化时，不会初始化该对象，真正需要使用的时候才会创建该对象
    private static Demo2 demo2;

    private Demo2(){
        System.out.println("私有 Demo2 构造参数初始化");
    }

    public synchronized static Demo2 getInstance(){
        if (demo2 == null) {
            demo2 = new Demo2();
        }
        return demo2;
    }
    public static void main(Stringl args){
        Demo2 s1 = Demo2.getInstance();
        Demo2 s2 = Demo2.getInstance();
        System.out.println(s1 == s2);
    }
}

7.3、静态内部类

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

package com.lijie;

//静态内部类方式
public class Demo3{

    private Demo3(){
        System.out.println("私有 Demo3 构造参数初始化");
    }

    public static class SingletonClassInstance{
        private static final Demo3 DEMO_3 = new Demo3();
    }

    // 方法没有同步
    public static Demo3 getInstance(){
        return SingletonClassInstance.DEMO_3;
    }

    public static void main(String[] args){
        Demo3 s1 = Demo3.getInstance();
        Demo3 s2 = Demo3.getInstance();
        System.out.println(s1 == s2);
    }
}

7.4、举单例式

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

package com.lijie;

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

    public static Demo4 getInstance(){
        return Demo.INSTANCE.getInstance();
    }

    public static void main(String[] args){
        Demo4 s1 = Demo4.getInstance();
        Demo4 s2 = Demo4.getInstance();
        System.out.println(s1 == s2);
    }

    //定义枚举
    private static enum Demo {
        INSTANCE;
        //枚举元素为单例
        private Demo4 demo4;

        private Demo(){
            System.out.println("枚举 Demo 私有构造参数");
            demo4 = new Demo4();
        }

        public Demo4 getInstance(){
            return demo4;
        }
    }
}

5.双重检测锁方式

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

package com.lijie;

//双重检测锁方式
public class Demo5{

    private static Demo5 demo5;
    private Demo5(){
        System.out.println("私有 Demo4 构造参数初始化");
    }

    public static Demo5 getInstance(){
        if (demo5 == null) {
            synchronized (Demo5.class){
                if (demo5 == null) {
                    demo5 = new Demo5();
                }
            }
        }
        return demo5;
    }
    public static void main(String[] args){
        Demo5 s1 = Demo5.getInstance();
        Demo5 s2 = Demo5.getInstance();
        System.out.println(s1 == s2);
    }
}

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/111805.html