tomcat阅读第四篇(tomcat 配置文件解析工具 Digester)

前一章大概看了bootstrap的代码，知道了bootstrap除了主要实例化那三个类加载器，其他都是用CatalinaClassLoaler去加载Catalina类的执行对应方法，主要是init load start stop是这几个方法，在看Catalina源码之前，要首先看下tomcat里面的解析XML配置文件的工具集Digester和Rule。Digester源码在org\apache\tomcat\util\digester\Digester.java，最后编译的jar包是tomcat-util-scan.jar。

Digester部分

首先看下Digester类的定义public class Digester extends DefaultHandler2

可以看到Digester继承了DefaultHandler2类，我们知道DefaultHandler2是java中使用SAX方式解析XML文件的处理类。这里可以看出tomcat是使用SAX的方式来处理tomcat中的各种XML配置文件的。 看SAX主要是看SAX引擎解析XML的时候的几个回调方法，（startDocument、endDocument、startElement、endElement、characters），至于其他的几个方法可以待到将来更加深入分析的时候去看，现在一个个的来看这几个主要方法

1.startDocument

记录日志，实例化log 、saxlog、设置configured为true。

2.startElement重点方法

//记录log
        boolean debug = log.isDebugEnabled();

        if (saxLog.isDebugEnabled()) {
            saxLog.debug("startElement(" + namespaceURI + "," + localName + "," + qName + ")");
        }

       //格式化xml元素的属性，将${}属性用System属性来替换
        list = updateAttributes(list);

        //为类似<a>xxxx</a>标签做解析文本的准备
        bodyTexts.push(bodyText);
        bodyText = new StringBuilder();

        
        String name = localName;
        if ((name == null) || (name.length() < 1)) {
            name = qName;
        }

        /**
            类似<a><b></b></a>这个xml标签结构会被解析成
              a/b
*/
        StringBuilder sb = new StringBuilder(match);
        if (match.length() > 0) {
            sb.append('/');
        }
        sb.append(name);
        match = sb.toString();
        if (debug) {
            log.debug("  New match='" + match + "'");
        }

//更具match过滤出Rules，rule是addRuleXXX方法添加的
        List<Rule> rules = getRules().match(namespaceURI, match);
        matches.push(rules);
        if ((rules != null) && (rules.size() > 0)) {
            //循环调用rule的begin方法
for (int i = 0; i < rules.size(); i++) {
                try {
                    Rule rule = rules.get(i);
                    if (debug) {
                        log.debug("  Fire begin() for " + rule);
                    }
                    rule.begin(namespaceURI, name, list);
                } catch (Exception e) {
                    log.error("Begin event threw exception", e);
                    throw createSAXException(e);
                } catch (Error e) {
                    log.error("Begin event threw error", e);
                    throw e;
                }
            }
        } else {
            if (debug) {
                log.debug("  No rules found matching '" + match + "'.");
            }
        }

3.characters方法

//记录log
    if (saxLog.isDebugEnabled()) {
            saxLog.debug("characters(" + new String(buffer, start, length) + ")");
        }
//类似<a>xxxxx</a>,将xxxxx暂存bodyText
        bodyText.append(buffer, start, length);

4.endElement方法

//记log
boolean debug = log.isDebugEnabled();
        if (debug) {
            if (saxLog.isDebugEnabled()) {
                saxLog.debug("endElement(" + namespaceURI + "," + localName + "," + qName + ")");
            }
            log.debug("  match='" + match + "'");
            log.debug("  bodyText='" + bodyText + "'");
        }

        //用system属性格式化bodyText
        bodyText = updateBodyText(bodyText);

        String name = localName;
        if ((name == null) || (name.length() < 1)) {
            name = qName;
        }

        //获得startElment方法match出的rules
        List<Rule> rules = matches.pop();
        if ((rules != null) && (rules.size() > 0)) {
            String bodyText = this.bodyText.toString();
 //循环调用rule的body方法，将解析得到的当前标签的body传给rule的body方法， 
for (int i = 0; i < rules.size(); i++) {
                try {
                    Rule rule = rules.get(i);
                    if (debug) {
                        log.debug("  Fire body() for " + rule);
                    }
                    rule.body(namespaceURI, name, bodyText);
                } catch (Exception e) {
                    log.error("Body event threw exception", e);
                    throw createSAXException(e);
                } catch (Error e) {
                    log.error("Body event threw error", e);
                    throw e;
                }
            }
        } else {
            if (debug) {
                log.debug("  No rules found matching '" + match + "'.");
            }
            if (rulesValidation) {
                log.warn("  No rules found matching '" + match + "'.");
            }
        }
        
       //弹出当前的bodyText，给其他标签使用
        bodyText = bodyTexts.pop();
        if (rules != null) {
        //循环调用rule的end方法,注意是反向调用的，最先添加的rule最后被调用end方法
            for (int i = 0; i < rules.size(); i++) {
                int j = (rules.size() - i) - 1;
                try {
                    Rule rule = rules.get(j);
                    if (debug) {
                        log.debug("  Fire end() for " + rule);
                    }
                    rule.end(namespaceURI, name);
                } catch (Exception e) {
                    log.error("End event threw exception", e);
                    throw createSAXException(e);
                } catch (Error e) {
                    log.error("End event threw error", e);
                    throw e;
                }
            }
        }

        // Recover the previous match expression
        int slash = match.lastIndexOf('/');
        if (slash >= 0) {
            match = match.substring(0, slash);
        } else {
            match = "";
        }

5.endDocument方法

//记log
if (saxLog.isDebugEnabled()) {
            if (getCount() > 1) {
                saxLog.debug("endDocument():  " + getCount() + " elements left");
            } else {
                saxLog.debug("endDocument()");
            }
        }
    
        while (getCount() > 1) {
            pop();
        }

        //循环调用所用rule的finish方法
        Iterator<Rule> rules = getRules().rules().iterator();
        while (rules.hasNext()) {
            Rule rule = rules.next();
            try {
                rule.finish();
            } catch (Exception e) {
                log.error("Finish event threw exception", e);
                throw createSAXException(e);
            } catch (Error e) {
                log.error("Finish event threw error", e);
                throw e;
            }
        }
         //初始化Digester的属性
        clear();

Rule部分

我们先看下rule,rule主要是这几个方法,这是所有rule的父类主要几个方法

 

Public abstract class Rule{
………………
public Digester getDigester() {
        return digester;
    }
    
   public void setDigester(Digester digester) {}
…………..
//startElement的时候调用
    public void begin(String namespace, String name, Attributes attributes) throws Exception {
    }
//endElement的时候调用
    public void body(String namespace, String name, String text) throws Exception {
      
    }
//endElement的时候调用 
    public void end(String namespace, String name) throws Exception {
    
    }
//endDocument的时候调用
    public void finish() throws Exception {
}
}

 

我们主要分析Digest类中AddRuleXXX中的几个Rule（CallMethodRule、CallParamRule、FactoryCreateRule、ObjectCreateRule、SetNextRule、SetPropertiesRule）

1.  CallMethodRule和CallParamRule配合使用（以<a>xxxxx</a>举例）

当解析到<a>的时候，CallMethodRule的begin方法调用实例化parameter数组push进Digester，调用CallParamRule的begin方法赋值parameter数组

 

当解析到</a>的时候，从Digester中peek出object，object反射调用method，传入begin的时候解析到的参数

2.  FactoryCreateRule（以<a>xxxxx</a>举例）

Begein方法，解析<a>调用实现了ObjectCreationFactory接口的对象的createObject方法，传入标签的attribute创建对象，push进Digester

 

End方法，解析到</a>Digester pop出begin push的object

3.  ObjectCreateRule（以<a classname=’xxxxx’>xxxxx</a>举例）Begin方法，通过catalinaClassLoader加载classname类名的类

4.  SetNextRule End方法，在parent对象上调用methodName参数的方法，child作为方法参数传入,下图是Digester中ArrayStack<Object>的父子Object

 

5.  SetPropertiesRule(<a att1=’1’ att2=’2’></a>)

Begin方法，peek Digester的object，读取标签的attributes设置object的属性,括号中<a>标签为例，设置object的att1属性值1，att2属性值2

Digester中的addRulexxx(String pattern,XXXX),其中pattern参数，和Digester方法startElement中match比较来过滤得到当前标签对应的rules 

---------------------------------------------------------------------------------------------------------------------

下面是我调用Digester解析一个简单xml的小例子，如果想测试的话需要导入lib下面的2个jar包(tomcat-util-scan.jar、tomcat-util.jar)和bin下面的jar包（tomcat-juli.jar），

我没添加解析Address标签的rule，可以动手试下

实体类

Address类

package tomcat9DigesterTest;

public class Address {
    
    private String contry;
    
    private String state;

    public String getContry() {
        return contry;
    }

    public void setContry(String contry) {
        this.contry = contry;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
    
    
}

Container类

package tomcat9DigesterTest;

import java.util.ArrayList;
import java.util.List;

public class Container {
    
    private List<Note>  notes = new ArrayList<Note>();
    
    public void addNote(Note note){
        notes.add(note);
    }

    public List<Note> getNotes() {
        return notes;
    }
    
    public void writeNote(String issue){
        for(Note note: notes){
            note.setFrom("huangshi");
            note.setTo("shenzhen");
            note.setHeading("My Dear");
            note.setBody("balabalabalabalabalabalabalabalabalabala");
        }
    }
}

Note类
package tomcat9DigesterTest;

public class Note {
    
    private String from;
    
    private String to;
    
    private String heading;
    
    private String body;

    public String getFrom() {
        return from;
    }

    public void setFrom(String from) {
        this.from = from;
    }

    public String getTo() {
        return to;
    }

    public void setTo(String to) {
        this.to = to;
    }

    public String getHeading() {
        return heading;
    }

    public void setHeading(String heading) {
        this.heading = heading;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }
}

Xml文件

<?xml version="1.0"  ?>
<note>
    <to>Tove</to>
    <from>Jani</from>
    <heading>Reminder</heading>
    <body>Don't forget me this weekend!</body>
    <address contry="USA" state="L.A."></address>
    <address contry="UK" state="London"></address>
</note>

Main类

package tomcat9DigesterTest;

import java.io.IOException;
import java.io.InputStream;

import org.apache.tomcat.util.digester.CallMethodRule;
import org.apache.tomcat.util.digester.Digester;
import org.xml.sax.SAXException;

public class DigesterTest {

    public static void main(String[] args) throws IOException, SAXException {
        // TODO Auto-generated method stub
        Digester digester= new Digester();
        
        Container c = new Container();
        digester.push(c);
        
        InputStream is = DigesterTest.class.getClassLoader().getResourceAsStream("test.xml");
        
        digester.setValidating(false);
        
        digester.setNamespaceAware(false);
        
        digester.addRule("note",new CallMethodRule("writeNote",0));
        digester.addObjectCreate("note","tomcat9DigesterTest.Note");
        digester.addSetNext("note", "addNote", "tomcat9DigesterTest.Note");
        
        digester.parse(is);
        
        System.out.println(c.getNotes().size());
        
        Note note = c.getNotes().get(0);
        System.out.println(note.getFrom()+":"+note.getTo()+":"+note.getHeading()+":"+note.getBody());
    }
}

 最近发现，tomcat用的xml解析方式，现在是apache commons下的一个项目

http://commons.apache.org/proper/commons-digester/guide/core.html