建站
咨詢
售后
建站咨詢
新聞中心
最近在看Tomcat的源碼，下面用博客記下看源碼的一些心得。
10年積累的做網(wǎng)站、網(wǎng)站建設(shè)經(jīng)驗，可以快速應(yīng)對客戶對網(wǎng)站的新想法和需求。提供各種問題對應(yīng)的解決方案。讓選擇我們的客戶得到更好、更有力的網(wǎng)絡(luò)服務(wù)。我雖然不認識你，你也不認識我。但先網(wǎng)站設(shè)計后付款的網(wǎng)站建設(shè)流程，更有恭城免費網(wǎng)站建設(shè)讓你可以放心的選擇與我們合作。
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
- // 反射調(diào)用Catalina的start方法
- daemon.start(); 3
- } else if (command.equals("stop")) {
- daemon.stopServer(args);
- }
- } catch (Throwable t) {
- t.printStackTrace();
- }
- }
從以上可以很清楚的看出tomcat是通過參數(shù)的不同進行相應(yīng)的命令調(diào)用。
1 啟動、初始化(加載類)
啟動之前要進行相應(yīng)的init()初始化,進行相應(yīng)的環(huán)境設(shè)置以及包的加,以下是init()方法。(org.apache.catalina.startup.Bootstrap.init())
Java代碼
- public void init()
- throws Exception
- {
- setCatalinaHome();//設(shè)置Catalina安裝目錄
- setCatalinaBase();//設(shè)置Catalina工作目錄
- initClassLoaders();//加載jar包
- // 將classload設(shè)置進線程,以便我們使用時進行調(diào)用
- Thread.currentThread().
- setContextClassLoader(catalinaLoader);
- SecurityClassLoad.securityClassLoad(catalinaLoader);
- // 加載啟動類和調(diào)用它的process方法
- if (log.isDebugEnabled())
- log.debug("Loading startup class");
- Class startupClass =
- catalinaLoader.loadClass
- ("org.apache.catalina.startup.Catalina");
- Object startupInstance = startupClass.newInstance();
- // 設(shè)置共享擴張類加載器
- 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內(nèi)部和web應(yīng)用程序可以看到的類(%CATALINA_HOME%/bin/common下的jar文件)，Catalina負責加載的是tomcat內(nèi)部使用的類(%CATALINA_HOME%/server下的jar文件)，這些類對web應(yīng)用程序不可見。Shared負責加載的是web應(yīng)用程序之間共享的類(%CATALINA_BASE%/shared下的jar文件)，這些類對于tomcat內(nèi)部是不可見的。如果%CATALINA_HOME%/conf/catalina.Properties中沒有指定Common的搜索路徑，則用當前的類的類加載器即系統(tǒng)類加載器作為Common。
2 裝載相應(yīng)的資源
下面主要講解tomcat的load()方法。下圖是Catalina.load方法的時序圖。
(1) 從上面的時序圖可以看出首先調(diào)用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方法結(jié)束，初期化的工作結(jié)束，下面開始進入start方法。
3 容器啟動
容器啟動時，會調(diào)用Catalina.start()，下圖為它的時序圖。從圖中可以看出StandardService的start方法被調(diào)用后會分別對Container和Connector進行start方法的調(diào)用。
1. Bootstrap調(diào)用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調(diào)用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調(diào)用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()方法主要實現(xiàn)了兩個功能，standardEngine的啟動和connector的啟動，下面分別來介紹。
#p#
下面是standardEngine的啟動和connector的啟動
● standardEngine的啟動
(1) 首先是StandardEngine.start()被調(diào)用
Java代碼
- public void start() throws LifecycleException {
- // Standard container startup
- //進行l(wèi)ogger,manager,cluster,realm,resource的啟動
- super.start();
- }
(2) super.start()--->org.apache.catalina.core.ContainerBase#start()
Java代碼
- public synchronized void start() throws LifecycleException {
- //(省略) server.xml中配置應(yīng)用組件的啟動
- //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()被調(diào)用
Java代碼
- public synchronized void start() throws LifecycleException {
- //返回到以上的containerBase#start執(zhí)行pipeline
- super.start();
- }
(4) StandardPipeline#start
Java代碼
- public synchronized void start() throws LifecycleException {
- // 將會調(diào)用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的啟動過程中，主要完成了以下任務(wù)。
----------------------------------------------------------------------------------------------------------------------
a) 設(shè)置web app的具體目錄webappResources。
b) postWorkDirectory ()，創(chuàng)建臨時文件目錄。Tomcat下面有一個work目錄，用來存放臨時文件。
c) 觸發(fā)START_EVENT事件監(jiān)聽，在這個事件監(jiān)聽里面會啟動ContextConfig的start()事件，ContextConfig是用來配置web.xml的。
d) 為context創(chuàng)建welcome files，通常是這三個啟動文件：index.html、index.htm、index.jsp
e) 配置filter
f) 啟動帶有 的Servlet。
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方法調(diào)用完畢。整個server啟動完畢。
#p#
本次講解一下Tomcat請求處理的流程，不當之處還請comment。
一. Tomcat 總體結(jié)構(gòu)
Tomcat采用模塊化管理，下面是 Tomcat 的總體結(jié)構(gòu)圖：
從上圖中可以看出 Tomcat 的核心是兩個組件：Connector 和 Container。下面是一些概念的介紹。
① Server
一個server代表了整個catalina servlet容器，在Tomcat里面的Server的用處是啟動和監(jiān)聽服務(wù)端事件(諸如重啟、關(guān)閉等命令)。
② Service
Service是由一個或多個Connector與一個Engine的組合。
③ Connector
Connector將在某個指定的端口上監(jiān)聽客戶的請求，把從socket傳遞過來的數(shù)據(jù)，封裝成Request，傳遞給Engine來處理，并從Engine處獲得響應(yīng)并返回給客戶。
Tomcat通常會用到兩種Connector：
a) Http Connector 在端口8080處偵聽來自客戶browser的http請求。
b) AJP Connector 在端口8009處偵聽來自其它WebServer(Apache)的servlet/jsp代理請求。
二、請求處理過程解析
1. Connector處理請求
Connector處理請求的流程大致如下：
Connector組件啟動后，會偵聽相關(guān)的端口的客戶端請求。
(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 協(xié)議相關(guān)的信息(org.apache.coyote.http11.Http11Processor)
Java代碼
- void process(InputStream input, OutputStream output) throws IOException{
- ~~略~~
- inputBuffer.setInputStream(input);
- outputBuffer.setOutputStream(output);
- inputBuffer.parseHeaders();
- //http11 協(xié)議頭在此方法中被取出
- adapter.service(request, response);
- //adapter 是org.apache.catalina.connector.CoyoteAdapter 的 一個實例
- }
接下來的流程交由容器進行處理。
2. 容器處理請求
容器交由Pipeline處理，這個Pipeline里面會放置一些vavle，請求沿著pipeline傳遞下去并且vavle對其進行相關(guān)的處理。比如說日志等，valve還可以自定義，具體需要查看server.xml配置文件。相關(guān)類圖如下：
Tomcat的主要處理組件Engine、Host、Context和Wrapper的實現(xiàn)都會實現(xiàn)Pipeline接口，實際對請求的處理是一個Adpater，Tomcat中Adapter的實現(xiàn)是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傳來的請求調(diào)用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);
- //創(chuàng)建request、response對象
- ~~略~~
- }
- try {
- if (postParseRequest(req, request, res, response)) {
- connector.getContainer().getPipeline().getFirst().invoke(request, response);
- //此處的Container是StandardEngine對象
- ~~略~~
- }
- }
(2) 默認StandardEngine的Pipeline會有StandardEngineValve處理單元(參照StandardEngine構(gòu)造函數(shù))。(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) { &nb
新聞名稱：分享Tomcat源碼系列三部曲
網(wǎng)站地址：http://m.5511xx.com/article/dpdoshs.html
