java八股文面试[设计模式]——Spring框架中的设计模式

小鱼儿 2024-03-04 06:06 52阅读 0赞

###### 1）简单工厂 ######

**BeanFactory**。Spring中的BeanFactory就是简单工厂模式的体现，根据传入一个**唯一的标识**来获得Bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。

###### 2）工厂方法 ######

**FactoryBean接口**

实现了FactoryBean接口的bean是一类叫做factory的bean。其特点是，spring会在使用**getBean**()调用获得该bean时，会自动调用该bean的**getObject**()方法，所以返回的不是factory这个bean，而是这个bean.getOjbect()方法的**返回值**。

public interface BeanFactory {
            ...
    	Object getBean(String name) throws BeansException;
            ...
    }

###### 3）单例模式 ######

Spring依赖注入Bean实例**默认是单例**的。我们也可以手动设置**scope**改变bean的状态

Spring的**依赖注入**（包括lazy-init方式）都是发生在AbstractBeanFactory的getBean里。getBean的doGetBean方法调用**getSingleton**进行bean的创建。

Spring注册bean过程中使用**DDC单例模式**，首先从**缓存**singletonObjects中获取bean实例，如果为null，对singletonObjects加锁，然后从缓存中获取锁，如果还是为null，就创建bean。这样双重判断，能够避免在**加锁的瞬间**，有其他依赖注入引发bean实例的创建，从而造成重复创建的结果。

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    	...
    
            @Nullable
    	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    		Object singletonObject = this.singletonObjects.get(beanName);
    		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
    				synchronized (this.singletonObjects) {
    					singletonObject = this.earlySingletonObjects.get(beanName);
    					return singletonObject;
    				}
    			}
    		return singletonObject != null ? singletonObject:null;
    	}
            ...
    }

###### 4）适配器模式 ######

SpringMVC中的适配器**HandlerAdatper**。

HandlerAdatper使得Handler的**扩展**变得容易，只需要增加一个新的**Handler**和一个对应的**HandlerAdapter**即可。

因此Spring定义了一个适配接口，使得每一种Controller有一种**对应的适配器实现类**，让适配器代替controller执行相应的方法。这样在扩展Controller时，只需要增加一个适配器类就完成了SpringMVC的扩展了。

> 适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡。（菜鸟教程）

SpringAOP中 **AdvisorAdapter** ，它有三个实现：MethodBeforAdviceAdapter、AfterReturnningAdviceAdapter、ThrowsAdviceAdapter。 Spring会根据不同的 AOP 配置来使用对应的 **Advice**，与策略模式不同的是，一个方法可以同时拥有多个Advice。

###### 5）装饰器模式 ######

Spring中用到的包装器模式在类名上有两种表现：一种是类名中含有**Wrapper**，另一种是类名中含有**Decorator**。

动态地给一个对象添加一些额外的职责。

就增加功能来说，Decorator模式相比**生成子类更为灵活**。

Spring 中**配置 DataSource 的时候**，DataSource 可能是**不同的数据库和数据源**。我们能否根据客户的需求在少修改原有类的代码下动态**切换不同的数据源**？这个时候就要用到装饰者模式。Spring 中用到的包装器模式在**类名上含有 `Wrapper`或者 `Decorator`**。这些类基本上都是动态地给一个对象添加一些额外的职责

###### 6）代理模式 ######

AOP底层，就是**动态代理**模式的实现。

代理又分静态代理和动态代理，熟悉Spring AOP的，应该了解AOP使用动态代理实现的，分JDK和CGlib动态代理（JdkDynamicAopProxy和CglibAopProxy）。

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
        ...
        
        public Object getProxy() {
            return this.getProxy(ClassUtils.getDefaultClassLoader());
        }
        ...
    }
    
    class CglibAopProxy implements AopProxy, Serializable {
         ...
    
         @Override
         public Object getProxy() {
    	return getProxy(null);
         }
         ...
    }

###### 7）观察者模式 ######

Spring 基于观察者模式，实现了自身的**事件机制**也就是事件驱动模型，事件驱动模型通常也被理解成观察者或者**发布/订阅模型**。

> 当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。

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

事件角色：

Spring 中默认的几种事件，都是对 **ApplicationContextEvent** 的实现(继承自ApplicationContextEvent)：

Context**Started**Event：ApplicationContext 启动后触发的事件;

Context**Stopped**Event：ApplicationContext 停止后触发的事件;

Context**Refreshed**Event：ApplicationContext 初始化或刷新完成后触发的事件;

Context**Closed**Event：ApplicationContext 关闭后触发的事件。

事件**监听者**角色：

Application**Listener** 充当了事件监听者角色，它是一个接口，里面只定义了一个 onApplicationEvent（）方法来处理ApplicationEvent

在 Spring中我们只要实现 ApplicationListener 接口实现 **onApplicationEvent**() 方法即可完成监听事件

事件**发布者**角色：

ApplicationEvent**Publisher** 接口的**publishEvent**（）这个方法在AbstractApplicationContext类中被实现，阅读这个方法的实现，你会发现实际上事件真正是通过ApplicationEventMulticaster来广播出去的

Spring 的事件流程总结

定义一个事件: 实现一个继承自 ApplicationEvent，并且写相应的构造函数；

定义一个事件监听者：实现 ApplicationListener 接口，重写 onApplicationEvent() 方法；

使用事件发布者发布消息: 可以通过 ApplicationEventPublisher 的 publishEvent() 方法发布消息。

###### 8）策略模式 ######

Spring框架的资源**访问Resource接口**。该接口提供了更强的**资源访问能力**，Spring 框架本身大量使用了 Resource 接口来访问底层资源。

Rsource 接口是具体资源**访问策略**的**抽象**，也是所有资源访问类所实现的接口。

Resource 接口本身没有提供访问任何底层资源的实现逻辑，针对不同的底层资源，Spring 将会提供**不同的 Resource 实现类**，不同的实现类负责不同的**资源访问逻辑**。

> 在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的 **执行算法**。

Spring中提供了**InstantiationStrategy**（实例化策略接口，子类被用来根据**rootBeanDefinition**来创建实例对象）实例化策略接口，其中有两个实现，分别是**Simple**InstantiationStrategy以及**CglibSubclassing**InstantiationStrategy

Spring Aop支持JDK动态代理实现和cglib实现，**AopProxy**是**策略接口**，JdkDynamicAopProxy、CglibAopProxy是两个实现了AopProxy接口的**策略类**。

策略模式中，策略一般通过策略类工厂来创建，在Spring源码中，可以看到**AopProxyFactory**是一个工厂类接口。

DefaultAopProxyFactory则是实现AopProxy的一个**默认**工厂类，用来创建AopProxy对象。如下图，策略实例在createAopProxy方法中创建。

（hasNoUserSuppliedProdyInterfaces方法则用于判断**用哪种动态代理方式**）

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
    
        @Override
        public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
            if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
                Class<?> targetClass = config.getTargetClass();
                if (targetClass == null) {
                    throw new AopConfigException("TargetSource cannot determine target class: " +
                            "Either an interface or a target is required for proxy creation.");
                }
                if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                    return new JdkDynamicAopProxy(config);
                }
                return new ObjenesisCglibAopProxy(config);
            }
            else {
                return new JdkDynamicAopProxy(config);
            }
        }
    
        /**
         * Determine whether the supplied {@link AdvisedSupport} has only the
         * {@link org.springframework.aop.SpringProxy} interface specified
         * (or no proxy interfaces specified at all).
         */
        private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
            Class<?>[] ifcs = config.getProxiedInterfaces();
            return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
        }
    
    }

###### **9）原型模式**： ######

> 原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

在 spring 中用到的原型模式有： scope="prototype" ，每次获取的是通过克隆生成的新实例，对其进行修改时对 原有实例对象不造成任何影响。

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
       ...
       // 官译：返回指定 bean 的一个实例，该实例可以是共享的，也可以是独立的。
       protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
    			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
           ...
           else if (mbd.isPrototype()) {
    		// It's a prototype -> create a new instance.
    		Object prototypeInstance = null;
    		try {
    		     beforePrototypeCreation(beanName);
    		     prototypeInstance = createBean(beanName, mbd, args);
    		}
    	        finally {
    		    afterPrototypeCreation(beanName);
    		}
    		    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
    		}
           ...
       } 
       ...
    }

###### **10）模板模式**： ######

> 在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

Spring中的 **AbstractPlatform**TransactionManager **事务管理器** 就是非常经典的模板模式的应用，父类都对于自己要实现的逻辑搭建了一个骨架，主要的功能是由抽象方法完成，由子类来完成。

public abstract class AbstractPlatformTransactionManager implements PlatformTransactionManager, Serializable {
       ...
       // 返回当前事务状态的事务对象。
       protected abstract Object doGetTransaction() throws TransactionException;
    
       // 根据给定的事务定义开始一个具有语义的新事务。
       protected abstract void doBegin(Object transaction, TransactionDefinition definition)
    			throws TransactionException;
    
       // 执行给定事务的实际提交。
       protected abstract void doCommit(DefaultTransactionStatus status) throws TransactionException;
    
       // 执行给定事务的实际回滚。
       protected abstract void doRollback(DefaultTransactionStatus status) throws TransactionException;
       ...
    }

###### **11）责任链模式**： ######

> 责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

**DispatcherServlet** 中的 **doDispatch()** 方法中获取与请求匹配的处理器HandlerExecutionChain，this.getHandler() 方法的处理使用到了责任链模式。

public class DispatcherServlet extends FrameworkServlet { 
        ...
        protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
            HandlerExecutionChain mappedHandler;
        }
        ...
    }

###### 总结 ######

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

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

知识来源：马士兵教育

[Spring篇-Spring中使用了哪些设计模式 - 知乎][Spring_-Spring_ -]

[https://www.cnblogs.com/csq-66/p/16699257.html][https_www.cnblogs.com_csq-66_p_16699257.html]

[Spring_-Spring_ -]: https://zhuanlan.zhihu.com/p/545864894
[https_www.cnblogs.com_csq-66_p_16699257.html]: https://www.cnblogs.com/csq-66/p/16699257.html