一个上下文容器(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[i] instanceof Lifecycle)
- ((Lifecycle) mappers[i]).start();
- }
- Container children[] = findChildren();
- for (int i = 0; i < children.length; i++) {
- if (children[i] instanceof Lifecycle)
- ((Lifecycle) children[i]).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[i].getBackgroundProcessorDelay() <= 0) {
- processChildren(children[i], cl);
- }
- }
- }
- }
ContainerBackgroundProcessor是ContainerBase的内部类,
在他的run方法里,有一个while循环定期的调用它的processChildren方法