Tomcat源码阅读之StandardHost与HostConfig的分析
前面的文章分析了StandardEngine，这里来分析一下由Engine对象来管理的另外一种对象吧：Host。。
一般情况下，在tomcat中都是默认使用StandardHost类型。。。这里先来看看在catalina是如何配置创建StandardHost对象的吧：
//创建host对象
digester.addObjectCreate(prefix + "Host",
"org.apache.catalina.core.StandardHost", //创建host对象的配置
"className");
digester.addSetProperties(prefix + "Host");
digester.addRule(prefix + "Host",
new CopyParentClassLoaderRule()); //会将host的parentClassloader设置为engine的，engine被设置为sharedloader
digester.addRule(prefix + "Host", //为host设置配置的监听
new LifecycleListenerRule
("org.apache.catalina.startup.HostConfig", //这个算是比较重要的吧，在里面会具体的创建context啥的
"hostConfigClass"));
digester.addSetNext(prefix + "Host",
"addChild",
"org.apache.catalina.Container"); // 在engine上面调用addChild方法，用于添加当前的host到engine上面去
这部分具体的涉及到Host对象的创建，第一个是具体的创建要用的host对象，也就是StandardHost对象，接着是指定为host设置的parentclassLoader为engine的parentClassLoader，在前面的文章中，我们知道engine的parentClassLoader会被设置为sharedLoader，所以这里host对象的parentClassLoader也会被设置为sharedLoader。。
然后还有比较重要的配置项吧，为StandardHost对象添加lifecycle的监听器，为HostConfig类型的对象。。它是比较重要的吧，因为它会具体的负责对context的创建，启动啥的。。这个一会再来说吧。。
然后就最后调用engine的addChild方法将当前host对象添加到engine上面去了。。。
好啦，到这里怎样创建host对象应该算是知道了吧。。。那么接下来来看看host接口是如何定义的吧：
public interface Host extends Container {
//host的一些事件的定义，添加别名，移除别名啥的
public static final String ADD_ALIAS_EVENT = "addAlias";
public static final String REMOVE_ALIAS_EVENT = "removeAlias";
public String getXmlBase(); //当前host对象的配置文件的路径，这个文件不一定存在吧 /conf/enginename/hostname/
public void setXmlBase(String xmlBase);
public File getConfigBaseFile(); //当前host的配置xml文件
public String getAppBase(); //当前host的app在什么地方
public File getAppBaseFile(); //获取app的放的目录的文件引用
public void setAppBase(String appBase); //设置app存放的路径
public boolean getAutoDeploy(); //是否自动部署
public void setAutoDeploy(boolean autoDeploy); //是否自动部署
public String getConfigClass(); //用于监听context的listener的类型
public void setConfigClass(String configClass);
public boolean getDeployOnStartup(); //启动的时候部署？
public void setDeployOnStartup(boolean deployOnStartup);
public String getDeployIgnore();
public Pattern getDeployIgnorePattern(); //context名字匹配用的正则表达式
public void setDeployIgnore(String deployIgnore);
public ExecutorService getStartStopExecutor(); //用于启动和停止子container（也就是context）的executor
public boolean getCreateDirs(); //如果是ture的话，那么会尝试为应用程序和host的配置创建文件夹
public void setCreateDirs(boolean createDirs);
public boolean getUndeployOldVersions(); //是否自动卸载程序的老版本
public void setUndeployOldVersions(boolean undeployOldVersions);
public void addAlias(String alias); //为当前host添加别名
public String[] findAliases(); //获取当前host的所有别名
public void removeAlias(String alias); //移除一个别名
}
接口定义稍微长一些吧，不过也还挺简单的，主要是一些配置，别名什么的管理，这个具体看上面的注释应该能比较的清楚吧。
好啦，接下来来看看StandardHost是怎么实现的吧，先来看看简单的继承体系：
这个应该算是很简单的吧，首先也是一个容器。。。然后实现了host接口。。。这里来看看它的构造函数吧：
public StandardHost() {
super();
pipeline.setBasic(new StandardHostValve()); //设置basic
}
没做什么事情吧，无非是在pipeline上面添加了一个basic的valve对象。。。接下来再来看看一些重要的属性的定义吧：
private String[] aliases = new String[0]; //当前host对象的别名的数组
private final Object aliasesLock = new Object(); //锁
private String appBase = "webapps"; //默认的app的路径是tomcat根路径下的webapps文件夹
private volatile File appBaseFile = null; //引用这个文件夹
private String xmlBase = null; //xml配置文件所在的目录
private volatile File hostConfigBase = null; //host的默认配置路径 conf/ + enginename + / + hostname
private boolean autoDeploy = true; //默认是自动部署的
private String configClass =
"org.apache.catalina.startup.ContextConfig"; // 默认的config类型，是个listener，通过监听当前host的状态来部署context啥的
private String contextClass =
"org.apache.catalina.core.StandardContext"; //默认用到的context对象的类型
private boolean deployOnStartup = true; //默认在启动的时候部署应用
private boolean deployXML = !Globals.IS_SECURITY_ENABLED;
private boolean copyXML = false; //
private String errorReportValveClass =
"org.apache.catalina.valves.ErrorReportValve"; //用于保存的valve默认的类型
private boolean unpackWARs = true; //默认要解压war包
private String workDir = null; //app的work路径
private boolean createDirs = true; //默认在启动的时候创建文件夹
private final Map<ClassLoader, String> childClassLoaders = //跟踪每个app的classLoaer，用于定位内存泄露
new WeakHashMap<>();
private Pattern deployIgnore = null;
private boolean undeployOldVersions = false; //默认不卸载老版本
嗯，具体这些属性的用处在注释上应该比较的清楚了。。其实host对象本身无非就是对这些属性的管理。。自己并没有太多的要做的事情。。方法也基本上都是对这些属性的设置什么的。。。这里就不具体的来分析这些方法了，有兴趣自己看看就是了。。挺简单的。。。
那么这里来看看host对象的pipeline上的basic的valve干了的invoke做了什么事情吧。。我们在前面知道。。在engine的basic的vavle上将会调用请求所属的host的pipeline来处理请求。。
//其实这里主要是是调用当前请求的context的pipeline来处理
public final void invoke(Request request, Response response)
throws IOException, ServletException {
// Select the Context to be used for this Request
Context context = request.getContext(); //获取当前请求所属的context
if (context == null) { //如果没法找到context，那么可以直接返回错误了
response.sendError
(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
sm.getString("standardHost.noContext"));
return;
}
context.bind(Globals.IS_SECURITY_ENABLED, MY_CLASSLOADER);
if (request.isAsyncSupported()) { //设置当前请求是否支持异步
request.setAsyncSupported(context.getPipeline().isAsyncSupported());
}
// Don't fire listeners during async processing
// If a request init listener throws an exception, the request is
// aborted
boolean asyncAtStart = request.isAsync();
// An async error page may dispatch to another resource. This flag helps
// ensure an infinite error handling loop is not entered
boolean errorAtStart = response.isError();
if (asyncAtStart || context.fireRequestInitEvent(request)) { //用于让ServletRequestListener，表示有请求进来了
// Ask this Context to process this request
try {
context.getPipeline().getFirst().invoke(request, response); //调用所属的context来处理了
} catch (Throwable t) { //如果有异常的话，那么需要返回错误
ExceptionUtils.handleThrowable(t);
if (errorAtStart) {
container.getLogger().error("Exception Processing " +
request.getRequestURI(), t);
} else {
request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, t);
throwable(request, response, t);
}
}
// If the request was async at the start and an error occurred then
// the async error handling will kick-in and that will fire the
// request destroyed event *after* the error handling has taken
// place
if (!(request.isAsync() || (asyncAtStart &&
request.getAttribute(
RequestDispatcher.ERROR_EXCEPTION) != null))) {
// Protect against NPEs if context was destroyed during a
// long running request.
if (context.getState().isAvailable()) {
if (!errorAtStart) {
// Error page processing
response.setSuspended(false);
Throwable t = (Throwable) request.getAttribute(
RequestDispatcher.ERROR_EXCEPTION);
if (t != null) {
throwable(request, response, t);
} else {
status(request, response);
}
}
context.fireRequestDestroyEvent(request);
}
}
}
// Access a session (if present) to update last accessed time, based on a
// strict interpretation of the specification
if (ACCESS_SESSION) {
request.getSession(false);
}
context.unbind(Globals.IS_SECURITY_ENABLED, MY_CLASSLOADER);
}
嗯，代码虽然挺长的，其实主要也就是要调用当前请求所属的context的pipeline来处理这个请求的。。。
嗯，这里其实StandardHost部分的内容也就差不多了吧。。接下来来看看前面提到的HostConfig对象。。它将会用于监听host对象的生命周期事件，例如启动，停止是什么的。。。
继承体系还是蛮简单的吧，实现了LifecycleListener接口，那么表示当前对象可以响应lifecycle对象的生命周期事件，例如启动停止。。。接下来来看看它的一些重要的属性以及构造函数吧：
protected String contextClass = "org.apache.catalina.core.StandardContext"; //用到的context的类型的名字
protected Host host = null; //监听的host对象
protected ObjectName oname = null; //在jmx上面注册的名字
protected static final StringManager sm =
StringManager.getManager(Constants.Package);
protected boolean deployXML = false; //是否要处理app的context的xml配置文件
protected boolean copyXML = false; //是否要将xml配置文件移动到/conf/enginename/hostname/下面
protected boolean unpackWARs = false; //是否要解压war
protected final Map<String, DeployedApplication> deployed = //所有已经部署的应用，key是context的名字
new ConcurrentHashMap<>();
protected final ArrayList<String> serviced = new ArrayList<>();
protected Digester digester = createDigester(contextClass); //用于即系xml文件的
private final Object digesterLock = new Object();
protected final Set<String> invalidWars = new HashSet<>(); //忽略的war包
public String getContextClass() { //获取用到的context的类型
return (this.contextClass);
}
这里属性有些还是非常很总要的，例如deployed，用于代表每一个已经部署的web应用程序。。。接下来来看看它的lifecycleEvent方法的定义吧，也就是它是如何响应事件的：
//相应监听的host的生命周期的事件
public void lifecycleEvent(LifecycleEvent event) {
// Identify the host we are associated with
try {
host = (Host) event.getLifecycle(); //当前所监听的lifecycle对象，这里监听的是host对象
if (host instanceof StandardHost) { //根据host的信息，来设置一些配置
setCopyXML(((StandardHost) host).isCopyXML());
setDeployXML(((StandardHost) host).isDeployXML());
setUnpackWARs(((StandardHost) host).isUnpackWARs());
setContextClass(((StandardHost) host).getContextClass());
}
} catch (ClassCastException e) {
log.error(sm.getString("hostConfig.cce", event.getLifecycle()), e);
return;
}
// Process the event that has occurred
if (event.getType().equals(Lifecycle.PERIODIC_EVENT)) { //周期事件
check();
} else if (event.getType().equals(Lifecycle.START_EVENT)) {
start(); //开始进行部署
} else if (event.getType().equals(Lifecycle.STOP_EVENT)) {
stop(); //停止
}
}
这里首先是在host对象上面来拿一些配置的信息，然后根据事件的类型进行相应的处理。。这里就来看看对于启动的事件是怎么相应的吧：
//当监听的host启动的时候会执行这个方法，其实主要是context的部署
public void start() {
if (log.isDebugEnabled())
log.debug(sm.getString("hostConfig.start"));
try {
ObjectName hostON = host.getObjectName(); //获取host的jmx上面注册的名字
oname = new ObjectName
(hostON.getDomain() + ":type=Deployer,host=" + host.getName()); //根据host的名字生成当前对象的名字
Registry.getRegistry(null, null).registerComponent
(this, oname, this.getClass().getName()); //在jmx上面注册当前对象
} catch (Exception e) {
log.error(sm.getString("hostConfig.jmx.register", oname), e);
}
if (host.getCreateDirs()) { //如果要创建文件夹，这个是用于存放host的配置文件。/conf/enginename/hostname，还有就是app的目录
File[] dirs = new File[] {host.getAppBaseFile(),host.getConfigBaseFile()};
for (int i=0; i<dirs.length; i++) {
if (!dirs[i].mkdirs() && !dirs[i].isDirectory()) { //如果目录不存在的话，那么创建目录
log.error(sm.getString("hostConfig.createDirs",dirs[i]));
}
}
}
if (!host.getAppBaseFile().isDirectory()) { //如果app的目录不是文件夹，那么错误了
log.error(sm.getString("hostConfig.appBase", host.getName(),
host.getAppBaseFile().getPath()));
host.setDeployOnStartup(false);
host.setAutoDeploy(false);
}
if (host.getDeployOnStartup()) //一般都是
deployApps(); //开始部署应用
}
这里要做的其实主要是在jmx上的注册，然后对配置文件目录的处理，接着再是调用deployApps方法来具体的部署应用web应用程序。。。
//app的部署
protected void deployApps() {
File appBase = host.getAppBaseFile(); //获取app的路径目录的文件夹引用 /webapps
File configBase = host.getConfigBaseFile(); //获取host的配置文件的路径 /conf/enginename/hostname/
String[] filteredAppPaths = filterAppPaths(appBase.list()); //这里过滤一下app的路径，用host里的正则表达式来判断文件夹的名字是否符合规定
// Deploy XML descriptors from configBase
deployDescriptors(configBase, configBase.list()); //先处理host的配置
// Deploy WARs
deployWARs(appBase, filteredAppPaths); //部署app文件夹的war包
// Deploy expanded folders
deployDirectories(appBase, filteredAppPaths); //部署app文件夹里面的文件
}
首先获取了host的配置文件的目录以及存放app的文件夹的目录，然后对app的文件的名字进行一些过滤，毕竟context的名字不能随便取的嘛。。接着就是开始部署应用程序了，这里分为两种吧，一种是不是war包类型的，另外一种就是部署文件夹类型的。。。这里就来看看部署文件夹类型的吧，war包无非就是多了一层解压而已。。。
// 部署应用，文件夹类型的，前面是所有app所在的目录的引用，后面是要部署的文件夹的名字
protected void deployDirectories(File appBase, String[] files) {
if (files == null)
return;
ExecutorService es = host.getStartStopExecutor(); //后去host对象用于启动停止子container的executor
List<Future<?>> results = new ArrayList<>();
for (int i = 0; i < files.length; i++) { //遍历每一个文件夹
if (files[i].equalsIgnoreCase("META-INF"))
continue;
if (files[i].equalsIgnoreCase("WEB-INF"))
continue;
File dir = new File(appBase, files[i]); //创建文件的file引用
if (dir.isDirectory()) { //这里需要是一个文件夹
ContextName cn = new ContextName(files[i], false); //根据文件夹的名字来设置context的名字
if (isServiced(cn.getName()) || deploymentExists(cn.getName())) //是否有同名的
continue;
results.add(es.submit(new DeployDirectory(this, cn, dir))); //添加一个deploy文件夹的任务，派遣到executor里面进行 其实是config.deployDirectory
}
}
for (Future<?> result : results) {
try {
result.get();
} catch (Exception e) {
log.error(sm.getString(
"hostConfig.deployDir.threaded.error"), e);
}
}
}
这里是遍历当前app所在文件夹，然后根据文件夹的名字来创建context的名字，然后在host的executor上面提交部署的任务，具体的执行如下：
//第一个参数是context的名字，第二个参数是文件夹的引用
protected void deployDirectory(ContextName cn, File dir) {
// Deploy the application in this directory
if( log.isInfoEnabled() ) //打印正在部署啥
log.info(sm.getString("hostConfig.deployDir",
dir.getAbsolutePath()));
Context context = null;
//有的web应用可能有定义context的配置
File xml = new File(dir, Constants.ApplicationContextXml); //"META-INF/context.xml"; 当前context的配置文件，这个也不一一定有
File xmlCopy =
new File(host.getConfigBaseFile(), cn.getBaseName() + ".xml"); //获取host的配置文件夹里面当前context的配置，这个不一定有
DeployedApplication deployedApp; //用于引用已经部署的app
boolean copyThisXml = copyXML;
try {
if (deployXML && xml.exists()) { //根据应用的配置来创建
synchronized (digesterLock) {
try {
context = (Context) digester.parse(xml);
} catch (Exception e) {
log.error(sm.getString(
"hostConfig.deployDescriptor.error",
xml), e);
context = new FailedContext();
} finally {
if (context == null) {
context = new FailedContext();
}
digester.reset();
}
}
if (copyThisXml == false && context instanceof StandardContext) {
// Host is using default value. Context may override it.
copyThisXml = ((StandardContext) context).getCopyXML();
}
if (copyThisXml) {
InputStream is = null;
OutputStream os = null;
try {
is = new FileInputStream(xml);
os = new FileOutputStream(xmlCopy);
IOTools.flow(is, os);
// Don't catch IOE - let the outer try/catch handle it
} finally {
try {
if (is != null) is.close();
} catch (IOException e){
// Ignore
}
try {
if (os != null) os.close();
} catch (IOException e){
// Ignore
}
}
context.setConfigFile(xmlCopy.toURI().toURL());
} else {
context.setConfigFile(xml.toURI().toURL());
}
} else if (!deployXML && xml.exists()) {
// Block deployment as META-INF/context.xml may contain security
// configuration necessary for a secure deployment.
log.error(sm.getString("hostConfig.deployDescriptor.blocked",
cn.getPath(), xml, xmlCopy));
context = new FailedContext();
} else { //一般没有context的配置的话，就在这里创建context org.apache.catalina.core.StandardContext
context = (Context) Class.forName(contextClass).newInstance();
}
Class<?> clazz = Class.forName(host.getConfigClass()); //为context创建config对象 org.apache.catalina.startup.ContextConfig
LifecycleListener listener =
(LifecycleListener) clazz.newInstance(); // 创建listener的对象，然后添加到context上面去
context.addLifecycleListener(listener);
context.setName(cn.getName()); //设置当前context的名字
context.setPath(cn.getPath()); //应用所在的路径
context.setWebappVersion(cn.getVersion()); //当前版本
context.setDocBase(cn.getBaseName());
host.addChild(context); //在host添加context，在host里面，会将context的name与context对应起来，而且这里还会进行context的启动
} catch (Throwable t) {
ExceptionUtils.handleThrowable(t);
log.error(sm.getString("hostConfig.deployDir.error",
dir.getAbsolutePath()), t);
} finally {
deployedApp = new DeployedApplication(cn.getName(), //创建DeployedApplication对象，表设一个部署的应用
xml.exists() && deployXML && copyThisXml);
// Fake re-deploy resource to detect if a WAR is added at a later
// point
//重新热部署的东西
deployedApp.redeployResources.put(dir.getAbsolutePath() + ".war",
Long.valueOf(0));
deployedApp.redeployResources.put(dir.getAbsolutePath(),
Long.valueOf(dir.lastModified()));
if (deployXML && xml.exists()) { //如果有context的配置文件
if (copyThisXml) {
deployedApp.redeployResources.put(
xmlCopy.getAbsolutePath(),
Long.valueOf(xmlCopy.lastModified()));
} else {
deployedApp.redeployResources.put(
xml.getAbsolutePath(),
Long.valueOf(xml.lastModified()));
// Fake re-deploy resource to detect if a context.xml file is
// added at a later point
deployedApp.redeployResources.put(
xmlCopy.getAbsolutePath(),
Long.valueOf(0));
}
} else {
// Fake re-deploy resource to detect if a context.xml file is
// added at a later point
deployedApp.redeployResources.put(
xmlCopy.getAbsolutePath(),
Long.valueOf(0));
if (!xml.exists()) {
deployedApp.redeployResources.put(
xml.getAbsolutePath(),
Long.valueOf(0));
}
}
addWatchedResources(deployedApp, dir.getAbsolutePath(), context); //添加web应用程序资源的监控
// Add the global redeploy resources (which are never deleted) at
// the end so they don't interfere with the deletion process
addGlobalRedeployResources(deployedApp); //添加全局的资源
}
deployed.put(cn.getName(), deployedApp); //表示这个app已经部署了，key是当前context的名字，后面是
}
代码也还算是比较长的吧，其实主要要做得到事情就是处理当前web应用程序的context的配置，然后创建context的对象，然后调用host对象的addChild方法将当前创建的context加入到host里面去。。。
好啦，到这里就算差不多了。。干货不多吧，主要就集中在context的创建和部署上了。。。