亚洲免费在线-亚洲免费在线播放-亚洲免费在线观看-亚洲免费在线观看视频-亚洲免费在线看-亚洲免费在线视频

How Tomcat Works(九)

系統 1899 0

本文接下來描述servlet容器是怎樣管理其相關組件的生命周期的,首先本人描述一下事件監聽模式,也可以稱為觀察者模式,該模式分為以下角色

即抽象主題角色 具體主題角色 抽象觀察者角色及具體觀察者角色,通常在主題角色里面維持一個觀察者角色的聚集,并定義了對觀察者角色的添加和刪除方法;在主題角色事件發生時,通過迭代向這些觀察者角色發布事件。

在tomcat容器中,管理其相關組件的生命周期即是基于事件監聽模式實現的,相關接口和類為org.apache.catalina.Lifecycle接口、org.apache.catalina.LifecycleListener接口、org.apache.catalina.LifecycleEvent類

org.apache.catalina.Lifecycle接口定義如下

      
        public
      
      
        interface
      
      
         Lifecycle {
    
      
      
        public
      
      
        static
      
      
        final
      
       String START_EVENT = "start"
      
        ;
   
      
      
        public
      
      
        static
      
      
        final
      
       String BEFORE_START_EVENT = "before_start"
      
        ;
   
      
      
        public
      
      
        static
      
      
        final
      
       String AFTER_START_EVENT = "after_start"
      
        ;
   
      
      
        public
      
      
        static
      
      
        final
      
       String STOP_EVENT = "stop"
      
        ;
   
      
      
        public
      
      
        static
      
      
        final
      
       String BEFORE_STOP_EVENT = "before_stop"
      
        ;
   
      
      
        public
      
      
        static
      
      
        final
      
       String AFTER_STOP_EVENT = "after_stop"
      
        ;
    
      
      
        public
      
      
        void
      
      
         addLifecycleListener(LifecycleListener listener);
    
      
      
        public
      
      
         LifecycleListener[] findLifecycleListeners();
   
      
      
        public
      
      
        void
      
      
         removeLifecycleListener(LifecycleListener listener);
    
      
      
        public
      
      
        void
      
       start() 
      
        throws
      
      
         LifecycleException;
   
      
      
        public
      
      
        void
      
       stop() 
      
        throws
      
      
         LifecycleException;

}
      
    

上面的六個靜態字符串代表六種類型的事件,接著的三個方法addLifecycleListener()、 findLifecycleListeners()、removeLifecycleListener()為與事件監聽器相關的,最后的兩個方法start()和stop()為啟動與關閉操作,組件必須提供這兩種方法的實現,供其父組件調用。

org.apache.catalina.LifecycleEvent類用于傳遞事件及攜帶事件數據

      
        public
      
      
        final
      
      
        class
      
      
         LifecycleEvent
    
      
      
        extends
      
      
         EventObject {
   
      
      
        public
      
      
         LifecycleEvent(Lifecycle lifecycle, String type) {
        
      
      
        this
      
      (lifecycle, type, 
      
        null
      
      
        );
    }
   
      
      
        public
      
      
         LifecycleEvent(Lifecycle lifecycle, String type, Object data) {

        
      
      
        super
      
      
        (lifecycle);
        
      
      
        this
      
      .lifecycle =
      
         lifecycle;
        
      
      
        this
      
      .type =
      
         type;
        
      
      
        this
      
      .data =
      
         data;
    }
   
      
      
        private
      
       Object data = 
      
        null
      
      
        ;
   
      
      
        private
      
       Lifecycle lifecycle = 
      
        null
      
      
        ;
   
      
      
        private
      
       String type = 
      
        null
      
      
        ;
   
      
      
        public
      
      
         Object getData() {
        
      
      
        return
      
       (
      
        this
      
      
        .data);
    }
    
      
      
        public
      
      
         Lifecycle getLifecycle() {
        
      
      
        return
      
       (
      
        this
      
      
        .lifecycle);
    }
   
      
      
        public
      
      
         String getType() {
        
      
      
        return
      
       (
      
        this
      
      
        .type);
    }
}
      
    

org.apache.catalina.LifecycleListener為監聽器接口

      
        public
      
      
        interface
      
      
         LifecycleListener {


    
      
      
        /**
      
      
        
     * Acknowledge the occurrence of the specified event.
     *
     * 
      
      
        @param
      
      
         event LifecycleEvent that has occurred
     
      
      
        */
      
      
        public
      
      
        void
      
      
         lifecycleEvent(LifecycleEvent event);


}
      
    

通常實現了Lifecycle接口并且對某個事件注冊了監聽器的組件必須提供 Lifecycle接口中三個與監聽器相關方法(分別為addLifecycleListener()、 findLifecycleListeners()、removeLifecycleListener())的實現,然后該組件需要將所有注冊的監聽器存儲到數組、ArrayList或者其他類似的對象中;tomcat容器提供了一個工具類org.apache.catalina.util.LifecycleSupport來幫助組件管理監聽器,并觸發相應的生命周期事件。

      
        public
      
      
        final
      
      
        class
      
      
         LifecycleSupport {
   
      
      
        public
      
      
         LifecycleSupport(Lifecycle lifecycle) {

        
      
      
        super
      
      
        ();
        
      
      
        this
      
      .lifecycle =
      
         lifecycle;

    }
   
      
      
        private
      
       Lifecycle lifecycle = 
      
        null
      
      
        ;
    
      
      
        private
      
       LifecycleListener listeners[] = 
      
        new
      
       LifecycleListener[0
      
        ];
    
      
      
        public
      
      
        void
      
      
         addLifecycleListener(LifecycleListener listener) {

      
      
      
        synchronized
      
      
         (listeners) {
          LifecycleListener results[] 
      
      =
            
      
        new
      
       LifecycleListener[listeners.length + 1
      
        ];
          
      
      
        for
      
       (
      
        int
      
       i = 0; i < listeners.length; i++
      
        )
              results[i] 
      
      =
      
         listeners[i];
          results[listeners.length] 
      
      =
      
         listener;
          listeners 
      
      =
      
         results;
      }

    }
   
      
      
        public
      
      
         LifecycleListener[] findLifecycleListeners() {

        
      
      
        return
      
      
         listeners;

    }
   
      
      
        public
      
      
        void
      
      
         fireLifecycleEvent(String type, Object data) {

        LifecycleEvent event 
      
      = 
      
        new
      
      
         LifecycleEvent(lifecycle, type, data);
        LifecycleListener interested[] 
      
      = 
      
        null
      
      
        ;
        
      
      
        synchronized
      
      
         (listeners) {
            interested 
      
      =
      
         (LifecycleListener[]) listeners.clone();
        }
        
      
      
        for
      
       (
      
        int
      
       i = 0; i < interested.length; i++
      
        )
            interested[i].lifecycleEvent(event);

    }
    
      
      
        public
      
      
        void
      
      
         removeLifecycleListener(LifecycleListener listener) {

        
      
      
        synchronized
      
      
         (listeners) {
            
      
      
        int
      
       n = -1
      
        ;
            
      
      
        for
      
       (
      
        int
      
       i = 0; i < listeners.length; i++
      
        ) {
                
      
      
        if
      
       (listeners[i] ==
      
         listener) {
                    n 
      
      =
      
         i;
                    
      
      
        break
      
      
        ;
                }
            }
            
      
      
        if
      
       (n < 0
      
        )
                
      
      
        return
      
      
        ;
            LifecycleListener results[] 
      
      =
              
      
        new
      
       LifecycleListener[listeners.length - 1
      
        ];
            
      
      
        int
      
       j = 0
      
        ;
            
      
      
        for
      
       (
      
        int
      
       i = 0; i < listeners.length; i++
      
        ) {
                
      
      
        if
      
       (i !=
      
         n)
                    results[j
      
      ++] =
      
         listeners[i];
            }
            listeners 
      
      =
      
         results;
        }
    }
}
      
    

下面我們來看Context容器(SimpleContext實例)是怎么實現生命周期管理及觸發監聽器事件的,關鍵代碼如下

      
        public
      
      
        class
      
       SimpleContext 
      
        implements
      
      
         Context, Pipeline, Lifecycle {


      
      
        protected
      
       LifecycleSupport lifecycle = 
      
        new
      
       LifecycleSupport(
      
        this
      
      
        );


      
      
        //
      
      
         implementation of the Lifecycle interface's methods
      
      
        public
      
      
        void
      
      
         addLifecycleListener(LifecycleListener listener) {
    lifecycle.addLifecycleListener(listener);
  }

  
      
      
        public
      
      
         LifecycleListener[] findLifecycleListeners() {
    
      
      
        return
      
      
        null
      
      
        ;
  }

  
      
      
        public
      
      
        void
      
      
         removeLifecycleListener(LifecycleListener listener) {
    lifecycle.removeLifecycleListener(listener);
  }

  
      
      
        public
      
      
        synchronized
      
      
        void
      
       start() 
      
        throws
      
      
         LifecycleException {
    
      
      
        if
      
      
         (started)
      
      
      
        throw
      
      
        new
      
       LifecycleException("SimpleContext has already started"
      
        );

    
      
      
        //
      
      
         Notify our interested LifecycleListeners
      
      
    lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, 
      
        null
      
      
        );
    started 
      
      = 
      
        true
      
      
        ;
    
      
      
        try
      
      
         {
      
      
      
        //
      
      
         Start our subordinate components, if any
      
      
        if
      
       ((loader != 
      
        null
      
      ) && (loader 
      
        instanceof
      
      
         Lifecycle))
        ((Lifecycle) loader).start();

      
      
      
        //
      
      
         Start our child containers, if any
      
      
      Container children[] =
      
         findChildren();
      
      
      
        for
      
       (
      
        int
      
       i = 0; i < children.length; i++
      
        ) {
        
      
      
        if
      
       (children[i] 
      
        instanceof
      
      
         Lifecycle)
          ((Lifecycle) children[i]).start();
      }

      
      
      
        //
      
      
         Start the Valves in our pipeline (including the basic),
      
      
      
        //
      
      
         if any
      
      
        if
      
       (pipeline 
      
        instanceof
      
      
         Lifecycle)
        ((Lifecycle) pipeline).start();
      
      
      
        //
      
      
         Notify our interested LifecycleListeners
      
      
      lifecycle.fireLifecycleEvent(START_EVENT, 
      
        null
      
      
        );
    }
    
      
      
        catch
      
      
         (Exception e) {
      e.printStackTrace();
    }

    
      
      
        //
      
      
         Notify our interested LifecycleListeners
      
      
    lifecycle.fireLifecycleEvent(AFTER_START_EVENT, 
      
        null
      
      
        );
  }

  
      
      
        public
      
      
        void
      
       stop() 
      
        throws
      
      
         LifecycleException {
    
      
      
        if
      
       (!
      
        started)
      
      
      
        throw
      
      
        new
      
       LifecycleException("SimpleContext has not been started"
      
        );
    
      
      
        //
      
      
         Notify our interested LifecycleListeners
      
      
    lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, 
      
        null
      
      
        );
    lifecycle.fireLifecycleEvent(STOP_EVENT, 
      
      
        null
      
      
        );
    started 
      
      = 
      
        false
      
      
        ;
    
      
      
        try
      
      
         {
      
      
      
        //
      
      
         Stop the Valves in our pipeline (including the basic), if any
      
      
        if
      
       (pipeline 
      
        instanceof
      
      
         Lifecycle) {
        ((Lifecycle) pipeline).stop();
      }

      
      
      
        //
      
      
         Stop our child containers, if any
      
      
      Container children[] =
      
         findChildren();
      
      
      
        for
      
       (
      
        int
      
       i = 0; i < children.length; i++
      
        ) {
        
      
      
        if
      
       (children[i] 
      
        instanceof
      
      
         Lifecycle)
          ((Lifecycle) children[i]).stop();
      }
      
      
      
        if
      
       ((loader != 
      
        null
      
      ) && (loader 
      
        instanceof
      
      
         Lifecycle)) {
        ((Lifecycle) loader).stop();
      }
    }
    
      
      
        catch
      
      
         (Exception e) {
      e.printStackTrace();
    }
    
      
      
        //
      
      
         Notify our interested LifecycleListeners
      
      
    lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, 
      
        null
      
      
        );
  }
}
      
    

Context容器實例持有對LifecycleSupport lifecycle = new LifecycleSupport(this)的引用,與事件監聽器相關方法均為操作該實例的相應方法

在其與生命周期相關方法start()和stop()方法里面,分別調用相關組件的生命周期方法,并采用LifecycleSupport lifecycle引用發布事件

一個簡單的監聽器實現如下:

      
        public
      
      
        class
      
       SimpleContextLifecycleListener 
      
        implements
      
      
         LifecycleListener {

  
      
      
        public
      
      
        void
      
      
         lifecycleEvent(LifecycleEvent event) {
    Lifecycle lifecycle 
      
      =
      
         event.getLifecycle();
    System.out.println(
      
      "SimpleContextLifecycleListener's event " +
      
        
      event.getType().toString());
    
      
      
        if
      
      
         (Lifecycle.START_EVENT.equals(event.getType())) {
      System.out.println(
      
      "Starting context."
      
        );
    }
    
      
      
        else
      
      
        if
      
      
         (Lifecycle.STOP_EVENT.equals(event.getType())) {
      System.out.println(
      
      "Stopping context."
      
        );
    }
  }
}
      
    

子容器wrapper實例(SimpleWrapper),同樣實現了Lifecycle接口,其相關實現與Context容器類似

      
        public
      
      
        class
      
       SimpleWrapper 
      
        implements
      
      
         Wrapper, Pipeline, Lifecycle {


      
      
        protected
      
       LifecycleSupport lifecycle = 
      
        new
      
       LifecycleSupport(
      
        this
      
      
        );


      
      
        //
      
      
         implementation of the Lifecycle interface's methods
      
      
        public
      
      
        void
      
      
         addLifecycleListener(LifecycleListener listener) {
  }

  
      
      
        public
      
      
         LifecycleListener[] findLifecycleListeners() {
    
      
      
        return
      
      
        null
      
      
        ;
  }

  
      
      
        public
      
      
        void
      
      
         removeLifecycleListener(LifecycleListener listener) {
  }

  
      
      
        public
      
      
        synchronized
      
      
        void
      
       start() 
      
        throws
      
      
         LifecycleException {
    System.out.println(
      
      "Starting Wrapper " +
      
         name);
    
      
      
        if
      
      
         (started)
      
      
      
        throw
      
      
        new
      
       LifecycleException("Wrapper already started"
      
        );

    
      
      
        //
      
      
         Notify our interested LifecycleListeners
      
      
    lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, 
      
        null
      
      
        );
    started 
      
      = 
      
        true
      
      
        ;

    
      
      
        //
      
      
         Start our subordinate components, if any
      
      
        if
      
       ((loader != 
      
        null
      
      ) && (loader 
      
        instanceof
      
      
         Lifecycle))
      ((Lifecycle) loader).start();

    
      
      
        //
      
      
         Start the Valves in our pipeline (including the basic), if any
      
      
        if
      
       (pipeline 
      
        instanceof
      
      
         Lifecycle)
      ((Lifecycle) pipeline).start();

    
      
      
        //
      
      
         Notify our interested LifecycleListeners
      
      
    lifecycle.fireLifecycleEvent(START_EVENT, 
      
        null
      
      
        );
    
      
      
        //
      
      
         Notify our interested LifecycleListeners
      
      
    lifecycle.fireLifecycleEvent(AFTER_START_EVENT, 
      
        null
      
      
        );
  }

  
      
      
        public
      
      
        void
      
       stop() 
      
        throws
      
      
         LifecycleException {
    System.out.println(
      
      "Stopping wrapper " +
      
         name);
    
      
      
        //
      
      
         Shut down our servlet instance (if it has been initialized)
      
      
        try
      
      
         {
      instance.destroy();
    }
    
      
      
        catch
      
      
         (Throwable t) {
    }
    instance 
      
      = 
      
        null
      
      
        ;
    
      
      
        if
      
       (!
      
        started)
      
      
      
        throw
      
      
        new
      
       LifecycleException("Wrapper " + name + " not started"
      
        );
    
      
      
        //
      
      
         Notify our interested LifecycleListeners
      
      
    lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, 
      
        null
      
      
        );

    
      
      
        //
      
      
         Notify our interested LifecycleListeners
      
      
    lifecycle.fireLifecycleEvent(STOP_EVENT, 
      
        null
      
      
        );
    started 
      
      = 
      
        false
      
      
        ;

    
      
      
        //
      
      
         Stop the Valves in our pipeline (including the basic), if any
      
      
        if
      
       (pipeline 
      
        instanceof
      
      
         Lifecycle) {
      ((Lifecycle) pipeline).stop();
    }

    
      
      
        //
      
      
         Stop our subordinate components, if any
      
      
        if
      
       ((loader != 
      
        null
      
      ) && (loader 
      
        instanceof
      
      
         Lifecycle)) {
      ((Lifecycle) loader).stop();
    }

    
      
      
        //
      
      
         Notify our interested LifecycleListeners
      
      
    lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, 
      
        null
      
      
        );
  }
}
      
    

其他相關組件的相關實現不再贅述

---------------------------------------------------------------------------?

本系列How Tomcat Works系本人原創?

轉載請注明出處 博客園 刺猬的溫馴?

本人郵箱: ? chenying998179 # 163.com ( #改為@

本文鏈接 http://www.cnblogs.com/chenying99/p/3235736.html

How Tomcat Works(九)


更多文章、技術交流、商務合作、聯系博主

微信掃碼或搜索:z360901061

微信掃一掃加我為好友

QQ號聯系: 360901061

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧,狠狠點擊下面給點支持吧,站長非常感激您!手機微信長按不能支付解決辦法:請將微信支付二維碼保存到相冊,切換到微信,然后點擊微信右上角掃一掃功能,選擇支付二維碼完成支付。

【本文對您有幫助就好】

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描上面二維碼支持博主2元、5元、10元、自定義金額等您想捐的金額吧,站長會非常 感謝您的哦!!!

發表我的評論
最新評論 總共0條評論
主站蜘蛛池模板: 久久国产香蕉一区精品 | 日韩一区二区三区四区 | 久久精品一区二区三区不卡 | 国内精品久久久久久影院8f | julia紧身裙中文字幕在线看 | 久久精品中文字幕免费 | 精品在线视频播放 | 国产福利免费观看 | 亚洲欧美一区二区三区在线播放 | 欧美三级在线观看不卡视频 | 伊人久久波多野结衣中文字幕 | 欧美中文字幕一区 | 欧美日韩一区在线观看 | 国产午夜免费 | 99精品国产成人一区二区在线 | 伊人色强在线网 | 97视频在线观看播放 | 狠狠色狠狠色综合婷婷tag | 国产色婷婷免费视频 | 国产精品视频久久久久 | 成人18免费网 | 亚洲国产精品久久日 | 天天色色网| 成人私人影院在线观看网址 | 成人午夜私人影院入口 | 天天射天天怕 | 欧美日视频 | 爱爱免费网站 | a级黄片毛片 | 最近在线更新中文字幕1 | 亚洲成在人线影视天堂网 | 91精品国产高清久久久久 | 高清欧美色欧美综合网站 | 精品特级一级毛片免费观看 | 四虎2020| 99国产精品久久久久久久成人热 | 激情开心婷婷 | 日韩精品午夜视频一区二区三区 | 亚洲国产成人在线视频 | 伊人色综合网一区二区三区 | 福利视频久久 |