spring中用到的设计模式

1. Spring 中的 Singleton

首先区分 singleton pattern 与 Spring 中的 singleton bean

• 根据单例模式的目的 Ensure a class only has one instance, and provide a global point of access to it

• 显然 Spring 中的 singleton bean 并非实现了单例模式，singleton bean 只能保证每个容器内，相同 id 的 bean 单实例

• 当然 Spring 中也用到了单例模式，例如

  • org.springframework.transaction.TransactionDefinition#withDefaults

  • org.springframework.aop.TruePointcut#INSTANCE

  • org.springframework.aop.interceptor.ExposeInvocationInterceptor#ADVISOR

  • org.springframework.core.annotation.AnnotationAwareOrderComparator#INSTANCE

  • org.springframework.core.OrderComparator#INSTANCE

2. Spring 中的 Builder

定义 Separate the construction of a complex object from its representation so that the same construction process can create different representations

它的主要亮点有三处：

1. 较为灵活的构建产品对象

2. 在不执行最后 build 方法前，产品对象都不可用

3. 构建过程采用链式调用，看起来比较爽

Spring 中体现 Builder 模式的地方：

• org.springframework.beans.factory.support.BeanDefinitionBuilder

• org.springframework.web.util.UriComponentsBuilder

• org.springframework.http.ResponseEntity.HeadersBuilder

• org.springframework.http.ResponseEntity.BodyBuilder

3. Spring 中的 Factory Method

定义 Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses

根据上面的定义，Spring 中的 ApplicationContext 与 BeanFactory 中的 getBean 都可以视为工厂方法，它隐藏了 bean （产品）的创建过程和具体实现

Spring 中其它工厂：

• org.springframework.beans.factory.FactoryBean

• @Bean 标注的静态方法及实例方法

• ObjectFactory 及 ObjectProvider

前两种工厂主要封装第三方的 bean 的创建过程，后两种工厂可以推迟 bean 创建，解决循环依赖及单例注入多例等问题

4. Spring 中的 Adapter

定义 Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces--->将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。

典型的实现有两处：

• org.springframework.web.servlet.HandlerAdapter – 因为控制器实现有各种各样，比如有

  • 大家熟悉的 @RequestMapping 标注的控制器实现

  • 传统的基于 Controller 接口（不是 @Controller注解啊）的实现

  • 较新的基于 RouterFunction 接口的实现

  • 它们的处理方法都不一样，为了统一调用，必须适配为 HandlerAdapter 接口

• org.springframework.beans.factory.support.DisposableBeanAdapter – 因为销毁方法多种多样，因此都要适配为 DisposableBean 来统一调用销毁方法

5. Spring 中的 Composite

定义 Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly

典型实现有：

• org.springframework.web.method.support.HandlerMethodArgumentResolverComposite

• org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite

• org.springframework.web.servlet.handler.HandlerExceptionResolverComposite

• org.springframework.web.servlet.view.ViewResolverComposite

composite 对象的作用是，将分散的调用集中起来，统一调用入口，它的特征是，与具体干活的实现实现同一个接口，当调用 composite 对象的接口方法时，其实是委托具体干活的实现来完成

6. Spring 中的 Decorator

定义 Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality--->修饰器对类行为的改变，是代码编译时发生的，而不是在运行时。修饰器能在编译阶段运行代码。也就是说，修饰器本质就是编译时执行的函数

典型实现：

• org.springframework.web.util.ContentCachingRequestWrapper

7. Spring 中的 Proxy

定义 Provide a surrogate or placeholder for another object to control access to it

装饰器模式注重的是功能增强，避免子类继承方式进行功能扩展，而代理模式更注重控制目标的访问

典型实现：

• org.springframework.aop.framework.JdkDynamicAopProxy

• org.springframework.aop.framework.ObjenesisCglibAopProxy

8. Spring 中的 Chain of Responsibility

定义 Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it--->将多个对象组成一条责任链，然后按照它们在职责链上的顺序一个一个地找出到底应该谁来负责处理。这种模式被称为Chain of Responsibility模式。

典型实现：

• org.springframework.web.servlet.HandlerInterceptor

9. Spring 中的 Observer

定义 Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically--->指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

典型实现：

• org.springframework.context.ApplicationListener

• org.springframework.context.event.ApplicationEventMulticaster

• org.springframework.context.ApplicationEvent

10. Spring 中的 Strategy

定义 Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it--->可以整体的替换一个算法的实现部分，能够整体的替换算法，能让我们轻松地用不同方法解决同一个问题。

典型实现：

• org.springframework.beans.factory.support.InstantiationStrategy

• org.springframework.core.annotation.MergedAnnotations.SearchStrategy

• org.springframework.boot.autoconfigure.condition.SearchStrategy

11. Spring 中的 Template Method

定义 Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure--->定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。

典型实现：

• 大部分以 Template 命名的类，如 JdbcTemplate，TransactionTemplate

• 很多以 Abstract 命名的类，如 AbstractApplicationContext