• Tomcat启动分析(Tomcat7.0)


    1)bin目录下的bootstrap.jar中的main方法启动Tomcat

    org.apache.catalina.startup.Bootstrap类下的main方法

    可以看到Bootstrap类使用单例方式在main方法中初始化Bootstrap对象

    private static Bootstrap daemon = null;
    private Object catalinaDaemon = null;
    protected ClassLoader commonLoader = null;
    protected ClassLoader catalinaLoader = null;
    protected ClassLoader sharedLoader = null;
    

     调用Bootstrap对象的init()方法

    public static void main(String[] args)
    {
        if (daemon == null)
        {
          Bootstrap bootstrap = new Bootstrap();
          try {
            bootstrap.init();
          } catch (Throwable t) {
            handleThrowable(t);
            t.printStackTrace();
            return;
          }
          daemon = bootstrap;
        }
        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(new StringBuilder().append("Bootstrap: command "").append(command).append("" does not exist.").toString());
          }
        }
        catch (Throwable t) {
          if (((t instanceof InvocationTargetException)) && (t.getCause() != null))
          {
            t = t.getCause();
          }
          handleThrowable(t);
          t.printStackTrace();
          System.exit(1);
        }
      }
      
    

    Bootstrap对象的init()方法,引导类Bootstrap负责引导,在其init方法内部创建容器启动所需的类加载器,以及用于JMX监控的MBeanServer

    public void init()
        throws Exception
      {
        setCatalinaHome();
        setCatalinaBase();
        
        initClassLoaders();
        
        Thread.currentThread().setContextClassLoader(this.catalinaLoader);
        
        SecurityClassLoad.securityClassLoad(this.catalinaLoader);
        
        if (log.isDebugEnabled())
          log.debug("Loading startup class");
        Class<?> startupClass = this.catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
        
        Object startupInstance = startupClass.newInstance();
        
        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] = this.sharedLoader;
        Method method = startupInstance.getClass().getMethod(methodName, paramTypes);
        
        method.invoke(startupInstance, paramValues);
        
        this.catalinaDaemon = startupInstance;
      }
      
    

    仍然在Bootstrap类中,初始化所需要的类加载器

    private void initClassLoaders()
      {
        try
        {
          this.commonLoader = createClassLoader("common", null);
          if (this.commonLoader == null)
          {
            this.commonLoader = getClass().getClassLoader();
          }
          this.catalinaLoader = createClassLoader("server", this.commonLoader);
          this.sharedLoader = createClassLoader("shared", this.commonLoader);
        } catch (Throwable t) {
          handleThrowable(t);
          log.error("Class loader creation threw exception", t);
          System.exit(1);
        }
      }
    

     

    我们继续看到main方法中调用了Bootstrap对象的load(args)方法和start()方法

    daemon.load(args);
    daemon.start();

    我们看到load(args)方法,Bootstrap调用Catalina的load()方法加载Server的配置(也就是server.xml),将加载的配置信息委托给Digester类进行相关内容的解析。

    通过反射调用了Bootstrap对象中catalinaDaemon对象的load()方法,

    private void load(String[] arguments)
        throws Exception
      {
        String methodName = "load";
        Object[] param;
        Class<?>[] paramTypes;
        Object[] param; if ((arguments == null) || (arguments.length == 0)) {
          Class<?>[] paramTypes = null;
          param = null;
        } else {
          paramTypes = new Class[1];
          paramTypes[0] = arguments.getClass();
          param = new Object[1];
          param[0] = arguments;
        }
        Method method = this.catalinaDaemon.getClass().getMethod(methodName, paramTypes);
        
        if (log.isDebugEnabled())
          log.debug(new StringBuilder().append("Calling startup class ").append(method).toString());
        method.invoke(this.catalinaDaemon, param);
      }
    

      

    我们可以看到在上面的init()方法中初始化了org.apache.catalina.startup.Catalina对象,通过之前初始化的catalinaLoader类加载器

    该类在lib包下的catalina.jar包中

     Class<?> startupClass = this.catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");
        
        Object startupInstance = startupClass.newInstance();
        
        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] = this.sharedLoader;
        Method method = startupInstance.getClass().getMethod(methodName, paramTypes);
        
        method.invoke(startupInstance, paramValues);
        
        this.catalinaDaemon = startupInstance;
    

      

    我们看该类中的load方法是如何加载server.xml文件的。

    public void load()
      {
        long t1 = System.nanoTime();
        
        initDirs();
        
        initNaming();
        
        Digester digester = createStartDigester();
        
        InputSource inputSource = null;
        InputStream inputStream = null;
        File file = null;
        try {
          file = configFile();
          inputStream = new FileInputStream(file);
          inputSource = new InputSource(file.toURI().toURL().toString());
        } catch (Exception e) {
          if (log.isDebugEnabled()) {
            log.debug(sm.getString("catalina.configFail", new Object[] { file }), e);
          }
        }
        if (inputStream == null) {
          try {
            inputStream = getClass().getClassLoader().getResourceAsStream(getConfigFile());
            
            inputSource = new InputSource(getClass().getClassLoader().getResource(getConfigFile()).toString());
          }
          catch (Exception e)
          {
            if (log.isDebugEnabled()) {
              log.debug(sm.getString("catalina.configFail", new Object[] { getConfigFile() }), e);
            }
          }
        }
        
        if (inputStream == null) {
          try {
            inputStream = getClass().getClassLoader().getResourceAsStream("server-embed.xml");
            
            inputSource = new InputSource(getClass().getClassLoader().getResource("server-embed.xml").toString());
          }
          catch (Exception e)
          {
            if (log.isDebugEnabled()) {
              log.debug(sm.getString("catalina.configFail", new Object[] { "server-embed.xml" }), e);
            }
          }
        }
        
        if ((inputStream == null) || (inputSource == null)) {
          if (file == null) {
            log.warn(sm.getString("catalina.configFail", new Object[] { getConfigFile() + "] or [server-embed.xml]" }));
          }
          else {
            log.warn(sm.getString("catalina.configFail", new Object[] { file.getAbsolutePath() }));
            
            if ((file.exists()) && (!file.canRead())) {
              log.warn("Permissions incorrect, read permission is not allowed on the file.");
            }
          }
          return;
        }
        try
        {
          inputSource.setByteStream(inputStream);
          digester.push(this);
          digester.parse(inputSource);
          
          try
          {
            inputStream.close();
          }
          catch (IOException e) {}
          
          getServer().setCatalina(this);
        }
        catch (SAXParseException spe)
        {
          log.warn("Catalina.start using " + getConfigFile() + ": " + spe.getMessage()); return;
        }
        catch (Exception e)
        {
          log.warn("Catalina.start using " + getConfigFile() + ": ", e); return;
        }
        finally {
          try {
            inputStream.close();
          }
          catch (IOException e) {}
        }
        
        initStreams();
        
        try
        {
          getServer().init();
        } catch (LifecycleException e) {
          if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE")) {
            throw new Error(e);
          }
          log.error("Catalina.start", e);
        }
        
        long t2 = System.nanoTime();
        if (log.isInfoEnabled()) {
          log.info("Initialization processed in " + (t2 - t1) / 1000000L + " ms");
        }
      }
      
      public void load(String[] args)
      {
        try
        {
          if (arguments(args)) {
            load();
          }
        } catch (Exception e) {
          e.printStackTrace(System.out);
        }
      }
    
    protected boolean arguments(String[] args)
      {
        boolean isConfig = false;
        
        if (args.length < 1) {
          usage();
          return false;
        }
        
        for (int i = 0; i < args.length; i++) {
          if (isConfig) {
            this.configFile = args[i];
            isConfig = false;
          } else if (args[i].equals("-config")) {
            isConfig = true;
          } else if (args[i].equals("-nonaming")) {
            setUseNaming(false);
          } else { if (args[i].equals("-help")) {
              usage();
              return false; }
            if (args[i].equals("start")) {
              this.starting = true;
              this.stopping = false;
            } else if (args[i].equals("configtest")) {
              this.starting = true;
              this.stopping = false;
            } else if (args[i].equals("stop")) {
              this.starting = false;
              this.stopping = true;
            } else {
              usage();
              return false;
            }
          }
        }
        return true;
      }

    看到Catalina类当中的变量,表明解析文件的位置。

    protected String configFile = "conf/server.xml";
    
    protected File configFile()
      {
        File file = new File(this.configFile);
        if (!file.isAbsolute()) {
          file = new File(System.getProperty("catalina.base"), this.configFile);
        }
        return file;
      }
    

    看到configFile方法创建File对象的过程

    我们将看到load方法中调用getServer().init()调用 Server对象的init方法。

    Catalina获取到Server的配置信息后,执行StandardServer容器的init()方法。Tomcat的所有容器类都实现了统一的Lifecycle接口,由基类LifecycleBase提供统一的init方法来负责处理容器的状态,调用模板方法initInternal来处理各个容器自身所负责的内容。关于Tomcat的容器结构可以参看本系列文章的《Tomcat7源码解读(一)——容器静态结构概述》。StandardServer容器在其initInternal()方法中完成Mbean的设定,GlobalNamingResources的初始化和类加载器的设置。然后执行StandardService容器的init方法。

    StandardService同StandardServer容器,由基类LifecycleBase完成容器的生命周期状态设定,而在initInternal()方法中启动Container,Executor,Connector的init方法

    StandardService类位于lib包下的catalina.jar包中,

    org.apache.catalina.core.StandardService的父类中有init方法,

    public final synchronized void init()
        throws LifecycleException
      {
        if (!this.state.equals(LifecycleState.NEW)) {
          invalidTransition("before_init");
        }
        setStateInternal(LifecycleState.INITIALIZING, null, false);
        try
        {
          initInternal();
        } catch (Throwable t) {
          ExceptionUtils.handleThrowable(t);
          setStateInternal(LifecycleState.FAILED, null, false);
          throw new LifecycleException(sm.getString("lifecycleBase.initFail", new Object[] { toString() }), t);
        }
        
        setStateInternal(LifecycleState.INITIALIZED, null, false);
      }
      
    

    是在org.apache.catalina.util.LifecycleBase类当中,调用了initInternal()方法。

    看到LifecyceBase类的父类中

    protected void initInternal()
        throws LifecycleException
      {
        if (this.oname == null) {
          this.mserver = Registry.getRegistry(null, null).getMBeanServer();
          
          this.oname = register(this, getObjectNameKeyProperties());
        }
      }
    
    protected void initInternal()
        throws LifecycleException
      {
        super.initInternal();
        
        this.onameStringCache = register(new StringCache(), "type=StringCache");
        
        MBeanFactory factory = new MBeanFactory();
        factory.setContainer(this);
        this.onameMBeanFactory = register(factory, "type=MBeanFactory");
        
        this.globalNamingResources.init();
        
        if (getCatalina() != null) {
          ClassLoader cl = getCatalina().getParentClassLoader();
          
          while ((cl != null) && (cl != ClassLoader.getSystemClassLoader())) {
            if ((cl instanceof URLClassLoader)) {
              URL[] urls = ((URLClassLoader)cl).getURLs();
              for (URL url : urls) {
                if (url.getProtocol().equals("file")) {
                  try {
                    File f = new File(url.toURI());
                    if ((f.isFile()) && (f.getName().endsWith(".jar")))
                    {
                      ExtensionValidator.addSystemResource(f);
                    }
                  }
                  catch (URISyntaxException e) {}catch (IOException e) {}
                }
              }
            }
            
            cl = cl.getParent();
          }
        }
        
        for (int i = 0; i < this.services.length; i++) {
          this.services[i].init();
        }
      }
    

      

    看到Bootstrap类当中调用玩load方法之后,开始调用start方法,方法也是调用Catalina类当中的start方法来启动Tomcat

    public void start()
      {
        if (getServer() == null) {
          load();
        }
        
        if (getServer() == null) {
          log.fatal("Cannot start server. Server instance is not configured.");
          return;
        }
        
        long t1 = System.nanoTime();
        
        try
        {
          getServer().start();
        } catch (LifecycleException e) {
          log.error("Catalina.start: ", e);
        }
        
        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 CatalinaShutdownHook();
          }
          Runtime.getRuntime().addShutdownHook(this.shutdownHook);
          
          LogManager logManager = LogManager.getLogManager();
          if ((logManager instanceof ClassLoaderLogManager)) {
            ((ClassLoaderLogManager)logManager).setUseShutdownHook(false);
          }
        }
        
        if (this.await) {
          await();
          stop();
        }
      }
    

    看到调用的还是StandardServer类的start方法来启动Tomcat容器

    看到类似于init的方式,我们看到也是通过调用org.apache.catalina.util.LifeCycleBase类的start方法调用一系列的startInternal方法来启动的

    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 (log.isDebugEnabled()) {
            Exception e = new LifecycleException();
            log.debug(sm.getString("lifecycleBase.alreadyStarted", new Object[] { toString() }), e);
          }
          else if (log.isInfoEnabled()) {
            log.info(sm.getString("lifecycleBase.alreadyStarted", new Object[] { toString() }));
          }
          
          return;
        }
        
        if (this.state.equals(LifecycleState.NEW)) {
          init();
        } else if (this.state.equals(LifecycleState.FAILED)) {
          stop();
        } else if ((!this.state.equals(LifecycleState.INITIALIZED)) && (!this.state.equals(LifecycleState.STOPPED)))
        {
          invalidTransition("before_start");
        }
        
        setStateInternal(LifecycleState.STARTING_PREP, null, false);
        try
        {
          startInternal();
        } catch (Throwable t) {
          ExceptionUtils.handleThrowable(t);
          setStateInternal(LifecycleState.FAILED, null, false);
          throw new LifecycleException(sm.getString("lifecycleBase.startFail", new Object[] { toString() }), t);
        }
        
        if ((this.state.equals(LifecycleState.FAILED)) || (this.state.equals(LifecycleState.MUST_STOP)))
        {
          stop();
        }
        else
        {
          if (!this.state.equals(LifecycleState.STARTING)) {
            invalidTransition("after_start");
          }
          
          setStateInternal(LifecycleState.STARTED, null, false);
        }
      }
    

      

  • 相关阅读:
    Vue学习笔记【28】——Vue路由(使用 children 属性实现路由嵌套)
    Vue学习笔记【27】——Vue路由(设置路由)
    Vue学习笔记【26】——Vue路由(什么是路由)
    Vue学习笔记【25】——Vue组件(组件间传值)
    Vue学习笔记【24】——Vue组件(组件切换)
    Vue学习笔记【23】——Vue组件(组件的定义)
    ga统计
    token验证机制
    网站发布(项目上线流程)
    使用CSS将图片转换成黑白(灰色、置灰) & 毛玻璃效果
  • 原文地址:https://www.cnblogs.com/wuxinliulei/p/5158523.html
Copyright © 2020-2023  润新知