Detaillierte Erklärung, wie Tomcat die Servlet-Initialisierung aus der Quellcodeanalyse aufruft

Tomcat Tomcat = neuer Tomcat();
        tomcat.setPort(8080);
        //Jede Containerebene neu erstellen und die Beziehung zwischen den Containerebenen aufrechterhalten tomcat.addWebapp("/","/");
        tomcat.start();
        //Blockieren Sie den Abhörport tomcat.getServer().await();

 
    öffentlicher Kontext addWebapp(Host host, String contextPath, String docBase) {
        //Holen Sie sich einen Listener ContextConfig durch Reflektion,
        //Die durch Reflexion erhaltene Klasse muss eine Implementierungsklasse von LifecycleListener sein. Geben Sie getConfigClass ein, um die Implementierungsklasse abzurufen (org.apache.catalina.startup.ContextConfig).
        LifecycleListener-Listener = null;
        versuchen {
            Klasse<?> clazz = Klasse.forName(getHost().getConfigClass());
            listener = (LifecycleListener) clazz.getConstructor().newInstance();
        } Fang (ReflectiveOperationException e) {
            // In IAE einbinden, da wir die Methodensignatur nicht einfach ändern können in
            // um die spezifischen geprüften Ausnahmen auszulösen
            wirf eine neue IllegalArgumentException(e);
        }
 
        gibt addWebapp zurück (Host, Kontextpfad, DocBase, Listener);
    }

öffentlicher Kontext addWebapp(Host host, String contextPath, String docBase,
            LifecycleListener-Konfiguration) {
 
        Stille (Host, Kontextpfad);
 
        //Holen Sie sich einen Kontextcontainer (StandardContext)
        Kontext ctx = Kontext erstellen(Host, Kontextpfad);
        ctx.setPath(Kontextpfad);
        ctx.setDocBase(docBase);
 
        wenn (addDefaultWebXmlToWebapp) {
            ctx.addLifecycleListener(getDefaultWebXmlListener());
        }
 
        ctx.setConfigFile(getWebappConfigFile(docBase, Kontextpfad));
        //Fügen Sie den Listener zum Kontext hinzu ctx.addLifecycleListener(config);
 
        if (addDefaultWebXmlToWebapp && (config-Instanz von ContextConfig)) {
            // Verhindern Sie, dass es sucht (wenn es eines findet, tritt ein Dup-Fehler auf)
            ((ContextConfig) config).setDefaultWebXml(noDefaultWebXmlPath());
        }
 
        wenn (Host == null) {
            //getHost erstellt Container Schicht für Schicht und verwaltet die Eltern-Kind-Beziehung der Container getHost().addChild(ctx);
        } anders {
            host.addChild(ctx);
        }
 
        ctx zurückgeben;
    }

  öffentlicher Host getHost() {
        //Für jede LayerEngine neue Container erstellen engine = getEngine();
        wenn (engine.findChildren().Länge > 0) {
            return (Host) engine.findChildren()[0];
        }
 
        Host Host = neuer StandardHost();
        host.setName(Hostname);
        //Den übergeordneten und untergeordneten Container in Tomcat pflegen getEngine().addChild(host);
        Gastgeber zurückgeben;
    }

  @Überschreiben
    public void addChild(Container-Kind) {
        wenn (Globals.IS_SECURITY_ENABLED) {
            PrivilegierteAktion<Void> dp =
                neues PrivilegedAddChild(Kind);
            AccessController.doPrivileged(dp);
        } anders {
            //Der untergeordnete Parameter ist hier der Kontextcontainer addChildInternal(child);
        }
    }

 private void addChildInternal(Container-Kind) {
 
        wenn( log.isDebugEnabled() )
            log.debug("Kind hinzufügen " + Kind + " " + dies);
        synchronisiert(Kinder) {
            wenn (Kinder.get(Kind.getName()) != null)
                neue IllegalArgumentException werfen("addChild: Child name '" +
                                                   Kind.getName() +
                                                   "' ist nicht eindeutig");
            child.setParent(this); // Kann IAE auslösen
            Kinder.put(Kind.getName(), Kind);
    }

  öffentliche void start() wirft LifecycleException {
        //Verhindern, dass der Server-Container erstellt wird getServer();
        //Holen Sie sich den Connector-Container und setzen Sie ihn auf den Service-Container getConnector();
        //Die Implementierung von „Start“ wird hier in der Klasse LifecycleBase implementiert. //Die Methode LifecycleBase ist eine Vorlagenmethode, die im Tomcat-Startprozess sehr kritisch ist. server.start();
    }

geschützt void startInternal() wirft LifecycleException {
 
        fireLifecycleEvent(CONFIGURE_START_EVENT, null);
        setState(LifecycleState.STARTING);
 
        globalNamingResources.start();
 
        // Starten Sie unsere definierten Services
        synchronisiert (servicesLock) {
            //Starten Sie den Servicecontainer. In einem Tomcat können mehrere Servicecontainer konfiguriert werden. Jeder Servicecontainer entspricht einer unserer Serviceanwendungen für (Service service : services) {
                //Entspricht StandardService.startInternal()
                service.start();
            }
        }
    }

 // Starten Sie unsere untergeordneten Container, falls vorhanden
        //Hinzugefügt in der Methode addChild im Prozess addWwbapp, also müssen wir es hier finden //Was wir hier finden, ist der Kontextcontainer Container children[] = findChildren();
        Liste<Zukunft<Leer>> Ergebnisse = neue ArrayList<>();
        für (Container-Kind: Kinder) {
            //Starten Sie den Thread-Pool asynchron, um den Kontextcontainer zu starten und ein neues StartChild einzugeben
            Ergebnisse.Hinzufügen(startStopExecutor.submit(neues StartChild(Kind)));
        }

    private statische Klasse StartChild implementiert Callable<Void> {
 
        privates Container-Kind;
 
        öffentliches StartChild(Container-Unterelement) {
            dieses.Kind = Kind;
        }
 
        @Überschreiben
        öffentlicher Void call() wirft LifecycleException {
            //Starten Sie den Kontext, indem Sie eigentlich StandardContext.startInternal() aufrufen.
            Kind.Start();
            gibt null zurück;
        }
    }

   geschützt void fireLifecycleEvent(String-Typ, Objektdaten) {
        LifecycleEvent-Ereignis = neues LifecycleEvent(dieses, Typ, Daten);
        //lifecycleListeners Legen Sie im ersten Schritt der Methode addwebapp das Listening-ContextConfig-Objekt für (LifecycleListener listener : lifecycleListeners) { fest.
            //Die lifecycleEvent()-Methode von contextConfig wird hier aufgerufen listener.lifecycleEvent(event);
        }
    }

öffentliche void Lebenszyklusereignis(Lebenszyklusereignis-Ereignis) {
 
        // Identifizieren Sie den Kontext, mit dem wir verbunden sind
        versuchen {
            Kontext = (Kontext) event.getLifecycle();
        } Fang (ClassCastException e) {
            log.error(sm.getString("contextConfig.cce", event.getLifecycle()), e);
            zurückkehren;
        }
 
        // Das aufgetretene Ereignis verarbeiten
        wenn (event.getType().equals(Lifecycle.CONFIGURE_START_EVENT)) {
            //Schließen Sie die Inhaltsanalyse von web.xml ab configureStart();
        } sonst wenn (event.getType().equals(Lifecycle.BEFORE_START_EVENT)) {
            vorStart();
        } sonst wenn (event.getType().equals(Lifecycle.AFTER_START_EVENT)) {
            // docBase für Verwaltungstools wiederherstellen
            wenn (originalDocBase != null) {
                Kontext.setDocBase(originalDocBase);
            }
        } sonst wenn (event.getType().equals(Lifecycle.CONFIGURE_STOP_EVENT)) {
            konfigurierenStop();
        } sonst wenn (event.getType().equals(Lifecycle.AFTER_INIT_EVENT)) {
            init();
        } sonst wenn (event.getType().equals(Lifecycle.AFTER_DESTROY_EVENT)) {
            zerstören();
        }
 
    }

öffentlicher Boolescher Wert loadOnStartup(Containerkinder[]) {
 
        // Sammeln Sie "Load on Startup"-Servlets, die initialisiert werden müssen
        TreeMap<Integer, ArrayList<Wrapper>> map = neues TreeMap<>();
        für (Container-Kind: Kinder) {
            //Der Wrapper ist hier das Servlet, das wir zuvor gekapselt haben
            Wrapper Wrapper = (Wrapper) Kind;
            int loadOnStartup = wrapper.getLoadOnStartup();
            wenn (loadOnStartup < 0) {
                weitermachen;
            }
            Integer-Schlüssel = Integer.valueOf(loadOnStartup);
            ArrayList<Wrapper> Liste = map.get(Schlüssel);
            wenn (Liste == null) {
                Liste = neue ArrayList<>();
                map.put(Schlüssel, Liste);
            }
            Liste.Hinzufügen(Wrapper);
        }
 
        // Laden Sie die gesammelten "Load on Startup"-Servlets
        für (ArrayList<Wrapper> Liste : map.values()) {
            für (Wrapper Wrapper: Liste) {
                versuchen {
                    //Die Lademethode ruft schließlich die Init-Methode des Servlets auf: wrapper.load();
                } Fang (ServletException e) {
                    getLogger().error(sm.getString("standardContext.loadOnStartup.loadException",
                          getName(), wrapper.getName()), StandardWrapper.getRootCause(e));
                    // HINWEIS: Ladefehler (einschließlich eines Servlets, das
                    // UnavailableException von der init()-Methode) sind NICHT
                    // fatal für den Anwendungsstart
                    // sofern nicht failCtxIfServletStartFails="true" angegeben ist
                    wenn(getComputedFailCtxIfServletStartFails()) {
                        gibt false zurück;
                    }
                }
            }
        }
        gibt true zurück;
 
    }