Spring之架构（一）启动入口

一、Spring配置启动类

package config;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

/**
 * Servlet3.0环境下，容器会在类路径中查找实现javax.servlet.ServletContainerInitializer接口的类;
 * Spring提供了这个接口的实现，名为SpringServletContainerInitializer；
 * 而这个类返回来又会去查找实现WebApplicationInitializer的类并将配置任务交给他们来实现。
 * Spring3.2引入了一个便利的WebApplicationInitializer基础实现，也就是AbstractAnnotationConfigDispatcherServletInitializer;
 * 我们自己建的SpitterWebInitializer继承了AbstractAnnotationConfigDispatcherServletInitializer；
 * 因此当部署到Servlet3.0容器的时候，容器会自动发现它，并用它来配置Servlet上下文；
 */
public class SpitterWebInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    /** 将DispatcherServlet映射到"/"，这表示他会是应用默认的Servlet，他会处理进入应用的所有请求. */
    @Override
    protected String[] getServletMappings() {
        return new String[] { "/" };
    }

    /**
     * DispatcherServlet启动时，他会创建Spring应用上下文，并加载配置文件或者配置类中的bean；
     * 我么要求DispatcherServlet启动时，会加载WebConfig中的bean
     */
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class<?>[] { WebConfig.class };
    }

    /**
     * 但是在Spring Web中，通常还有另一个上下文应用。它是由ContextLoaderListener创建的;
     * DispatcherServlet加载包含Web组件的bean如controller，视图解析器，处理映射器;
     * ContextLoaderListener要加载应用中的其他的bean，通常是驱动后端的中间层和数据层组件;
     * 比如没有扫描到service层时，controller层bean的依赖注入就会在ContextLoaderListener加载时报错;
     */
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class<?>[] { RootConfig.class };
    }

}

 通过intellij idea查看继承树:

----------------------------------------------------------------

我们发现树顶是个interface，Classname： WebApplicationInitializer

public interface WebApplicationInitializer {

    /**
     * Configure the given {@link ServletContext} with any servlets, filters, listeners
     * context-params and attributes necessary for initializing this web application. See
     * examples {@linkplain WebApplicationInitializer above}.
     * @param servletContext the {@code ServletContext} to initialize
     * @throws ServletException if any call against the given {@code ServletContext}
     * throws a {@code ServletException}
     */
    void onStartup(ServletContext servletContext) throws ServletException;

}

 WebApplicationInitializer接口只有一个void onStartup(ServletContext servletContext)抽象方法，顾名思义就是启动web容器。

----------------------------------------------------------------------------------------

我再来看AbstractContextLoaderInitializer是如何实现这个WebApplicationInitializer接口的：

public abstract class AbstractContextLoaderInitializer implements WebApplicationInitializer {

    /** Logger available to subclasses */
    protected final Log logger = LogFactory.getLog(getClass());


    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        registerContextLoaderListener(servletContext);
    }

    /**
     * Register a {@link ContextLoaderListener} against the given servlet context. The
     * {@code ContextLoaderListener} is initialized with the application context returned
     * from the {@link #createRootApplicationContext()} template method.
     * @param servletContext the servlet context to register the listener against
     */
    protected void registerContextLoaderListener(ServletContext servletContext) {
        WebApplicationContext rootAppContext = createRootApplicationContext();
        if (rootAppContext != null) {
            ContextLoaderListener listener = new ContextLoaderListener(rootAppContext);
            listener.setContextInitializers(getRootApplicationContextInitializers());
            servletContext.addListener(listener);
        }
        else {
            logger.debug("No ContextLoaderListener registered, as " +
                    "createRootApplicationContext() did not return an application context");
        }
    }

    /**
     * Create the "<strong>root</strong>" application context to be provided to the
     * {@code ContextLoaderListener}.
     * <p>The returned context is delegated to
     * {@link ContextLoaderListener#ContextLoaderListener(WebApplicationContext)} and will
     * be established as the parent context for any {@code DispatcherServlet} application
     * contexts. As such, it typically contains middle-tier services, data sources, etc.
     * @return the root application context, or {@code null} if a root context is not
     * desired
     * @see org.springframework.web.servlet.support.AbstractDispatcherServletInitializer
     */
    protected abstract WebApplicationContext createRootApplicationContext();

    /**
     * Specify application context initializers to be applied to the root application
     * context that the {@code ContextLoaderListener} is being created with.
     * @since 4.2
     * @see #createRootApplicationContext()
     * @see ContextLoaderListener#setContextInitializers
     */
    protected ApplicationContextInitializer<?>[] getRootApplicationContextInitializers() {
        return null;
    }

}

 AbstractContextLoaderInitializer重写了onStartup并且追加了2个抽象方法和一个具体方法

AbstractContextLoaderInitializer调用onStartup方法时，直接调用registerContextLoaderListener方法，

而registerContextLoaderListener先是调用了createRootApplicationContext返回一个WebApplicationContext rootAppContext，

registerContextLoaderListener然后创建ContextLoaderListener listener = new ContextLoaderListener(rootAppContext)对象;

通过listener的setContextInitializers方法，又调用了本类另一个抽象方法getRootApplicationContextInitializers().

最后通过addListener方法把listener注册到servletContext。

----------------------------------------------------------------------------------------

我们再来看继承树的下一个AbstractDispatcherServletInitializer

public abstract class AbstractDispatcherServletInitializer extends AbstractContextLoaderInitializer {

    /**
     * The default servlet name. Can be customized by overriding {@link #getServletName}.
     */
    public static final String DEFAULT_SERVLET_NAME = "dispatcher";


    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        super.onStartup(servletContext);
        registerDispatcherServlet(servletContext);
    }

    /**
     * Register a {@link DispatcherServlet} against the given servlet context.
     * <p>This method will create a {@code DispatcherServlet} with the name returned by
     * {@link #getServletName()}, initializing it with the application context returned
     * from {@link #createServletApplicationContext()}, and mapping it to the patterns
     * returned from {@link #getServletMappings()}.
     * <p>Further customization can be achieved by overriding {@link
     * #customizeRegistration(ServletRegistration.Dynamic)} or
     * {@link #createDispatcherServlet(WebApplicationContext)}.
     * @param servletContext the context to register the servlet against
     */
    protected void registerDispatcherServlet(ServletContext servletContext) {
        String servletName = getServletName();
        Assert.hasLength(servletName, "getServletName() must not return empty or null");

        WebApplicationContext servletAppContext = createServletApplicationContext();
        Assert.notNull(servletAppContext,
                "createServletApplicationContext() did not return an application " +
                "context for servlet [" + servletName + "]");

        FrameworkServlet dispatcherServlet = createDispatcherServlet(servletAppContext);
        dispatcherServlet.setContextInitializers(getServletApplicationContextInitializers());

        ServletRegistration.Dynamic registration = servletContext.addServlet(servletName, dispatcherServlet);
        Assert.notNull(registration,
                "Failed to register servlet with name '" + servletName + "'." +
                "Check if there is another servlet registered under the same name.");

        registration.setLoadOnStartup(1);
        registration.addMapping(getServletMappings());
        registration.setAsyncSupported(isAsyncSupported());

        Filter[] filters = getServletFilters();
        if (!ObjectUtils.isEmpty(filters)) {
            for (Filter filter : filters) {
                registerServletFilter(servletContext, filter);
            }
        }

        customizeRegistration(registration);
    }

    /**
     * Return the name under which the {@link DispatcherServlet} will be registered.
     * Defaults to {@link #DEFAULT_SERVLET_NAME}.
     * @see #registerDispatcherServlet(ServletContext)
     */
    protected String getServletName() {
        return DEFAULT_SERVLET_NAME;
    }

    /**
     * Create a servlet application context to be provided to the {@code DispatcherServlet}.
     * <p>The returned context is delegated to Spring's
     * {@link DispatcherServlet#DispatcherServlet(WebApplicationContext)}. As such,
     * it typically contains controllers, view resolvers, locale resolvers, and other
     * web-related beans.
     * @see #registerDispatcherServlet(ServletContext)
     */
    protected abstract WebApplicationContext createServletApplicationContext();

    /**
     * Create a {@link DispatcherServlet} (or other kind of {@link FrameworkServlet}-derived
     * dispatcher) with the specified {@link WebApplicationContext}.
     * <p>Note: This allows for any {@link FrameworkServlet} subclass as of 4.2.3.
     * Previously, it insisted on returning a {@link DispatcherServlet} or subclass thereof.
     */
    protected FrameworkServlet createDispatcherServlet(WebApplicationContext servletAppContext) {
        return new DispatcherServlet(servletAppContext);
    }

    /**
     * Specify application context initializers to be applied to the servlet-specific
     * application context that the {@code DispatcherServlet} is being created with.
     * @since 4.2
     * @see #createServletApplicationContext()
     * @see DispatcherServlet#setContextInitializers
     * @see #getRootApplicationContextInitializers()
     */
    protected ApplicationContextInitializer<?>[] getServletApplicationContextInitializers() {
        return null;
    }

    /**
     * Specify the servlet mapping(s) for the {@code DispatcherServlet} &mdash;
     * for example {@code "/"}, {@code "/app"}, etc.
     * @see #registerDispatcherServlet(ServletContext)
     */
    protected abstract String[] getServletMappings();

    /**
     * Specify filters to add and map to the {@code DispatcherServlet}.
     * @return an array of filters or {@code null}
     * @see #registerServletFilter(ServletContext, Filter)
     */
    protected Filter[] getServletFilters() {
        return null;
    }

    /**
     * Add the given filter to the ServletContext and map it to the
     * {@code DispatcherServlet} as follows:
     * <ul>
     * <li>a default filter name is chosen based on its concrete type
     * <li>the {@code asyncSupported} flag is set depending on the
     * return value of {@link #isAsyncSupported() asyncSupported}
     * <li>a filter mapping is created with dispatcher types {@code REQUEST},
     * {@code FORWARD}, {@code INCLUDE}, and conditionally {@code ASYNC} depending
     * on the return value of {@link #isAsyncSupported() asyncSupported}
     * </ul>
     * <p>If the above defaults are not suitable or insufficient, override this
     * method and register filters directly with the {@code ServletContext}.
     * @param servletContext the servlet context to register filters with
     * @param filter the filter to be registered
     * @return the filter registration
     */
    protected FilterRegistration.Dynamic registerServletFilter(ServletContext servletContext, Filter filter) {
        String filterName = Conventions.getVariableName(filter);
        Dynamic registration = servletContext.addFilter(filterName, filter);
        if (registration == null) {
            int counter = -1;
            while (counter == -1 || registration == null) {
                counter++;
                registration = servletContext.addFilter(filterName + "#" + counter, filter);
                Assert.isTrue(counter < 100,
                        "Failed to register filter '" + filter + "'." +
                        "Could the same Filter instance have been registered already?");
            }
        }
        registration.setAsyncSupported(isAsyncSupported());
        registration.addMappingForServletNames(getDispatcherTypes(), false, getServletName());
        return registration;
    }

    private EnumSet<DispatcherType> getDispatcherTypes() {
        return (isAsyncSupported() ?
                EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD, DispatcherType.INCLUDE, DispatcherType.ASYNC) :
                EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD, DispatcherType.INCLUDE));
    }

    /**
     * A single place to control the {@code asyncSupported} flag for the
     * {@code DispatcherServlet} and all filters added via {@link #getServletFilters()}.
     * <p>The default value is "true".
     */
    protected boolean isAsyncSupported() {
        return true;
    }

    /**
     * Optionally perform further registration customization once
     * {@link #registerDispatcherServlet(ServletContext)} has completed.
     * @param registration the {@code DispatcherServlet} registration to be customized
     * @see #registerDispatcherServlet(ServletContext)
     */
    protected void customizeRegistration(ServletRegistration.Dynamic registration) {
    }

}

抽象类AbstractDispatcherServletInitializer也重写了onStartup，先是通过super.onStartup(servletContext)完成父类servletContext的初始化，

然后调用registerDispatcherServlet(servletContext)方法来注册DispatcherServlet;

具体流程：String servletName = getServletName()来获取servletName，获取一个WebApplicationContext servletAppContext对象，

FrameworkServlet dispatcherServlet = createDispatcherServlet(servletAppContext);来建一个dispatcherServlet

而protected abstract String[] getServletMappings()抽象了servlet映射的路径；

 

---------------------------------------------------------------------------------------

我们再来看看继承树的下一个AbstractAnnotationConfigDispatcherServletInitializer抽象类

public abstract class AbstractAnnotationConfigDispatcherServletInitializer
        extends AbstractDispatcherServletInitializer {

    /**
     * {@inheritDoc}
     * <p>This implementation creates an {@link AnnotationConfigWebApplicationContext},
     * providing it the annotated classes returned by {@link #getRootConfigClasses()}.
     * Returns {@code null} if {@link #getRootConfigClasses()} returns {@code null}.
     */
    @Override
    protected WebApplicationContext createRootApplicationContext() {
        Class<?>[] configClasses = getRootConfigClasses();
        if (!ObjectUtils.isEmpty(configClasses)) {
            AnnotationConfigWebApplicationContext rootAppContext = new AnnotationConfigWebApplicationContext();
            rootAppContext.register(configClasses);
            return rootAppContext;
        }
        else {
            return null;
        }
    }

    /**
     * {@inheritDoc}
     * <p>This implementation creates an {@link AnnotationConfigWebApplicationContext},
     * providing it the annotated classes returned by {@link #getServletConfigClasses()}.
     */
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext servletAppContext = new AnnotationConfigWebApplicationContext();
        Class<?>[] configClasses = getServletConfigClasses();
        if (!ObjectUtils.isEmpty(configClasses)) {
            servletAppContext.register(configClasses);
        }
        return servletAppContext;
    }

    /**
     * Specify {@link org.springframework.context.annotation.Configuration @Configuration}
     * and/or {@link org.springframework.stereotype.Component @Component} classes to be
     * provided to the {@linkplain #createRootApplicationContext() root application context}.
     * @return the configuration classes for the root application context, or {@code null}
     * if creation and registration of a root context is not desired
     */
    protected abstract Class<?>[] getRootConfigClasses();

    /**
     * Specify {@link org.springframework.context.annotation.Configuration @Configuration}
     * and/or {@link org.springframework.stereotype.Component @Component} classes to be
     * provided to the {@linkplain #createServletApplicationContext() dispatcher servlet
     * application context}.
     * @return the configuration classes for the dispatcher servlet application context or
     * {@code null} if all configuration is specified through root config classes.
     */
    protected abstract Class<?>[] getServletConfigClasses();

}

AbstractAnnotationConfigDispatcherServletInitializer创建了2个WebApplicationContext，

rootAppContext和servletAppContext

servletAppContext将getServletConfigClasses()方法返回的Class进行注册

rootAppContext将getRootConfigClasses()方法返回的Class进行注册

----------------------------------------------------------------------------------

最后作为SpitterWebInitializer指定两个上下文AppContext需要注册Class，并且实现servlet映射的路径即可。

 由于继承了父类的各种方法，当servlet3.0环境以上时，tomcat启动时会寻找实现AbstractAnnotationConfigDispatcherServletInitializer

的SpitterWebInitializer，并调用onstart方法进行不断的方法调用直到把上下文和映射路径加载完毕，即完成了启动。