热部署
在Tomcat中可以通过Host标签设置热部署，当 autoDeploy为true时，在运行中的Tomcat中丢入一个war包，那么Tomcat不需要重启就可以自动加载该war包。
<Host name="localhost" appBase="webapps"
unpackWARs="true" autoDeploy="true" >
Tomcat的容器中都包含有 backgroundProcessorDelay 属性和 backgroundProcess方法，默认的实现是，在每个容器启动时，当backgroundProcessorDelay大于1时（单位是秒），则会周期性的执行当前容器及所有子容器的backgroundProcess方法。
ContainerBase：
protected synchronized void startInternal() throws LifecycleException {
//...省略
threadStart();
}
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();
}
ContainerBackgroundProcessor：
public void run() {
Throwable t = null;
String unexpectedDeathMessage = sm.getString(
"containerBase.backgroundProcess.unexpectedThreadDeath",
Thread.currentThread().getName());
try {
while (!threadDone) {
try {
Thread.sleep(backgroundProcessorDelay * 1000L);
} catch (InterruptedException e) {
// Ignore
}
if (!threadDone) {
Container parent = (Container) getMappingObject();
ClassLoader cl =
Thread.currentThread().getContextClassLoader();
if (parent.getLoader() != null) {
cl = parent.getLoader().getClassLoader();
}
//note 执行所有子容器的backgroundProcessorDelay方法
processChildren(parent, cl);
}
}
} catch (RuntimeException e) {
t = e;
throw e;
} catch (Error e) {
t = e;
throw e;
} finally {
if (!threadDone) {
log.error(unexpectedDeathMessage, t);
}
}
}
protected void processChildren(Container container, ClassLoader cl) {
try {
if (container.getLoader() != null) {
Thread.currentThread().setContextClassLoader
(container.getLoader().getClassLoader());
}
//执行当前容器的backgroundProcess
container.backgroundProcess();
} catch (Throwable t) {
ExceptionUtils.handleThrowable(t);
} finally {
Thread.currentThread().setContextClassLoader(cl);
}
//在执行子容器的backgroundProcess
Container[] children = container.findChildren();
for (int i = 0; i < children.length; i++) {
if (children[i].getBackgroundProcessorDelay() <= 0) {
processChildren(children[i], cl);
}
}
}
backgroundProcessorDelay的设置在Engine标签中，因为默认实现包含所有子容器，所有在最顶层的容器上配置一个即可。
<Engine name="Catalina" defaultHost="localhost" backgroundProcessorDelay="20">
我们知道war包的管理应该是属于它的上一层容器Host，在Host中并没有重写backgroundProcess方法。
StandardHost：
public void backgroundProcess() {
if (!getState().isAvailable())
return;
if (cluster != null) {
try {
cluster.backgroundProcess();
} catch (Exception e) {
log.warn(sm.getString("containerBase.backgroundProcess.cluster", cluster), e);
}
}
if (loader != null) {
try {
loader.backgroundProcess();
} catch (Exception e) {
log.warn(sm.getString("containerBase.backgroundProcess.loader", loader), e);
}
}
if (manager != null) {
try {
manager.backgroundProcess();
} catch (Exception e) {
log.warn(sm.getString("containerBase.backgroundProcess.manager", manager), e);
}
}
Realm realm = getRealmInternal();
if (realm != null) {
try {
realm.backgroundProcess();
} catch (Exception e) {
log.warn(sm.getString("containerBase.backgroundProcess.realm", realm), e);
}
}
Valve current = pipeline.getFirst();
while (current != null) {
try {
current.backgroundProcess();
} catch (Exception e) {
log.warn(sm.getString("containerBase.backgroundProcess.valve", current), e);
}
current = current.getNext();
}
//发送事件
fireLifecycleEvent(Lifecycle.PERIODIC_EVENT, null);
}
Host父类的实现也没有包含自动部署相关的内容，那么只能是在最后通过事件的机制去实现了，最后会发送一个Host的Lifecycle.PERIODIC_EVENT，Host对应的监听器是HostConfig。
HostConfig：
public void lifecycleEvent(LifecycleEvent event) {
try {
host = (Host) event.getLifecycle();
if (host instanceof StandardHost) {
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;
}
//当Host的周期时间到达时，即Host中的backgroundProcess方法被调用时触发
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();
}
}
在HostConfig中，存在Host周期性事件的监听处理。
HostConfig：
protected void check() {
//Host的属性，必须设置server.xml中的Host标签autoDeploy属性为true才进行热部署检测
if (host.getAutoDeploy()) {
//检测已经部署的是否存在修改，存在删除应用文件夹和卸载Context（通过判断文件的修改时间与上次部署时是否一致），删除之后，下面会当做新增的重新部署
DeployedApplication[] apps =
deployed.values().toArray(new DeployedApplication[0]);
for (int i = 0; i < apps.length; i++) {
if (!isServiced(apps[i].name))
checkResources(apps[i], false);
}
if (host.getUndeployOldVersions()) {
checkUndeploy();
}
//主要是部署新增的应用
deployApps();
}
}
protected synchronized void checkResources(DeployedApplication app,
boolean skipFileModificationResolutionCheck) {
String[] resources =
app.redeployResources.keySet().toArray(new String[0]);
long currentTimeWithResolutionOffset =
System.currentTimeMillis() - FILE_MODIFICATION_RESOLUTION_MS;
for (int i = 0; i < resources.length; i++) {
File resource = new File(resources[i]);
if (log.isDebugEnabled())
log.debug("Checking context[" + app.name +
"] redeploy resource " + resource);
long lastModified =
app.redeployResources.get(resources[i]).longValue();
if (resource.exists() || lastModified == 0) {
//判断修改时间是否一致
if (resource.lastModified() != lastModified && (!host.getAutoDeploy() ||
resource.lastModified() < currentTimeWithResolutionOffset ||
skipFileModificationResolutionCheck)) {
//...省略
//从已加载的容器中，卸载Context应用
undeploy(app);
//如果是解压为文件夹的，则删除
deleteRedeployResources(app, resources, i, false);
return;
}
//... 省略
}
}
protected void deployApps() {
File appBase = appBase();
File configBase = configBase();
//获取Host中appBase下所有的文件
String[] filteredAppPaths = filterAppPaths(appBase.list());
//部署xml
deployDescriptors(configBase, configBase.list());
//部署War包
deployWARs(appBase, filteredAppPaths);
//部署文件夹，也就是静态资源
deployDirectories(appBase, filteredAppPaths);
}
protected void deployWARs(File appBase, String[] files) {
if (files == null)
return;
ExecutorService es = host.getStartStopExecutor();
List<Future<?>> results = new ArrayList<Future<?>>();
for (int i = 0; i < files.length; i++) {
//只处理war包，别的不管
if (files[i].equalsIgnoreCase("META-INF"))
continue;
if (files[i].equalsIgnoreCase("WEB-INF"))
continue;
File war = new File(appBase, files[i]);
if (files[i].toLowerCase(Locale.ENGLISH).endsWith(".war") &&
war.isFile() && !invalidWars.contains(files[i]) ) {
ContextName cn = new ContextName(files[i], true);
if (isServiced(cn.getName())) {
continue;
}
//是否已经部署过了
if (deploymentExists(cn.getName())) {
DeployedApplication app = deployed.get(cn.getName());
boolean unpackWAR = unpackWARs;
if (unpackWAR && host.findChild(cn.getName()) instanceof StandardContext) {
unpackWAR = ((StandardContext) host.findChild(cn.getName())).getUnpackWAR();
}
if (!unpackWAR && app != null) {
// Need to check for a directory that should not be
// there
File dir = new File(appBase, cn.getBaseName());
if (dir.exists()) {
if (!app.loggedDirWarning) {
log.warn(sm.getString(
"hostConfig.deployWar.hiddenDir",
dir.getAbsoluteFile(),
war.getAbsoluteFile()));
app.loggedDirWarning = true;
}
} else {
app.loggedDirWarning = false;
}
}
//已经部署过了则跳过
continue;
}
//检测路径是否正确
if (!validateContextPath(appBase, cn.getBaseName())) {
log.error(sm.getString(
"hostConfig.illegalWarName", files[i]));
invalidWars.add(files[i]);
continue;
}
//没有部署过，则提交到线程池中异步处理
results.add(es.submit(new DeployWar(this, cn, war)));
}
}
//等待所有war包部署完成
for (Future<?> result : results) {
try {
result.get();
} catch (Exception e) {
log.error(sm.getString(
"hostConfig.deployWar.threaded.error"), e);
}
}
}
在HostConfig中，会周期性的检测部署的文件（主要是war包），是否发生了变化（通过与上次部署时的文件修改时间对比），发生变化则卸载应用并删除部署的应用文件夹；然后继续判断该war包是否已部署（对于修改的已经被删除，此时不算已部署），如果未部署，则通过线程池异步提交部署。
DeployWar：
public void run() {
config.deployWAR(cn, war);
}
HostConfig：
protected void deployWAR(ContextName cn, File war) {
//...省略了对war包的解析和获取conext.xml
Context context = null;
//创建出该war包的Conext容器
context = (Context) Class.forName(contextClass).newInstance();
//添加到子节点，然后启动容器
host.addChild(context);
//...省略
//添加到已部署应用目录中
deployed.put(cn.getName(), deployedApp);
}
StandardHost：
public void addChild(Container child) {
child.addLifecycleListener(new MemoryLeakTrackingListener());
if (!(child instanceof Context))
throw new IllegalArgumentException
(sm.getString("standardHost.notContext"));
super.addChild(child);
}
private void addChildInternal(Container child) {
//...省略
try {
if ((getState().isAvailable() ||
LifecycleState.STARTING_PREP.equals(getState())) &&
startChildren) {
//启动Conext容器
child.start();
}
} catch (LifecycleException e) {
log.error("ContainerBase.addChild: start: ", e);
throw new IllegalStateException("ContainerBase.addChild: start: " + e);
} finally {
fireContainerEvent(ADD_CHILD_EVENT, child);
}
}
在部署war中，异步创建了Conext应用容器并启动该容器，此时还为解压war中的内容，则最终对war包的处理应该是Context的应用容器中。
由于内容太长，此处省略Context启动的部分内容，在Context启动之前，会发送事件Lifecycle.BEFORE_START_EVENT至监听器ContextConfig中。
ContextConfig：
public void lifecycleEvent(LifecycleEvent event) {
try {
context = (Context) event.getLifecycle();
} catch (ClassCastException e) {
return;
}
if (event.getType().equals(Lifecycle.CONFIGURE_START_EVENT)) {
configureStart();
} else if (event.getType().equals(Lifecycle.BEFORE_START_EVENT)) {
//启动之前处理
beforeStart();
} else if (event.getType().equals(Lifecycle.AFTER_START_EVENT)) {
// Restore docBase for management tools
if (originalDocBase != null) {
context.setDocBase(originalDocBase);
}
} else if (event.getType().equals(Lifecycle.CONFIGURE_STOP_EVENT)) {
configureStop();
} else if (event.getType().equals(Lifecycle.AFTER_INIT_EVENT)) {
init();
} else if (event.getType().equals(Lifecycle.AFTER_DESTROY_EVENT)) {
destroy();
}
}
protected synchronized void beforeStart() {
try {
fixDocBase();
} catch (IOException e) {
}
antiLocking();
}
protected void fixDocBase()
throws IOException {
Host host = (Host) context.getParent();
//拿到上层目录
String appBase = host.getAppBase();
File canonicalAppBase = new File(appBase);
if (canonicalAppBase.isAbsolute()) {
canonicalAppBase = canonicalAppBase.getCanonicalFile();
} else {
canonicalAppBase =
new File(getBaseDir(), appBase)
.getCanonicalFile();
}
//war的文件夹名（即war包取掉后缀的名字）
String docBase = context.getDocBase();
if (docBase == null) {
// Trying to guess the docBase according to the path
String path = context.getPath();
if (path == null) {
return;
}
ContextName cn = new ContextName(path, context.getWebappVersion());
docBase = cn.getBaseName();
}
File file = new File(docBase);
//如果不是绝对路径，则转换为具体路径
if (!file.isAbsolute()) {
docBase = (new File(canonicalAppBase, docBase)).getPath();
} else {
docBase = file.getCanonicalPath();
}
file = new File(docBase);
String origDocBase = docBase;
ContextName cn = new ContextName(context.getPath(),
context.getWebappVersion());
String pathName = cn.getBaseName();
//是否解压war包
boolean unpackWARs = true;
if (host instanceof StandardHost) {
unpackWARs = ((StandardHost) host).isUnpackWARs();
if (unpackWARs && context instanceof StandardContext) {
unpackWARs = ((StandardContext) context).getUnpackWAR();
}
}
if (docBase.toLowerCase(Locale.ENGLISH).endsWith(".war") && !file.isDirectory()) {
if (unpackWARs) {
//加载war包
URL war = new URL("jar:" + (new File(docBase)).toURI().toURL() + "!/");
//解压war包到应用文件夹中
docBase = ExpandWar.expand(host, war, pathName);
file = new File(docBase);
docBase = file.getCanonicalPath();
if (context instanceof StandardContext) {
((StandardContext) context).setOriginalDocBase(origDocBase);
}
} else {
//不解压则校验war包即可（URL类加载器可以加载URL的war包）
URL war =
new URL("jar:" + (new File (docBase)).toURI().toURL() + "!/");
ExpandWar.validate(host, war, pathName);
}
}
}
//...省略
}
在ContextConfig中，监听了Context的启动，如果设置了解压war包，则在此处解压war包，完成最终的步骤。
热部署总结：
即Tomcat中存在一个定时任务，该定时任务会去扫描Host下的war包文件，然后文件 修改时间来判断是否存在修改，存在修改则删除卸载Context应用容器；并且当存在新增 时，则会异步的创建该Context应用容器，如果设置了解压最后还会解压成文件夹，从而完 成了热部署机制的实现。
热加载
在Tomcat中，可以通过Context标签设置热加载，reloadable设置为true时生效，一般调试时才使用，对性能消耗很大。
<Context docBase="app-test" reloadable="true" path=""/>
热加载是属于Conext应用容器的，也是在定时任务的backgroundProcess方法中实现，毕竟线程是属于重量级资源，能在一个线程实现就少创建一个线程。
StandardContext：
public void backgroundProcess() {
//...省略
if (loader != null) {
try {
//热加载war包下的所有资源（WEB-INF/classes、WEB-INF/lib）
loader.backgroundProcess();
} catch (Exception e) {
}
}
//...省略
}
WebappLoader：
public void backgroundProcess() {
//设置了server.xml中的Context中的reloadable为true时并且发生变化时才会重新加载
if (reloadable && modified()) {
try {
Thread.currentThread().setContextClassLoader
(WebappLoader.class.getClassLoader());
if (container instanceof StandardContext) {
//重新加载容器
((StandardContext) container).reload();
}
} finally {
if (container.getLoader() != null) {
Thread.currentThread().setContextClassLoader
(container.getLoader().getClassLoader());
}
}
} else {
closeJARs(false);
}
}
public boolean modified() {
return classLoader != null ? classLoader.modified() : false ;
}
WebappClassLoader:
public boolean modified() {
int length = paths.length;
//最后一次文件修改时间的列表
int length2 = lastModifiedDates.length;
//如果当前文件夹内容多了，则使用久的文件夹长度遍历（避免数组越界）
if (length > length2)
length = length2;
//遍历当前war包文件夹的所有文件
for (int i = 0; i < length; i++) {
try {
//拿到当前文件的修改时间
long lastModified =
((ResourceAttributes) resources.getAttributes(paths[i]))
.getLastModified();
//和该文件上一次的修改时间对比，存在一个不同则为已修改
if (lastModified != lastModifiedDates[i]) {
return (true);
}
}
}
length = jarNames.length;
//判断war包是否被删除
if (getJarPath() != null) {
try {
//获取war包中文件列表
NamingEnumeration<Binding> enumeration =
resources.listBindings(getJarPath());
int i = 0;
while (enumeration.hasMoreElements() && (i < length)) {
NameClassPair ncPair = enumeration.nextElement();
String name = ncPair.getName();
//不是jar包则跳过
if (!name.endsWith(".jar"))
continue;
//如果jar包列表对不上，则表示jar包发生变化
if (!name.equals(jarNames[i])) {
return (true);
}
i++;
}
if (enumeration.hasMoreElements()) {
while (enumeration.hasMoreElements()) {
NameClassPair ncPair = enumeration.nextElement();
String name = ncPair.getName();
//添加了新的jar包也是已修改
if (name.endsWith(".jar")) {
return (true);
}
}
} else if (i < jarNames.length) {
return (true);
}
}
//...省略
}
return (false);
}
StandardContext:
public synchronized void reload() {
if (!getState().isAvailable())
throw new IllegalStateException
(sm.getString("standardContext.notStarted", getName()));
setPaused(true);
//停止容器
stop();
//再启动容器
start();
setPaused(false);
}
protected synchronized void stopInternal() throws LifecycleException {
//... 其它内容省略
//拿到旧的类加载器
ClassLoader old = bindThread();
//解绑类加载器
unbindThread(old);
if ((loader != null) && (loader instanceof Lifecycle)) {
//...停止类加载器，即清除所有的引用，下次加载类时则会重新加载
((Lifecycle) loader).stop();
}
}
在上述代码中，我们可以看到Tomcat是通过对比classes和lib文件夹中的jar包来判断是否发生了变化，主要是判断classes文件夹是否减少、或者发生修改；判断lib文件夹下的jar包是否新增、减少；如果发生了上述情况则属于修改，然后重新加载当前Context应用容器，并清理当前Context的类加载器中的所有引用，下次加载类时则重新加载，从而实现了热加载机制。
热加载总结：
在Tomcat的后台定时任务中，如果开启了热加载，会检测classes文件夹下和lib下的jar包的内容是否发生了变化，如果发生了变化则会重新加载Context应用容器，清除对应的类加载器的引用，从而实现热加载，因为会遍历classes下的所有文件，所以很消耗资源，线上环境最好别开启，开发时使用即可。