tomcat启动(二)org.apache.catalina.startup.Bootstrap分析

时间：2021-09-05 13:44:20
/**

 * Bootstrap loader for Catalina.  This application constructs a class loader

 * for use in loading the Catalina internal classes (by accumulating all of the

 * JAR files found in the "server" directory under "catalina.home"), and

 * starts the regular execution of the container.  The purpose of this

 * roundabout approach is to keep the Catalina internal classes (and any

 * other classes they depend on, such as an XML parser) out of the system

 * class path and therefore not visible to application level classes.

这个类构造一个类加载器来加载Catalina内部类（通过在server目录下的catalina.home来找到所有的jar文件），和开始定期执行container容器。

这种回旋处理方法的目的是保持Catalina内部类（以及其依赖的任何其他类，如XML解析器）脱离系统类路径，因此对应用程序级别不可见

入口main方法

在进入main之前会前执行static静态模块代码：主要是设置catalina.home和catalina.base的路径

public static void main(String args[]) {
bootstrap初始化init()
设置守护进程daemon = bootstrap;
识别启动bootstrap时传递的参数command = args[args.length - 1];//start
daemon.setAwait(true);
daemon.load(args);
daemon.start();}

上面damemon守护进程的方法setAwait(),load(),start()其实是反射调用的org.apache.catalina.startup.Catalina类的方法

到这里其实就进入到Catalina类的。

--------------------------Bootstrap类解析完毕------下面是对init方法解释---------------------------------------------------------

初始化init方法(初始化守护进程)：

在这个方法里主要流程

1、初始化类加载器initClassLoaders()----------commonLoader，catalinaLoader，sharedLoade会先加载catalina.base/conf/catalina.propertises配置文件

然后读取common.loader键所对应的值

Catalina.properties文件下

common.loader="${catalina.base}/lib","${catalina.base}/lib/*.jar","${catalina.home}/lib","${catalina.home}/lib/*.jar"

补充下：

commonLoader再定义时使用ClassLoader定义，但是创建返回的是URLClassLoader。公有类定义，子类返回，这个思路值得借鉴

public class URLClassLoader extends SecureClassLoader implements Closeable

URLClassLoader继承SecureClassLoader

public class SecureClassLoader extends ClassLoader

SecureClassLoader继承ClassLoader

ClassLoader commonLoader = null;
ClassLoader catalinaLoader = null;
ClassLoader sharedLoader = null;

private void initClassLoaders() {

        try {

            commonLoader = createClassLoader("common", null);

            if( commonLoader == null ) {

                // no config file, default to this loader - we might be in a 'single' env.

                commonLoader=this.getClass().getClassLoader();

            }

            catalinaLoader = createClassLoader("server", commonLoader);

            sharedLoader = createClassLoader("shared", commonLoader);

createClassLoader()

获取common.loader键对应的值

String value = CatalinaProperties.getProperty(name + ".loader");

String[] repositoryPaths = getPaths(value);

。。。省略部分代码

        for (String repository : repositoryPaths) {

            // Check for a JAR URL repository

            try {

                @SuppressWarnings("unused")

                URL url = new URL(repository);

                repositories.add(

                        new Repository(repository, RepositoryType.URL));

                continue;

            } catch (MalformedURLException e) {

                // Ignore

            }

            // Local repository

            if (repository.endsWith("*.jar")) {

                repository = repository.substring

                    (0, repository.length() - "*.jar".length());

                repositories.add(

                        new Repository(repository, RepositoryType.GLOB));

            } else if (repository.endsWith(".jar")) {

                repositories.add(

                        new Repository(repository, RepositoryType.JAR));

            } else {

                repositories.add(

                        new Repository(repository, RepositoryType.DIR));

            }

        }
return ClassLoaderFactory.createClassLoader(repositories, parent);最后调用这个方法将repositories内存放的类和资源的路径绑定到commonLoader。这里返回的是new URLClassLoader

createClassLoader()方法获取到

common.loader="${catalina.base}/lib","${catalina.base}/lib/*.jar","${catalina.home}/lib","${catalina.home}/lib/*.jar"

接下来会判断这个字符串是以什么结尾

${catalina.base}/lib
${catalina.home}/lib

/lib是目录 commonLoader会加载整个目录下的资源，包括所有clsss、jar包及其它类型资源

${catalina.base}/lib/*.jar
${catalina.home}/lib/*.jar

表示整个目录下所有jar包资源，仅仅是.jar后缀的资源

解释下RepositoryType这是一个枚举类型，定义再类org.apache.catalina.startup.ClassLoaderFactory内部

public static enum RepositoryType {

        DIR,表示整个目录下的资源，包括所有clsss、jar包及其它类型资源。

        GLOB,表示整个目录下所有jar包资源，仅仅是.jar后缀的资源。

        JAR,表示单个jar包资源。

        URL表示网络上得某个jar包资源

    }

2、为当前线程设置classLoader

Thread.currentThread().setContextClassLoader(catalinaLoader);catalinaLoader其实就是commonLoader

用静态类SecurityClassLoad预加载类资源

SecurityClassLoad.securityClassLoad(catalinaLoader);

securityClassLoad(ClassLoader loader, boolean requireSecurityManager)　　{　　　
。。。。。略。。。。。。。。。。
　　　　　loadCorePackage(loader);

        loadCoyotePackage(loader);

        loadLoaderPackage(loader);

        loadRealmPackage(loader);

        loadServletsPackage(loader);

        loadSessionPackage(loader);

        loadUtilPackage(loader);

        loadValvesPackage(loader);

        loadWebResourcesPackage(loader);

        loadJavaxPackage(loader);

        loadConnectorPackage(loader);

        loadTomcatPackage(loader);
}

3、初始化org.apache.catalina.startup.Catalina利用反射调用它的setParentClassLoader设置sharedLoader；（设置的parentClassLoader的原因和用处暂不完全清楚，看源码估计会在server.xml加载部分会使用到）

参考资源

Tomcat内核之类加载器工厂

具体源码解析：http://blog.csdn.net/u011545486/article/details/52002626

相关文章