设计模式（一）——几种常用设计模式简单剖析

1 认识设计模式

1.1 设计模式简介

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。它描述了在软件设计过程中的一些不断重复发生的问题，以及该问题的解决方案。
使用设计模式的目的是为了代码重用、让代码更容易被他人理解、保证代码可靠性。

1.2 设计原则

优良的系统设计具备：
1.可扩展性(Extensibility)
2.灵活性(Flexibility)
3.组件化可插拔式(Pluggability)
常用设计原则：

1.2.1 单一职责原则

定义：一个对象应该只包含单一的职责，并且该职责被完整地封装在一个类中。
类的职责主要包括两个方面：数据职责和行为职责，数据职责通过其属性来体现，而行为职责通过其方法来体现。
实例：以登录为例
原始设计方案：

使用单一职责重构：

1.2.2 开闭原则

定义：一个软件实体应当对扩展开放，对修改关闭。
实例：拿报表功能来说， BarChart 和PieChart 为不同的报表功能，此时在ChartDisplay 中使用报表功能，可以直接new对应的功能，但如果增加新的报表功能，在ChartDisplay 中使用，就需要改代码了，这就违背了开闭
原则。
原始设计方案：

基于开闭原则重构：

1.2.3 里氏代换原则

定义：所有引用基类（父类）的地方必须能透明地使用其子类的对象。
实例：我们以给客户发消息为例，给VIP客户(VipCustomer)和普通客户(CommonCustomer)发消息,在SendMessage 中分别定义给普通会员和VIP发消息，如果以后有新的客户分类，不仅要添加客户分类，还要修改SendMessage ，违背了开闭原则。
原始设计方案：

基于里氏代换原则进行重构：

1.2.4 依赖倒转原则

定义：抽象不应该依赖于细节，细节应当依赖于抽象。换言之，要针对接口编程，而不是针对实现编程。
我们可以把之前的开闭原则案例修改一下，利用Spring框架进行修改，可读性更强，同时遵循了开闭原则、里氏代换原则和依赖倒转原则，如下图：

1.2.5 接口隔离原则

定义：使用多个专门的接口，而不使用单一的总接口，即客户端不应该依赖那些它不需要的接口。
实例：
原始设计方案：

基于接口隔离原则进行重构:

1.2.6 合成复用原则

定义：尽量使用对象组合，而不是继承来达到复用的目的。
实例：
原始设计方案：

基于合成复用原则进行重构:

1.2.7 迪米特法则

定义：一个软件实体应当尽可能少地与其他实体发生相互作用。
通过引 入一个合理的第三者来降低现有对象之间的耦合度。
实例：
原始设计方案：

基于迪米特法则进行重构：

1.3 设计模式分类

(1)创建型模式：用于描述“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”，单例、原型、工厂方法、抽象工厂、建造者5种设计模式属于创建型模式。
(2)结构型模式：用于描述如何将类或对象按某种布局组成更大的结构，代理、适配器、桥接、装饰、外观、享元、组合7种设计模式属于结构型模式。
(3)行为型模式：用于描述类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，以及怎样分配职责。模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器11种设计模式属于行为型模式。

2 设计模式常用案例

2.1 单例模式

单利模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。该类还提供了一种访问它唯一对象的方式，其他类可以直接访问该方法获取该对象实例，而不需要实例化该类的对象。
特点：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
优点：
1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。
2、避免对资源的多重占用（比如写文件操作）。

2.2 多种单例模式讲解

2.2.1 单利模式-饿汉式

public class SingleModel {
   
    //整个应用程序中只有1个实例
    private static SingleModel singleModel = new SingleModel();
    //只有自己能创建自己的实例
    private SingleModel() {
   
    }
    //对外提供获取该实例的方法
    public static SingleModel getInstance(){
   
        return singleModel;
    }
    public void message(){
   
        System.out.println("hello!");
    }
}

2.2.2 懒汉式

特点：
1、延迟加载创建，也就是用到对象的时候，才会创建
2、线程安全问题需要手动处理(不添加同步方法，线程不安全，添加了同步方法，效率低)
3、实现容易
案例：

public class SingleModel1 {
   
    //1.只能有一个实例
    private static SingleModel1 singleModel;

    //2.只能是自己创建自己的实例
    private SingleModel1() {
   
    }
    //3.对外提供一个方法用于获取唯一实例
    //synchronized  性能瓶颈,不加多线程时不安全
    public static synchronized SingleModel1 getSingleModel(){
   
        if(singleModel==null){
   
            singleModel =  new SingleModel1();
        }
        return singleModel;
    }
}

2.2.3 双重校验锁

public class SingleModel2 {
   
    //1.只能有一个实例
    private static SingleModel2 singleModel;
    //2.只能是自己创建自己的实例
    private SingleModel2() {
   
    }
    //3.对外提供一个方法用于获取唯一实例
    public static SingleModel2 getSingleModel(){
   
        //instance为空的时候才创建对象
        if(singleModel==null){
   
        	//同步锁，效率比懒汉式高
            synchronized (SingleModel2.class){
   
                if(singleModel==null){
   
                	//这里需要判断第2次为空,防止多线程不安全
                    singleModel =  new SingleModel2();
                }
            }
        }
        return singleModel;
    }
}

3 Spring设计模式剖析

3.1 观察者模式

对象之间存在一对多或者一对一依赖，当一个对象改变状态，依赖它的对象会收到通知并自动更新。
MQ其实就属于一种观察者模式，发布者发布信息，订阅者获取信息，订阅了就能收到信息，没订阅就收不到信息。
优点：
1、观察者和被观察者是抽象耦合的。
2、建立一套触发机制
缺点：
1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。

3.1.1 Spring观察者模式

ApplicationContext 事件机制是观察者设计模式的实现，通过ApplicationEvent 类和ApplicationListener 接口，可以实现ApplicationContext 事件处理。
关键对象说明：
1、ApplicationContext容器对象
2、ApplicationEvent事件对象（ContextRefreshedEvent容器刷新事件）
3、ApplicationListener事件监听对象

3.1.2 ApplicationContext事件监听

创建监听对象：ApplicationContextListener
被监听（被观察）的对象：ContextRefreshedEvent
当所有的bean都初始化完成并被成功装载后会触发该事件，实现ApplicationListener<ContextRefreshedEvent> 接口可以收到监听动作，然后可以写自己的逻辑。

public class ApplicationContextListener implements 
ApplicationListener<ContextRefreshedEvent> {
   
	@Override
	public