Grosse MàJ
This commit is contained in:
olivier
Binary file not shown.
@ -0,0 +1,136 @@
|
||||
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 intialize 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 retrives 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 invokation 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) Invokation of the servlet class
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user