[Tomcat6.0源码]组件的实例化

最新推荐文章于 2023-03-21 13:48:10 发布
最新推荐文章于 2023-03-21 13:48:10 发布
阅读量595 收藏
点赞数
文章标签： service server report null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woorh/article/details/7951728
版权

一、Server和Service的实例化

Catalina.createStartDigester();中Server对象的创建。

digester.addObjectCreate("Server",
                         "org.apache.catalina.core.StandardServer",
                         "className");
digester.addSetProperties("Server");
digester.addSetNext("Server",
                    "setServer",
                    "org.apache.catalina.Server");

Catalina类继承自Embedded，而Embedded  extends StandardService implements Lifecycle

调用Catalina的setServer方法其实是调用StandardService的setServer

    public void setServer(Server server) {

        this.server = server;

    }

Server对象的创建没什么悬念。看看Service对象：

    digester.addObjectCreate("Server/Service",
                             "org.apache.catalina.core.StandardService",
                             "className");
    digester.addSetProperties("Server/Service");
    digester.addSetNext("Server/Service",
                        "addService",
                        "org.apache.catalina.Service");

StandardService对象创建后，会调用StandardServer的addService方法：

    public void addService(Service service) {

        service.setServer(this);

        synchronized (services) {
            Service results[] = new Service[services.length + 1];
            System.arraycopy(services, 0, results, 0, services.length);
            results[services.length] = service;
            services = results;

            if (initialized) {
                try {
                    service.initialize();
                } catch (LifecycleException e) {
                    log.error(e);
                }
            }

            if (started && (service instanceof Lifecycle)) {
                try {
                    ((Lifecycle) service).start();
                } catch (LifecycleException e) {
                    ;
                }
            }

            // Report this property change to interested listeners
            support.firePropertyChange("service", null, service);
        }

    }

StandardService先关联上StandardServer，然后把它加到StandardServer的service数组，这样就相互关联了。

如果已经初始化，则这个StandardService执行初始化，如果已经启动，也要启动。现在我们还在创建对象的阶段，初始化和启动都不会执行。

二、Connector的实例化

Catalina.createStartDigester();Connector对象的创建规则：

        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");

解析到<Connector>节点时，Digester会调用ConnectorCreateRule的begin方法，传入的参数是节点的属性。

    public void begin(Attributes attributes) throws Exception {
        Service svc = (Service)digester.peek();
        Executor ex = null;
        if ( attributes.getValue("executor")!=null ) {
            ex = svc.getExecutor(attributes.getValue("executor"));
        }
        Connector con = new Connector(attributes.getValue("protocol"));
        if ( ex != null )  _setExecutor(con,ex);
        
        digester.push(con);
    }

至于创建什么样的Connector，要看属性protocol的值。server.xml默认有两个Connector，一个端口8080，protocol="HTTP/1.1"，另一个端口8009，protocol="AJP/1.3"。8080大家都知道，据说后者多用于集群。
Connector的构造方法：

    public Connector(String protocol)
        throws Exception {
        setProtocol(protocol);
        // Instantiate protocol handler
        try {
            Class clazz = Class.forName(protocolHandlerClassName);
            this.protocolHandler = (ProtocolHandler) clazz.newInstance();
        } catch (Exception e) {
            log.error
                (sm.getString
                 ("coyoteConnector.protocolHandlerInstantiationFailed", e));
        }
    }

setProtocol方法，主要为了设置protocalHandlerClassName的值。接着再创建对象。

    public void setProtocol(String protocol) {

        if (AprLifecycleListener.isAprAvailable()) {
            if ("HTTP/1.1".equals(protocol)) {
                setProtocolHandlerClassName
                    ("org.apache.coyote.http11.Http11AprProtocol");
            } else if ("AJP/1.3".equals(protocol)) {
                setProtocolHandlerClassName
                    ("org.apache.coyote.ajp.AjpAprProtocol");
            } else if (protocol != null) {
                setProtocolHandlerClassName(protocol);
            } else {
                setProtocolHandlerClassName
                    ("org.apache.coyote.http11.Http11AprProtocol");
            }
        } else {
            if ("HTTP/1.1".equals(protocol)) {
                setProtocolHandlerClassName
                    ("org.apache.coyote.http11.Http11Protocol");
            } else if ("AJP/1.3".equals(protocol)) {
                setProtocolHandlerClassName
                    ("org.apache.jk.server.JkCoyoteHandler");
            } else if (protocol != null) {
                setProtocolHandlerClassName(protocol);
            }
        }

    }

AprLifecycleListener未被实例化过，会执行else块中的语句。

protocal="HTTP/1.1"的Connector会创建Http11Protocol对象赋值给protocolHandler属性。 

回到StandardService.addConnector()上来：

    public void addConnector(Connector connector) {

        synchronized (connectors) {
            connector.setContainer(this.container);
            connector.setService(this);
            Connector results[] = new Connector[connectors.length + 1];
            System.arraycopy(connectors, 0, results, 0, connectors.length);
            results[connectors.length] = connector;
            connectors = results;

            if (initialized) {
                try {
                    connector.initialize();
                } catch (LifecycleException e) {
                    log.error(sm.getString(
                            "standardService.connector.initFailed",
                            connector), e);
                }
            }

            if (started && (connector instanceof Lifecycle)) {
                try {
                    ((Lifecycle) connector).start();
                } catch (LifecycleException e) {
                    log.error(sm.getString(
                            "standardService.connector.startFailed",
                            connector), e);
                }
            }

            // Report this property change to interested listeners
            support.firePropertyChange("connector", null, connector);
        }

    }

Connector要关联StandardService的container，这个container其实是StandardEngine对象。关联StandardService后，将添加到StandardService的connectors数组中。

三、Engine的实例化

Catalina.createStartDigester()配置Engine的规则:

digester.addRuleSet(new EngineRuleSet("Server/Service/"));

digester.addRuleSet():

    public void addRuleSet(RuleSet ruleSet) {

        String oldNamespaceURI = getRuleNamespaceURI();
        String newNamespaceURI = ruleSet.getNamespaceURI();
        if (log.isDebugEnabled()) {
            if (newNamespaceURI == null) {
                log.debug("addRuleSet() with no namespace URI");
            } else {
                log.debug("addRuleSet() with namespace URI " + newNamespaceURI);
            }
        }
        setRuleNamespaceURI(newNamespaceURI);
        ruleSet.addRuleInstances(this);
        setRuleNamespaceURI(oldNamespaceURI);

    }

这里会调用EngineRuleSet的addRuleInstances()方法进行配置规则，这种折腾来折腾去的设计一般都能称得上设计模式，具体是哪种，待学。

EngineRuleSet.addRuleInstances():

    public void addRuleInstances(Digester digester) {
        
        digester.addObjectCreate(prefix + "Engine",
                                 "org.apache.catalina.core.StandardEngine",
                                 "className");
        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");

        //Cluster configuration start
        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");
        //Cluster configuration end

        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");

    }

StandardEngine对象出栈的时候，当做StandardService.setContainer()的参数进行赋值，即StandardService的container保存的是StandardEngine对象：

   /**
     * The Container associated with this Service. (In the case of the
     * org.apache.catalina.startup.Embedded subclass, this holds the most
     * recently added Engine.)
     */
    protected Container container = null;

四、Host的实例化

Catalina.createStartDigester()配置Host的规则:

digester.addRuleSet(new HostRuleSet("Server/Service/Engine/"));

addRuleSet实际上会调用HostRuleSet.addRuleInstances()进行配置rule:

    public void addRuleInstances(Digester digester) {

        digester.addObjectCreate(prefix + "Host",
                                 "org.apache.catalina.core.StandardHost",
                                 "className");
        digester.addSetProperties(prefix + "Host");
        digester.addRule(prefix + "Host",
                         new CopyParentClassLoaderRule());
        digester.addRule(prefix + "Host",
                         new LifecycleListenerRule
                         ("org.apache.catalina.startup.HostConfig",
                          "hostConfigClass"));
        digester.addSetNext(prefix + "Host",
                            "addChild",
                            "org.apache.catalina.Container");

        digester.addCallMethod(prefix + "Host/Alias",
                               "addAlias", 0);

        //Cluster configuration start
        digester.addObjectCreate(prefix + "Host/Cluster",
                                 null, // MUST be specified in the element
                                 "className");
        digester.addSetProperties(prefix + "Host/Cluster");
        digester.addSetNext(prefix + "Host/Cluster",
                            "setCluster",
                            "org.apache.catalina.Cluster");
        //Cluster configuration end

        digester.addObjectCreate(prefix + "Host/Listener",
                                 null, // MUST be specified in the element
                                 "className");
        digester.addSetProperties(prefix + "Host/Listener");
        digester.addSetNext(prefix + "Host/Listener",
                            "addLifecycleListener",
                            "org.apache.catalina.LifecycleListener");

        digester.addRuleSet(new RealmRuleSet(prefix + "Host/"));

        digester.addObjectCreate(prefix + "Host/Valve",
                                 null, // MUST be specified in the element
                                 "className");
        digester.addSetProperties(prefix + "Host/Valve");
        digester.addSetNext(prefix + "Host/Valve",
                            "addValve",
                            "org.apache.catalina.Valve");

    }

1.给Host对象加了一个HostConfig的监听器，到时候调用StandardHost.start()的时候也会调用HostConfig.start()。而HostConfig.start()则会去启动所有部署在tomcat上的项目，这是后话。

2.Host对象出栈的时候是调用StandardEngine的addChild方法进行处理的：

    public void addChild(Container child) {

        if (!(child instanceof Host))
            throw new IllegalArgumentException
                (sm.getString("standardEngine.notHost"));
        super.addChild(child);

    }

继续调用父类ContainerBase的addChild方法：

    public void addChild(Container child) {
        if (Globals.IS_SECURITY_ENABLED) {
            PrivilegedAction dp =
                new PrivilegedAddChild(child);
            AccessController.doPrivileged(dp);
        } else {
            addChildInternal(child);
        }
    }

addChildInternal(child):

    private void addChildInternal(Container child) {

        if( log.isDebugEnabled() )
            log.debug("Add child " + child + " " + this);
        synchronized(children) {
            if (children.get(child.getName()) != null)
                throw new IllegalArgumentException("addChild:  Child name '" +
                                                   child.getName() +
                                                   "' is not unique");
            child.setParent(this);  // May throw IAE
            children.put(child.getName(), child);

            // Start child
            if (started && startChildren && (child instanceof Lifecycle)) {
                boolean success = false;
                try {
                    ((Lifecycle) child).start();
                    success = true;
                } catch (LifecycleException e) {
                    log.error("ContainerBase.addChild: start: ", e);
                    throw new IllegalStateException
                        ("ContainerBase.addChild: start: " + e);
                } finally {
                    if (!success) {
                        children.remove(child.getName());
                    }
                }
            }

            fireContainerEvent(ADD_CHILD_EVENT, child);
        }

    }

ContainerBase.children是HashMap：

    /**
     * The child Containers belonging to this Container, keyed by name.
     */
    protected HashMap children = new HashMap();

StandardHost和StandardEngine相互关联，多对一的关系。
如果conf/server.xml有Context节点，实例化过程与Host类似。StandardContext和StandardHost也是多对一的关系。

Server（1-N）Service（1-1）Engine（1-N）Host（1-N）Context（1-N）。

                                               Connector（1-N）        

woorh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Vue2 中组件的本质、组件的实例化、组件实例的挂载
f18855666661的博客
10-11 1971
这篇博客的内容是讲讲在 Vue2 中，组件在底层的本质。在这里，直接抛出结论：组件的本质就是一个个的构造函数，这些函数以组件的定义 options 对象为参数，在 Vue2 中，最顶级的组件就是我们从 vue.js 中导入的 Vue 函数，而子组件是 Vue 底层通过 extend 函数创建出来的 VueComponent 函数。通过 new 这些组件的构造函数，我们可以创建出组件实例。
VUE源码分析之子组件实例化过程
liubangbo的专栏
09-18 1221
还是先上一个简单的例子，我们用例子来分析： <script src="./vue.js"></script> <div id="app"> <child-comp :parent-msg = "'here is parent msg'"> </child-comp> </div&gt...
Vue组件化开发实例
最新发布
m0_67587581的博客
03-21 208
例如我们需要实现一个10*10的图片表格，使用常规形式，我们则需要写100个img，工作量十分巨大，。Vue可以进行组件化开发，组件是Vue的基本结构单元，开发过程中只需要按照Vue规范定义组件，将组件渲染到页面即可。组件可以提高代码的复用性。
关于组件实例化生命周期
stone5的专栏
05-28 498
关于组件实例化生命周期描述执行的序列步骤，当你从一个组件类创建一个组件时。作为生命周期的一部分，Flex自动调用组件方法，分发事件，使组件可视。下例是在AS中创建一个按钮并增加到一个容器中：1.调用组件的构造函数，新建一个组件：// Create a Button control. var b:Button = new Button()2.通过设置它的属性，配置组件，如：// Configur
实例化一个新控件-html
chenyd9027的博客
06-23 762
int nrPixels = iSurf->w * iSurf->h; for(int i = 0; i int nrPixels = iSurf->w * iSurf->h; int nrPixels = iSurf->w * iSurf->h; for(int i = 0; i < nrPixels; i++) int
apache tomcat6.0 源代码
04-11
Apache Tomcat 6.0是Apache...通过研究Apache Tomcat 6.0的源代码，开发者能够理解Web服务器内部工作流程，提高故障排查能力，以及根据特定需求进行定制化开发。同时，这也是一种学习Java EE规范和最佳实践的有效方式。
两台服务器上做Apache2.2+Tomcat6.0+mod_jk的负载均衡
07-28
"两台服务器上做Apache2.2+Tomcat6.0+mod_jk的负载均衡"是一个典型的分布式系统架构，旨在通过在多台服务器之间分配工作负载来提高系统的稳定性和性能。下面将详细介绍这个配置涉及的知识点： 1. **Apache ...
tomcat源码
03-26
Tomcat6.0版本是历史上非常流行的一个版本，对于开发者来说，深入理解其源码有助于提升对Web服务运行机制、HTTP协议以及Java Servlet规范的理解。 1. **Tomcat架构** Tomcat的核心架构基于Catalina、Jasper、 ...
java6.0源码-JavaOperaLink:使用OperaLinkAPI检索用户快速拨号的简单servlet
06-04
Servlet在第一次请求时被实例化，然后处理多个请求，最后在Web应用停止时被销毁。 - HttpServlet是Servlet API中预定义的抽象类，提供了处理HTTP请求的基本方法，如`doGet()`和`doPost()`。 3. **OperaLink API**...
apache-tomcat-7.0.62-src和apache-tomcat-6.0.39-src的源码
10-15
通过对这两个版本源码的学习，你将能够深入理解Tomcat的工作原理，包括请求生命周期、会话管理、错误处理、国际化支持等方面。这对于Java EE开发者来说是一笔宝贵的财富，不仅可以帮助优化应用性能，还能提升问题...
关于组件实例化的生命周期
zhuegg的专栏
02-20 738
     组件实例化生命周期描述了用组件类创建组件对象时所发生的一系列步骤.作为生命周期的一部分,Flex 自动调用组件的方法,发出事件,并使组件可见。下面例子用ActionScript 创建一个Button 控件，并将其加入到容器之中：//创建一个Box 容器。var boxContainer:Box = new Box();//设置Box 容器…//创建Button 控件。var b:Butt
Vue 的组件化过程
longtengg1的博客
04-20 601
所谓组件化， 就是把⻚⾯拆分成多个组件 (component)， 每个组件依赖的 CSS、 JavaScript、 模板、 图⽚等资源放在⼀起开发和维护。 组件是资源独⽴的， 组件在系统内部可复⽤， 组件和组件之间可以嵌套。 ...
vue组件化知识
iceylia的博客
08-21 1000
vue笔记
Tomcat 6 启动过程分析 (4) - server 的初始化
JackyCheng2007
04-30 89
前面说了，Catalina在load方法中试用Digester来构建一个StandardServer （org.apache.catalina.core）。然后调用server.initialize();来初始化。那我们就分析一下这个方法。 public final class StandardServer implements Lifecycle, Server, MBeanRegis...
JQueryEasyUI 组件的实例化
寂寞的一只狗的博客
03-09 1055
1、 组件实例化方式有两种 通过class属性实例化组件。 通过javascript代码实例化组件。   需要先引用   提示： 下面的方法不能同时使用 会发生错误 1、通过class属性实例化组件编码规则 通过特定的HTML标签，添加class属性和data
面试官：Vue中组件和插件有什么区别？
weixin_44475093的博客
12-07 5156
一、组件是什么回顾一下对组件的定义：组件就是把图形、非图形的各种逻辑均抽象为一个统一的概念（组件）来实现开发的模式，在Vue中每一个.vue文件都可以视为一个组件组件的优势降低整个系统的...
tomcat源码研读笔记—tomcat的启动之三 StandardEngine的启动
plkkoko的专栏
03-21 1184
这一章节开始，我们进入了所谓的“容器”内部了，standardEngine启动的源码如下：   public void start() throws LifecycleException {       // Log our server identification information       System.out.println(ServerInfo.getServerInfo());...
高阶组件应用-组件重新实例化
neoveee的博客
06-01 1348
背景在参与beisenCloud和pageBuilder的对接任务中，出现了这样一个问题：有两个组件同时关联了同一个属性组件，并且在constructor和componentDidMount内等做了一些初始化操作，当在这两个组件之间切换的时候，由于属性组件已经被首次render了，所以只进行了diff算法，并没有重新生成一个新的组件实例，从而导致了属性组件没有同步更新方案当然，我们可以在属性组件内添
Tomcat 6.0虚拟目录配置与安全设置
"关于tomcat 6.0的配置以及连接池原理的介绍" 在Tomcat 6.0中配置虚拟目录是实现多应用部署的关键步骤。虚拟目录允许你将不同的Web应用程序映射到服务器的不同物理路径，使得用户可以通过一个统一的URL来访问这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值