Tomcat初始化
Tomcat初始化
maven依赖
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-core</artifactId>
<version>8.5.16</version>
</dependency>
<!-- tomcat对jsp支持 -->
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-jasper</artifactId>
<version>8.5.16</version>
</dependency>
Tomcat启动类
package web.embedded.tomcat;
import org.apache.catalina.*;
import org.apache.catalina.connector.Connector;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.core.StandardHost;
import org.apache.catalina.core.StandardWrapper;
import org.apache.catalina.startup.Tomcat;
import org.apache.tomcat.util.descriptor.web.FilterDef;
import org.apache.tomcat.util.descriptor.web.FilterMap;
public class LjhTomcat {
private static final String CONTEXTPATH = "/context";
private static final String FILTERNAME = "ljhFilter";
private static final String FILTERURL = "/*";
private static final String SERVLETNAME = "ljhServlet";
private static final String SERVLETURL = "/servlet";
public static void main(String[] args) throws LifecycleException {
Tomcat tomcat = new Tomcat();
Service service = tomcat.getService();
Connector connector = new Connector("HTTP/1.1");
connector.setPort(8080);
service.addConnector(connector);
Engine engine = tomcat.getEngine();
service.setContainer(engine);
StandardHost host = new StandardHost();
host.setName("localhost");
engine.addChild(host);
Context context = new StandardContext();
context.setName("index");
context.setPath(CONTEXTPATH);
context.addLifecycleListener(new Tomcat.FixContextListener());
host.addChild(context);
FilterDef filterDef = new FilterDef();
filterDef.addInitParameter("key", "value");
filterDef.setFilterName(FILTERNAME);
filterDef.setFilter(new LjhFilter());
context.addFilterDef(filterDef);
FilterMap filterMap = new FilterMap();
filterMap.setFilterName(FILTERNAME);
filterMap.addURLPattern(FILTERURL);
context.addFilterMap(filterMap);
context.addParameter("name", "value");
Wrapper wrapper = new StandardWrapper();
wrapper.addInitParameter("servletkey", "servletvalue");
wrapper.setServlet(new LjhServlet());
wrapper.setName(SERVLETNAME);
context.addChild(wrapper);
context.addServletMappingDecoded(SERVLETURL,SERVLETNAME);
Set set = new HashSet();
set.add("A");
context.addServletContainerInitializer(new LjhServletContainerInitializer(),set);
context.addApplicationListener("web.listener.MyServletContextListener");
context.addApplicationListener("web.listener.MyServletContextAttributeListener");
context.addApplicationListener("web.listener.MyServletRequestListener");
context.addApplicationListener("web.listener.MyServletRequestAttributeListener");
context.addApplicationListener("web.listener.MyHttpSessionListener");
context.addApplicationListener("web.listener.MyHttpSessionAttributeListener");
tomcat.start();
tomcat.getServer().await();
}
}
生命周期介绍
每一个组件都实现了Lifecycle接口，因此都符合上图中的生命周期流程。每一个组件运行前都需要先init>start，具体抽象实现在LifecycleBase的start()方法中。
Tomcat容器主要的几个组成部分
这几个组件并不是语法上的父子关系，只是因为子容器需要在指定的父容器内运行。Engine、Host、Context、Wrapper实现了容器接口，对应的组件实现类StandardEngine、StandardHost、StandardContext、StandardWrapper也都继承了Container的抽象实现类ContainerBase，ContainerBase中有一个Pipeline属性，主要是用来管理valve。以上的几个实现容器接口的组件都有对应的valve，分别是StandardEngineValve、StandardHostValve、StandardContextValve、StandardWrapperValve，用来完成对应组件负责的请求处理。我们常用的Filter、Servlet处理逻辑都在其中。
各组件的启动流程
StandardService的startInternal()方法如下：
StandardContext的startInternal()方法如下：
@Override
protected synchronized void startInternal() throws LifecycleException {
......
// Notify our interested LifecycleListeners
//这里就开始了事件通知，会将扫描到的ServletContainerInitializer实例和其上的@HandlesTypes注解配置的类包装到一个Map中，最终将这些类和ServletContext作为两个参数传入ServletContainerInitializer的onStartup方法。
fireLifecycleEvent(Lifecycle.CONFIGURE_START_EVENT, null);
// Start our child containers, if not already started
//先初始化启动StandardWrapper,Pipeline,StandardWrapperValve
for (Container child : findChildren()) {
if (!child.getState().isAvailable()) {
child.start();
}
}
// Start the Valves in our pipeline (including the basic),
// if any
if (pipeline instanceof Lifecycle) {
((Lifecycle) pipeline).start();
}
......
// servletContext.setInitParameter(String name, String value)
mergeParameters();
// 执行ServletContainerInitializers接口的onStartup方法
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;
}
}
// 配置并且调用application event listeners
if (ok) {
if (!listenerStart()) {
log.error(sm.getString("standardContext.listenerFail"));
ok = false;
}
}
......
// 主要执行Filter的初始化工作
if (ok) {
if (!filterStart()) {
log.error(sm.getString("standardContext.filterFail"));
ok = false;
}
}
// 加载StandardWrapper(Servlet),并初始化
if (ok) {
if (!loadOnStartup(findChildren())){
log.error(sm.getString("standardContext.servletFail"));
ok = false;
}
}
// Start ContainerBackgroundProcessor thread
super.threadStart();
} finally {
// Unbinding thread
unbindThread(oldCCL);
}
......
}
ServletContainerInitializer接口：接口的初始化工作在其他监听器、过滤器、Servlet初始化之前完成。ServletContainerInitializer的xml形式的逻辑主要在ContextConfig中，他是由ContainerMBean类加入的。
可以看到最终将这个上下文配置类加入了StandardContext生命周期监听集合中。容器中调用的fireLifecycleEvent()方法会触发ContextConfig的lifecycleEvent方法。
ContextConfig的主要方法webConfig()代码如下：
protected void webConfig() {
......
// Step 3. Look for ServletContainerInitializer implementations
if (ok) {
//主要去META-INF/services/javax.servlet.ServletContainerInitializer文件中寻找ServletContainerInitializer的实现类，并且实例化出来（需要一个无参构造方法），
//同时还会获取其实现类上的@HandlesTypes注解配置的Class[]
processServletContainerInitializers();
}
......
// Step 11. Apply the ServletContainerInitializer config to the
// context
//最终加入到StandardContext的servlet容器初始化Map中
if (ok) {
for (Map.Entry<ServletContainerInitializer,
Set<Class<?>>> entry :
initializerClassMap.entrySet()) {
if (entry.getValue().isEmpty()) {
context.addServletContainerInitializer(
entry.getKey(), null);
} else {
context.addServletContainerInitializer(
entry.getKey(), entry.getValue());
}
}
}
}
关于ServletContainerInitializer的使用可以参考org.springframework.web.SpringServletContainerInitializer。
listenerStart()：先将配置的Listener类名实例化，然后按接口类型ServletContextAttributeListener、ServletRequestAttributeListener、ServletRequestListener、HttpSessionIdListener、HttpSessionAttributeListener归入事件监听器集合，ServletContextListener、HttpSessionListener归入生命周期监听器集合，最后执行ServletContextListener接口的contextInitialized()方法。
loadOnStartup：启动load-on-startup参数必须为整数，小于0代表启动时期不做初始化，默认为-1。正数的值越小，启动优先级越高。如果值相同，有hash值决定，主要通过hashmap.values().toArray(results)获取。
public boolean loadOnStartup(Container children[]) {
// Collect "load on startup" servlets that need to be initialized
TreeMap<Integer, ArrayList<Wrapper>> map = new TreeMap<>();
for (int i = 0; i < children.length; i++) {
Wrapper wrapper = (Wrapper) children[i];
int loadOnStartup = wrapper.getLoadOnStartup();
if (loadOnStartup < 0)
continue;
Integer key = Integer.valueOf(loadOnStartup);
ArrayList<Wrapper> list = map.get(key);
if (list == null) {
list = new ArrayList<>();
map.put(key, list);
}
list.add(wrapper);
}
// Load the collected "load on startup" servlets
for (ArrayList<Wrapper> list : map.values()) {
for (Wrapper wrapper : list) {
......
//servlet.init(StandardWrapperFacade)
wrapper.load();
......
return true;
}
设计模式
通知方法fireLifecycleEvent的代码如下：
protected void fireLifecycleEvent(String type, Object data) {
LifecycleEvent event = new LifecycleEvent(this, type, data);
for (LifecycleListener listener : lifecycleListeners) {
listener.lifecycleEvent(event);
}
}
public class EventObject implements java.io.Serializable {
private static final long serialVersionUID = 5516075349620653480L;
protected transient Object source;
public EventObject(Object source) {
if (source == null)
throw new IllegalArgumentException("null source");
this.source = source;
}
public Object getSource() {
return source;
}
public String toString() {
return getClass().getName() + "[source=" + source + "]";
}
}
public final class LifecycleEvent extends EventObject {
private static final long serialVersionUID = 1L;
private final Object data;
private final String type;
public LifecycleEvent(Lifecycle lifecycle, String type, Object data) {
super(lifecycle);
this.type = type;
this.data = data;
}
public Object getData() {
return data;
}
public Lifecycle getLifecycle() {
return (Lifecycle) getSource();
}
public String getType() {
return this.type;
}
}
public interface LifecycleListener {
public void lifecycleEvent(LifecycleEvent event);
}