初始提交
diff --git a/tomcat-uid/webapps/docs/architecture/startup/serverStartup.txt b/tomcat-uid/webapps/docs/architecture/startup/serverStartup.txt
new file mode 100644
index 0000000..7eac279
--- /dev/null
+++ b/tomcat-uid/webapps/docs/architecture/startup/serverStartup.txt
@@ -0,0 +1,138 @@
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+Tomcat 5 Startup Sequence
+
+Sequence 1. Start from Command Line
+Class: org.apache.catalina.startup.Bootstrap
+What it does:
+ a) Set up classloaders
+ commonLoader (common)-> System Loader
+ sharedLoader (shared)-> commonLoader -> System Loader
+ catalinaLoader(server) -> commonLoader -> System Loader
+ b) Load startup class (reflection)
+ org.apache.catalina.startup.Catalina
+ setParentClassloader -> sharedLoader
+ Thread.contextClassloader -> catalinaLoader
+ c) Bootstrap.daemon.init() complete
+
+Sequence 2. Process command line argument (start, startd, stop, stopd)
+Class: org.apache.catalina.startup.Bootstrap (assume command->start)
+What it does:
+ a) Catalina.setAwait(true);
+ b) Catalina.load()
+ b1) initDirs() -> set properties like
+ catalina.home
+ catalina.base == catalina.home (most cases)
+ b2) initNaming
+ setProperty(javax.naming.Context.INITIAL_CONTEXT_FACTORY,
+ org.apache.naming.java.javaURLContextFactory ->default)
+ b3) createStartDigester()
+ Configures a digester for the main server.xml elements like
+ org.apache.catalina.core.StandardServer (can change of course :)
+ org.apache.catalina.deploy.NamingResources
+ Stores naming resources in the J2EE JNDI tree
+ org.apache.catalina.LifecycleListener
+ implements events for start/stop of major components
+ org.apache.catalina.core.StandardService
+ The single entry for a set of connectors,
+ so that a container can listen to multiple connectors
+ ie, single entry
+ org.apache.coyote.tomcat5.CoyoteConnector
+ Connectors to listen for incoming requests only
+ It also adds the following rulesets to the digester
+ NamingRuleSet
+ EngineRuleSet
+ HostRuleSet
+ ContextRuleSet
+ b4) Load the server.xml and parse it using the digester
+ Parsing the server.xml using the digester is an automatic
+ XML-object mapping tool, that will create the objects defined in server.xml
+ Startup of the actual container has not started yet.
+ b5) Assigns System.out and System.err to the SystemLogHandler class
+ b6) Calls initialize on all components, this makes each object register itself with the
+ JMX agent.
+ During the process call the Connectors also initialize the adapters.
+ The adapters are the components that do the request pre-processing.
+ Typical adapters are HTTP1.1 (default if no protocol is specified,
+ org.apache.coyote.http11.Http11Protocol)
+ AJP1.3 for mod_jk etc.
+
+ c) Catalina.start()
+ c1) Starts the NamingContext and binds all JNDI references into it
+ c2) Starts the services under <Server> which are:
+ StandardService -> starts Engine (ContainerBase ->Logger,Loader,Realm,Cluster etc)
+ c3) StandardHost (started by the service)
+ Configures a ErrorReportValvem to do proper HTML output for different HTTP
+ errors codes
+ Starts the Valves in the pipeline (at least the ErrorReportValve)
+ Configures the StandardHostValve,
+ this valves ties the Webapp Class loader to the thread context
+ it also finds the session for the request
+ and invokes the context pipeline
+ Starts the HostConfig component
+ This component deploys all the webapps
+ (webapps & conf/Catalina/localhost/*.xml)
+ Webapps are installed using the deployer (StandardHostDeployer)
+ The deployer will create a Digester for your context, this digester
+ will then invoke ContextConfig.start()
+ The ContextConfig.start() will process the default web.xml (conf/web.xml)
+ and then process the applications web.xml (WEB-INF/web.xml)
+
+ c4) During the lifetime of the container (StandardEngine) there is a background thread that
+ keeps checking if the context has changed. If a context changes (timestamp of war file,
+ context xml file, web.xml) then a reload is issued (stop/remove/deploy/start)
+
+ d) Tomcat receives a request on an HTTP port
+ d1) The request is received by a separate thread which is waiting in the PoolTcpEndPoint
+ class. It is waiting for a request in a regular ServerSocket.accept() method.
+ When a request is received, this thread wakes up.
+ d2) The PoolTcpEndPoint assigns the a TcpConnection to handle the request.
+ It also supplies a JMX object name to the catalina container (not used I believe)
+ d3) The processor to handle the request in this case is Coyote Http11Processor,
+ and the process method is invoked.
+ This same processor is also continuing to check the input stream of the socket
+ until the keep alive point is reached or the connection is disconnected.
+ d4) The HTTP request is parsed using an internal buffer class (Coyote Http11 Internal Buffer)
+ The buffer class parses the request line, the headers, etc and store the result in a
+ Coyote request (not an HTTP request) This request contains all the HTTP info, such
+ as servername, port, scheme, etc.
+ d5) The processor contains a reference to an Adapter, in this case it is the
+ Coyote Tomcat 5 Adapter. Once the request has been parsed, the Http11 processor
+ invokes service() on the adapter. In the service method, the Request contains a
+ CoyoteRequest and CoyoteRespons (null for the first time)
+ The CoyoteRequest(Response) implements HttpRequest(Response) and HttpServletRequest(Response)
+ The adapter parses and associates everything with the request, cookies, the context through a
+ Mapper, etc
+ d6) When the parsing is finished, the CoyoteAdapter invokes its container (StandardEngine)
+ and invokes the invoke(request,response) method.
+ This initiates the HTTP request into the Catalina container starting at the engine level
+ d7) The StandardEngine.invoke() simply invokes the container pipeline.invoke()
+ d8) By default the engine only has one valve the StandardEngineValve, this valve simply
+ invokes the invoke() method on the Host pipeline (StandardHost.getPipeLine())
+ d9) the StandardHost has two valves by default, the StandardHostValve and the ErrorReportValve
+ d10) The standard host valve associates the correct class loader with the current thread
+ It also retrieves the Manager and the session associated with the request (if there is one)
+ If there is a session access() is called to keep the session alive
+ d11) After that the StandardHostValve invokes the pipeline on the context associated
+ with the request.
+ d12) The first valve that gets invoked by the Context pipeline is the FormAuthenticator
+ valve. Then the StandardContextValve gets invoke.
+ The StandardContextValve invokes any context listeners associated with the context.
+ Next it invokes the pipeline on the Wrapper component (StandardWrapperValve)
+ d13) During the invocation of the StandardWrapperValve, the JSP wrapper (Jasper) gets invoked
+ This results in the actual compilation of the JSP.
+ And then invokes the actual servlet.
+ e) Invocation of the servlet class