前面的文章分析了在tomcat中的container与pipeline的设计。。。我们知道Server是Service对象的容器，
而Service可以有多个connector对象，但是只能有一个container（一般就是engine对象）对象。。
所以分析各个不同的container对象的入口就在于service对象。。。而在tomcat中一般都是用StandardService这个类型。。。
先来看看一个初略的继承结构吧：
这里其实StandardService算是比较简单的了，首先它继承了LifecycleMBeanBase，这说明这个对象在启动之后将会被注册到JMX上去。。。同时它实现了service接口。。。这里就先来看看这个接口的定义吧：
package org.apache.catalina;
import org.apache.catalina.connector.Connector;
import org.apache.catalina.mapper.Mapper;
public interface Service extends Lifecycle {
public Container getContainer(); //获取拥有的container，service对象只拥有一个container
public void setContainer(Container container); //设置拥有的container
public String getName(); //service的名字
public void setName(String name);
public Server getServer(); //返回所属的server对象
public void setServer(Server server);
public ClassLoader getParentClassLoader(); //获取parentClassLoader
public void setParentClassLoader(ClassLoader parent);
public String getDomain(); //在jmx注册在哪个domain下面
public void addConnector(Connector connector); //添加一个connector
public Connector[] findConnectors(); //返回所有的connector
public void removeConnector(Connector connector); // 移除一个connecter
public void addExecutor(Executor ex); //添加一个executor
public Executor[] findExecutors(); //返回所有的executor
public Executor getExecutor(String name); //根据名字获取executor
public void removeExecutor(Executor ex); //移除一个executor
Mapper getMapper(); //用于请求的map
}
上面接口的定义其实也还挺简单的，无非首先拥有的container对象的管理，另外这里会管理容纳多个connector对象，同时还有executor对象，在以前分析connector部分的时候，我们知道在connector的创建的时候可以指定executor对象，这里指定的executor就是定义在servie对象里面的，当然如果没有指定的话，那么将会创建默认的executor、。、、、
同时这里还有一个非常重要的值得注意的东西，那就是mapper，他将会具体的负责请求的路由。。。
好啦，那么接下来来看看StandardService类型的属性的定义吧：
private String name = null;
private static final StringManager sm =
StringManager.getManager(Constants.Package);
private Server server = null; //所属的server对象
protected final PropertyChangeSupport support = new PropertyChangeSupport(this); //用于支持监听属性的修改
protected Connector connectors[] = new Connector[0]; //connector的数组
private final Object connectorsLock = new Object(); //当修改connector时候用到的锁
protected final ArrayList<Executor> executors = new ArrayList<>(); //所有定义的executor，connector可以用这个里面定义的executor
protected Container container = null; //关联的container
private ClassLoader parentClassLoader = null; //classLoader
protected final Mapper mapper = new Mapper(); //用于请求的map,host的map，warpper，context的map啥的
这里具体每个属性是干嘛用的注释应该说的蛮清楚的吧。。。接下来来看看StandardService启动吧：
//启动
protected void startInternal() throws LifecycleException {
if(log.isInfoEnabled())
log.info(sm.getString("standardService.start.name", this.name));
setState(LifecycleState.STARTING);
// Start our defined Container first
if (container != null) {
synchronized (container) {
container.start(); //先启动container
}
}
synchronized (executors) {
for (Executor executor: executors) {
executor.start(); //启动所有的executor
}
}
mapperListener.start(); //启动mapperListener
// Start our defined Connectors second
synchronized (connectorsLock) {
for (Connector connector: connectors) {
try {
// If it has already failed, don‘t try and start it
if (connector.getState() != LifecycleState.FAILED) {
connector.start(); //启动所有的connector
}
} catch (Exception e) {
log.error(sm.getString(
"standardService.connector.startFailed",
connector), e);
}
}
}
}
这里代码应该也挺简单的吧，首先设置当前组件的状态，然后启动拥有的container对象，其实一般都是engine，然后启动所有定义的executor对象，接着启动mapperListener，这个非常重要，待会分析
接下来就是启动connector，这样service就算是启动起来了。。。
嗯，其实service这部分真的很简单。。没啥说的。。。
还啦。。。接下来就来看看mapperListener的start干了啥吧。。。
先来看看MapperListener的比较初略的继承体系吧：
这里LifecycleMBeanBase的继承，说明对象的启动会被注册到jmx上面去。。。另外这里比较有意思的是实现了ContainerListener和LifecycleListener，说明既可以响应container的事件，例如添加child，添加valve啥的，同时还可以响应组件的状态事件。。。。
这里先来看看它的属性的定义吧：
private final Mapper mapper; //service的mapper，用于对请求进行路由
private final Service service; //所属的service对象
private static final StringManager sm =
StringManager.getManager(Constants.Package);
private final String domain = null; //注册在jmx哪个域名下面
public MapperListener(Mapper mapper, Service service) {
this.mapper = mapper;
this.service = service;
}
这里属性不多吧，具体的干啥用的都在注释后面贴了出来。。。
接下来来看看它的启动吧：
public void startInternal() throws LifecycleException {
setState(LifecycleState.STARTING);
// Find any components that have already been initialized since the
// MBean listener won‘t be notified as those components will have
// already registered their MBeans
findDefaultHost(); //获取当前engine默认的host
Engine engine = (Engine) service.getContainer(); //获取当前service的container，其实也就是engine
addListeners(engine); //为engine添加listener,将listener都设置为当前
Container[] conHosts = engine.findChildren(); //获取这个engine所有的host
for (Container conHost : conHosts) { //遍历engine下面的所有的host定义
Host host = (Host) conHost;
if (!LifecycleState.NEW.equals(host.getState())) {
// Registering the host will register the context and wrappers
registerHost(host); //登记host对象
}
}
}
这个首先设置当前组件的状态，接着获取engine对象定义的默认的host的名字，看一段配置文件就知道了：
<Engine name="Catalina" defaultHost="localhost">
每一个engine都可以指定默认使用的host对象，后面的就是设置为默认的host对象的名字。。
这里获取service对象拥有的container对象，其实就是engine对象，然后调用addListeners方法为其添加监听，最后再遍历当前engine对象的所有的host对象，调用registerHost方法注册他们。。
这里先来看看这个addListeners方法吧：
//为container对象添加lister，都设置为当前
private void addListeners(Container container) {
container.addContainerListener(this); //将这个container对象的container事件的监听设置为当前对象
container.addLifecycleListener(this); //设置当前对象来监听状态事件
for (Container child : container.findChildren()) { //遍历这个对象的所有的子container对象
addListeners(child); //同时将所有的子container的监听设置为当前对象
}
}
这里其实递归的来设置container的监听，不光设置当前container对象，还要讲当前container对象的子container的监听都设置了。。这样就保证了当前service整个container的体系都设置了当前MapperListener为监听。。。
好啦，既然要设置监听，那么我们就来看看对于事件他将会做啥吧，首先来看看如何来响应container的事件吧：
//也就是有child加入，或者valve加入的时候会激活 的事件，这里会将child的listener也设置为当前
public void containerEvent(ContainerEvent event) {
if (Container.ADD_CHILD_EVENT.equals(event.getType())) { //如果是添加child的事件
Container child = (Container) event.getData();
addListeners(child); // 为这个child添加listener，将其的lifecycle和containerlistenre都指定为当前对象
// If child is started then it is too late for life-cycle listener
// to register the child so register it here
if (child.getState().isAvailable()) {
if (child instanceof Host) {
registerHost((Host) child); //如果这个对象是host，那么需要注册host
} else if (child instanceof Context) {
registerContext((Context) child); //如果是context那么需要登记
} else if (child instanceof Wrapper) { //如果是warpper，登记
registerWrapper((Wrapper) child);
}
}
} else if (Container.REMOVE_CHILD_EVENT.equals(event.getType())) {
Container child = (Container) event.getData();
removeListeners(child);
// No need to unregister - life-cycle listener will handle this when
// the child stops
} else if (Host.ADD_ALIAS_EVENT.equals(event.getType())) {
// Handle dynamically adding host aliases
mapper.addHostAlias(((Host) event.getSource()).getName(),
event.getData().toString());
} else if (Host.REMOVE_ALIAS_EVENT.equals(event.getType())) {
// Handle dynamically removing host aliases
mapper.removeHostAlias(event.getData().toString());
} else if (Wrapper.ADD_MAPPING_EVENT.equals(event.getType())) { //warper的mapping事件
// Handle dynamically adding wrappers
Wrapper wrapper = (Wrapper) event.getSource(); //获取当前warpper对象
Context context = (Context) wrapper.getParent(); //获取当前warpper所属的context
String contextPath = context.getPath(); // 获取context的path
if ("/".equals(contextPath)) { //如果是根
contextPath = "";
}
String version = ((Context) wrapper.getParent()).getWebappVersion();
String hostName = context.getParent().getName(); //获取host的名字
String wrapperName = wrapper.getName(); //获取warpper对象的名字
String mapping = (String) event.getData(); //要map的路径
boolean jspWildCard = ("jsp".equals(wrapperName)
&& mapping.endsWith("/*"));
mapper.addWrapper(hostName, contextPath, version, mapping, wrapper, //在engine的mapper上面注册
jspWildCard, context.isResourceOnlyServlet(wrapperName));
} else if (Wrapper.REMOVE_MAPPING_EVENT.equals(event.getType())) {
// Handle dynamically removing wrappers
Wrapper wrapper = (Wrapper) event.getSource();
String contextPath = ((Context) wrapper.getParent()).getPath();
if ("/".equals(contextPath)) {
contextPath = "";
}
String version = ((Context) wrapper.getParent()).getWebappVersion();
String hostName = wrapper.getParent().getParent().getName();
String mapping = (String) event.getData();
mapper.removeWrapper(hostName, contextPath, version, mapping);
} else if (Context.ADD_WELCOME_FILE_EVENT.equals(event.getType())) {
// Handle dynamically adding welcome files
Context context = (Context) event.getSource();
String hostName = context.getParent().getName();
String contextPath = context.getPath();
if ("/".equals(contextPath)) {
contextPath = "";
}
String welcomeFile = (String) event.getData();
mapper.addWelcomeFile(hostName, contextPath,
context.getWebappVersion(), welcomeFile);
} else if (Context.REMOVE_WELCOME_FILE_EVENT.equals(event.getType())) {
// Handle dynamically removing welcome files
Context context = (Context) event.getSource();
String hostName = context.getParent().getName();
String contextPath = context.getPath();
if ("/".equals(contextPath)) {
contextPath = "";
}
String welcomeFile = (String) event.getData();
mapper.removeWelcomeFile(hostName, contextPath,
context.getWebappVersion(), welcomeFile);
} else if (Context.CLEAR_WELCOME_FILES_EVENT.equals(event.getType())) {
// Handle dynamically clearing welcome files
Context context = (Context) event.getSource();
String hostName = context.getParent().getName();
String contextPath = context.getPath();
if ("/".equals(contextPath)) {
contextPath = "";
}
mapper.clearWelcomeFiles(hostName, contextPath,
context.getWebappVersion());
}
}
这里很重要吧，首先是对于ADD_CHILD_EVENT事件，如果这里就设对这个加入的子container对象的监听，然后根据不同的类型，进行相应的登记 。。。。。
其实到这里就对整个MapperListener的运行就算比较了解了，通过对container的监控，来进行整个请求的map处理。。。这里就来看看registerHost方法做了啥吧：
//登记host对象
private void registerHost(Host host) {
String[] aliases = host.findAliases(); //获取当前host的别名
mapper.addHost(host.getName(), aliases, host); // 将host与其名字对应起来
for (Container container : host.findChildren()) { //登记这个host下面的所有的context
if (container.getState().isAvailable()) {
registerContext((Context) container);
}
}
if(log.isDebugEnabled()) {
log.debug(sm.getString("mapperListener.registerHost",
host.getName(), domain, service));
}
}
这个其实就是在service对象中的mapper中建立host的名字，别名与host对象的对象。。这样通过名字就能很快的索引到host了。。。。它用于干啥呢？嗯，其实就是对http请求的host字段进行路由。。。
好啦，接下来来看看registerContext方法，怎么登记context对象吧（其实一个context对象就对应着一个web应用程序）。。
//登记context对象，在里面要接着登记warrper
private void registerContext(Context context) {
String contextPath = context.getPath(); //获取context的path
if ("/".equals(contextPath)) {
contextPath = "";
}
Host host = (Host)context.getParent(); //这里获取的其实是host
WebResourceRoot resources = context.getResources(); //获取root
String[] welcomeFiles = context.findWelcomeFiles(); //获取welcomeFile
mapper.addContextVersion(host.getName(), host, contextPath,
context.getWebappVersion(), context, welcomeFiles, resources); //对添加context的map
for (Container container : context.findChildren()) {
registerWrapper((Wrapper) container); //登记所有的warpper对象
}
if(log.isDebugEnabled()) {
log.debug(sm.getString("mapperListener.registerContext",
contextPath, service));
}
}
这里首先获获取了当前context的path，然后获取这个context所属的host对象，接着获取webroot的引用，以及首页啥的，然后将这些属性一起注册到service的mapper上面去，这样就能够很快的对http请求的context的进行定位了。。。最后解释登记Wrapper(这里可以先简单的理解为servlet的一层包装)了：
//登记warpper对象
private void registerWrapper(Wrapper wrapper) {
String wrapperName = wrapper.getName(); //获取名字
Context context = (Context) wrapper.getParent(); //获取所属的context对象
String contextPath = context.getPath(); //获取context的path
if ("/".equals(contextPath)) {
contextPath = "";
}
String version = ((Context) wrapper.getParent()).getWebappVersion(); //webapp的版本
String hostName = context.getParent().getName(); //
String[] mappings = wrapper.findMappings(); //获取这个warpper所有的mapping信息，毕竟一个servlet可能可以处理多个请求路径嘛
for (String mapping : mappings) { //根据mapping的信息，在service的mapper里面进行mapper
boolean jspWildCard = (wrapperName.equals("jsp")
&& mapping.endsWith("/*"));
mapper.addWrapper(hostName, contextPath, version, mapping, wrapper,
jspWildCard,
context.isResourceOnlyServlet(wrapperName));
}
if(log.isDebugEnabled()) {
log.debug(sm.getString("mapperListener.registerWrapper",
wrapperName, contextPath, service));
}
}
这里其实跟上面的差不多，只不过注册的时候多了一些信息，到这里位置，host的索引，context索引，直到warpper（servlet）的索引就算都搞定了。。。
那么是不是整个http请求的路由也就差不多啦。。。也就差分析Mapper对象了，这个以后再说吧。。
这里整个MapperListener的工作也都差不多啦，当然也还有一些状态事件的相应，例如启动啥的，其实要做的事情也都差不多，无非是登记，或者基础mapper的登记。。。。
这样对于tomcat是如何维护请求的map信息也就比较的清楚了。。。。