从设计模式的角度来看Spring框架

共计 4947 个字符，预计需要花费 13 分钟才能阅读完成。

设计模式是众多软件开发人员在长期的开发过程中，不断的踩坑和试验总结出来的一种工作经验，一种解决问题的方案。它可以让我们的编程变的更加工程化。

IOC（Inversion of Control）是Spring中最重要的一个概念，本质上它就是一种解耦的思想。通过Spring IOC容器来管理实例对象，实现对具有依赖关系对象的解耦。

假设对象a依赖对象b，当对象a需要使用对象b的时候，就必须自己去创建。当系统引入了IOC容器后，对象a和对象b就失去了直接的联系。这个时候，对象a需要使用对象b，就可以让IOC容器去创建一个对象b，然后再注入到对象a中。
对象a获取对象b的过程，由主动变成了被动，控制权反转，这就是控制反转。

Sping IOC容器就像是一个工厂，一个生产对象的工厂。当我们需要创建一个对象时，只需要配置好配置文件/注解即可
，不需要去关心不同的对象在底层是怎么创建出来的。IOC容器负责创建对象，为对象之间建立连接，为每个对象做配置，并控制对象的整个生命周期，直到对象被完全销毁。

依赖注入是实现控制反转的一种设计模式，就是将实例变量传入到一个对象中。

Spring使用工厂模式通过BeanFactory或者ApplicationContext来创建Bean对象。

BeanFactory：延迟注入，在使用到某个bean时才注入，节省内存
ApplicationContext：容器启动时，一次性创建所有Bean
BeanFactory 仅提供最基本的依赖注入功能，ApplicationContext 扩展了 BeanFactory ，一般使用ApplicationContext更多一点。
ApplicationContext有三个实现类：
1. ClassPathXmlApplication：把上下文文件当成类路径资源。
2. FileSystemXmlApplication：从文件系统中的 XML 文件载入上下文定义信息。
3. XmlWebApplicationContext：从Web系统中的XML文件载入上下文定义信息。

单例类只能有一个实例。必须自己创建这个实例。

对于频繁使用的对象，比如数据库连接，可以减少new的次数和GC的开销

Spring中的Bean的默认作用域就是单例（Singleton）。
bean 还有下面几种作用域：

prototype : 每次请求都会创建一个新的 bean 实例。
request : 每一次HTTP请求都会产生一个新的bean，该bean仅在当前HTTP request内有效。
session : 每一次HTTP请求都会产生一个新的 bean，该bean仅在当前 HTTP session 内有效。
global-session：全局session作用域，仅仅在基于portlet的web应用中才有意义，Spring5已经没有了。Portlet是能够生成语义代码(例如：HTML)片段的小型Java Web插件。它们基于portlet容器，可以像servlet一样处理HTTP请求。但是，与 servlet 不同，每个 portlet 都有不同的会话

Spring单例的实现方式：

xml : <bean id="userService" class="top.snailclimb.UserService" scope="singleton"/>
注解：@Scope(value = "singleton")

AOP(Aspect-Oriented Programming) 面向切面编程。将与业务无关的，却被业务模块共同调用的功能（日志管理，权限管理，事务处理等）封装起来，降低系统的耦合性，增加代码的复用性。

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

当然，我们也可以使用AspectJ，这是Java生态中最完整的AOP框架了。
AspectJ 相比于 Spring AOP 功能更加强大，但是 Spring AOP 相对来说更简单。

如果我们的切面比较少，那么两者性能差异不大。但是，当切面太多的话，最好选择 AspectJ ，它比Spring AOP 快很多。
在python里，装饰器就是切面编程的思想。

模板方法是一种行为设计模式。它定义的是一个操作的算法骨架，而将一些实现延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤的实现方式。

Spring 中 jdbcTemplate、hibernateTemplate 等以 Template 结尾的对数据库操作的类，它们就使用到了模板模式。一般情况下，我们都是使用继承的方式来实现模板模式，但是 Spring 并没有使用这种方式，而是使用Callback 模式与模板方法模式配合，既达到了代码复用的效果，同时增加了灵活性。

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

定义一个事件：实现一个继承自ApplicationEvent，并编写相应的构造函数；
定义一个事件监听者：实现ApplicationListener接口，重写 onApplicationEvent()方法；
使用事件发布者发布消息：可以通过ApplicationEventPublisher的publishEvent()方法发布消息；

// 定义一个事件,继承自ApplicationEvent并且写相应的构造函数
public class DemoEvent extends ApplicationEvent{
    private static final long serialVersionUID = 1L;

    private String message;

    public DemoEvent(Object source,String message){
        super(source);
        this.message = message;
    }

    public String getMessage() {
         return message;
          }

// 定义一个事件监听者,实现ApplicationListener接口，重写 onApplicationEvent() 方法；
@Component
public class DemoListener implements ApplicationListener<DemoEvent>{

    //使用onApplicationEvent接收消息
    @Override
    public void onApplicationEvent(DemoEvent event) {
        String msg = event.getMessage();
        System.out.println("接收到的信息是："+msg);
    }

}
// 发布事件，可以通过ApplicationEventPublisher  的 publishEvent() 方法发布消息。
@Component
public class DemoPublisher {

    @Autowired
    ApplicationContext applicationContext;

    public void publish(String message){
        //发布事件
        applicationContext.publishEvent(new DemoEvent(this, message));
    }
}

ApplicationEvent (org.springframework.context包下)充当事件的角色,这是一个抽象类，它继承了java.util.EventObject并实现了 java.io.Serializable接口。

Spring 中默认存在以下事件，他们都是对 ApplicationContextEvent 的实现(继承自ApplicationContextEvent)：

ContextStartedEvent：ApplicationContext 启动后触发的事件;
ContextStoppedEvent：ApplicationContext 停止后触发的事件;
ContextRefreshedEvent：ApplicationContext 初始化或刷新完成后触发的事件;
ContextClosedEvent：ApplicationContext 关闭后触发的事件。

适配器模式（Adapter Pattern）将一个接口转换为客户希望的另一个接口，适配器使不兼容的那些类可以一起工作，也叫包装器（Wrapper）。

Spring AOP使用的是代理模式，但是Spring AOP的增强或通知使用了适配器模式。与之相关的接口是AdvisorAdapter。
Advice常见的类型有：

BeforeAdvice（目标方法调用前,前置通知）
AfterAdvice（目标方法调用后,后置通知）
AfterReturningAdvice(目标方法执行结束后，return之前)
每个每个类型Advice（通知）都有对应的拦截器:MethodBeforeAdviceInterceptor、AfterReturningAdviceAdapter、AfterReturningAdviceInterceptor。Spring预定义的通知要通过对应的适配器，适配成 MethodInterceptor接口(方法拦截器)类型的对象（如：MethodBeforeAdviceInterceptor 负责适配 MethodBeforeAdvice）。

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

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

Spring 框架中用到了哪些设计模式？

工厂设计模式 : Spring使用工厂模式通过 BeanFactory、ApplicationContext 创建 bean 对象。
代理设计模式 : Spring AOP 功能的实现。
单例设计模式 : Spring 中的 Bean 默认都是单例的。
模板方法模式 : Spring 中 jdbcTemplate、hibernateTemplate 等以 Template 结尾的对数据库操作的类，它们就使用到了模板模式。
包装器设计模式 : 我们的项目需要连接多个数据库，而且不同的客户在每次访问中根据需要会去访问不同的数据库。这种模式让我们可以根据客户的需求能够动态切换不同的数据源。
观察者模式: Spring 事件驱动模型就是观察者模式很经典的一个应用。
适配器模式 :Spring AOP 的增强或通知(Advice)使用到了适配器模式、spring MVC 中也是用到了适配器模式适配Controller。
装饰器模式: …

正文完