Tomcat源码走读 04-tomcat的server.xml解析

最新推荐文章于 2021-07-08 20:20:00 发布
最新推荐文章于 2021-07-08 20:20:00 发布
阅读量206 收藏
点赞数
分类专栏： javaweb tomcat 文章标签： tomcat server.xml解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34988540/article/details/97616156
版权

04-tomcat的server.xml解析

tomcat的server.xml的解析依靠的是Digester对象，入口在Catalina.load()中。

1.Digester digester = createStartDigester();

protected Digester createStartDigester() {
        Digester digester = new Digester();
        digester.setValidating(false);
        digester.setRulesValidation(true);
        HashMap<Class<?>, List<String>> fakeAttributes =
            new HashMap<Class<?>, List<String>>();
        ArrayList<String> attrs = new ArrayList<String>();
        attrs.add("className");
        fakeAttributes.put(Object.class, attrs);
        digester.setFakeAttributes(fakeAttributes);
        digester.setUseContextClassLoader(true);
        digester.addObjectCreate("Server",
                                 "org.apache.catalina.core.StandardServer",
                                 "className");
        digester.addSetProperties("Server");
        digester.addSetNext("Server",
                            "setServer",
                            "org.apache.catalina.Server");
        digester.addObjectCreate("Server/GlobalNamingResources",
                                 "org.apache.catalina.deploy.NamingResources");
        digester.addSetProperties("Server/GlobalNamingResources");
        digester.addSetNext("Server/GlobalNamingResources",
                            "setGlobalNamingResources",
                            "org.apache.catalina.deploy.NamingResources");
        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");
        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");
        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/"));
        addClusterRuleSet(digester, "Server/Service/Engine/Host/Cluster/");
        digester.addRuleSet(new NamingRuleSet("Server/Service/Engine/Host/Context/"));
        digester.addRule("Server/Service/Engine",
                         new SetParentClassLoaderRule(parentClassLoader));
        addClusterRuleSet(digester, "Server/Service/Engine/Cluster/");
        return (digester);
    }

如上，主要是在指定digester的解析规则，下面我们就分析下上面的规则：

1.1 digester.addObjectCreate() ==> addRule(pattern,new ObjectCreateRule(className, attributeName));

主要是创建一个ObjectCreateRule对象创建规则，在digester解析过程中主要是调用rule对象的begin和end方法，begin处理开始标签，end处理闭合标签。所以我们主要是看这两个方法：

public void begin(String namespace, String name, Attributes attributes)
            throws Exception {
        String realClassName = className; //className就是我们创建ObjectCreateRule对象时传入的全类名
        if (attributeName != null) {
            String value = attributes.getValue(attributeName); //从server.xml的节点中获取attributeName属性的值
            if (value != null) {
                realClassName = value; //将该值赋值给realClassName 
            }
        }
        Class<?> clazz = digester.getClassLoader().loadClass(realClassName);
        Object instance = clazz.newInstance(); //创建指定的对象
        digester.push(instance); //把该对象压到digester的栈顶。
    }
public void end(String namespace, String name) throws Exception {
        Object top = digester.pop(); //出栈
    }

从上面可以知道ObjectCreateRule的作用就是读取指定的pattern节点创建节点指定的对象并在digester的stack中做压栈和出栈操作。

1.2 digester.addSetProperties() ==> addRule(pattern, new SetPropertiesRule());

创建一个属性赋值规则。他只有begin方法：

public void begin(String namespace, String theName, Attributes attributes)
            throws Exception {
        Object top = digester.peek(); //获取栈顶对象
        int attNamesLength = 0;
        if (attributeNames != null) {
            attNamesLength = attributeNames.length;
        }
        int propNamesLength = 0;
        if (propertyNames != null) {
            propNamesLength = propertyNames.length;
        }
        for (int i = 0; i < attributes.getLength(); i++) {
            String name = attributes.getLocalName(i);
            if ("".equals(name)) {
                name = attributes.getQName(i);
            }
            String value = attributes.getValue(i);
            for (int n = 0; n<attNamesLength; n++) {
                if (name.equals(attributeNames[n])) {
                    if (n < propNamesLength) {
                        name = propertyNames[n];
                    } else {
                        name = null;
                    }
                    break;
                }
            } 
            if (!digester.isFakeAttribute(top, name) 
                    && !IntrospectionUtils.setProperty(top, name, value)  //从节点中获取指定的属性并赋值给对象
                    && digester.getRulesValidation()) {
            }
        }
    }

可以知道SetPropertiesRule的作用就是给对象赋值

1.3 digester.addSetNext() ==> addRule(pattern, new SetNextRule(methodName, paramType));

创建一个方法调用的规则。

public void end(String namespace, String name) throws Exception {
        Object child = digester.peek(0); //获取栈顶的对象
        Object parent = digester.peek(1); //获取栈顶下一个对象
        IntrospectionUtils.callMethod1(parent, methodName,
                child, paramType, digester.getClassLoader()); //用child做参数传入parent的指定方法中
    }

SetNextRule的作用就是指定父子的联系。

1.4 digester.addRule(“Server/Service/Connector”,new ConnectorCreateRule());添加connector对象创建规则。

public void begin(String namespace, String name, Attributes attributes)
            throws Exception {
        Service svc = (Service)digester.peek(); //获取栈顶对象，根据xml结构，connector的外层就是standardservice。
        Executor ex = null;
        if ( attributes.getValue("executor")!=null ) {
            ex = svc.getExecutor(attributes.getValue("executor")); //如果connector节点有executor属性的话获取该executor。
        }
        Connector con = new Connector(attributes.getValue("protocol")); //创建节点指定协议的connector对象
        if ( ex != null )  _setExecutor(con,ex);
        digester.push(con); //压栈
    }
    public void _setExecutor(Connector con, Executor ex) throws Exception {
        Method m = IntrospectionUtils.findMethod(con.getProtocolHandler().getClass(),"setExecutor",new Class[] {java.util.concurrent.Executor.class});
        if (m!=null) {
            m.invoke(con.getProtocolHandler(), new Object[] {ex});
        }else {
        }
    }
    public void end(String namespace, String name) throws Exception {
        digester.pop(); //出栈
    }

1.5 digester.addRule(“Server/Service/Connector”,new SetAllPropertiesRule(new String[]{“executor”})); 赋值Connector除了executor属性以外的属性

1.6 digester.addRuleSet() 批量添加规则。具体实现和上面差不多，这里以EngineRuleSet为例。

public void addRuleInstances(Digester digester) {
        digester.addObjectCreate(prefix + "Engine",
                                 "org.apache.catalina.core.StandardEngine",
        digester.addSetProperties(prefix + "Engine");
        digester.addRule(prefix + "Engine",
                         new LifecycleListenerRule
                         ("org.apache.catalina.startup.EngineConfig",
                          "engineConfigClass"));
        digester.addSetNext(prefix + "Engine",
                            "setContainer",
                            "org.apache.catalina.Container");
        digester.addObjectCreate(prefix + "Engine/Cluster",
                                 null, // MUST be specified in the element
                                 "className");
        digester.addSetProperties(prefix + "Engine/Cluster");
        digester.addSetNext(prefix + "Engine/Cluster",
                            "setCluster",
                            "org.apache.catalina.Cluster");
        digester.addObjectCreate(prefix + "Engine/Listener",
                                 null, // MUST be specified in the element
                                 "className");
        digester.addSetProperties(prefix + "Engine/Listener");
        digester.addSetNext(prefix + "Engine/Listener",
                            "addLifecycleListener",
                            "org.apache.catalina.LifecycleListener");
        digester.addRuleSet(new RealmRuleSet(prefix + "Engine/"));
        digester.addObjectCreate(prefix + "Engine/Valve",
                                 null, // MUST be specified in the element
                                 "className");
        digester.addSetProperties(prefix + "Engine/Valve");
        digester.addSetNext(prefix + "Engine/Valve",
                            "addValve",
                            "org.apache.catalina.Valve");

    }

可以看到原理和上面都是一样的，只不过这里是批量添加规则。

2. 现在了解了digester的解析规则之后我们在回过头来看createStartDigester方法：

protected Digester createStartDigester() {
        digester.addObjectCreate("Server",
                                 "org.apache.catalina.core.StandardServer",
                                 "className"); //解析server节点，创建standardserver对象
        digester.addSetProperties("Server"); //因为这里面指定的属性名为空，所以实际什么都没做
        digester.addSetNext("Server",
                            "setServer",
                            "org.apache.catalina.Server"); //在Catalina.load()中在digester.parse()之前先压栈了catalina对象，所以这里获取的栈顶对象是刚压的server对象，栈顶下面的第一个是catalina对象，所以这里是调用catalina.setServer(server)。
        digester.addObjectCreate("Server/GlobalNamingResources",
                                 "org.apache.catalina.deploy.NamingResources"); //解析GlobalNamingResources节点，创建NamingResources对象
        digester.addSetProperties("Server/GlobalNamingResources");//什么都不做
        digester.addSetNext("Server/GlobalNamingResources",
                            "setGlobalNamingResources",
                            "org.apache.catalina.deploy.NamingResources"); //根据xml结构，此时的栈顶是standardserver，这是这里是调用standardserver.setGlobalNamingResources()。
        digester.addObjectCreate("Server/Listener",
                                 null, // MUST be specified in the element
                                 "className"); //解析Listener节点，因为这里没有个默认的className，所以这个节点必须指定className属性。
        digester.addSetProperties("Server/Listener");
        digester.addSetNext("Server/Listener",
                            "addLifecycleListener",
                            "org.apache.catalina.LifecycleListener"); //同理调用StandardServer.addLifecycleListener()，添加server的生命周期监听
        digester.addObjectCreate("Server/Service",
                                 "org.apache.catalina.core.StandardService",
                                 "className"); //解析Service节点，创建StandardService对象。
        digester.addSetProperties("Server/Service");
        digester.addSetNext("Server/Service",
                            "addService",
                            "org.apache.catalina.Service"); //StandardServer.addService()
        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"); //standardservice.addLifecycleListener()，添加service的生命周期监听
        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");
        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/"));
        addClusterRuleSet(digester, "Server/Service/Engine/Host/Cluster/");
        digester.addRuleSet(new NamingRuleSet("Server/Service/Engine/Host/Context/"));
        digester.addRule("Server/Service/Engine",
                         new SetParentClassLoaderRule(parentClassLoader)); //设置Engine的parentClassLoader为catalina的parentClassLoader，也就是tomcat启动的时候设置给catalina的sharedLoader
        addClusterRuleSet(digester, "Server/Service/Engine/Cluster/");
        return (digester);
    }

总结，从server.xml可以清楚的看到tomcat容器的结构和父子关系。而这个解析过程也是跟这个父子关系息息相关。在解析的过程中通过在digester里面进出栈来保证父子之间空间之间的联系。
1，Server，Service等节点解析规则中都有指定可以获取节点的className属性，也就是说我们如果不想用tomcat的StandardService等的话，可以自定义我们自己的Service，server等等，然后再相应的节点里面指定className属性为我们自定的类。
2，再解析的过程中通过各个父容器的addXXX()方法，使得父容器持有子容器的对象集合。
3，我们可以创建自己的LifecycleListener放在相应的节点里面来监听Server或者Service等的生命周期事件。
4，Engine的父类加载器被设置成了sharedLoader

枫林晚丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
app-service-4121.doc
08-30
app-servicee代码走读
tomcat源码解析(一)--启动与Server.xml文件的解析
樱落山庄
06-24 3347
后台大部分功能是用java来实现的，因此很有必要了解tomcat的底层实现。写下此文留做复习用吧。至于一些概念在一书《深入剖析tomcat》已经有很详细的分析了。 说明一下本文分析的tomcat的版本为8.5.2。开始： 首先找到org.apache.catalina.startup包下的Bootstrap类，它就是tomcat的启动类。找到main方法如下： public static v
Tomcat源码解读『server.xml解析』
卓立的博客
12-19 752
上篇文章我们介绍到，在Catalina的load方法中，完成了server.xml的解析，将server.xml配置的Server、Service、Connector、Engine、Host各组件实例化，并维护父子级关系。本篇文章我们来看一下server.xml是如何解析的。 不难看到，parseServerXml方法执行后，各Tomcat组件就已经生成了。 1. parseServerXml 核心的解析逻辑就在上图38~49行： Digester digester = start ? c
Tomcat源码分析——server.xml文件的解析
weixin_34363171的博客
03-17 116
前言 在《Tomcat源码分析——server.xml文件的加载》一文中我们介绍了server.xml的加载，本文基于Tomcat7.0的Java源码，接着对server.xml文件是如何解析的进行分析。 概要 规则 Tomcat将server.xml文件中的所有元素上的属性都抽象为Rule，以Server元素为例，在内存中对应Server实例，Serv...
Tomcat服务器Server.xml详解
热门推荐
七叔的博客
07-08 2万+
不从恶人的计谋，不站罪人的道路，不坐亵慢人的座位，惟喜爱耶和华的律法，昼夜思想，这人便为有福！他要像一棵树栽在溪水旁，按时候结果子，叶子也不枯干。凡他所做的尽都顺利。
Tomcat 7 启动分析（三）Digester 的使用
weixin_42073629的博客
10-26 402
前一篇文章里最后看到 Bootstrap 的 main 方法最后会调用 org.apache.catalina.startup.Catalina 对象的 load 和 start 两个方法，那么就来看看这两个方法里面到底做了些什么。 load 方法： 1 /** 2 * Start a new server instance. 3 */ 4 public void load() { 5 6 long t1 = System.n
Apache Spark源码走读之4 -- DStream实时流数据处理
01-06
Apache Spark源码走读之4 -- DStream实时流数据处理
法学专业-个人简历表格.doc
01-05
此外，他还拥有北京海淀走读大学计算机与电子技术专业的大专学历，对IT领域有深入的理解和技术基础。 【工作经历】 1. 北京永基华颜经贸有限公司（2004年至今） - 李先生在此担任法务经理，负责合同起草、审阅、...
Apache Spark源码走读之2 -- Job的提交与运行
01-06
Apache Spark源码走读之2 -- Job的提交与运行.pdf
互联网五位一体家校互动模式探析-互联网-计算机.pdf
最新发布
11-10
另外，不少学校，特别是走读制的普通中学，通过短信和微信方式，建立了与家长间的有效沟通机制。然而，这些传统的家校互动方式依然存在一些不足之处，例如家长方只能成为信息的被动接受者，而不能积极参与到教育活动...
Java读取和修改Tomcat的server.xml配置文件（多个service配置适用）
qq_36811160的博客
05-18 1117
1、读取工具类 public static Document getXMLAttribute(String filepath, String nodeName){ Document document = null; List<Map<String,String>> retListmap = new ArrayList<>(); try { //创建解析器 SAXReader r
tomcat服务器的Server.xml配置详解
编程界的一名小学生
09-10 2万+
tomcat是一个开源的轻量级WEB应用服务器 Server.xml是tomcat一个重要的配置文件，下面结合网上看到的和自己使用经验来做的总结，有什么不对的希望各位大佬明确指出，小弟不胜感激。 server.xml实例： 一： 1、最外层是<server></server>元素，<server>元素是server.xml的根元素，其属性shutdo...
tomcat解析(十四)web.xml解析
holly2k的专栏
02-02 1922
对于web.xml文件的解析所使用的Rule为WebRuleSet类,查看其addRuleInstances可得知其设置的具体Rule内容,如下:     /** * Add the set of Rule instances defined in this RuleSet to the * specified Digester instance, associating t
Tomcat7启动分析（三）Digester的使用
预流
07-23 167
前一篇文章里最后看到Bootstrap的main方法最后会调用org.apache.catalina.startup.Catalina对象的load和start两个方法，那么就来看看这两个方法里面到底做了些什么。   load方法： /** * Start a new server instance. */ public void load() ...
tomcat源码浅析（二）之server.xml的解析
烈冬冰夏的博客
04-01 430
server.xml的解析是使用Digester来解析的，Digester的详细规则如下： Catalina.createstartdigester代码 protected Digester createStartDigester() {          long t1=System.currentTimeMillis();          // Initialize t
tomcat源码解析（三）——Digester类源码解析及Rule分析
gh-0_0的博客
07-24 3609
在这篇文章中主要针对tomcat源码中Rule部分的解析；这部分功能主要涉及server.xml文件加载和tomcat容器中个组件初始化的过程，而且对于新手程序员来说理解过程较为复杂。在我之前的文章中《tomcat源码解析（一）——Bootstrap和Catalina启动部分》和《tomcat源码解析（二）——xml解析过程分析》分别对启动过程和xml解析进行了分析。 之前的文章中遗留了几个问题
tomcat解析(八)Catalina.createStartDigester
holly2k的专栏
01-26 2476
在tomcat解析(四)中我们讲到了Catalina的load及start方法启动及准备整个tomcat服务器，而这两个方法最终又将该任务交由server的initialize及start方法处理，该变更将引用Server类的实例，但初始化时为空，因此我们需要该对象实例化过程，而该过程尽在Catalina.load方法的第三步骤里(可看tomcat解析四).首先我们需要了解一下其中的createS
“万物本源”之Tomcat启动源码分析（前传）
weixin_33860553的博客
09-30 161
为什么80%的码农都做不了架构师？>>> ...
java高级开发--反射详解
Sandm_Wzm的博客
05-21 277
实例化对象： 通过类的构造方法实例化对象（正向） 获取Class : 通过实例化对象获取创建该对象的类（反向） Object 类中 getClass() 返回一个Class类型的对象 Class : 类型 类： 现实事物的抽象 对象： 现实的具体事物（你所关注的事物对象） 一丶三种实例化对象 1丶通过构造方法实例化对象 2丶通过反射创建类的实例化对象 类的Class对象的n...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值