浅读tomcat架构设计和tomcat启动过程(1)

2021年7月7日 2点热度 0条评论 来源: 飘渺红尘✨

  一图甚千言,这张图真的是耽搁我太多时间了:

    

 

 

 

 

     下面的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   

 

 

 

 

      

  

    

 

 

  

 

    原文作者:飘渺红尘✨
    原文地址: https://www.cnblogs.com/piaomiaohongchen/p/14977272.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系管理员进行删除。