之前介绍过 Catalina加载过程是Bootstrap的load调用的 Tomcat8源码笔记(二)Bootstrap启动
按照Catalina的load过程，大致如下： 接下来一步步分析加载过程
一.initDirs
从系统环境变量、VM参数中读取java.io.tmpdir， 并校验文件夹合法性； 未指定java.io.tmpdir，会抛出异常，所以我们启动时指定VM参数：
-Djava.io.tmpdir=E:/Tomcat_Source_Code/apache-tomcat-8.0.53-src/catalina-home/temp
二.initNaming
initNaming设置一些额外的环境变量，在创建Digester时可能会用到.
三.createStartDigester
createStartDigester作用： 实例化Digester，设置validating标志位false，rulesValidating标志位true，fakeAttributes为{Object.class=[className]},useContextClassLoader标志位true，以上几种属性标志位是为了进行解析server.xml而设置的 。 再接着添加了一大段的 addObjectCreate 、addSetProperties、addSetNext， 这些是用来设置解析server.xml的规则，Tomcat的server.xml我们没见过xsd、DTD来约束文档书写规则吧，但是也不能不按照顺序随意些，比如我们不能将Servers标签写到Service标签里面吧。下面会具体分析添加规则部分。
贴上一份Tomcat8中默认的Server.xml内容，虽然平时部署到Tomcat也没怎么仔细关注过它，可能关注也只是关注到Tomcat端口而已、或者简单配置虚拟图片服务器。现在仔细看这份xml文档，与常见的spring、mybatis的文档不同，前面没有声明DTD或XSD，所以Tomcat要自己定义规则、自己按照规则来解析这样一份XML。
四.Rule抽象类
Rule抽象类的定义如下，省略了setter/getter方法，可以看出来Rule两个属性：关联的Digester以及命名空间namespaceURI，此外的方法就是begin、body、end、finish，这就是一个Rule规则实例化的生命周期，就是按顺序解析XML，按顺序调用begin、body、end、finish方法就能实例化对象；
Rule具体的实现类下面分析，代码中Digester又是addObjectCreate 、addSetProperties、addSetNext一大串，先来addObjectCreate:
添加ObjectCreate时候，会先将Rule和Digester关联，然后每个规则加入到Digester的rules属性中，rules属性为Rules接口，默认采用RuleBase作为实现类。
Rules和RuleBase
RuleBase的add(String,Rule)方法：
rules属性Rule的集合，目的是有序地保存最开始注册的Rule规则；cache属性，按照pattern来保存,目的是比如Server组件，创建ObjectCreate、属性赋值setPropertiesRule、设置调用方法SetNextRule三个属性规则，通过pattern 字符串就能将同一组件的不同规则保存在一起. 而pattern中 / 用来分隔标签下的子标签，比如Server下的Service,Server/Service.
五.configFile
configFile默认为conf/server.xml，Bootstrap的catalinaBase之前Bootstrao启动时候静态代码块赋的值，从系统变量或VM参数中读取catalina.base；简而言之，就是读取catalina.base/conf/server.xml文件.
六.解析server.xml
inputStream就是上面server.xml的FileInputStream ,赋给InputSource实例. push以及parse方法下面记录.
六.一 Digester的push方法
Digester实例将Catalina实例存入stack中，并且Digester的root属性也为Catalina实例，这里的ArrayStack是Tomcat自己实现的类，继承自ArrayList。 这一步将Catalina放入Digester的stack集合相当于第一位置，下标为0的位置，很关键！
六.二 Digester的parse方法， 解析server.xml的地方
configure是初始化打印日志log ; getXmlReader深入发现就是调用SAXParserFactory.newInstance().newSAXParser()，采用SAX的方式解析server.xml，并且设置内容解析器为this对象，也就是Digester，Digester重写了解析的规则。
很想贴一张SAXParser解析流程图，找了半天没搜到，我简单介绍下，SAX解析过程中DefaultHandler类，Digester就继承了DefaultHandler2,当然也继承了DefaultHandler。这个接口呢，startDocument开始解析xml时执行，startElement开始解析元素时执行，characters解析元素内容，endElement结束元素解析，然后循环往复解析，直到解析完成之后endDocument . SAX解析xml优点内存占用小，解析速度快，因为一边读取xml一边解析。Digester类的startDocument就没必要看了，直接从startElement开始记录.
startElement解析过程
server.xml中元素namespaceURI都为空，match解析到Server就是Server,解析到Server下Service就是Server/Service，与之间加入到Digester的pattern是一致的，这里就按照这个规则找到Rule的集合，加入到matches中，并且遍历Rule集合分别调用begin方法，比如以Server元素为例。
Server标签解析：
Server一共有三个Rule，分别是ObjectCreateRule、SetPropertiesRule、SetNextRule
此时ObjectCreateRule的className为org.apache.catalina.core.StandardServer，attributeName为className。 尝试从xml解析的attributes中找className，没有的情况下就用前面的className，使用当前线程的类加载器加载StandardServer，并且使用空参构造器实例化一个StandardServer，具体的StandardServer实例化下章记录，实例化完成的server加入到digester的stack，就是前面说的那个ArrayList子类中，第一位是Catalina,所以StandardServer是第二位.
SetPropertiesRule
digester peek方法返回栈首，深入查看发现就是其stack中最后一位元素，即上面的StandardServer；之后遍历attributes，可以理解为键值对集合，如果键是”className“，isFakeAttribute返回true，后面设置属性的方法就不会执行；如果键不是“className“，就会给StandardServer设置属性，IntrospectionUtils.setProperty可以理解为给对象属性赋值的方法。 比如常见的 <Server port="8005" shutdown="SHUTDOWN"> ，这个xml解析之后attributes就是{port=8005,shutdown=SHUTDOWN}，给对象属性赋值方法，也就是遍历对象的方法尝试寻找setPort/setShutdown，然后反射调用。
SetNextRule的begin方法没有做任何处理，跳过；另外server.xml中元素都没有body内容，characters我们也跳过；下面SAX解析发现又会跳进入到startElement中，因为Server元素没有结束，还有子元素要解析。
下面继续以一个Listener元素进行分析，仍然是startElement，之前match=”Server”,还没结束，现在match变成了“Server/Listener”
StringBuilder sb = new StringBuilder(match);
if (match.length() > 0) {
sb.append('/');
}
sb.append(name);
match = sb.toString();
if (debug) {
log.debug(" New match='" + match + "'");
}
// Fire "begin" events for all relevant rules
List<Rule> rules = getRules().match(namespaceURI, match);
matches.push(rules);
之前向Digester添加解析规则时，添加了这样的规则：
所以现在通过Server/Listener同样可以得到三个Rule，和Server一样解析，调用空参构造器初始化第一个VersionLoggerListener，设置属性(虽然没有属性值要设置，因为className不在设置属性范围内)，setNextRule(虽然这个begin什么也没做)， 可以进入endElement分析，第一个endElement是Listener元素的：
endElement伪代码如下： matches也是ArrayStack类型的，pop返回ArrayList集合的最后一个元素，也就是Listener的List<Rule>,遍历Rule集合，分别调用其body方法；因为Tomcat的server.xml大部分或者几乎就没有元素体有内容的元素，所以Rule实现类的body方法都是空实现； 逆序遍历Rule集合，分别调用Rule的end方法 ； 最后结束一个元素，就将match的 / 去掉一重，保证下次解析正确性；
SetNextRule的end方法记录：
peek(0)返回digester中最后添加的一个元素，peek(1)返回倒数第二个添加的元素，分别是VersionLoggerListener以及StandardServer，反射调用peek(1)也就是StandardServer的addLifecycleListener，将peek(0)添加到StandardServer的监听器集合。
ObjectCreateRule的end方法
将当前正在创建的元素从digester中移除，ObjectCreateRule所以是最后执行的，start的时候顺序调用Rule集合，end时候逆序调用Rule集合；
上述就是Server元素所有子元素的解析流程，循环往复，直到最后才解析Server元素的endDocument方法，而前面分析得到Rule集合的end方法，只需要关注SetNextRule和ObjectCreateRule的end方法即可。到了Server时候Digester的stack中元素如下，[Catalina，StandardServer]，所以按照分析会调用Catalina的setServer将解析完成的StandardServer赋给Catalina ； 而StandardServer的ObjectCreateRule会将 StandardServer从Digester移除； 加载过程中另外解析的xml，因为暂时不知道用途，这里就不记录了。
七. Catalina加载过程后续步骤
之前将StandardServer赋给了Catalina，现在也将Catalina赋给StandardServer，双向引用；之后给StandardServer设置catalina.home和catalina.base；初始化流，主要是控制台输出流改变，再之后调用StandardServer的init方法初始化容器！StandardServer初始化工作比较复杂，留作下篇博客记录。
八
简单按照Tomcat的server.xml解析规则，自定义了一个测试类，完成解析XML，目的是查看解析的效果：对Tomcat各个组件有个直观的了解。
import org.apache.catalina.*;
import org.apache.catalina.Server;
import org.apache.catalina.connector.Connector;
import org.apache.catalina.core.StandardHost;
import org.apache.catalina.deploy.NamingResourcesImpl;
import org.apache.catalina.startup.*;
import org.apache.tomcat.util.digester.ArrayStack;
import org.apache.tomcat.util.digester.Digester;
import org.apache.tomcat.util.digester.Rule;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.ext.DefaultHandler2;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParserFactory;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
public class ParserTest {
private String match="";
private ArrayStack<List<Rule>> stack=new ArrayStack();
public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
ParserTest test = new ParserTest();
test.test();
}
public void test() throws IOException, ParserConfigurationException, SAXException {
SAXParserFactory factory = SAXParserFactory.newInstance();
InputSource inputSource = new InputSource();
inputSource.setByteStream(new FileInputStream("E:\Tomcat_Source_Code\apache-tomcat-8.0.53-src\conf\server.xml"));
Digester digester=new Digester();
addRule(digester);
digester.push(new Catalina());
factory.newSAXParser().parse(inputSource,new DefaultHandler2(){
@Override
public void startElement(final String uri, final String localName, final String qName, final Attributes attributes) throws SAXException {
String name = localName;
if ((name == null) || (name.length() < 1)) {
name = qName;
}
if (match.length()>0) match+="/";
match+=name;
List<Rule> rules = digester.getRules().match(uri, ParserTest.this.match);
stack.push(rules);
if(rules!=null && rules.size()>0){
for(int i=0;i<rules.size();i++){
Rule rule = rules.get(i);
try {
rule.begin(uri,name,attributes);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
@Override
public void endElement(final String uri, final String localName, final String qName) throws SAXException {
String name = localName;
if ((name == null) || (name.length() < 1)) {
name = qName;
}
List<Rule> rules = stack.pop();
if(rules!=null && rules.size()>0){
for(int i=0;i<rules.size();i++){
Rule rule = rules.get(i);
try {
rule.body(uri,name,"");
} catch (Exception e) {
e.printStackTrace();
}
}
}
if(rules!=null){
for(int j=rules.size()-1;j>=0;j--){
Rule rule = rules.get(j);
try {
rule.end(uri,name);
} catch (Exception e) {
e.printStackTrace();
}
}
}
if(match.lastIndexOf("/")>0){
match=match.substring(0,match.lastIndexOf("/"));
}else{
match="";
}
}
@Override
public void characters(final char[] ch, final int start, final int length) throws SAXException {
super.characters(ch, start, length);
}
@Override
public void endDocument() throws SAXException {
if(stack.size()>0){
stack.pop();
}
Iterator<Rule> iterator = digester.getRules().rules().iterator();
while(iterator.hasNext()){
Rule rule = iterator.next();
try {
rule.finish();
} catch (Exception e) {
e.printStackTrace();
}
}
match="";
stack.clear();
}
});
System.out.println("解析XML完毕:");
Catalina catalina = (Catalina) digester.getRoot();
System.out.println("Cataline信息:"+catalina);
Server server = catalina.getServer();
System.out.println("Server信息:"+server);
System.out.printf("Server端口:%s,SHUTDOWN:%s
",server.getPort(),server.getShutdown());
NamingResourcesImpl globalNamingResources = server.getGlobalNamingResources();
System.out.println("GlobalNamingResources信息:"+globalNamingResources);
LifecycleListener[] listeners = server.findLifecycleListeners();
for (LifecycleListener listener:listeners) {
System.out.println("Listener信息:"+listener);
}
Service[] services = server.findServices();
for (Service service:services) {
System.out.println("Service信息:"+service.getName());
Connector[] connectors = service.findConnectors();
for(Connector connector:connectors){
System.out.println("Connector信息:"+connector.getProtocol());
}
Container container = service.getContainer();
System.out.println("Container容器信息:"+container.getName());
Container[] children = container.findChildren();
int i=1;
for(Container child:children){
System.out.println(container.getName()+"子容器"+(i++)+"信息:"+child.getName());
if(child instanceof StandardHost){
StandardHost host= (StandardHost) child;
System.out.printf("APP_BASE: %s, UnpackWARS: %s, Auto_Deploy:%s
" ,host.getAppBase(),host.isUnpackWARs(),host.getAutoDeploy());
Valve[] valves = host.getPipeline().getValves();
for(Valve valve:valves){
System.out.println(valve.getClass());
}
}
}
}
}
public static void addRule(Digester digester){
HashMap<Class<?>, List<String>> fakeAttributes = new HashMap<>();
ArrayList<String> attrs = new ArrayList<>();
attrs.add("className");
fakeAttributes.put(Object.class, attrs);
digester.setFakeAttributes(fakeAttributes);
digester.setUseContextClassLoader(true);
// Configure the actions we will be using
digester.addObjectCreate("Server","org.apache.catalina.core.StandardServer","className"); //初始化的Server对象StandardServer
digester.addSetProperties("Server");
digester.addSetNext("Server", "setServer", "org.apache.catalina.Server");
digester.addObjectCreate("Server/GlobalNamingResources",
"org.apache.catalina.deploy.NamingResourcesImpl");
digester.addSetProperties("Server/GlobalNamingResources");
digester.addSetNext("Server/GlobalNamingResources",
"setGlobalNamingResources",
"org.apache.catalina.deploy.NamingResourcesImpl");
digester.addObjectCreate("Server/Listener",
null, // MUST be specified in the element
"className");
digester.addSetProperties("Server/Listener");
digester.addSetNext("Server/Listener",
"addLifecycleListener",
"org.apache.catalina.LifecycleListener");
digester.addObjectCreate("Server/Service",
"org.apache.catalina.core.StandardService",
"className");
digester.addSetProperties("Server/Service");
digester.addSetNext("Server/Service",
"addService",
"org.apache.catalina.Service");
digester.addObjectCreate("Server/Service/Listener",
null, // MUST be specified in the element
"className");
digester.addSetProperties("Server/Service/Listener");
digester.addSetNext("Server/Service/Listener",
"addLifecycleListener",
"org.apache.catalina.LifecycleListener");
//Executor
digester.addObjectCreate("Server/Service/Executor",
"org.apache.catalina.core.StandardThreadExecutor",
"className");
digester.addSetProperties("Server/Service/Executor");
digester.addSetNext("Server/Service/Executor",
"addExecutor",
"org.apache.catalina.Executor");
digester.addRule("Server/Service/Connector",
new ConnectorCreateRule());
digester.addRule("Server/Service/Connector",
new SetAllPropertiesRule(new String[]{"executor"}));
digester.addSetNext("Server/Service/Connector",
"addConnector",
"org.apache.catalina.connector.Connector");
digester.addObjectCreate("Server/Service/Connector/Listener",
null, // MUST be specified in the element
"className");
digester.addSetProperties("Server/Service/Connector/Listener");
digester.addSetNext("Server/Service/Connector/Listener",
"addLifecycleListener",
"org.apache.catalina.LifecycleListener");
// Add RuleSets for nested elements
digester.addRuleSet(new NamingRuleSet("Server/GlobalNamingResources/"));
digester.addRuleSet(new EngineRuleSet("Server/Service/"));
digester.addRuleSet(new HostRuleSet("Server/Service/Engine/"));
digester.addRuleSet(new ContextRuleSet("Server/Service/Engine/Host/"));
digester.addRuleSet(new NamingRuleSet("Server/Service/Engine/Host/Context/"));
// When the 'engine' is found, set the parentClassLoader.
digester.addRule("Server/Service/Engine",new SetParentClassLoaderRule(Thread.currentThread().getContextClassLoader()));
}
public static class SetParentClassLoaderRule extends Rule {
public SetParentClassLoaderRule(ClassLoader parentClassLoader) {
this.parentClassLoader = parentClassLoader;
}
ClassLoader parentClassLoader = null;
@Override
public void begin(String namespace, String name, Attributes attributes)
throws Exception {
if (digester.getLogger().isDebugEnabled()) {
digester.getLogger().debug("Setting parent class loader");
}
Container top = (Container) digester.peek();
top.setParentClassLoader(parentClassLoader);
}
}
}
查看解析效果： 也让我们大致对Tomca组件有个了解，Catalina持有Server,一个Server持有多个Service,Service组件持有多个Connector连接器，负责对外监听HTTP、AJP等等连接；Service组件只能有一个Container,通常是Engine，Engine容器中有Host容器，Host中就是Context容器；
九. 总结
Catalina加载的过程解析catalina.home下conf/server.xml，并完成实例化工作，并且调用了StandardServer init方法，总体流程是这样，具体细节后面再记录。