Spring源码分析 - Tomcat Servlet规范实现与Spring Web应用自动装配

本系列文章基于以下版本。

Spring Framework 版本:v5.2.8.RELEASE

Apache Tomcat 版本:v9.0.37

引子

以前做web应用开发,web.xml是必然要打交道的一个文件,通过它配置应用信息,各种servlets、filters和listeners等。

现在开发,已经见不到这个文件了。这意味着,有一种隐式的方式替代了显式的配置文件方式,来完成同样的工作。

这就是本文要讲的“Web应用自动装配”。

正题

Web应用自动装配,依赖于Servlet容器和Servlet开发框架的合作。前者实现Servlet规范,提供扩展服务,后者实现扩展服务,完成实际工作。

Servlet容器以Apache Tomcat来分析。

Servlet开发框架以Spring Framework来分析。

Tomcat Servlet规范实现

新的Servlet规范为 ServletContext 新增了若干接口。

源码文件(apache-tomcat-9.0.37-src\java\javax\servlet\ServletContext.java)

1
2
3
4
5
6
7
8
9
public interface ServletContext {

public ServletRegistration.Dynamic addServlet(String servletName, String className);
...
public FilterRegistration.Dynamic addFilter(String filterName, String className);
...
public void addListener(String className);
...
}

有了这些接口,就提供了通过代码配置servlets、filters和listeners等的能力,即web应用初始化。

什么时候怎么做呢?

Servlet规范提供了 ServletContainerInitializer

源码文件(apache-tomcat-9.0.37-src\java\javax\servlet\ServletContainerInitializer.java)

1
2
3
4
public interface ServletContainerInitializer {

void onStartup(Set<Class<?>> c, ServletContext ctx) throws ServletException;
}

Servlet容器会在启动的合适时机回调该接口实现类的 onStartup 方法,用户(此处为Servlet开发框架)实现该接口完成具体的初始化工作。

为了减少耦合,Tomcat采用了类似 Java SPI 的服务提供发现机制。

源码文件(apache-tomcat-9.0.37-src\java\org\apache\catalina\startup\WebappServiceLoader.java)

1
2
3
4
5
6
7
8
public class WebappServiceLoader<T> {
private static final String CLASSES = "/WEB-INF/classes/";
private static final String LIB = "/WEB-INF/lib/";
private static final String SERVICES = "META-INF/services/";

public List<T> load(Class<T> serviceType) throws IOException {
String configFile = SERVICES + serviceType.getName();
...

WebappServiceLoader 查找并加载 META-INF/services/ 下的服务实现。

源码文件(apache-tomcat-9.0.37-src\java\org\apache\catalina\startup\ContextConfig.java)

1
2
3
4
5
6
7
8
protected void processServletContainerInitializers() {

List<ServletContainerInitializer> detectedScis;
try {
WebappServiceLoader<ServletContainerInitializer> loader = new WebappServiceLoader<>(context);
detectedScis = loader.load(ServletContainerInitializer.class);
} catch (IOException e) {
...

如此,就能找到 ServletContainerInitializer 接口的实现类,该实现类由Servlet开发框架提供,便将具体初始化工作转移到了用户方。

我们注意到 onStartup 有两个参数,第2个是 ServletContext,不用多说。第一个是做什么的?

根据前面描述,ServletContainerInitializer 是来做web 应用初始化工作的,它提供了一个Servlet容器到Servlet开发框架的桥梁。Servlet开发框架具体实现时,也会定义一些初始化接口,然后在 onStartup 时调用这些接口服务。

第一个参数就是Servlet容器通过类似ASM字节码解析方式,加载的Servlet开发框架的web应用初始化接口实现类集合。

这就是涉及到要筛选出相应的web应用初始化接口实现类,所以Servlet规范提供了 @HandlesTypes 注解。

Spring Framework扩展实现

Spring的 ServletContainerInitializer 实现类如下。

源码文件(spring-framework\spring-web\src\main\java\org\springframework\web\SpringServletContainerInitializer.java)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
@HandlesTypes(WebApplicationInitializer.class)
public class SpringServletContainerInitializer implements ServletContainerInitializer {
@Override
public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
throws ServletException {

List<WebApplicationInitializer> initializers = new LinkedList<>();

if (webAppInitializerClasses != null) {
for (Class<?> waiClass : webAppInitializerClasses) {
// Be defensive: Some servlet containers provide us with invalid classes,
// no matter what @HandlesTypes says...
if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
try {
initializers.add((WebApplicationInitializer)
ReflectionUtils.accessibleConstructor(waiClass).newInstance());
}
catch (Throwable ex) {
throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
}
}
}
}

if (initializers.isEmpty()) {
servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
return;
}

servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
AnnotationAwareOrderComparator.sort(initializers);
for (WebApplicationInitializer initializer : initializers) {
initializer.onStartup(servletContext);
}
}
}

Spring的web应用初始化接口为 WebApplicationInitializer,通过 @HandlesTypes 注解告知Servlet容器筛选加载其实现类,并作为第1个参数传入 onStartup,依次回调实现类的 onStartup,完成web应用初始化工作。

Spring中,WebApplicationInitializer 有若干实现。

源码文件(spring-framework\spring-web\src\main\java\org\springframework\web\context\AbstractContextLoaderInitializer.java)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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);
}

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");
}
}

该实现会向 ServletContext 添加 ContextLoaderListener

源码文件(spring-framework\spring-web\src\main\java\org\springframework\web\context\ContextLoaderListener.java)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ContextLoaderListener extends ContextLoader implements ServletContextListener {

public ContextLoaderListener(WebApplicationContext context) {
super(context);
}

@Override
public void contextInitialized(ServletContextEvent event) {
initWebApplicationContext(event.getServletContext());
}

@Override
public void contextDestroyed(ServletContextEvent event) {
closeWebApplicationContext(event.getServletContext());
ContextCleanupListener.cleanupAttributes(event.getServletContext());
}

ContextLoaderListener 的主要作用是使用传入的或创建新的Spring上下文,配置刷新该上下文,并保存到到 ServletContext

其他的一些实现类型提供了包括向 ServletContext 添加servlets, filters,创建Spring MVC上下文等功能。

Servlet容器启动时机

源码文件(apache-tomcat-9.0.37-src\java\org\apache\catalina\core\StandardContext.java)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@Override
protected synchronized void startInternal() throws LifecycleException {
// Notify our interested LifecycleListeners
fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT, null);
...

// Call ServletContainerInitializers
for (Map.Entry<ServletContainerInitializer, Set<Class<?>>> entry :
initializers.entrySet()) {
try {
entry.getKey().onStartup(entry.getValue(),
getServletContext());
} catch (ServletException e) {
log.error(sm.getString("standardContext.sciFail"), e);
ok = false;
break;
}
}

// Configure and call application event listeners
if (ok) {
if (!listenerStart()) {
log.error(sm.getString("standardContext.listenerFail"));
ok = false;
}
}
}

CONFIGURE_START_EVENT 会最终触发扫描加载 ServletContainerInitializer 的实现类(SpringServletContainerInitializer) 和 筛选加载 @HandlesType 注解指定的接口或注解(WebApplicationInitializer)实现类。

entry.getKey().onStartup 即回调 ServletContainerInitializer 实现类(SpringServletContainerInitializer)的 onStartup 方法。

listenerStart 会调用 ServletContextListener 实现类(ContextLoaderListener) 的 contextInitialized