曹工说Tomcat1：从XML解析说起

一、前言

第一次被人喊曹工，我相当诧异，那是有点久的事情了，楼主13年校招进华为，14年在东莞出差，给东莞移动的通信设备进行版本更新。他们那边的一个小伙子来接我的时候，这么叫我的，刚听到的时候，心里一紧，楼主本来进去没多久，业务也不怎么熟练，感觉都是新闻联播里才听到什么“陈工”，“李工”之类的叫法，感觉也是经验丰富、技术强硬的工人才被人这么称呼。反正呢，咋一下，心里虚的很，好歹呢，后边遇到问题了就及时和总部沟通，最后问题还是解决了，没有太丢脸。毕业至今，6年过去，楼主也已经早不在华为了，但是想起来还是觉得这个名字有点好玩，因为后来待了几家公司，再也没人这么叫我了，哈哈。。。

言归正传，曹工准备和大家一起，深入学习一下 Tomcat。Tomcat 的重要性，对于从事 Java Web开发的工程师来说，想来不用多说了，从当初在学校时，那时还是Struts2、Spring、Hibernate的天下时，Tomcat 就已经是部署 Servlet应用的主流容器了。现在后端框架换成了Spring MVC、Spring、Mybatis（或JPA），但是Tomcat 依然是主流Servlet容器。当然，Tomcat有点重，有很多对我们来说，现在根本用不到或者很少用的功能，比如 JNDI、JSP、SessionManager、Realm、Cluster、Servlet Pool、AJP等。另外，Tomcat由connector和container部分组成，其中的container部分由大到小一共分了四层，engine——》host——》context——》wrapper（即servlet）。其中engine可以包含多个host，但这个其实没啥用，无非是一个别名而已，像现在的互联网企业，一个Tomcat可能放几个webapp，更多的，可能只放一个webapp。除此之外，connector部分的AJP connector、BIO connector代码，对我们来说，也没什么用，静态页面现在主流几乎都放 nginx，谁还弄个 apache（毕业后从没用过）？

当然，楼主绝对不是要否定这些技术，我只是想说，我们要学的东西已经够多了，一些不够主流的技术还是先不要耗费大力气去弄，你想啊，一个Tomcat你学半年，mq、JVM、mysql、netty、框架、JDK源码、Redis、分布式、微服务这些还学不学了。上面的有些技术还是很有用，比如楼主最近就喜欢用 JSP 来 debug 线上代码。

去掉这些非主要的功能，剩下的东西就只有：NIO的connector、Container中的Host——》Context——》Wrapper，这个架构其实和Netty差得就不多了，学完这个后，再看Netty，会简单很多，同时，我们也能有一个横向对比的视角，来看看它们的异同点。

再次言归正传，Tomcat 里有很多的配置文件，比如常用的server.xml、webapp的web.xml，还有些不常用的，比如conf目录下的context.xml、tomcat-users.xml、甚至包括Tomcat 源码 jar 包里的每个包下都有的mbeans-descriptors.xml（看到源码不要慌，我们先不管那些mbean）。这么多xml，都需要解析，工作量还是很大的， 同样，我们也希望不要消耗太多内存，毕竟Java还是比较吃内存。

曹工说Tomcat，准备弄成一个系列，这篇是第一篇，由于楼主也菜（毕竟大家这么多年了再也没叫过我曹工），对于一些资料，别人写得比我好的，我就引用过来，当然，我会注明出处。

二、xml解析方式

当前主流的xml解析方式，共有4种，1、DOM解析；2、SAX解析；3、JDOM解析；4、DOM4J解析。详细看这里吧：https://www.cnblogs.com/longqingyang/p/5577937.html

其中，DOM模型，需要把整个文档读入内存，然后构建出一个树形结构，比较消耗内存，但是也比较好做修改。在Jquery中就会构建一个dom树，平时找个元素什么的，只需要根据id或者class去查找就行，找到了进行修改也方便，编码特别简单。 而SAX解析方式不一样，它会按顺序解析文档，并在适当的时候触发事件，比如针对下面的xml片段：

<Service name="Catalina">

    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
    //其他元素省略。。

</Service>

 

检测到一个<Service>，就会触发START_ELEMENT事件，然后调用我们的handler进行处理。读到 中间内容，发现有子元素<Connector>，又会触发<Connector>的 START_ELEMENT事件，然后再触发 <Connector>的 END_ELEMENT事件，最后才触发<Service>的END_ELEMENT事件。所以，SAX就是基于事件流来进行编码，只要掌握清楚了事件触发的时机，写个handler是不难的。

sax模型有个优点是，我们在获取到想要的内容后，完全可以手动终止解析。在上面的xml片段中，假设我们只关心<Connector>，那么在<Connector>的 END_ELEMENT 事件对应的handler中，我们可以手动抛出异常，来终止整个解析，这样就不用像 dom 模型一样读入并解析整个文档。

这里引用下前面博文里总结的论点：

dom优点：

　　　　　　1、形成了树结构，有助于更好的理解、掌握，且代码容易编写。

　　　　　　2、解析过程中，树结构保存在内存中，方便修改。（Tomcat 不需要改配置文件，鸡肋）

　　　　缺点：

　　　　　　1、由于文件是一次性读取，所以对内存的耗费比较大（tomcat作为容器，必须追求性能，肯定不能太耗内存）。

　　　　　　2、如果XML文件比较大，容易影响解析性能且可能会造成内存溢出。

sax优点：

　　　　　　1、采用事件驱动模式，对内存耗费比较小。（这个好，正好适合 tomcat）

　　　　　　2、适用于只读取不修改XML文件中的数据时。（笔者修改补充，这个也适合tomcat，不需要修改配置文件，只需要读取并处理）

　　　　缺点：

　　　　　　1、编码比较麻烦。（还好。）

　　　　　　2、很难同时访问XML文件中的多处不同数据。（确实，要访问的话，只能自己搞个field存起来，比如hashmap）

 

结合上面笔者自己的理解，相信大家能理解，Tomcat 为啥要基于sax模型来读取配置文件了，当然了，Tomcat 是用的Digester，不过Digester是基于 SAX 的。我们下面先来看看怎么基于 SAX解析 XML。

三、利用sax解析xml

1、准备工作

假设有个程序员，叫小明，性别男，爱好女，他有一个相对完美的女朋友，1米7，罩杯C++，一米五的大长腿。那么在xml里，可能是这样的：

<?xml version='1.0' encoding='utf-8'?>

<Coder name="xiaoming" sex="man" love="girl">
    <Girl name="Catalina" height="170" breast="C++" legLength="150">
    </Girl>
6 </Coder>

 

对应于该xml，我们代码里定义了两个类，一个为Coder，一个为Girl。

package com.coder;

import lombok.Data;

/**
 * desc: 
 * @author: caokunliang
 * creat_date: 2019/6/29 0029
 * creat_time: 11:12
 **/
@Data
public class Coder {
    private String name;

    private String sex;

    private String love;
    /**
     * 女朋友
     */
    private Girl girl;
}

 

package com.coder;

import lombok.Data;

/**
 * desc: 
 * @author: caokunliang
 * creat_date: 2019/6/29 0029
 * creat_time: 11:13
 **/
@Data
public class Girl {
    private String name;
    private String height;
    private String breast;
    private String legLength;

}

 

我们的最终目的，是生成一个Coder 对象，再生成一个Girl 对象，同时，要把 Girl 对象设到 Coder 对象里面去。按照 sax 编程模型，sax 的解析器在解析过程中，会按如下顺序，触发以下4个事件：

 

2、coder的startElement事件处理

package com.coder;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.ext.DefaultHandler2;
import org.xml.sax.helpers.DefaultHandler;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.LinkedList;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * desc:
 * @author: caokunliang
 * creat_date: 2019/6/29 0029
 * creat_time: 11:06
 **/
public class GirlFriendHandler  extends DefaultHandler {
    private LinkedList<Object> stack = new LinkedList<>();

    private AtomicInteger eventOrderCounter = new AtomicInteger(0);

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        System.out.println("startElement: " + qName + " It's the " + eventOrderCounter.getAndIncrement() + " one");

32         if ("Coder".equals(qName)){

            Coder coder = new Coder();

            coder.setName(attributes.getValue("name"));
            coder.setSex(attributes.getValue("sex"));
            coder.setLove(attributes.getValue("love"));

40             stack.push(coder);
        }
    }

  

    public static void main(String[] args) {
        GirlFriendHandler handler = new GirlFriendHandler();

        SAXParserFactory spf = SAXParserFactory.newInstance();
        try {
            SAXParser parser = spf.newSAXParser();
            InputStream inputStream = ClassLoader.getSystemClassLoader()
                    .getResourceAsStream("girlfriend.xml");

            parser.parse(inputStream, handler);
        } catch (ParserConfigurationException | SAXException | IOException e) {
            e.printStackTrace();
        }
    }
}

 

这里，先看46行，我们先 new 了 一个 GirlFriendHandler ，然后通过工厂，获取了一个  SAXParser 实例，然后读取了classpath 下的 girlfriend.xml ，然后利用 parser 对该xml 进行解析。接下来，再看GirlFriendHandler 类，该类继承了 org.xml.sax.helpers.DefaultHandler，org.xml.sax.helpers.DefaultHandler里面的方法都是空实现，继承该方法主要就是方便我们重写。 我们首先重写了 com.coder.GirlFriendHandler#startElement 方法，这个方法里，我们首先进行计算，打印访问顺序。

然后，在32行，我们判断，如果当前的元素为 coder，则生成一个 coder 对象，并填充属性，然后放到 handler 的一个 实例变量里，该变量利用链表实现栈的功能。该方法执行结束后，stack 中就会存进了coder 对象。

 

3、girl的startElement事件处理

为了缩短篇幅，这里只贴出部分有改动的代码。

 @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        System.out.println("startElement: " + qName + " It's the " + eventOrderCounter.getAndIncrement() + " one");

        if ("Coder".equals(qName)){

            Coder coder = new Coder();

            coder.setName(attributes.getValue("name"));
            coder.setSex(attributes.getValue("sex"));
            coder.setLove(attributes.getValue("love"));

            stack.push(coder);
        }else if ("Girl".equals(qName)){

            Girl girl = new Girl();
            girl.setName(attributes.getValue("name"));
            girl.setBreast(attributes.getValue("breast"));
            girl.setHeight(attributes.getValue("height"));
            girl.setLegLength(attributes.getValue("legLength"));

            Coder coder = (Coder)stack.peek();
            coder.setGirl(girl);
        }
    }

 

14行，判断是否为 Girl 元素；16-20行主要对 Girl 的属性进行赋值，22 行从栈中取出 Coder对象，23行设置 coder 的 girl 属性。现在应该明白了stack 的作用了吧，主要是方便我们访问前面已经处理过的对象。

4、girl 元素的 endElement事件

不做处理。当然，也可以做点啥，比如把小明的女朋友抢了。。。当然，我们不是那种人。

5、coder 元素的 endElement事件

 @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        System.out.println("endElement: " + qName + " It's the " + eventOrderCounter.getAndIncrement() + " one");

        if ("Coder".equals(qName)){
            Object o = stack.pop();
            System.out.println(o);
        }
    }

 

这里，我们重写了endElement，主要是遇到 coder 元素结尾时，将 coder元素从栈中弹出来，并打印。

 

6、执行结果

 可以看到，小明已经有了一个相当不错的女朋友。鼓掌！

7、改进

现在，假设小明和女朋友有了突飞猛进的发展，女朋友怀孕了，这时候，xml 就会变成下面这样：

    <Girl name="Catalina" height="170" breast="C++" legLength="150" pregnant="true">

 

那我们代码可能就不太满足了，首先， girl 这个当然肯定要改，这个没办法，但是，我们的handler好像也要加一行：

girl.setIsPregnant(true);

 

这就麻烦了，虽然改动不多。但你改了还得测，还得重新打包，烦呐。。小明真的坑啊，没事把人家弄怀孕干嘛。。当时怎么不用反射呢，反射的话，不就没这么多麻烦了吗？

为了给小明的操作买单，我们改了一版：

@Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        System.out.println("startElement: " + qName + " It's the " + eventOrderCounter.getAndIncrement() + " one");

        if ("Coder".equals(qName)) {

            Coder coder = new Coder();

 9             setProperties(attributes,coder);

            stack.push(coder);
        } else if ("Girl".equals(qName)) {

            Girl girl = new Girl();
15             setProperties(attributes, girl);

            Coder coder = (Coder) stack.peek();
            coder.setGirl(girl);
        }
    }

其中第9/15行，利用反射完成属性的映射。具体代码如下，比较多，这里为了避免篇幅太长，折叠了。我们还新增了一个工具类 TwoTuple，方便方法进行多值返回。

private void setProperties(Attributes attributes, Object object) {
        Method[] methods = object.getClass().getMethods();
        ArrayList<Method> list = new ArrayList<>();
        list.addAll(Arrays.asList(methods));
        list.removeIf(o -> o.getParameterCount() != 1);


        for (int i = 0; i < attributes.getLength(); i++) {
            // 获取属性名
            String attributesQName = attributes.getQName(i);
            String setterMethod = "set" + attributesQName.substring(0, 1).toUpperCase() + attributesQName.substring(1);

            String value = attributes.getValue(i);
            TwoTuple<Method, Object[]> tuple = getSuitableMethod(list, setterMethod, value);
            // 没有找到合适的方法
            if (tuple == null) {
                continue;
            }

            Method method = tuple.first;
            Object[] params = tuple.second;
            try {
                method.invoke(object,params);
            } catch (IllegalAccessException | InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }

    private TwoTuple<Method, Object[]> getSuitableMethod(List<Method> list, String setterMethod, String value) {

        for (Method method : list) {

            if (!Objects.equals(method.getName(), setterMethod)) {
                continue;
            }

            Object[] params = new Object[1];

            /**
             * 1；如果参数类型就是String，那么就是要找的
             */
            Class<?>[] parameterTypes = method.getParameterTypes();
            Class<?> parameterType = parameterTypes[0];
            if (parameterType.equals(String.class)) {
                params[0] = value;
                return new TwoTuple<>(method,params);
            }

            Boolean ok = true;

            // 看看int是否可以转换
            String name = parameterType.getName();
            if (name.equals("java.lang.Integer")
                    || name.equals("int")){
                try {
                    params[0] = Integer.valueOf(value);
                }catch (NumberFormatException e){
                    ok = false;
                    e.printStackTrace();
                }
                // 看看 long 是否可以转换
            }else if (name.equals("java.lang.Long")
                    || name.equals("long")){
                try {
                    params[0] = Long.valueOf(value);
                }catch (NumberFormatException e){
                    ok = false;
                    e.printStackTrace();
                }
                // 如果int 和 long 不行，那就只有尝试boolean了
            }else if (name.equals("java.lang.Boolean") ||
                    name.equals("boolean")){
                params[0] = Boolean.valueOf(value);
            }

            if (ok){
                return new TwoTuple<Method,Object[]>(method,params);
            }
        }
        return null;
    }

package com.coder;

public class TwoTuple<A, B> {

    public final A first;

    public final B second;

    public TwoTuple(A a, B b){
        first = a;
        second = b;
    }

    @Override
    public String toString(){
        return "(" + first + ", " + second + ")";
    }

}

8、后续

后续其实还会有很多变化，我们这里不一一演示了。比如小明的职业可能发生变化，可能会秃，小明的女朋友后续会变成一个当妈的。但我们这里的类型还是写死的，明显是要不得的，所以这个例子，其实还有相当的优化空间。但是，幸运的是，这些工作也不用我们去做，Tomcat 就利用了 digester 机制来动态而灵活地处理这些变化。

四、总结及源码

本篇作为一个开篇，讲了xml解析的sax模型。xml 解析，对于写sdk、写框架的开发者来说，还是很重要的，大家学了这个，就扫平了自己写框架的第一个障碍了。 当然，这个sax解析还很基础，Tomcat 要是照我们这么写，那估计也活不到现在。Tomcat 其实是用了 Digester 来解析 xml，相当方便和高效。下一讲我们就说说Digester。

源码：

https://github.com/cctvckl/tomcat-saxtest

我拉了个微信群，方便大家和我一起学习，后续tomcat完了后，也会写别的内容。 同时，最近在准备面试，也会分享些面试内容。