分享Tomcat源碼系列三部曲
最近在看Tomcat的源碼，下面用博客記下看源碼的一些心得。
Tomcat是從org.apache.catalina.startup.Bootstrap#main()開始啟動. 大致分為三個步驟，即init、load和start。代碼如下:
Java代碼
- public static void main(String args[]) {
- try {
- // Attempt to load JMX class
- new ObjectName("test:foo=bar");
- } catch (Throwable t) {
- System.out.println(JMX_ERROR_MESSAGE);
- try {
- // Give users some time to read the message before exiting
- Thread.sleep(5000);
- } catch (Exception ex) {
- }
- return;
- }
- if (daemon == null) {
- daemon = new Bootstrap();
- try {
- daemon.init(); ★1
- } catch (Throwable t) {
- t.printStackTrace();
- return;
- }
- }
- try {
- String command = "start";
- if (args.length > 0) {
- command = args[args.length - 1];
- }
- if (command.equals("startd")) {
- args[0] = "start";
- daemon.load(args);
- daemon.start();
- } else if (command.equals("stopd")) {
- args[0] = "stop";
- daemon.stop();
- } else if (command.equals("start")) {
- daemon.setAwait(true);
- daemon.load(args); ★2
- // 反射調用Catalina的start方法
- daemon.start(); ★3
- } else if (command.equals("stop")) {
- daemon.stopServer(args);
- }
- } catch (Throwable t) {
- t.printStackTrace();
- }
- }
從以上可以很清楚的看出tomcat是通過參數的不同進行相應的命令調用。
★1 啟動、初始化(加載類)
啟動之前要進行相應的init()初始化,進行相應的環境設置以及包的加,以下是init()方法。(org.apache.catalina.startup.Bootstrap.init())
Java代碼
- public void init()
- throws Exception
- {
- setCatalinaHome();//設置Catalina安裝目錄
- setCatalinaBase();//設置Catalina工作目錄
- initClassLoaders();//加載jar包
- // 將classload設置進線程,以便我們使用時進行調用
- Thread.currentThread().
- setContextClassLoader(catalinaLoader);
- SecurityClassLoad.securityClassLoad(catalinaLoader);
- // 加載啟動類和調用它的process方法
- if (log.isDebugEnabled())
- log.debug("Loading startup class");
- Class startupClass =
- catalinaLoader.loadClass
- ("org.apache.catalina.startup.Catalina");
- Object startupInstance = startupClass.newInstance();
- // 設置共享擴張類加載器
- if (log.isDebugEnabled())
- log.debug("Setting startup class properties");
- String methodName = "setParentClassLoader";
- Class paramTypes[] = new Class[1];
- paramTypes[0] = Class.forName("java.lang.ClassLoader");
- Object paramValues[] = new Object[1];
- paramValues[0] = sharedLoader;
- Method method =
- startupInstance.getClass().getMethod(methodName,
- paramTypes);
- method.invoke(startupInstance, paramValues);
- catalinaDaemon = startupInstance;
- }
在加載jar的時候，需要初始化classloader，代碼如下：(org.apache.catalina.startup.Bootstrap)
Java代碼
- private void initClassLoaders() {
- try {
- commonLoader = createClassLoader("common", null);
- catalinaLoader= createClassLoader("server", commonLoader);
- sharedLoader = createClassLoader("shared", commonLoader);
- } catch (Throwable t) {
- log.error("Class loader creation threw exception", t);
- System.exit(1);
- }
- }
tomcat中的加載方式是:
|-------commonLoader (common)-> System Loader
|-------sharedLoader (shared)-> commonLoader -> System Loader
|-------catalinaLoader(server) -> commonLoader -> System Loader
Common是公共類加載器，負責加載tomcat內部和web應用程序可以看到的類(%CATALINA_HOME%/bin/common下的jar文件)，Catalina負責加載的是tomcat內部使用的類(%CATALINA_HOME%/server下的jar文件)，這些類對web應用程序不可見。Shared負責加載的是web應用程序之間共享的類(%CATALINA_BASE%/shared下的jar文件)，這些類對于tomcat內部是不可見的。如果%CATALINA_HOME%/conf/catalina.Properties中沒有指定Common的搜索路徑，則用當前的類的類加載器即系統類加載器作為Common。
★2 裝載相應的資源
下面主要講解tomcat的load()方法。下圖是Catalina.load方法的時序圖。
(1) 從上面的時序圖可以看出首先調用Catalina類的load()方法，具體代碼如下：
(org.apache.catalina.startup.Catalina)。
Java代碼
- public void load() {
- initDirs();
- // Before digester - it may be needed
- initNaming();
- // Create and execute our Digester
- Digester digester = createStartDigester();
- try {
- inputSource.setByteStream(inputStream);
- digester.push(this);
- digester.parse(inputSource); //對server.xml進行解析
- inputStream.close();
- }
- ......
- // Start the new server
- if (server instanceof Lifecycle) {
- try {
- server.initialize(); //server初始化工作
- } catch (LifecycleException e) {
- log.error("Catalina.start", e);
- }
- }
- long t2 = System.currentTimeMillis();
- log.info("Initialization processed in " + (t2 - t1) + " ms");
- }
(2) 在上面的load()方法中需要進行server的初始化工作，下圖為Catalina.initialize的時序圖，從圖中可以看出server初始化所完成的工作。
至此，load方法結束，初期化的工作結束，下面開始進入start方法。
★3 容器啟動
容器啟動時，會調用Catalina.start()，下圖為它的時序圖。從圖中可以看出StandardService的start方法被調用后會分別對Container和Connector進行start方法的調用。
1. Bootstrap調用Catalina的start方法
Catalina.start()方法(org.apache.catalina.startup.Catalina.start())
Java代碼
- public void start() {
- // 啟動server
- if (server instanceof Lifecycle) {
- try {
- ((Lifecycle) server).start();
- ......
- }
2. Catalina調用StandardServer的start方法
StandardServer.start() (org.apache.catalina.core.StandardServer.start() )
Java代碼
- public void start() throws LifecycleException {
- synchronized (services) {
- for (int i = 0; i < services.length; i++) {
- if (services[i] instanceof Lifecycle)
- ((Lifecycle) services[i]).start();
- }
- }
3. StandardServer調用StandardService的start方法
Java代碼
- org.apache.catalina.core.StandardService.start() ）
- public void start() throws LifecycleException {
- if (container != null) {
- synchronized (container) {
- if (container instanceof Lifecycle) {
- // standardEngine的啟動
- ((Lifecycle) container).start();
- }
- }
- //兩個connector的啟動，8080和8009
- synchronized (connectors) {
- for (int i = 0; i < connectors.length; i++) {
- if (connectors[i] instanceof Lifecycle)
- ((Lifecycle) connectors[i]).start();
- }
- }
- }
以上StandardService.start()方法主要實現了兩個功能，standardEngine的啟動和connector的啟動，下面分別來介紹。
#p#
下面是standardEngine的啟動和connector的啟動
● standardEngine的啟動
(1) 首先是StandardEngine.start()被調用
Java代碼
- public void start() throws LifecycleException {
- // Standard container startup
- //進行logger,manager,cluster,realm,resource的啟動
- super.start();
- }
(2) super.start()--->org.apache.catalina.core.ContainerBase#start()
Java代碼
- public synchronized void start() throws LifecycleException {
- //(省略) server.xml中配置應用組件的啟動
- //StandardHost容器的啟動,
- Container children[] = findChildren();
- for (int i = 0; i < children.length; i++) {
- if (children[i] instanceof Lifecycle)
- ((Lifecycle) children[i]).start();
- }
- //StandardPipeline的啟動(容器與容器間的管道)
- if (pipeline instanceof Lifecycle)
- ((Lifecycle) pipeline).start();
- }
(3) StandardHost.start()被調用
Java代碼
- public synchronized void start() throws LifecycleException {
- //返回到以上的containerBase#start執行pipeline
- super.start();
- }
(4) StandardPipeline#start
Java代碼
- public synchronized void start() throws LifecycleException {
- // 將會調用HostConfig#start方法
- lifecycle.fireLifecycleEvent(START_EVENT, null);
- // Notify our interested LifecycleListeners
- lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
- }
(5) HostConfig#start
Java代碼
- public void start() {
- //部暑webapps
- deployApps();
- }
(6) HostConfig#deployApps
Java代碼
- protected void deployApps() {
- File appBase = appBase();
- File configBase = configBase();
- // Deploy XML descriptors from configBase
- deployDescriptors(configBase, configBase.list());
- // Deploy WARs, and loop if additional descriptors are found
- deployWARs(appBase, appBase.list());
- // Deploy expanded folders
- deployDirectories(appBase, appBase.list());
- }
(7) deployWARs
Java代碼
- protected void deployWARs(File appBase, String[] files) {
- ……
- deployWAR(contextPath, dir, file);
- }
(8) deployWAR
Java代碼
- protected void deployWAR(String contextPath, File war, String file) {
- if (context instanceof Lifecycle) {
- // (省略)
- Class clazz = Class.forName(host.getConfigClass());
- LifecycleListener listener =
- (LifecycleListener) clazz.newInstance();
- ((Lifecycle) context).addLifecycleListener(listener);
- }
- context.setPath(contextPath);
- context.setDocBase(file);
- //以下這一步跟進去，,StandardContext的啟動
- host.addChild(context);
- }
(9) StandardContext#start
在Context的啟動過程中，主要完成了以下任務。
----------------------------------------------------------------------------------------------------------------------
a) 設置web app的具體目錄webappResources。
b) postWorkDirectory ()，創建臨時文件目錄。Tomcat下面有一個work目錄，用來存放臨時文件。
c) 觸發START_EVENT事件監聽，在這個事件監聽里面會啟動ContextConfig的start()事件，ContextConfig是用來配置web.xml的。
d) 為context創建welcome files，通常是這三個啟動文件：index.html、index.htm、index.jsp
e) 配置filter
f) 啟動帶有
g) 注冊JMX。
----------------------------------------------------------------------------------------------------------------------
至此，Container啟動完畢，下面是connector的啟動。
● connector的啟動
(1) org.apache.catalina.connector.Connector.start()
Java代碼
- public void start() throws LifecycleException {
- // Http11Protocol的啟動
- protocolHandler.start();
- }
(2) Http11Protocol#start
Java代碼
- public void start() throws Exception {
- try {
- //到了終點的啟動
- endpoint.start();
- } catch (Exception ex) {
- log.error(sm.getString("http11protocol.endpoint.starterror"), ex);
- throw ex;
- }
(3) JIoEndPoint#start
Java代碼
- public void start()
- throws Exception {
- for (int i = 0; i < acceptorThreadCount; i++) {
- //這里的acceptor是一個線程,里面是一個serversocket的啟動
- Thread acceptorThread = new Thread(new Acceptor(), getName() + "-Acceptor-" + i);
- acceptorThread.setPriority(threadPriority);
- acceptorThread.setDaemon(daemon);
- acceptorThread.start();
- }
- }
(4) Acceptor#run
Java代碼
- public void run() {
- // Accept the next incoming connection from the server socket
- try {
- //這里進行了accept()，等待客戶端消息，進行接收
- Socket socket = serverSocketFactory.acceptSocket(serverSocket);
- serverSocketFactory.initSocket(socket);
- // Hand this socket off to an appropriate processor
- if (!processSocket(socket)) {
- // Close socket right away
- try {
- socket.close();
- } catch (IOException e) {
- // Ignore
- }
- }
- }catch ( IOException x ) {
- if ( running ) log.error(sm.getString("endpoint.accept.fail"), x);
- } catch (Throwable t) {
- log.error(sm.getString("endpoint.accept.fail"), t);
- }
- }
至此Connector.start方法調用完畢。整個server啟動完畢。
#p#
本次講解一下Tomcat請求處理的流程，不當之處還請comment。
一. Tomcat 總體結構
Tomcat采用模塊化管理，下面是 Tomcat 的總體結構圖：
從上圖中可以看出 Tomcat 的核心是兩個組件：Connector 和 Container。下面是一些概念的介紹。
① Server
一個server代表了整個catalina servlet容器，在Tomcat里面的Server的用處是啟動和監聽服務端事件(諸如重啟、關閉等命令)。
② Service
Service是由一個或多個Connector與一個Engine的組合。
③ Connector
Connector將在某個指定的端口上監聽客戶的請求，把從socket傳遞過來的數據，封裝成Request，傳遞給Engine來處理，并從Engine處獲得響應并返回給客戶。
Tomcat通常會用到兩種Connector：
a) Http Connector 在端口8080處偵聽來自客戶browser的http請求。
b) AJP Connector 在端口8009處偵聽來自其它WebServer(Apache)的servlet/jsp代理請求。
二、請求處理過程解析
1. Connector處理請求
Connector處理請求的流程大致如下：
Connector組件啟動后，會偵聽相關的端口的客戶端請求。
(1) 接受一個新的連接請求(org.apache.tomcat.util.net.TcpWorkerThread)
Java代碼
- void runIt(Object[] perThrData){
- Socket s = null;
- try {
- s = endpoint.acceptSocket(); //獲取一個請求
- } finally {
- if (endpoint.isRunning()) {
- endpoint.tp.runIt(this);
- // 此處啟動另一個TcpWorkerTread去接受其他請求，此線程處理已接受的請求
- }
- }
- TcpConnection con = null;
- con = (TcpConnection) perThrData[0];
- con.setEndpoint(endpoint);
- con.setSocket(s);endpoint.getConnectionHandler().processConnection(con,(Object[]) perThrData[1]);
- }
(2) 新接收的請求被傳到Http11ConnectionHandler中處理。(org.apache.coyote.http11.Http11Protocol.Http11ConnectionHandler)
Java代碼
- void processConnection(TcpConnection connection, Object[] thData){
- Http11Processor processor=null;
- processor=(Http11Processor)thData[Http11Protocol.THREAD_DATA_PROCESSOR];
- socket=connection.getSocket();
- InputStream in = socket.getInputStream();
- OutputStream out = socket.getOutputStream();
- processor.setSocket(socket );
- processor.process(in, out);
- //processor是org.apache.coyote.http11.Http11Processor 的 一個實例
- }
(3) 在 Http11Processor 中處理 http11 協議相關的信息(org.apache.coyote.http11.Http11Processor)
Java代碼
- void process(InputStream input, OutputStream output) throws IOException{
- ~~略~~
- inputBuffer.setInputStream(input);
- outputBuffer.setOutputStream(output);
- inputBuffer.parseHeaders();
- //http11 協議頭在此方法中被取出
- adapter.service(request, response);
- //adapter 是org.apache.catalina.connector.CoyoteAdapter 的 一個實例
- }
接下來的流程交由容器進行處理。
2. 容器處理請求
容器交由Pipeline處理，這個Pipeline里面會放置一些vavle，請求沿著pipeline傳遞下去并且vavle對其進行相關的處理。比如說日志等，valve還可以自定義，具體需要查看server.xml配置文件。相關類圖如下：
Tomcat的主要處理組件Engine、Host、Context和Wrapper的實現都會實現Pipeline接口，實際對請求的處理是一個Adpater，Tomcat中Adapter的實現是CoyoteAdapter，因此容器請求處理的入口是CoyoteAdapter的service方法。
1. CoyoteAdapter.service
--組裝好請求處理鏈
--StandardEngine. getPipeline().getFirst().invoke(request, response);
--StandardEngineValve.invoke
2. StandardEngineValve.invoke
--Host.getPipeline().getFirst().invoke(request, response);
--StandardHostValve.invoke
3. StandardHostValve.invoke
--Context. getPipeline().getFirst().invoke(request, response);
--StandardContextValve.invoke
4. StandardContextValve.invoke
--ServletRequestListener.requestInitialized
--Wrapper.getPipeline().getFirst().invoke(request, response);
--StandardWrapperValve.invoke
-- ServletRequestListener.requestDestroyed
5. StandardWrapperValve.invoke
--組裝Filter+Servlet
--處理請求
(1) Connector傳來的請求調用CoyoteAdapter.service()方法。(org.apache.catalina.connector.CoyoteAdapter)
Java代碼
- public void service(org.apache.coyote.Request req,
- org.apache.coyote.Response res)
- throws Exception {
- ~~略~~
- if (request == null) {
- request = (Request) connector.createRequest();
- request.setCoyoteRequest(req);
- response = (Response) connector.createResponse();
- response.setCoyoteResponse(res);
- //創建request、response對象
- ~~略~~
- }
- try {
- if (postParseRequest(req, request, res, response)) {
- connector.getContainer().getPipeline().getFirst().invoke(request, response);
- //此處的Container是StandardEngine對象
- ~~略~~
- }
- }
(2) 默認StandardEngine的Pipeline會有StandardEngineValve處理單元(參照StandardEngine構造函數)。(org.apache.catalina.core.StandardEngineValve)
Java代碼
- public final void invoke(Request request, Response response)
- throws IOException, ServletException {
- // Select the Host to be used for this Request
- Host host = request.getHost();
- if (host == null) {
- response.sendError
- (HttpServletResponse.SC_BAD_REQUEST,
- sm.getString("standardEngine.noHost",
- request.getServerName()));
- return;
- }
- // Ask this Host to process this request
- host.getPipeline().getFirst().invoke(request, response);
- }
(3) 同樣的，StandardHost的Pipeline會有StandardHostValve處理單元。StandardHostValve如何處理請求跟StandardEngineValve類似，接下來請求進入到StandardContextValve.invoke
(4) 同樣的，StandardContext的Pipeline會有StandardContextValve處理單元。
Java代碼
- public final void invoke(Request request, Response response)
- throws IOException, ServletException {
- // Disallow any direct access to resources under WEB-INF or META-INF MessageBytes requestPathMB = request.getRequestPathMB();
- if ((requestPathMB.startsWithIgnoreCase("/META-INF/", 0))
- || (requestPathMB.equalsIgnoreCase("/META-INF"))
- || (requestPathMB.startsWithIgnoreCase("/WEB-INF/", 0))
- || (requestPathMB.equalsIgnoreCase("/WEB-INF"))) {
- String requestURI = request.getDecodedRequestURI();
- notFound(requestURI, response);
- return;
- }
- // Wait if we are reloading
- while (context.getPaused()) {
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- ;
- }
- }
- // Select the Wrapper to be used for this Request
- Wrapper wrapper = request.getWrapper();
- if (wrapper == null) {
- String requestURI = request.getDecodedRequestURI();
- notFound(requestURI, response);
- return;
- }
- //ServletRequestListener. requestInitialized
- ~~略~~
- wrapper.getPipeline().getFirst().invoke(request, response);
- //ServletRequestListener.requestDestroyed
- ~~略~~
- }
(5) 同樣的，StandardWrapper這個Pipeline會有StandardWrapperValve這個處理單元。在invoke()方法調用Filter的同時，servlet.service()方法也將會被調用。
(org.apache.catalina.core.StandardWrapperValve)
Java代碼
- void invoke(Request request, Response response, ValveContext valveContext)
- throws IOException, ServletException{
- Servlet servlet = null;
- HttpServletRequest hreq = (HttpServletRequest) request.getRequest();
- //org.apache.catalina.Request被封裝成javax.servlet.http.HttpServletRequest.
- HttpServletResponse hres =(HttpServletResponse) response.getResponse();
- // org.apache.catalina.Response被封裝成javax.servlet.http.HttpServletResponse.
- servlet = wrapper.allocate(); // 裝載servlet
- if ((servlet != null) && (filterChain != null)) {
- filterChain.doFilter(hreq, hres); //調用此servlet的filterchain
- }
(6) 調用servlet的filterchain 處理 request和response
(org.apache.catalina.core.ApplicationFilterChain)
Java代碼
- void doFilter(ServletRequest request, ServletResponse response) throws
- IOException, ServletException{
- ~~略~~
- internalDoFilter(request,response);
- ~~略~~
- }
(7) 調用internalDoFilter()處理請求。(org.apache.catalina.core.ApplicationFilterChain)
Java代碼
- void internalDoFilter(ServletRequest request, ServletResponse response) throws
- IOException, ServletException{
- // 此處省略filter 處理的代碼，filter 被一個一個調用。
- // 如果http請求的是一個jsp頁面， 下面的 servlet 會是 org.apache.jasper.servlet.JspServlet 類的一個實例
- // 若是 html 頁面, 下面的 servlet 會是 org.apache.catalina.servlets.DefaultServlet 類的一個實例
- if ((request instanceof HttpServletRequest) &&
- (response instanceof HttpServletResponse)) {
- servlet.service((HttpServletRequest) request, (HttpServletResponse) response);
- servlet.service(request, response);
- } else {
- servlet.service(request, response);
- }
- }
至此，servlet.service()方法被調用。
【編輯推薦】
