在沒有SpringBoot內嵌有Tomcat之前，我們都是將項目打為War包放在Tomcat的webapp目錄下面，然后如果是Linux系統，運行命令start.sh、如果是Windows系統，運行命令start.bat以后就能啟動起來并訪問到頁面。如果是想要停止運行只需要運行shutdown.sh或者shutdown.bat就能將程序停止起來，那么Tomcat是如何做到只需要一個命令就將所有容器啟動起來呢?

腳本分析

start.sh和start.bat里面的內容相同，所以這里就主要分析start.sh的內容了。

1. os400=false  
2. case "`uname`" in  
3. OS400*) os400=true;;  
4. esac  
5. # resolve links - $0 may be a softlink  
6. # PRG是腳本路徑,如果當前腳本文件為軟連接,則會解析出PRG真正文件所在的路徑  
7. PRG="$0"  
8. while [ -h "$PRG" ] ; do # 判斷是否為軟連接  
9.  ls=`ls -ld "$PRG"` # 如果是軟連接,輸出中含有lin -> source的字符串  
10.  link=`expr "$ls" : '.*-> (.*)$'` # 模式匹配出源文件的路徑  
11.  if expr "$link" : '/.*' > /dev/null; then # 正則匹配 /.* 這里expr會輸出匹配個數,如果不為0,則說明$link包含目錄  
12.  PRG="$link"  
13.  else  
14.  PRG=`dirname "$PRG"`/"$link" # 當不包含目錄,說明軟連接和源文件在同一目錄  
15.  fi  
16. done  
17. # 獲取腳本目錄路徑  
18. PRGDIR=`dirname "$PRG"`  
19. EXECUTABLE=catalina.sh  
20. # Check that target executable exists  
21. if $os400; then  
22.  # -x will Only work on the os400 if the files are:  
23.  # 1. owned by the user  
24.  # 2. owned by the PRIMARY group of the user  
25.  # this will not work if the user belongs in secondary groups  
26.  eval  
27. else  
28.  if [ ! -x "$PRGDIR"/"$EXECUTABLE" ]; then  
29.  echo "Cannot find $PRGDIR/$EXECUTABLE"  
30.  echo "The file is absent or does not have execute permission"  
31.  echo "This file is needed to run this program"  
32.  exit 1  
33.  fi  
34. fi  
35. # 執行catalina.sh的start命令  
36. exec "$PRGDIR"/"$EXECUTABLE" start "$@"  

其實上面簡單來說就做了兩件事

1. 拿到腳本的真正路徑 
2. 執行catalina.sh的start命令 

而shutdown.sh和start.sh命令一樣，只不過后面是執行catalina.sh的stop命令

catalina.sh腳本

腳本中重要的步驟有以下幾個

1.設置兩個重要的環境變量，CATALINA_HOME、CATALINA_BASE

1. PRGDIR=`dirname "$PRG"`  
2.     [ -z "$CATALINA_HOME" ] && CATALINA_HOME=`cd "$PRGDIR/.." >/dev/null; pwd`  
3.     [ -z "$CATALINA_BASE" ] && CATALINA_BASE="$CATALINA_HOME"  

設置CLASSPATH變量，這里注意，默認是沒有setenv.sh文件的，可以自己新建一個并添加參數

1. CLASSPATH=  
2.   
3. if [ -r "$CATALINA_BASE/bin/setenv.sh" ]; then  
4.   
5. . "$CATALINA_BASE/bin/setenv.sh"  
6.   
7. elif [ -r "$CATALINA_HOME/bin/setenv.sh" ]; then  
8.   
9. . "$CATALINA_HOME/bin/setenv.sh"  
10.   
11. fi  

將bootstrap.jar作為CLASSPATH變量傳進去

1. if [ ! -z "$CLASSPATH" ] ; then  
2.      CLASSPATH="$CLASSPATH":  
3.     fi  
4.     CLASSPATH="$CLASSPATH""$CATALINA_HOME"/bin/bootstrap.jar  
5.     if [ -z "$CATALINA_OUT" ] ; then  
6.      CATALINA_OUT="$CATALINA_BASE"/logs/catalina.out  
7.     fi  

執行腳本參數，執行bootstrap.jar中的Bootstrap類中main方法，并傳入參數start

1. hift  
2.   
3. eval exec ""$_RUNJAVA"" ""$LOGGING_CONFIG"" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS   
4.   
5. -D$ENDORSED_PROP=""$JAVA_ENDORSED_DIRS""   
6.   
7. -classpath ""$CLASSPATH""   
8.   
9. -Djava.security.manager   
10.   
11. -Djava.security.policy==""$CATALINA_BASE/conf/catalina.policy""   
12.   
13. -Dcatalina.base=""$CATALINA_BASE""   
14.   
15. -Dcatalina.home=""$CATALINA_HOME""   
16.   
17. -Djava.io.tmpdir=""$CATALINA_TMPDIR""   
18.   
19. org.apache.catalina.startup.Bootstrap "$@" start  

在上面腳本中我們可以看出最后執行的都是從Bootstrap的main方法作為入口的，所以我們打開Tomcat源碼進去Bootstrap類中看它到底做了什么。

啟動類分析

作為Tomcat的入口類，我們先看看Bootstrap中做了什么。這里只貼出main方法中重要的代碼。

1. //初始化類加載器并且將Catalina文件加載進內存中  
2. bootstrap.init();  
3. String command = "start";  
4. if (args.length > 0) {  
5.  command = args[args.length - 1];  
6. }  
7. if (command.equals("startd")) {  
8.  args[args.length - 1] = "start";  
9.  //調用Catalina.java的load方法  
10.  daemon.load(args);  
11.  //調用Catalina.java的start  
12.  daemon.start();  
13. } else if (command.equals("stopd")) {  
14.  args[args.length - 1] = "stop";  
15.  //調用Catalina.java的stop  
16.  daemon.stop();  
17. } else if (command.equals("start")) {  
18.  daemon.setAwait(true);  
19.  daemon.load(args);  
20.  daemon.start();  
21.  if (null == daemon.getServer()) {  
22.  System.exit(1);  
23.  }  
24. } else if (command.equals("stop")) {  
25.  daemon.stopServer(args);  
26. } else if (command.equals("configtest")) {  
27.  daemon.load(args);  
28.  if (null == daemon.getServer()) {  
29.  System.exit(1);  
30.  }  
31.  System.exit(0);  
32. } else {  
33.  log.warn("Bootstrap: command "" + command + "" does not exist.");  
34. }  

這里是根據腳本中傳入的不同命令，調用Catalina不同的方法。由于我們主要分析的Tomcat如何做到一鍵式啟停的，所以我們主要分析Catalina的start方法。

在Catalina的satrt方法中我們看到了這一句

1. getServer().start();  

隨后經過Debug都是經過了Lifecycle的start方法，我們把Lifecycle的方法列出來

1. public interface Lifecycle {  
2.  public void addLifecycleListener(LifecycleListener listener);  
3.  public LifecycleListener[] findLifecycleListeners();  
4.  public void removeLifecycleListener(LifecycleListener listener);  
5.  public void init() throws LifecycleException;  
6.  public void start() throws LifecycleException;  
7.  public void stop() throws LifecycleException;  
8.  public void destroy() throws LifecycleException;  
9.  public LifecycleState getState();  
10.  public String getStateName();  
11.  public interface SingleUse {  
12.  }  
13. }  

然后再看它的實現類，我們發現我們前面所講的整體架構中的組件都實現了此類。而在它的子類LifecycleBase實現了start、init、stop等方法，并且里面都相應調用了startInternal、initInternal、stopInternal方法，這里我們如果對于設計模式了解的話，應該會想到這里運用了模板設計模式，抽象出所有子類的公有的代碼，然后重新定義一個內部抽象方法，其子類實現自己的定制化的操作。

在Server.xml中我們發現第一個層級也是Server，然后Catalina的satrt方法中第一個啟動的也是Server。

上面表示了Tomcat所有模塊的層級結構，只要是帶有層級的結構，我們應該能夠立馬想到組合設計模式，從這個層級結構中我們能夠得到模塊之間的關系，有大有小，有內有外。

• 有大有小：大組件管理小組件，例如Server管理Service，Service管理連接器和容器
• 有內有外：連接器控制對外的連接，而外層組件調用內層組件完成業務功能。即請求處理的過程是由外層組件驅動的。

那么根據上面的兩條，我們知道，有小才有大，有內才有外。這也就是整個層級的加載順序，先加載小組件再加載大組件，先加載內層組件再加載外層組件。此時我們應該就明白了Tomcat是如何做到一鍵式啟停的了。通過層級結構，加載的優先級。層層迭代進行啟動。而停止和啟動差不多。也是層層迭代進行停止。