ソースコード分析からTomcatがサーブレットの初期化を呼び出す方法の詳細な説明

Tomcat の tomcat = new Tomcat();
        ポート番号を8080に設定します。
        //コンテナの各レイヤーを新規作成し、コンテナの各レイヤー間の関係を維持します。tomcat.addWebapp("/","/");
        tomcatを起動します。
        //リスニングポートをブロックします tomcat.getServer().await();

 
    パブリックコンテキストaddWebapp(ホストhost、文字列contextPath、文字列docBase) {
        //リフレクションを通じてリスナーContextConfigを取得します。
        //リフレクションで取得したものは、LifecycleListener の実装クラスである必要があります。実装クラスを取得するには、getConfigClass と入力します (org.apache.catalina.startup.ContextConfig)
        ライフサイクルリスナーリスナー = null;
        試す {
            クラス<?> clazz = Class.forName(getHost().getConfigClass());
            リスナー = (LifecycleListener) clazz.getConstructor().newInstance();
        } キャッチ (ReflectiveOperationException e) {
            // メソッドシグネチャを簡単に変更できないため、IAEでラップします。
            // 特定のチェック例外をスローする
            新しい IllegalArgumentException(e) をスローします。
        }
 
        addWebapp(ホスト、contextPath、docBase、リスナー) を返します。
    }

パブリックコンテキストaddWebapp(ホストhost、文字列contextPath、文字列docBase、
            ライフサイクルリスナー設定) {
 
        沈黙(ホスト、コンテキストパス);
 
        //コンテキスト コンテナ (StandardContext) を取得します。
        コンテキスト ctx = createContext(host, contextPath);
        ctx.setPath(コンテキストパス);
        ctx.setDocBase(docBase);
 
        （WebアプリにDefaultWebXmlを追加する）{
            ctx.addLifecycleListener(getDefaultWebXmlListener());
        }
 
        ctx.setConfigFile(getWebappConfigFile(docBase, contextPath));
        //コンテキストにリスナーを追加します ctx.addLifecycleListener(config);
 
        if (addDefaultWebXmlToWebapp && (config instanceof ContextConfig)) {
            // 検索しないようにします (見つかった場合は重複エラーが発生します)
            ((ContextConfig) config).setDefaultWebXml(noDefaultWebXmlPath());
        }
 
        ホスト == null の場合 {
            //getHost はレイヤーごとにコンテナーを作成し、コンテナーの親子関係を維持します getHost().addChild(ctx);
        } それ以外 {
            ホストに子を追加します(ctx);
        }
 
        ctx を返します。
    }

  パブリックホストgetHost() {
        //各レイヤーに新しいコンテナを作成します。Engine engine = getEngine();
        （engine.findChildren().length>0）の場合{
            (ホスト) engine.findChildren()[0]を返します。
        }
 
        ホスト host = new StandardHost();
        ホスト名を設定します。
        //Tomcat 内の親子コンテナを維持します getEngine().addChild(host);
        ホストを返します。
    }

  @オーバーライド
    パブリック void addChild(コンテナの子) {
        (Globals.IS_SECURITY_ENABLED) の場合 {
            特権アクション<Void> dp =
                新しい PrivilegedAddChild(child);
            アクセスコントローラ.doPrivileged(dp);
        } それ以外 {
            //ここでの子パラメータはコンテキスト コンテナです addChildInternal(child);
        }
    }

 プライベートvoid addChildInternal(コンテナの子) {
 
        デバッグが有効かどうかをチェックします
            log.debug("子要素 " + 子要素 + " " + this を追加します);
        同期(子) {
            (children.get(child.getName()) != null) の場合
                新しい IllegalArgumentException をスローします ("addChild: 子の名前 '" +
                                                   子.getName() +
                                                   "' は一意ではありません");
            child.setParent(this); // IAE がスローされる可能性がある
            子の名前を取得します。
    }

  パブリック void start() は LifecycleException をスローします {
        // サーバー コンテナーが作成されないようにする getServer();
        //コネクタ コンテナーを取得し、サービス コンテナーに設定します getConnector();
        //ここでの start の実装は LifecycleBase クラスで実装されています //LifecycleBase メソッドはテンプレート メソッドであり、Tomcat の起動プロセスで非常に重要です server.start();
    }

保護されたvoid startInternal()はLifecycleExceptionをスローします{
 
        fireLifecycleEvent(CONFIGURE_START_EVENT、null);
        ライフサイクル状態を STARTING に設定します。
 
        グローバルネーミングリソースを開始します。
 
        // 定義したサービスを開始します
        同期 (servicesLock) {
            //サービスコンテナを起動します。Tomcat では複数のサービスコンテナを設定できます。各サービスコンテナは、(Service service : services) のサービスアプリケーションの 1 つに対応します。
                //StandardService.startInternal() に対応
                サービスを開始します。
            }
        }
    }

 // 子コンテナがある場合は起動します
        //addWwbapp プロセスの addChild メソッドで追加されたので、ここで見つける必要があります //ここで見つけるのはコンテキスト コンテナーです Container children[] = findChildren();
        List<Future<Void>> 結果 = new ArrayList<>();
        for (コンテナの子: children) {
            //スレッドプールを非同期的に開始してコンテキストコンテナを開始し、新しいStartChildに入ります
            結果を追加します(startStopExecutor.submit(新しい StartChild(child)));
        }

    プライベート静的クラス StartChild は Callable<Void> を実装します {
 
        プライベートコンテナの子。
 
        パブリック StartChild(コンテナの子) {
            this.child = 子;
        }
 
        @オーバーライド
        パブリック Void call() は LifecycleException をスローします {
            //コンテキストの開始を開始します。実際には StandardContext.startInternal() を呼び出します。
            子.start();
            null を返します。
        }
    }

   保護されたvoid fireLifecycleEvent(文字列型、オブジェクトデータ) {
        LifecycleEvent イベント = 新しい LifecycleEvent(this、type、data);
        //lifecycleListeners addwebappメソッドの最初のステップで、リスニングcontextConfigオブジェクトを設定します。(LifecycleListener listener : lifecycleListeners) {
            //contextConfig の lifecycleEvent() メソッドはここで呼び出されます listener.lifecycleEvent(event);
        }
    }

パブリック void lifecycleEvent(LifecycleEvent イベント) {
 
        // 関連付けられているコンテキストを識別する
        試す {
            コンテキスト = (コンテキスト) event.getLifecycle();
        } キャッチ (ClassCastException e) {
            ログエラー(sm.getString("contextConfig.cce", event.getLifecycle()), e);
            戻る;
        }
 
        // 発生したイベントを処理する
        イベントの getType() が Lifecycle.CONFIGURE_START_EVENT と等しい場合
            //web.xml のコンテンツ解析を完了します。configureStart();
        } そうでない場合 (event.getType().equals(Lifecycle.BEFORE_START_EVENT)) {
            開始する前に();
        } そうでない場合 (event.getType().equals(Lifecycle.AFTER_START_EVENT)) {
            // 管理ツールの docBase を復元します
            （元のドキュメントベースが null ではない場合）{
                コンテキスト.setDocBase(元のDocBase);
            }
        } そうでない場合 (event.getType().equals(Lifecycle.CONFIGURE_STOP_EVENT)) {
            停止を設定します。
        } そうでない場合 (event.getType().equals(Lifecycle.AFTER_INIT_EVENT)) {
            初期化();
        } そうでない場合 (event.getType().equals(Lifecycle.AFTER_DESTROY_EVENT)) {
            破壊する（）;
        }
 
    }

パブリックブールloadOnStartup(コンテナの子[]) {
 
        // 初期化が必要な「起動時にロード」サーブレットを収集します
        TreeMap<Integer, ArrayList<Wrapper>> map = new TreeMap<>();
        for (コンテナの子: children) {
            //ここでのラッパーは先ほどカプセル化したサーブレットです
            ラッパー wrapper = (ラッパー) child;
            int loadOnStartup = wrapper.getLoadOnStartup();
            起動時にロードが0の場合
                続く;
            }
            整数キー = Integer.valueOf(loadOnStartup);
            ArrayList<ラッパー> list = map.get(key);
            if (リスト == null) {
                リスト = 新しいArrayList<>();
                map.put(キー、リスト);
            }
            リストに追加(ラッパー);
        }
 
        // 収集された「起動時にロード」サーブレットをロードします
        (ArrayList<Wrapper> リスト: map.values()) の場合 {
            for (ラッパー wrapper : リスト) {
                試す {
                    //load メソッドは最終的にサーブレットの init メソッド wrapper.load() を呼び出します。
                } キャッチ (ServletException e) {
                    getLogger().error(sm.getString("standardContext.loadOnStartup.loadException",
                          getName()、wrapper.getName())、StandardWrapper.getRootCause(e));
                    // 注意: ロードエラー（エラーをスローするサーブレットを含む）
                    // init() メソッドからの UnavailableException は発生しません
                    // アプリケーションの起動に致命的
                    // failCtxIfServletStartFails="true" が指定されていない場合
                    if(getComputedFailCtxIfServletStartFails()) {
                        false を返します。
                    }
                }
            }
        }
        true を返します。
 
    }