浅读tomcat架构设计和tomcat启动过程(1)
一图甚千言,这张图真的是耽搁我太多时间了:
下面的tomcat架构设计代码分析,和这张图息息相关.
使用maven搭建本次的环境,贴出pom.xml完整内容:
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>groupId</groupId> <artifactId>JavaWebDemo</artifactId> <version>1.0-SNAPSHOT</version> <dependencies> <dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>2.5</version> </dependency> <dependency> <groupId>org.apache.tomcat</groupId> <artifactId>tomcat-catalina</artifactId> <version>8.0.14</version> </dependency> </dependencies> <properties> <maven.compiler.source>8</maven.compiler.source> <maven.compiler.target>8</maven.compiler.target> </properties> </project>
至此,环境已经准备就绪,就可以愉快看代码了.
tomcat的Server是由org.apache.catalina.startup.Catalina来管理的,Catalina是tomcat的管理类可以通过反射加载查看代码:
Catalina类中有很多方法,他们具有不同的含义,其中
public void load() {... public void start() {... public void stop() {...
这些方法用于管理tomcat的生命周期,其中load方法:
load方法重要前半部分:
public void load() { long t1 = System.nanoTime(); this.initDirs(); this.initNaming(); Digester digester = this.createStartDigester(); InputSource inputSource = null; InputStream inputStream = null; File file = null; try { file = this.configFile(); inputStream = new FileInputStream(file); inputSource = new InputSource(file.toURI().toURL().toString());
load方法重要后半部分:
this.getServer().setCatalina(this); this.getServer().setCatalinaHome(Bootstrap.getCatalinaHomeFile()); this.getServer().setCatalinaBase(Bootstrap.getCatalinaBaseFile()); this.initStreams(); try { this.getServer().init();
其中load方法是根据创建conf/server.xml文件来创建Server,并调用Server的init方法进行初始化
start和stop方法暂定,下面会讲到.这三个方法都会按照容器结构逐层调用相应的方法.
不过tomcat的入口main方法并不在Catalina类里,而是在org.apache.catalina.startup.Bootstrap类中,这样做的好处是tomcat管理类和入口类实现分离
Bootstrap是tomcat的入口,正常情况下启动tomcat就是调用Bootstrap类的main方法,代码如下:
public static void main(String[] args) { if (daemon == null) {
//新建一个bootstrap Bootstrap bootstrap = new Bootstrap(); try {
//初始化 bootstrap.init(); } catch (Throwable var3) { handleThrowable(var3); var3.printStackTrace(); return; } //赋值给daemon daemon = bootstrap; } else { Thread.currentThread().setContextClassLoader(daemon.catalinaLoader); } try { String command = "start"; if (args.length > 0) { command = args[args.length - 1]; } if (command.equals("startd")) { args[args.length - 1] = "start"; daemon.load(args); daemon.start(); } else if (command.equals("stopd")) { args[args.length - 1] = "stop"; daemon.stop(); } else if (command.equals("start")) { daemon.setAwait(true); daemon.load(args); daemon.start(); } else if (command.equals("stop")) { daemon.stopServer(args); } else if (command.equals("configtest")) { daemon.load(args); if (null == daemon.getServer()) { System.exit(1); } System.exit(0); } else { log.warn("Bootstrap: command \"" + command + "\" does not exist."); } } catch (Throwable var4) { Throwable t = var4; if (var4 instanceof InvocationTargetException && var4.getCause() != null) { t = var4.getCause(); } handleThrowable(t); t.printStackTrace(); System.exit(1); } }
Bootstrap类中的main方法只干两件事情,(1):新建一个bootstrap,并执行init方法初始化,初始化后赋值给daemon,然后处理main方法传入进来的命令,来判断执行对应的方法,比如传入start,执行start方法,如果传入错误的命令,直接告警command不存在.
在main方法中,daemon调用了好几个方法,当main方法传入的命令是start的时候,会自动调用setAwait(true),load()和start()方法:
} else if (command.equals("start")) { daemon.setAwait(true); daemon.load(args); daemon.start();
跟进start方法:
org.apache.catalina.startup.Bootstrap#182:
public void start() throws Exception { if (this.catalinaDaemon == null) { this.init(); } Method method = this.catalinaDaemon.getClass().getMethod("start", (Class[])null); method.invoke(this.catalinaDaemon, (Object[])null); }
首先会判断你的catalinaDaemon是否为空,不为空,再用反射调用start方法,然后实例化类.
所以上面的daemon.start相当于:(Catalina)catalinaDaemon.start()
同理,其他的方法如setAwait(true)和load方法也是通过反射调用,这里不在展示代码.
从前面的分析,我们知道tomcat入口类会调用tomcat管理类的start,load,setAwait方法:
tomcat入口类Bootstarp和tomcat管理类Catalina是相辅相成的:
Catalina的启动主要是调用setAwait,load和start方法来完成的,setAwait方法用于设置Server启动完成后是否进入等待状态的标志,如果为true就进入,否则讲究不进入
load方法会自动加载server.xml配置文件,创建并初始化Server [getServer.init()]
start方法用于启动服务器
下面一个个看下这些方法:
首先来看setAwait方法:
org.apache.startup.Catalina:
public void setAwait(boolean b) { this.await = b; }
这个方法就是设置await的属性值,await属性会在start方法中的服务器启动完成之后,使用它来判断是否进入等待状态:
查看load方法,文章开头已经讲了load方法,load方法中会根据conf/server.xml创建Server对象,并调用server的init方法来初始化
Catalina的start方法查看:
public void start() { if (this.getServer() == null) { this.load(); } if (this.getServer() == null) { log.fatal("Cannot start server. Server instance is not configured."); } else { long t1 = System.nanoTime(); try {
//调用Server的start方法启动服务器 this.getServer().start(); } catch (LifecycleException var7) { log.fatal(sm.getString("catalina.serverStartFail"), var7); try { this.getServer().destroy(); } catch (LifecycleException var6) { log.debug("destroy() failed for failed Server ", var6); } return; } long t2 = System.nanoTime(); if (log.isInfoEnabled()) { log.info("Server startup in " + (t2 - t1) / 1000000L + " ms"); } if (this.useShutdownHook) { if (this.shutdownHook == null) { this.shutdownHook = new Catalina.CatalinaShutdownHook(); } Runtime.getRuntime().addShutdownHook(this.shutdownHook); LogManager logManager = LogManager.getLogManager(); if (logManager instanceof ClassLoaderLogManager) { ((ClassLoaderLogManager)logManager).setUseShutdownHook(false); } } //判断等待状态 if (this.await) { this.await(); this.stop(); } } }
start方法主要调用了server的start方法启动服务器,并根据等待状态判断是否让程序进行等待状态
这里首先判断getServer是否存在,如果不存在就启动server的load方法进行初始化Server.然后调用Server的start方法来启动服务器,注册判断await属性.在tomcat入口类Bootstrap类中,设置await为true,所以需要进入等待状态,跟进逻辑判断的await方法,静态调试进入:
org.apache.catalina.core.StandServer:
发现await方法内部会执行一个while循环,这样程序就会停到awit方法,当await方法里的while循环退出时,就会执行stop方法,从而关闭服务器.
通过上面的学习,我们简单梳理了tomcat的入口类Bootstrap类和tomcat的管理类Catalina
继续学习往下突进:
Server接口的默认实现是org.apache.catalina.core.StandardServer,可通过反射加载进入查看代码:
public final class StandardServer extends LifecycleMBeanBase implements Server {
StandardServer类继承自LifecycleMBeanBase类,跟进LifecycleMBeanBase类:
org.apache.catalina.util.LifecycleMBeanBase:
LifecycleMBeanBase类又继承自LifecycleBase:
org.apache.catalina.util.LifecycleBase:
查看LifecycleBase类的init和start方法:
org.apache.catalina.util.LifecycleBase:
public final synchronized void init() throws LifecycleException { if (!this.state.equals(LifecycleState.NEW)) { this.invalidTransition("before_init"); } this.setStateInternal(LifecycleState.INITIALIZING, (Object)null, false); try { this.initInternal(); } catch (Throwable var2) { ExceptionUtils.handleThrowable(var2); this.setStateInternal(LifecycleState.FAILED, (Object)null, false); throw new LifecycleException(sm.getString("lifecycleBase.initFail", new Object[]{this.toString()}), var2); } this.setStateInternal(LifecycleState.INITIALIZED, (Object)null, false); }
发现init方法会调用initInternal方法:
initInternal是一个模块方法,需要其子类去实现此方法.
LifecycleBase类start方法:
截取部分:
public final synchronized void start() throws LifecycleException { if (!LifecycleState.STARTING_PREP.equals(this.state) && !LifecycleState.STARTING.equals(this.state) && !LifecycleState.STARTED.equals(this.state)) { if (this.state.equals(LifecycleState.NEW)) { this.init(); } else if (this.state.equals(LifecycleState.FAILED)) { this.stop(); } else if (!this.state.equals(LifecycleState.INITIALIZED) && !this.state.equals(LifecycleState.STOPPED)) { this.invalidTransition("before_start"); } this.setStateInternal(LifecycleState.STARTING_PREP, (Object)null, false); try { this.startInternal(); } catch (Throwable var2) { ExceptionUtils.handleThrowable(var2); this.setStateInternal(LifecycleState.FAILED, (Object)null, false); throw new LifecycleException(sm.getString("lifecycleBase.startFail", new Object[]{this.toString()}), var2); }
会调用this.startInternal();方法:
startInternal方法也是模块方法,需要其子类去具体实现方法:
我们的StandardServer类和LifecycleMBeanBase类都是继承自LifecycleBase,都是LifecycleBase的子类,都可以去实现方法的.
回到StandardServer类,查看initInternal方法实现:
org.apache.catalina.core.StandardServer:
protected void initInternal() throws LifecycleException { super.initInternal(); this.onameStringCache = this.register(new StringCache(), "type=StringCache"); MBeanFactory factory = new MBeanFactory(); factory.setContainer(this); this.onameMBeanFactory = this.register(factory, "type=MBeanFactory"); this.globalNamingResources.init(); if (this.getCatalina() != null) {
..................
查看startInternal方法具体实现:
protected void startInternal() throws LifecycleException { this.fireLifecycleEvent("configure_start", (Object)null); this.setState(LifecycleState.STARTING); this.globalNamingResources.start(); synchronized(this.servicesLock) { for(int i = 0; i < this.services.length; ++i) { this.services[i].start(); } } }
除了startInternal和initInternal方法,StandardServer中还实现了await方法,Catalina中就是调用它让服务器进入等待状态的:
public void await() { if (this.port != -2) { if (this.port == -1) { try { this.awaitThread = Thread.currentThread(); while(!this.stopAwait) { try { Thread.sleep(10000L); } catch (InterruptedException var64) { } } } finally { this.awaitThread = null; } } else { try { this.awaitSocket = new ServerSocket(this.port, 1, InetAddress.getByName(this.address)); } catch (IOException var67) { log.error("StandardServer.await: create[" + this.address + ":" + this.port + "]: ", var67); return; } boolean var32 = false; ServerSocket serverSocket; try { var32 = true; this.awaitThread = Thread.currentThread(); while(true) { if (this.stopAwait) { var32 = false; break; } serverSocket = this.awaitSocket; if (serverSocket == null) { var32 = false; break; } Socket socket = null; StringBuilder command = new StringBuilder(); label603: { label602: { try { label618: { long acceptStartTime = System.currentTimeMillis(); InputStream stream; try { socket = serverSocket.accept(); socket.setSoTimeout(10000); stream = socket.getInputStream(); } catch (SocketTimeoutException var69) { log.warn(sm.getString("standardServer.accept.timeout", new Object[]{System.currentTimeMillis() - acceptStartTime}), var69); continue; } catch (AccessControlException var70) { log.warn("StandardServer.accept security exception: " + var70.getMessage(), var70); continue; } catch (IOException var71) { if (this.stopAwait) { break label602; } log.error("StandardServer.await: accept: ", var71); break label618; } int expected; for(expected = 1024; expected < this.shutdown.length(); expected += this.random.nextInt() % 1024) { if (this.random == null) { this.random = new Random(); } } while(true) { if (expected <= 0) { break label603; } boolean var8 = true; int ch; try { ch = stream.read(); } catch (IOException var66) { log.warn("StandardServer.await: read: ", var66); ch = -1; } if (ch < 32) { break label603; } command.append((char)ch); --expected; } } } finally { try { if (socket != null) { socket.close(); } } catch (IOException var63) { } } var32 = false; break; } var32 = false; break; } boolean match = command.toString().equals(this.shutdown); if (match) { log.info(sm.getString("standardServer.shutdownViaPort")); var32 = false; break; } log.warn("StandardServer.await: Invalid command '" + command.toString() + "' received"); } } finally { if (var32) { ServerSocket serverSocket = this.awaitSocket; this.awaitThread = null; this.awaitSocket = null; if (serverSocket != null) { try { serverSocket.close(); } catch (IOException var62) { } } } } serverSocket = this.awaitSocket; this.awaitThread = null; this.awaitSocket = null; if (serverSocket != null) { try { serverSocket.close(); } catch (IOException var65) { } } } } }
StandardServer类中的await实现代码很长,他大概率的处理逻辑是这样的:
首先判断port端口号,port=多少就进入哪个逻辑判断:
port为-1就进入一个while循环:
代码中没有break语句,只有在调用stop的时候,当stopAwait为true,才会退出循环
当port为其他值得时候,走else语句:
创建ServerSocket对象,跟进代码,发现是个绑定操作,绑定地址和端口:
往下看代码,等待接收消息,它会把等待接收消息的数据存储到StringBuilder command中:
StringBuilder command = new StringBuilder(); label603: { label602: { try { label618: { long acceptStartTime = System.currentTimeMillis(); InputStream stream; try { socket = serverSocket.accept(); socket.setSoTimeout(10000); stream = socket.getInputStream(); } catch (SocketTimeoutException var69) { log.warn(sm.getString("standardServer.accept.timeout", new Object[]{System.currentTimeMillis() - acceptStartTime}), var69); continue; } catch (AccessControlException var70) { log.warn("StandardServer.accept security exception: " + var70.getMessage(), var70); continue; } catch (IOException var71) { if (this.stopAwait) { break label602; } log.error("StandardServer.await: accept: ", var71); break label618; } int expected; for(expected = 1024; expected < this.shutdown.length(); expected += this.random.nextInt() % 1024) { if (this.random == null) { this.random = new Random(); } } while(true) { if (expected <= 0) { break label603; } boolean var8 = true; int ch; try { ch = stream.read(); } catch (IOException var66) { log.warn("StandardServer.await: read: ", var66); ch = -1; } if (ch < 32) { break label603; } command.append((char)ch); --expected; }
继续往下看代码,就是把监听接收到的命令和shutdown匹配,如果匹配上,就break退出循环:
//检查在指定端口接收到的命令是否和shutdown匹配 boolean match = command.toString().equals(this.shutdown); if (match) { log.info(sm.getString("standardServer.shutdownViaPort")); var32 = false; break; }
这里的shutdown和port对应的是conf/server.xml文件中的:
这时程会在8005端口监听shutdown命令,如果接收到就关闭tomcat. 对接收到的数据,tomcat也是有要求的:
int ch; try { ch = stream.read(); } catch (IOException var66) { log.warn("StandardServer.await: read: ", var66); ch = -1; } if (ch < 32) { break label603; }
接收到的数据ascii<32,会自动截断掉摒弃.
现在已经讲完了Server的启动过程,以及上面讲的tomcat管理类和tomcat入口类,继续冲
Service的启动过程:
Service的默认实现类是:org.apache.catalina.core.StandardService
StandardService和StandardServer一样,都继承自LifecycleMBeanBase,而LifecycleMBeanBase继承自LifecycleBase:
所以StandardService也是会调用initInternal和startInternal方法:
来看下这两个方法:
先看initInternal方法:
protected void initInternal() throws LifecycleException { super.initInternal(); if (this.container != null) { this.container.init(); } Executor[] arr$ = this.findExecutors(); int len$ = arr$.length; int len$; for(len$ = 0; len$ < len$; ++len$) { Executor executor = arr$[len$]; if (executor instanceof JmxEnabled) { ((JmxEnabled)executor).setDomain(this.getDomain()); } executor.init(); } this.mapperListener.init(); synchronized(this.connectorsLock) { Connector[] arr$ = this.connectors; len$ = arr$.length; for(int i$ = 0; i$ < len$; ++i$) { Connector connector = arr$[i$]; try { connector.init(); } catch (Exception var9) { String message = sm.getString("standardService.connector.initFailed", new Object[]{connector}); log.error(message, var9); if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE")) { throw new LifecycleException(message); } } } } }
可以发现StandardService类的initInternl方法先调用父类型的initInternl方法,然后开始调用this.container.init(); executor.init();connector.init();
完整代码:
protected void startInternal() throws LifecycleException { if (log.isInfoEnabled()) { log.info(sm.getString("standardService.start.name", new Object[]{this.name})); } this.setState(LifecycleState.STARTING); if (this.container != null) { synchronized(this.container) { this.container.start(); } } synchronized(this.executors) { Iterator i$ = this.executors.iterator(); while(true) { if (!i$.hasNext()) { break; } Executor executor = (Executor)i$.next(); executor.start(); } } this.mapperListener.start(); synchronized(this.connectorsLock) { Connector[] arr$ = this.connectors; int len$ = arr$.length; for(int i$ = 0; i$ < len$; ++i$) { Connector connector = arr$[i$]; try { if (connector.getState() != LifecycleState.FAILED) { connector.start(); } } catch (Exception var8) { log.error(sm.getString("standardService.connector.startFailed", new Object[]{connector}), var8); } } } }
可以发现StandardService类的startInternl方法,主要调用了: this.container.start(); executor.start();this.mapperListener.start();connector.start();
mapperListener是Mapper的监听器,可以监听container容器的变化,executors是用在connectors中管理线程的线程池
在server.xml配置文件中有参考用法,不过默认是注释掉的:
内容如下:
<Service name="Catalina"> <!--The connectors can use a shared executor, you can define one or more named thread pools--> <!-- <Executor name="tomcatThreadPool" namePrefix="catalina-exec-" maxThreads="150" minSpareThreads="4"/> -->
这样Connector就配置了一个tomcatThreadPool线程池,最多可以同时启动150个线程,最少4个可用线程
整个tomcat的启动流程如下:
tomcat 入口类:Bootstrap---->tomcat 管理类:Calalina----->Sever实现类:StandardServer ----->Service实现类:StandardSercice ----->MapperListencer----->Executor----->Connector
