了解spring框架的设计模式

1、工厂模式（简单工厂和工厂方法）

     Spring 使用工厂模式可以通过 BeanFactory 或 ApplicationContext 创建 bean 对象

1.1 两个创建方式有何不同

       BeanFactory :延迟注入(使用到某个 bean 的时候才会注入),相比于ApplicationContext 来说会占用更少的内存，程序启动速度更快。

  ApplicationContext:容器启动的时候，不管你用没用到，一次性创建所有 bean 。BeanFactory 仅提供了最基本的依赖注入支持，ApplicationContext 扩展了 BeanFactory ,除了有BeanFactory的功能还有额外更多功能，所以一般开发人员使用ApplicationContext会更多 。

1.2  简单工厂

         简单工厂不算是一个真正的设计模式，它的实现方式是通过BeanFactory ，本质就是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。

拿动物类简单举个例

 1.3  工厂方法

        实现方式是通过ApplicationContext ，它定义一个抽象的工厂方法，通过让子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的。

 工厂方法的模式的组成部分

1 抽象产品(Product) ：定义产品的属性和行为

2 具体产品 (Concrete Product) ：实现抽象产品接口的具体类。

3 抽象工厂 (Factory) ：定义工厂的属性和行为以及返回实例化产品的方法。

4 具体工厂 (Concrete Factory) ：实现抽象工厂接口的具体类。

2、单例设计模式

        在开发过程中，很多时候有些频繁使用到的类我们并想每调用一次就创建一次，如果调用次数过多的话，不仅每次创建也会浪费时间，而且还会非常占用内存空间，这时候就体现了单例模型的重要性了，单例模型使需要的类都只创建一个对象，这不仅仅节约了内存空间，而且还提供了系统的性能。

2.1 "懒汉"模式

        "懒汉"模式比较简单粗暴，调用方法的时候进行判断，如果系统存在该对象，直接调用该对象，如果没有，就新创建一个对象。

public class Singleton01 {
    private static Singleton01 instance;
    private Singleton01() {
    }
    public static Singleton01 getInstance(){
        if(null==instance){
            instance = new Singleton01();
        }
        return instance;
    }
}
public class SingLetonTest {
    public static void main(String[] args) {
    
        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < 1000; i++) {
           SingLeton singLeton= SingLeton.getSingLeton();
            System.out.println(singLeton.hashCode());
            set.add(singLeton.hashCode());
        }
        System.out.println(set.size());

       //多线程运行
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 100; i++) {
                SingLeton singLeton= SingLeton.getSingLeton();
                System.out.println(singLeton.hashCode());
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 100; i++) {
                SingLeton singLeton= SingLeton.getSingLeton();
                System.out.println(singLeton.hashCode());
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        });
        t1.start();
        t2.start();

    }

}

        "懒汉"模式的缺点就是多线程访问的时候会发生线程安全问题，这线程安全问题可以通过加同步锁进行优化

 2.2  "饿汉"模式

        "饿汉"模式是通过static，直接在类加载的时候创建新的对象，当多线程访问的时候，JVM就会阻挡其他线程，这样就不会发生线程安全。

public class SingLeton2 {
    private static SingLeton2 singLeton = new SingLeton2();
    private SingLeton2() {
    }
    public static SingLeton2 getSingLeton(){
        return singLeton;
    }
}
public class SingLetonTest2 {
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            for (int i = 0; i < 100; i++) {
                SingLeton2 singLeton= SingLeton2.getSingLeton();
                System.out.println(singLeton.hashCode());
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 100; i++) {
                SingLeton2 singLeton= SingLeton2.getSingLeton();
                System.out.println(singLeton.hashCode());
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        });
        t1.start();
        t2.start();

    }

}

3、代理设计模式

代理模式在AOP中的应用

        AOP(Aspect-Oriented Programming，面向切面编程) 能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

        Spring AOP 就是基于动态代理的，如果要代理的对象，实现了某个接口，那么 Spring AOP 会使用 JDK Proxy 去创建代理对象，而对于没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候 Spring AOP 会使用 Cglib 生成一个被代理对象的子类来作为代理，如下图所示：

4、模板方法设计模式

        模板方法模式  又叫模板模式(Template Pattern)，它在一个抽象类公开定义了执行它的方法的模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。换种说法就是在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

public abstract class Template {
    //模板方法
    public final void TemplateMethod() {
        Operation1();
        Operation2();
        Operation3();
    }

    protected void Operation1() {
        
    }

    //抽象方法
    protected abstract void Operation2();

    protected abstract void Operation3();
}

public class Template0l extends Template {

    @Override
    public void Operation2() {
        //当前类实现
    }

    @Override
    public void Operation3() {
        //当前类实现
    }
}

5、观察者设计模式

        观察者设计模式是一种对象行为模式。它表示的是一种对象与对象之间具有依赖关系，当一个对象发生改变时，这个对象锁依赖的对象也会做出反应。Spring事件驱动模型就是观察者模式很经典的应用。

Spring事件驱动模型中的三种角色

1.事件角色

ApplicationEvent 充当事件的角色,这是一个抽象类

ApplicationContextEvent 的四个实现：

ContextStartedEvent：ApplicationContext 启动后触发的事件;

ContextStoppedEvent：ApplicationContext 停止后触发的事件;

ContextRefreshedEvent：ApplicationContext 初始化或刷新完成后触发的事件;

ContextClosedEvent：ApplicationContext 关闭后触发的事件

2.事件监听者角色

   ApplicationListener 充当了事件监听者角色，它是一个接口，里面只定义了一个 onApplicationEvent（）方法来处理ApplicationEvent。ApplicationListener接口类源码如下，可以看出接口定义看出接口中的事件只要实现了 ApplicationEvent就可以了。所以，在 Spring 中我们只要实现 ApplicationListener 接口的 onApplicationEvent() 方法即可完成监听事件

package org.springframework.context;
import java.util.EventListener;
@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
    void onApplicationEvent(E var1);
}

3.事件发布者角色

   ApplicationEventPublisher 充当了事件的发布者，它也是一个接口。

@FunctionalInterface
public interface ApplicationEventPublisher {
    default void publishEvent(ApplicationEvent event) {
        this.publishEvent((Object)event);
    }

    void publishEvent(Object var1);
}

6、适配器设计模式

        适配器模式(Adapter Pattern) 将一个接口转换成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作。

6.1  Spring AOP 中的适配器模式

        Spring AOP 的实现是基于代理模式，但是 Spring AOP 的增强或通知(Advice)使用到了适配器模式，与之相关的接口是AdvisorAdapter 。

        Advice 常用的类型有：BeforeAdvice（目标方法调用前,前置通知）、AfterAdvice（目标方法调用后,后置通知）、AfterReturningAdvice(目标方法执行结束后，return 之前)等等。每个类型 Advice（通知）都有对应的拦截器:MethodBeforeAdviceInterceptor、AfterReturningAdviceInterceptor、ThrowsAdviceInterceptor 等等。

        Spring 预定义的通知要通过对应的适配器，适配成 MethodInterceptor 接口(方法拦截器)类型的对象（如：MethodBeforeAdviceAdapter 通过调用 getInterceptor 方法，将 MethodBeforeAdvice 适配成 MethodBeforeAdviceInterceptor ）。

6.2  Spring MVC 中的适配器模式

        在 Spring MVC 中，DispatcherServlet 根据请求信息调用 HandlerMapping，解析请求对应的 Handler。解析到对应的 Handler（也就是我们平常说的 Controller 控制器）后，开始由HandlerAdapter 适配器处理。HandlerAdapter 作为期望接口，具体的适配器实现类用于对目标类进行适配，Controller 作为需要适配的类。

7、装饰者设计模式

        装饰者模式可以动态地给对象添加一些额外的属性或行为。相比于使用继承，装饰者模式更加灵活。简单点儿说就是当我们需要修改原有的功能，但我们又不愿直接去修改原有的代码时，设计一个 Decorator 套在原有代码外面。其实在 JDK 中就有很多地方用到了装饰者模式，比如 InputStream家族，InputStream 类下有 FileInputStream (读取文件)、BufferedInputStream (增加缓存,使读取文件速度大大提升)等子类都在不修改InputStream 代码的情况下扩展了它的功能。

8、策略设计模式

     该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。

        策略模式是准备一组算法，并将这组算法封装到一系列的策略类里面，作为一个抽象策略类的子类。策略模式的重心不是如何实现算法，而是如何组织这些算法，从而让程序结构更加灵活，具有更好的维护性和扩展性。

　A. 抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。

　B. 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。

　C. 环境（Context）类：持有一个策略类的引用，最终给客户端调用。

具体实例可以参考 

 【设计模式系列】策略模式看这篇就够了 - 掘金 (juejin.cn)

Spring 中的设计模式详解 | JavaGuide(Java面试 + 学习指南)