初探Tomcat的架構(gòu)設(shè)計

黑客技術(shù)點擊右側(cè)關(guān)注，了解黑客的世界！

Java開發(fā)進(jìn)階點擊右側(cè)關(guān)注，掌握進(jìn)階之路！

Python開發(fā)點擊右側(cè)關(guān)注，探討技術(shù)話題！

作者丨ytao
來源丨ytao（ytao-blog）

Tomcat 作為 servlet 容器實現(xiàn)，它是基于 Java 語言開發(fā)的輕量級應(yīng)用服務(wù)器。因為 Tomcat 作為應(yīng)用服務(wù)器，它有著完全開源，輕量，性能穩(wěn)定，部署成本低等優(yōu)點，所以它成為目前 Java 開發(fā)應(yīng)用部署的首選，幾乎每個Java Web開發(fā)者都有使用過，但是，你對 Tomcat 的整體設(shè)計有進(jìn)行過了解和思考嗎？

本文將基于 Tomcat8 進(jìn)行分析，具體版本為 Tomcat8 當(dāng)前官網(wǎng)最新修改(2019-11-21 09:28)的版本 v8.5.49

總體結(jié)構(gòu)

Tomcat 的總體結(jié)構(gòu)中有很多模塊，下圖列出我們將要進(jìn)行分析結(jié)構(gòu)中的主要模塊。其中主要分析的是Service，Connector，Engine，Host，Context，Wrapper。為避免圖層看著太亂，下圖中 n代表該組件可允許存在多個。

如上圖所描述的是：Server 是 tomcat 服務(wù)器，在 Server 中可以存在多個服務(wù) Service 。每個服務(wù)中可有多個連接器和一個 Servlet 引擎 Engine，一個 Service 中多個連接器對應(yīng)一個 Engine。每個 Engine 中，可存在多個域名，這里可用虛擬主機(jī)的概念來表示 Host。每個 Host 中可以存在多個應(yīng)用 Context。Server，Service，Connector，Engine，Host，Context，Wrapper 它們之間的關(guān)系，除了Connector和Engine，它們是平行關(guān)系，其它的都是存在包含關(guān)系。同時，它們也都繼承了 Lifecycle 接口，該接口提供的是生命周期的管理，里面包括：初始化（init），啟動（start），停止(stop)，銷毀(destroy)。當(dāng)它的父容器啟動時，會調(diào)用它子容器的啟動，停止也是一樣的。

上圖中，還可以看到，Engine，Host，Context，Wrapper 都繼承自 Container。它有個 backgroundProcess()方法，后臺異步處理，所以繼承它后可以方便的創(chuàng)建異步線程。在 Tomcat7 中，有看到 Service 持有的是 Container，而不是 Engine。估計這也是為什么在當(dāng)前版本中添加 Engine 方法名叫 setContainer。

Server

Tomcat 源碼中有提供 org.apache.catalina.Server接口，對應(yīng)的默認(rèn)實現(xiàn)類為 org.apache.catalina.core.StandardServer，接口里面提供有如下圖方法。

上圖中可以知道 Server 做的工作：對 Service，Address，Port，Catalina 以及全局命名資源的管理操作。Server 在進(jìn)行初始化的時候，會加載我們 server.xml 中配置的數(shù)據(jù)。

這里對其中的 Service 操作的 addService向定義的服務(wù)集添加新服務(wù)進(jìn)行分析：

1. // 保存服務(wù)的服務(wù)集

2. privateService services[] = newService[0];

3. 
   

4. finalPropertyChangeSupport support = newPropertyChangeSupport(this);

5. 
   

6. @Override

7. publicvoid addService(Service service) {

8. // 相互關(guān)聯(lián)

9. service.setServer(this);

10. 
    

11. // 利用同步鎖，防止并發(fā)訪問 來源：https://ytao.top

12. synchronized(servicesLock) {

13. Service results[] = newService[services.length + 1];

14. // copy 舊的服務(wù)到新的數(shù)組中

15. System.arraycopy(services, 0, results, 0, services.length);

16. // 添加新的 service

17. results[services.length] = service;

18. services = results;

19. 
    

20. // 如果當(dāng)前 server 已經(jīng)啟動，那么當(dāng)前添加的 service 就開始啟動

21. if(getState().isAvailable()) {

22. try{

23. service.start();

24. } catch(LifecycleException e) {

25. // Ignore

26. }

27. }

28. 
    

29. // 使用觀察者模式，當(dāng)被監(jiān)聽對象屬性值發(fā)生變化時通知監(jiān)聽器，remove 是也會調(diào)用。

30. support.firePropertyChange("service", null, service);

31. }

32. 
    

33. }

源碼中可以看到，向服務(wù)器中添加服務(wù)后，隨機(jī)會啟動服務(wù)，實則也服務(wù)啟動入口。

Service

Service 的主要職責(zé)就是將 Connector 和 Engine 的組裝在一起。兩者分開的目的也就是使請求監(jiān)聽和請求處理進(jìn)行解耦，能擁有更好的擴(kuò)展性。每個 Service 都是相互獨立的，但是共享一個JVM和系統(tǒng)類庫。這里提供了 org.apache.catalina.Service接口和默認(rèn)實現(xiàn)類 org.apache.catalina.coreStandardService。

在實現(xiàn)類 StandardService 中，主要分析 setContainer和 addConnector兩個方法。

1. privateEngine engine = null;

2. 
   

3. protectedfinalMapperListener mapperListener = newMapperListener(this);

4. 
   

5. @Override

6. publicvoid setContainer(Engine engine) {

7. Engine oldEngine = this.engine;

8. // 判斷當(dāng)前 Service 是否有關(guān)聯(lián) Engine

9. if(oldEngine != null) {

10. // 如果當(dāng)前 Service 有關(guān)聯(lián) Engine，就去掉當(dāng)前關(guān)聯(lián)的 Engine

11. oldEngine.setService(null);

12. }

13. // 如果當(dāng)前新的 Engine 不為空，那么 Engine 關(guān)聯(lián)當(dāng)前 Service，這里是個雙向關(guān)聯(lián)

14. this.engine = engine;

15. if(this.engine != null) {

16. this.engine.setService(this);

17. }

18. // 如果當(dāng)前 Service 啟動了，那么就開始啟動當(dāng)前新的 Engine

19. if(getState().isAvailable()) {

20. if(this.engine != null) {

21. try{

22. this.engine.start();

23. } catch(LifecycleException e) {

24. log.error(sm.getString("standardService.engine.startFailed"), e);

25. }

26. }

27. // 重啟 MapperListener ，獲取一個新的 Engine ，一定是當(dāng)前入?yún)⒌?Engine

28. try{

29. mapperListener.stop();

30. } catch(LifecycleException e) {

31. log.error(sm.getString("standardService.mapperListener.stopFailed"), e);

32. }

33. try{

34. mapperListener.start();

35. } catch(LifecycleException e) {

36. log.error(sm.getString("standardService.mapperListener.startFailed"), e);

37. }

38. 
    

39. // 如果當(dāng)前 Service 之前有 Engine 關(guān)聯(lián)，那么停止之前的 Engine

40. if(oldEngine != null) {

41. try{

42. oldEngine.stop();

43. } catch(LifecycleException e) {

44. log.error(sm.getString("standardService.engine.stopFailed"), e);

45. }

46. }

47. }

48. 
    

49. // Report this property change to interested listeners

50. support.firePropertyChange("container", oldEngine, this.engine);

51. }

52. 
    

53. /**

54. * 實現(xiàn)方式和 StandardServer#addService 類似，不在細(xì)述

55. * 注意，Connector 這里沒有像 Engine 一樣與 Service 實現(xiàn)雙向關(guān)聯(lián)

56. */

57. @Override

58. publicvoid addConnector(Connector connector) {

59. 
    

60. synchronized(connectorsLock) {

61. connector.setService(this);

62. Connector results[] = newConnector[connectors.length + 1];

63. System.arraycopy(connectors, 0, results, 0, connectors.length);

64. results[connectors.length] = connector;

65. connectors = results;

66. 
    

67. if(getState().isAvailable()) {

68. try{

69. connector.start();

70. } catch(LifecycleException e) {

71. log.error(sm.getString(

72. "standardService.connector.startFailed",

73. connector), e);

74. }

75. }

76. 
    

77. // Report this property change to interested listeners

78. support.firePropertyChange("connector", null, connector);

79. }

80. 
    

81. }

Connector

Connector 主要用于接收請求，然后交給 Engine 處理請求，處理完后再給 Connector 去返回給客戶端。當(dāng)前使用版本支持的協(xié)議有：HTTP，HHTP/2，AJP，NIO，NIO2，APR主要的功能包括：

• 監(jiān)聽服務(wù)器端口來讀取客戶端的請求。

• 解析協(xié)議并交給對應(yīng)的容器處理請求。

• 返回處理后的信息給客戶端

Connector 對應(yīng)服務(wù)器 server.xml 中配置信息的例子：

1. port="8080"protocol="HTTP/1.1"

2. connectionTimeout="20000"

3. redirectPort="8443"/>

這里通過配置監(jiān)聽的端口號 port，指定處理協(xié)議 protocol，以及重定向地址 redirectPort。協(xié)議處理類型通過實例化連接器時設(shè)置：

1. publicConnector() {

2. // 無參構(gòu)造，下面 setProtocol 中默認(rèn)使用HTTP/1.1

3. this(null);

4. }

5. 
   

6. publicConnector(String protocol) {

7. // 設(shè)置當(dāng)前連接器協(xié)議處理類型

8. setProtocol(protocol);

9. // 實例化協(xié)議處理器，并保存到當(dāng)前 Connector 中

10. ProtocolHandler p = null;

11. try{

12. Class clazz = Class.forName(protocolHandlerClassName);

13. p = (ProtocolHandler) clazz.getConstructor().newInstance();

14. } catch(Exception e) {

15. log.error(sm.getString(

16. "coyoteConnector.protocolHandlerInstantiationFailed"), e);

17. } finally{

18. this.protocolHandler = p;

19. }

20. 
    

21. if(Globals.STRICT_SERVLET_COMPLIANCE) {

22. uriCharset = StandardCharsets.ISO_8859_1;

23. } else{

24. uriCharset = StandardCharsets.UTF_8;

25. }

26. }

27. 
    

28. /**

29. * 這個設(shè)置再 tomcat9 中被移除，改為必配項

30. */

31. publicvoid setProtocol(String protocol) {

32. 
    

33. boolean aprConnector = AprLifecycleListener.isAprAvailable() &&

34. AprLifecycleListener.getUseAprConnector();

35. 
    

36. // 這里指定了默認(rèn)協(xié)議和 HTTP/1.1 一樣

37. if("HTTP/1.1".equals(protocol) || protocol == null) {

38. if(aprConnector) {

39. setProtocolHandlerClassName("org.apache.coyote.http11.Http11AprProtocol");

40. } else{

41. setProtocolHandlerClassName("org.apache.coyote.http11.Http11NioProtocol");

42. }

43. } elseif("AJP/1.3".equals(protocol)) {

44. if(aprConnector) {

45. setProtocolHandlerClassName("org.apache.coyote.ajp.AjpAprProtocol");

46. } else{

47. setProtocolHandlerClassName("org.apache.coyote.ajp.AjpNioProtocol");

48. }

49. } else{

50. // 最后如果不是通過指定 HTTP/1.1，AJP/1.3 類型的協(xié)議，就通過類名實例化一個協(xié)議處理器

51. setProtocolHandlerClassName(protocol);

52. }

53. }

ProtocolHandler 是一個協(xié)議處理器，針對不同的請求，提供不同實現(xiàn)。實現(xiàn)類 AbstractProtocol 在初始化時，會在最后調(diào)用一個抽象類 AbstractEndpoint 初始化來啟動線程來監(jiān)聽服務(wù)器端口，當(dāng)接收到請求后，調(diào)用 Processor 讀取請求，然后交給 Engine 處理請求。

Engine

Engine 對應(yīng)的是， org.apache.catalina.Engine接口和 org.apache.catalina.core.StandardEngine默認(rèn)實現(xiàn)類。Engine 的功能也比較簡單，處理容器關(guān)系的關(guān)聯(lián)。

但是實現(xiàn)類中的 addChild()不是指的子 Engine，而是只能是 Host。同時沒有父容器， setParent是不允許操作設(shè)置的。

1. @Override

2. publicvoid addChild(Container child) {

3. // 添加的子容器必須是 Host

4. if(!(child instanceofHost))

5. thrownewIllegalArgumentException

6. (sm.getString("standardEngine.notHost"));

7. super.addChild(child);

8. }

9. 
   

10. @Override

11. publicvoid setParent(Container container) {

12. 
    

13. thrownewIllegalArgumentException

14. (sm.getString("standardEngine.notParent"));

15. 
    

16. }

server.xml 可以配置我們的數(shù)據(jù)：

2. name="Catalina"defaultHost="localhost"jvmRoute="jvm1">

Host

Host 表示一個虛擬主機(jī)。應(yīng)為我們的服務(wù)器可設(shè)置多個域名，比如 demo.ytao.top，dev.ytao.top。那么我們就要設(shè)置兩個不同 Host 來處理不同域名的請求。當(dāng)過來的請求域名為 demo.ytao.top 時，那么它就會去找該域名 Host 下的 Context。所以我們的 server.xml 配置文件也提供該配置：

2. name="localhost"appBase="webapps"

3. unpackWARs="true"autoDeploy="true">

Context

到 Context 這里來，就擁有 Servlet 的運行環(huán)境，Engine，Host都是主要維護(hù)容器關(guān)系，不具備運行環(huán)境。我們暫且可將 Context 理解為一個應(yīng)用，例如我們在根目錄下有 ytao-demo-1 和 ytao-demo-2 兩個應(yīng)用，那么這里就是有兩個 Context。這里主要介紹的 addChild方法，該添加的子容器是 Wrapper：

1. @Override

2. publicvoid addChild(Container child) {

3. 
   

4. // Global JspServlet

5. Wrapper oldJspServlet = null;

6. 
   

7. // 這里添加的子容器只能時 Wrapper

8. if(!(child instanceofWrapper)) {

9. thrownewIllegalArgumentException

10. (sm.getString("standardContext.notWrapper"));

11. }

12. 
    

13. // 判斷子容器 Wrapper 是否為 JspServlet

14. boolean isJspServlet = "jsp".equals(child.getName());

15. 
    

16. // Allow webapp to override JspServlet inherited from global web.xml.

17. if(isJspServlet) {

18. oldJspServlet = (Wrapper) findChild("jsp");

19. if(oldJspServlet != null) {

20. removeChild(oldJspServlet);

21. }

22. }

23. 
    

24. super.addChild(child);

25. 
    

26. // 將servlet映射添加到Context組件

27. if(isJspServlet && oldJspServlet != null) {

28. /*

29. * The webapp-specific JspServlet inherits all the mappings

30. * specified in the global web.xml, and may add additional ones.

31. */

32. String[] jspMappings = oldJspServlet.findMappings();

33. for(int i=0; jspMappings!=null&& i

34. addServletMappingDecoded(jspMappings[i], child.getName());

35. }

36. }

37. }

這里也就是每個應(yīng)用中的 Servlet 管理中心。

Wrapper

Wrapper 是一個 Servlet 的管理中心，它擁有 Servlet 的整個生命周期，它是沒有子容器的，因為它自己就是最底層的容器了。這里主要對 Servlet 加載的分析：

1. publicsynchronizedServlet loadServlet() throwsServletException{

2. 
   

3. // 如果已經(jīng)實例化或者用實例化池，就直接返回

4. if(!singleThreadModel && (instance != null))

5. return instance;

6. 
   

7. PrintStream out = System.out;

8. if(swallowOutput) {

9. SystemLogHandler.startCapture();

10. }

11. 
    

12. Servlet servlet;

13. try{

14. long t1=System.currentTimeMillis();

15. // 如果 servlet 類名為空，直接拋出 Servlet 異常

16. if(servletClass == null) {

17. unavailable(null);

18. thrownewServletException

19. (sm.getString("standardWrapper.notClass", getName()));

20. }

21. 
    

22. // 從 Context 中獲取 Servlet

23. InstanceManager instanceManager = ((StandardContext)getParent()).getInstanceManager();

24. try{

25. servlet = (Servlet) instanceManager.newInstance(servletClass);

26. } catch(ClassCastException e) {

27. unavailable(null);

28. // Restore the context ClassLoader

29. thrownewServletException

30. (sm.getString("standardWrapper.notServlet", servletClass), e);

31. } catch(Throwable e) {

32. e = ExceptionUtils.unwrapInvocationTargetException(e);

33. ExceptionUtils.handleThrowable(e);

34. unavailable(null);

35. 
    

36. // Added extra log statement for Bugzilla 36630:

37. // https://bz.apache.org/bugzilla/show_bug.cgi?id=36630

38. if(log.isDebugEnabled()) {

39. log.debug(sm.getString("standardWrapper.instantiate", servletClass), e);

40. }

41. 
    

42. // Restore the context ClassLoader

43. thrownewServletException

44. (sm.getString("standardWrapper.instantiate", servletClass), e);

45. }

46. 
    

47. // 加載聲明了 MultipartConfig 注解的信息

48. if(multipartConfigElement == null) {

49. MultipartConfig annotation =

50. servlet.getClass().getAnnotation(MultipartConfig.class);

51. if(annotation != null) {

52. multipartConfigElement =

53. newMultipartConfigElement(annotation);

54. }

55. }

56. 
    

57. // 對 servlet 類型進(jìn)行檢查

58. if(servlet instanceofContainerServlet) {

59. ((ContainerServlet) servlet).setWrapper(this);

60. }

61. 
    

62. classLoadTime=(int) (System.currentTimeMillis() -t1);

63. 
    

64. if(servlet instanceofSingleThreadModel) {

65. if(instancePool == null) {

66. instancePool = newStack<>();

67. }

68. singleThreadModel = true;

69. }

70. 
    

71. // 初始化 servlet

72. initServlet(servlet);

73. 
    

74. fireContainerEvent("load", this);

75. 
    

76. loadTime=System.currentTimeMillis() -t1;

77. } finally{

78. if(swallowOutput) {

79. String log = SystemLogHandler.stopCapture();

80. if(log != null&& log.length() > 0) {

81. if(getServletContext() != null) {

82. getServletContext().log(log);

83. } else{

84. out.println(log);

85. }

86. }

87. }

88. }

89. return servlet;

90. 
    

91. }

這里加載 Servlet，如果該 Servlet 沒有被實例化過，那么一定要加載一個。

到目前為止，大致介紹了 Tomcat8 的主要組件，對 Tomcat 的整體架構(gòu)也有個大致了解了，Tomcat 源碼進(jìn)行重構(gòu)后，可讀性確實要好很多，建議大家可以去嘗試分析下，里面的使用的一些設(shè)計模式，我們在實際編碼過程中，還是有一定的借鑒意義。

?推薦↓↓↓?

長

按

關(guān)

注

?【16個技術(shù)公眾號】都在這里！

涵蓋：程序員大咖、源碼共讀、程序員共讀、數(shù)據(jù)結(jié)構(gòu)與算法、黑客技術(shù)和網(wǎng)絡(luò)安全、大數(shù)據(jù)科技、編程前端、Java、Python、Web編程開發(fā)、Android、iOS開發(fā)、Linux、數(shù)據(jù)庫研發(fā)、幽默程序員等。

萬水千山總是情，點個 “在看” 行不行