Spring 中用到的设计模式

工厂方法

工厂方法定义：父类定义了创建对象的接口，但是由子类来具体实现，工厂方法让类把实例化的动作推迟到了子类当中。

例如实现了 FactoryBean 接口的类，Spring 可以利用 getObject() 方法返回实现了该接口的类的实例；

AbstractFactoryBean 实现了 FactoryBean 接口，由子类去实现 createInstance 的逻辑

public abstract class AbstractFactoryBean<T>
        implements FactoryBean<T>, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {
    @Override
    public final T getObject() throws Exception {
        if (isSingleton()) {
            return (this.initialized ? this.singletonInstance : getEarlySingletonInstance());
        }
        else {
            return createInstance();
        }
    }
    protected abstract T createInstance() throws Exception;
    }

单例模式

单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

AbstractBeanFactory 提供 getBean 方法，具体调用到 DefaultSingletonBeanRegistry.getSingleton 方法中，使用 Double Check 方式获取单例 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);
                if (singletonObject == null && allowEarlyReference) {
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }
}

代理模式

AOP 的实现

• 静态代理，编写代理类，通过代理类操作被代理的对象
• 动态代理，利用反射、修改字节码的方式生成代理类

观察者模式

实现 ApplicationListener 接口，就可以接收对应的事件消息

@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
    void onApplicationEvent(E var1);
}

策略模式

通过实现 Resource 接口，提供更强的资源访问能力。

UrlResource、ClassPathResource、FileSystemResource 等等

模板方法模式

模板方法模式：一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行

AbstractApplicationContext 中的 refresh 方法，里面调用的一系列方法，其中 postProcessBeanFactory，onRefresh 的实现由子类去实现

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
    public void refresh() throws BeansException, IllegalStateException {
    synchronized(this.startupShutdownMonitor) {
        this.prepareRefresh();
        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
        this.prepareBeanFactory(beanFactory);
        try {
            this.postProcessBeanFactory(beanFactory);
            this.invokeBeanFactoryPostProcessors(beanFactory);
            this.registerBeanPostProcessors(beanFactory);
            this.initMessageSource();
            this.initApplicationEventMulticaster();
            this.onRefresh();
            this.registerListeners();
            this.finishBeanFactoryInitialization(beanFactory);
            this.finishRefresh();
        } catch (BeansException var9) {
            if (this.logger.isWarnEnabled()) {
                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
            }
            this.destroyBeans();
            this.cancelRefresh(var9);
            throw var9;
        } finally {
            this.resetCommonCaches();
        }
    }
}

适配器模式

适配器模式：将一个类的接口转换成客户希望的另外一个接口

Spring MVC 中的 HandlerAdapter

public interface HandlerAdapter {
    boolean supports(Object var1);
    @Nullable
    ModelAndView handle(HttpServletRequest var1, HttpServletResponse var2, Object var3) throws Exception;
    long getLastModified(HttpServletRequest var1, Object var2);
}

装饰器模式

装饰器模式：动态地给对象添加额外的功能

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