17,tomcat中StandardContext

trzxycx

　　一个上下文容器（Context）代表一个web应用，每一个上下文包括多个包装器（Wrapper），每个包装器代表一个Servlet
上下文还需要其它的一些组件如加载器和管理器
Context接口的标准实现，org.apache.catalina.core.StandardContext类
　　StandardContext配置
创建一个StandardContext实例之后，必须调用它的start方法，这样它就能为受到的HTTP请求服务了。一个StandardContext对象可能启动失败，
这时候属性available被设置为false，属性available表示了StandardContext对象的可用性。
在一个Tomcat部署中，StandardContext的配置过程做了以下事情：准备读取和解析%CATALINA_HOME%/conf 目录下面的web.xml，
部署所有应用程序，确保StandardContext实例可以处理应用级别的web.xml。
另外，配置需要添加一个验证器阀门和证书阀门（authenticator valve and a certificate valve）
StandardContext的属性之一是它属性configured,用来表示该StandardContext是否已经配置了
StandardContext使用一个事件监听器来作为它的配置器
当StandardContext实例的start方法被调用的时候，首先触发一个生命周期事件
。该事件唤醒一个监听器来配置该StandardContext实例。配置成功后，该监听器将configured属性设置为true。
否则，StandardContext对象拒绝启动，这样就不能对HTTP请求进行服务了。
　　StandardContext构造函数
public StandardContext() {
 super();
 pipeline.setBasic(new StandardContextValve());
 namingResources.setContainer(this);
}
在构造函数中，最重要的事情是在StandardContext的流水线上添加了一个类型为StandardContextValve的基本阀门
　　
启动StandardContext
Start方法初始化StandardContext对象并让生命周期监听器配置该StandardContext实例。如果配置成功，
生命周期监听器会将configured属性设置为true。最后start方法，将available属性设置为true或者false。
如果是true的话表示该StandardContext属性配置完毕并且所有相关子容器和组件已经成功启动，
这样就能对HTTP请求进行服务了，如果是false则表示出现了错误。

public synchronized void start() throws LifecycleException {
if (started)
throw new LifecycleException (sm.getString("containerBase.alreadyStarted", logName()));
lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
setAvailable(false);
setConfigured(false);
boolean ok = true;
if (getResources() == null) {
try {
if ((docBase != null) && (docBase.endsWith(".war")))
setResources(new WARDirContext());
else
setResources(new FileDirContext());
}catch (IllegalArgumentException e) {
ok = false;
}
}
if (ok && (resources instanceof ProxyDirContext)) {
DirContext dirContext = ((ProxyDirContext) resources).getDirContext();
if ((dirContext != null) && (dirContext instanceof BaseDirContext)) {
((BaseDirContext) dirContext).setDocBase(getBasePath());
((BaseDirContext) dirContext).allocate();
}
}
if (getLoader() == null) {
if (getPrivileged()) {
setLoader(new WebappLoader(this.getClass().getClassLoader()));
}else{
setLoader(new WebappLoader(getParentClassLoader()));
}
}
if (getManager() == null) {
setManager(new StandardManager());
}
// Initialize character set mapper
getCharsetMapper();
// Post work directory
postWorkDirectory();
String useNamingProperty = System.getProperty("catalina.useNaming");
if ((useNamingProperty != null) && (useNamingProperty.equals("false"))) {
useNaming = false;
}
if (ok && isUseNaming()) {
if (namingContextListener == null) {
namingContextListener = new NamingContextListener();
namingContextListener.setDebug(getDebug());
namingContextListener.setName(getNamingContextName()); addLifecycleListener(namingContextListener);
}
}
ClassLoader oldCCL = bindThread();
if (ok) {
try {
addDefaultMapper(this.mapperClass);
started = true;
if ((loader != null) && (loader instanceof Lifecycle))
((Lifecycle) loader).start();
if ((logger != null) && (logger instanceof Lifecycle))
((Lifecycle) logger).start();
// Unbinding thread
unbindThread(oldCCL);
oldCCL = bindThread();
if ((cluster != null) && (cluster instanceof Lifecycle))
((Lifecycle) cluster).start();
if ((realm != null) && (realm instanceof Lifecycle))
((Lifecycle) realm).start();
if ((resources != null) && (resources instanceof Lifecycle))
((Lifecycle) resources).start();
Mapper mappers[] = findMappers();
for (int i = 0; i < mappers.length; i++) {
if (mappers instanceof Lifecycle)
((Lifecycle) mappers).start();
}
Container children[] = findChildren();
for (int i = 0; i < children.length; i++) {
if (children instanceof Lifecycle)
((Lifecycle) children).start();
}
if (pipeline instanceof Lifecycle)
((Lifecycle) pipeline).start();
// Notify our interested LifecycleListeners
lifecycle.fireLifecycleEvent(START_EVENT, null);
if ((manager != null) && (manager instanceof Lifecycle))
((Lifecycle) manager).start();
} finally {
// Unbinding thread
unbindThread(oldCCL);
}
}
if (!getConfigured())
ok = false;
if (ok)
getServletContext().setAttribute (Globals.RESOURCES_ATTR, getResources());
if (ok) {
postWelcomeFiles();
}
if (ok) {
if (!listenerStart())
ok = false;
}
if (ok) {
if (!filterStart())
ok = false;
}
// Load and initialize all "load on startup" servlets
if (ok)
loadOnStartup(findChildren());
unbindThread(oldCCL);
if (ok){
setAvailable(true);
}else{
stop();
setAvailable(false);
}
lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
}

　　下面是该方法做的事情：
· 触发BEFORE_START事件
· 设置availability属性为false
· 设置configured属性为false
· 设置源（resources）
· 设置加载器
· 设置管理器
· 初始化属性map
· 启动跟该上下文相关的组件
· 启动子容器（包装器）
· 启动流水线
· 启动管理器
· 触发START事件
。监听器（ContextConfig）会进行一系列配置操作，配置成功后，将StandardContext实例的configured属性设置为true。
· 检查configured属性的值，如果为true：调用postWelcomPages方法，加载子包装器，并将available属性设置为true。
 如果configured属性为false调用stop方法
· 触发AFTER_START事件
　　Invoke方法
StandardContext's方法由相关联的连接器调用，
如果该上下文是一个主机（host）的子容器，
有该主机的invoke方法调用。StandardContext的invoke方法首先检查是否正在重加载该应用程序，
是的话，等待知道加载完毕。然后调用它的父类ContainerBase的invoke方法

public void invoke(Request request, Response response){
while (getPaused()) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) { ; }
}
if (swallowOutput) {
try {
SystemLogHandler.startCapture();
super.invoke(request, response);
}
}else {
super.invoke(request, response);
}
}
　　方法getPaused获得属性paused的值，当应用程序正在加载的时候该属性为ture。
　　
StandardContextMapper
对于每一个请求，invoke方法都会调用StandarContext流水线基本阀门的invoke方法。
StandarContext的基本阀门用org.apache.catalina.core.StandardContextValve类表示。
StandardContextValve实例查找包含它的StandardContext。StandardContextValve使用上下文容器的map来查找合适的包装器
StandardContext的父类ContainerBase定义了addDefaultMapper方法来添加

protected void addDefaultMapper(String mapperClass) {
if (mapperClass == null)
return;
if (mappers.size() >= 1)
return;
try {
Class clazz = Class.forName(mapperClass);
Mapper mapper = (Mapper) clazz.newInstance();
mapper.setProtocol("http");
addMapper(mapper);
} catch (Exception e) {}
}
　　重加载支持
StandardContext定义了reloadable属性来标识是否支持应用程序的重加载。
当允许重加载的时候，当web.xml或者WEB-INF/classes目录下的文件被改变的时候会重加载。
StandardContext 中Loader接口的标准实现WebappLoader类，有一个单独线程来检查WEB-INF目录下面所有类和JAR文件的时间戳
你需要做的是启动该线程，将 WebappLoader关联到StandardContext，使用setContainer方法即可

public void setContainer(Container container) {
if ((this.container != null) && (this.container instanceof Context))
((Context) this.container).removePropertyChangeListener(this);
Container oldContainer = this.container;
this.container = container;
support.firePropertyChange("container", oldContainer, this.container);
// Register with the new Container (if any)
if ((this.container!=null) && (this.container instanceof Context)) {
setReloadable( ((Context) this.container).getReloadable() );
((Context) this.container).addPropertyChangeListener(this);
}
}
　　
注意最后一个if语句块中，如果容器是一个上下文容器，调用setReloadable方法，
也就是说WebappLoader的reloadable属性跟StandardContext的reloadable属性相同。
下面是WebappLoader对setReload方法的实现：

public void setReloadable(boolean reloadable) {
boolean oldReloadable = this.reloadable;
this.reloadable = reloadable;
support.firePropertyChange("reloadable", new Boolean(oldReloadable), new Boolean(this.reloadable));
if (!started)
return;
if (!oldReloadable && this.reloadable)
threadStart();
else if (oldReloadable && !this.reloadable)
threadStop();
}
}
　　如果将reloadable属性设置为true，调用threadStart方法。如果从true到false，则调用threadStop方法。
threadStart方法启动一个线程持续的检查WEB-INF目录下面的类文件和JAR文件的时间戳。threadStop方法用于停止该线程。
类的时间戳是由backgroundProcess方法调用
　　backgroundProcess方法
一个上下文容器需要其它组件如加载器和管理器的支持。这些组件通常需要一个单独的线程来处理后台过程（background processing）
所有的后台过程都分享同一个线程。如果一个组件或者是容器需要定期的来执行操作，
它需要做的是将这些代码写入到backgroundProcess方法即可。

protected void threadStart() {
if (thread != null)
return;
if (backgroundProcessorDelay <= 0)
return;
threadDone = false;
String threadName = "ContainerBackgroundProcessor[" + toString() + "]";
thread = new Thread(new ContainerBackgroundProcessor(), threadName);
thread.setDaemon(true);
thread.start();
}
　　
方法threadStart传递一个ContainerBackgroundProcessor对象创建一个新线程。
ContainerBackgroundProcessor实现了java.lang.Runnable接口

protected class ContainerBackgroundProcessor implements Runnable {
public void run() {
while (!threadDone) {
try {
Thread.sleep(backgroundProcessorDelay * 1000L);
} catch (InterruptedException e) { ; }
if (!threadDone) {
Container parent = (Container) getMappingObject();
ClassLoader cl = Thread.currentThread().getContextClassLoader();
if (parent.getLoader() != null) {
cl = parent.getLoader().getClassLoader();
}
processChildren(parent, cl);
}
}
}
protected void processChildren(Container container, ClassLoader cl) {
try {
if (container.getLoader() != null) {
Thread.currentThread().setContextClassLoader (container.getLoader().getClassLoader());
}
container.backgroundProcess();
}catch (Throwable t) {}
finally {
Thread.currentThread().setContextClassLoader(cl);
}
Container[] children = container.findChildren();
for (int i = 0; i < children.length; i++) {
if (children.getBackgroundProcessorDelay() <= 0) {
processChildren(children, cl);
}
}
}
}
　　ContainerBackgroundProcessor是ContainerBase的内部类，
在他的run方法里，有一个while循环定期的调用它的processChildren方法