Java虚拟机--Tomcat类加载

Tomcat类加载

与很多服务器应用一样,Tomcat也实现了类加载器。

在Java虚拟机类加载的基础上,Tomcat进行了稍许改动,以适应自身业务的需求。

当Tomcat启动后,它会创建一组类加载器,这些类加载器也会形成双亲委派模型中的父子关系,父类加载器在子类加载器之上:

   Bootstrap
      |
   System
      |
   Common
   /     \
Webapp1   Webapp2 ...

结合双亲委派模型来看,Tomcat的类加载结构,如图所示:

image

Tomcat在原有双亲委派模型的基础上,增加了Common类加载器、Catalina类加载器、Shared类加载,以及WebApp类加载器。

如果将两者结合起来看,那么Bootstrap对应的是Bootstrap ClassLoader和Extension ClassLoader,System对应的是Application ClassLoader,Common对应的是Common ClassLoader、Catalina ClassLoader和Shared ClassLoader,WebApp1/WebApp2..对应的是WebApp ClassLoader。

Bootstrap ClassLoader:C++编写,无具体实现类,无法通过方法获得,负责加载<Java_Runtime_Home>/lib目录下的文件。

Extension ClassLoader:Java程序编写,sun.misc.Launcher.ExtClassLoader实现,负责加载<Java_Runtime_Home>/lib/ext目录下的文件。

Application ClassLoader:Java语言编写,sun.misc.Launcher.AppClassLoader实现,负责加载Tomcat目录下lib文件夹下的bootstrap.jar、commons-daemon.jar、tomcat-juli.jar。

Common ClassLoader:Java语言编写,org.apache.catalina.loader.StandardClassLoader实现(在tomcat源码中),负责加载Tomcat目录conf文件夹下的catalina.properties文件中的common.loader属性所指定的目录。

Catalina ClassLoader:Java语言编写,org.apache.catalina.loader.StandardClassLoader实现(在tomcat源码中),负责加载Tomcat目录conf文件夹下的catalina.properties文件中的server.loader属性所指定的目录。

Shared ClassLoader:Java语言编写,org.apache.catalina.loader.StandardClassLoader实现(在tomcat源码中),负责加载Tomcat目录conf文件夹下的catalina.properties文件中的shared.loader属性所指定的目录。

WebApp ClassLoader:Java语言编写,org.apache.catalina.loader.WebappClassLoader实现(在tomcat源码中),负责加载Tomcat目录webapps文件下中应用里的/WEB-INF/lib和/WEB-INF/class.

Tomcat目录结构中,有三组目录(/common/,/server/和shared/)可以存放公用Java类库,以及第四组Web应用程序目录/WEB-INF/

放置在common目录中:类库可被Tomcat和所有的Web应用程序共同使用。

放置在server目录中:类库可被Tomcat使用,但对所有的Web应用程序都不可见。

放置在shared目录中:类库可被所有的Web应用程序共同使用,但对Tomcat自己不可见。

放置在/WebApp/WEB-INF目录中:类库仅可以被此Web应用程序使用,对Tomcat和其他Web应用程序都不可见。
tomcat7.0目录结构

值得注意的是,在Tomcat的6.0版本之后,只有在tomcat/conf/catalina.properties文件中给server.loader属性和share.loader属性赋值后,才会去建立Catalina ClassLoader和Shared ClassLoader两个类加载器的实例,否则在用到这两个类加载器的地方都会用Common ClassLoader的实例代替(org.apache.catalina.loader.StandardClassLoader),而/common、/server和/shared目录在Tomcat6.0之后就不存在了,取而代之的是/lib目录。

默认类加载器配置

Tomcat类加载源码

说完了,Tomcat类加载的结构。本小节,具体说下Tomcat的类加载机制,想要说清楚,那必须还得从Tomcat源码来入手。

找到org.apache.catalina.startup.Bootstrap类,发现该类中有main方法,没错这就是Tomcat的起点。

public static void main(String args[]) {
    if (daemon == null) {
        // 创建Bootstrap对象:
        Bootstrap bootstrap = new Bootstrap();
        try {
            // bootstrap初始化
            bootstrap.init();
        } catch (Throwable t) {
            handleThrowable(t);
            t.printStackTrace();
            return;
        }
        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")) {

            // command为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 t) {
        .....省略
    }
}

在main方法中,我们首先创建了一个Bootstrap对象,并调用其init()方法。

在初始化结束后,判断虚拟机传入的指令,通常为“start”,开始加载、启动流程,调用了daemon.load(args)、daemon.start()方法来实现。

public void init() throws Exception {
    setCatalinaHome();
    setCatalinaBase();
    // Tomcat类加载器初始化
    initClassLoaders();

    // 设置线程上下文类加载器:
    Thread.currentThread().setContextClassLoader(catalinaLoader);
    
    SecurityClassLoad.securityClassLoad(catalinaLoader);

    if (log.isDebugEnabled())
        log.debug("Loading startup class");

    // 创建Catalina对象:
    Class<?> startupClass = 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] = sharedLoader;
    Method method = startupInstance.getClass().getMethod(methodName, paramTypes);
    
    // 将Catalina对象中的 parentClassLoader属性设置为sharedLoader类加载器
    method.invoke(startupInstance, paramValues);

    catalinaDaemon = startupInstance;
}

在Bootstrap初始化方法中,有两行值得注意,(1)initClassLoaders:初始化Tomcat类加载器、(2)Thread.currentThread().setContextClassLoader(catalinaLoader):将catalinaLoader设置为线程上下文类加载器(打破了双亲委派模型);

紧接着,又通过反射的方式,创建了Catalina对象,并对Catalina对象中的parentClassLoader属性重新赋值,赋值为sharedLoader类加载器,也就是common ClassLoader。注意,此处赋值的目的是为了后续创建WebApp ClassLoader使用。

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

在初始化Tomcat类加载器方法中,我们总共创建了3大类加载器,分别为commonLoader、catalinaLoader、sharedLoader。默认情况下,在Tomcat6.0之后,commonLoader、catalinaLoader、sharedLoader对象相同,并且均为org.apache.catalina.loader.StandardClassLoader实例。

Tomcat类加载器初始化时,很明确是指出catalina ClassLoader和shared ClassLoader类加载器的父类加载器为common ClassLoader类加载器,而common ClassLoader的父类加载器传值为null,继续调用createClassLoader()方法:

private ClassLoader createClassLoader(String name, ClassLoader parent)throws Exception {
    // 从conf/catalina.properties中获取具体的key:
    String value = CatalinaProperties.getProperty(name + ".loader");
    if ((value == null) || (value.equals("")))
        return parent;

    // 将common.loader中的值,替换成服务器上的绝对路径,并以;相隔
    value = replace(value);

    List<Repository> repositories = new ArrayList<Repository>();

    // 遍历value中的值:
    StringTokenizer tokenizer = new StringTokenizer(value, ",");
    while (tokenizer.hasMoreElements()) {
        String repository = tokenizer.nextToken().trim();
        if (repository.length() == 0) {
            continue;
        }
        ...省略

        // 将value中的值,组装成Repository对象,并存入到List集合中
        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);
}

在创建ClassLoader方法中,我们解析catalina.properties文件中的common.loader属性,默认值为${catalina.base}/lib,${catalina.base}/lib/.jar,${catalina.home}/lib,${catalina.home}/lib/.jar**,将默认值中的${}进行替换,最终得到了服务器上的绝对路径,例如:(catalina.base,catalina.home是环境变量中的值,可通过System.getProperty("xxx")获得)

F:\framework_code\apache-tomcat-7.0.88-src/lib,
F:\framework_code\apache-tomcat-7.0.88-src/lib/*.jar,
F:\framework_code\apache-tomcat-7.0.88-src/lib,
F:\framework_code\apache-tomcat-7.0.88-src/lib/*.jar

在得到这些绝对路径后,进行Repository对象组装,并添加到ArrayList集合中来。最后,调用ClassLoaderFactory.createClassLoader(repositories, parent)生成具体的ClassLoader实现类。

在创建common ClassLoader中:commonLoader = createClassLoader("common", null),传递父类加载器为parent = null,当实际创建类加载器对象时,会以系统类加载器(App ClassLoader)作为common ClassLoader的父类加载器。

说完了Common ClassLoader、Catalina ClassLoader、Shared ClassLoader的实例化,我们接下来在来看看WebApp ClassLoader在Tomcat中是如何初始化的!!!

之前,在创建Catalina对象时候,我们说到了对Catalina对象中的parentClassLoader属性重新赋值,是为了创建WebApp ClassLoader时使用。具体如何,我们来看下源码!!

由于Tomcat代码太多,本次不展示代码的流转过程,直接来看源码!

org.apache.catalina.loader.WebappClassLoader创建源码,存在于org.apache.catalina.loader.WebappLoader类的createClassLoader()方法中:

private WebappClassLoaderBase createClassLoader() throws Exception {

    Class<?> clazz = Class.forName(loaderClass);
    WebappClassLoaderBase classLoader = null;

    if (parentClassLoader == null) {
        parentClassLoader = container.getParentClassLoader();
    }
    Class<?>[] argTypes = { ClassLoader.class };
    Object[] args = { parentClassLoader };
    Constructor<?> constr = clazz.getConstructor(argTypes);
    classLoader = (WebappClassLoaderBase) constr.newInstance(args);

    return classLoader;
}

loaderClass是WebappLoader的实例变量,其值为org.apache.catalina.loader.WebappClassLoader,通过反射调用了WebappClassLoader的构造函数,然后传递了sharedLoader(也就是common ClassLoader)作为其父亲加载器。

来看下org.apache.catalina.loader.WebappClassLoader的构造器:

public WebappClassLoader(ClassLoader parent) {
    super(parent);
}

由于WebappClassLoader继承org.apache.catalina.loader.WebappClassLoaderBase类,所以来看看WebappClassLoaderBase类的构造:

public WebappClassLoaderBase(ClassLoader parent) {

    super(new URL[0], parent);

    ClassLoader p = getParent();
    if (p == null) {
        p = getSystemClassLoader();
    }
    this.parent = p;

    ClassLoader j = String.class.getClassLoader();
    if (j == null) {
        j = getSystemClassLoader();
        while (j.getParent() != null) {
            j = j.getParent();
        }
    }
    this.j2seClassLoader = j;

    securityManager = System.getSecurityManager();
    if (securityManager != null) {
        refreshPolicy();
    }
}

将父类加载传入,赋值给parent属性,为sharedLoader(也就是common ClassLoader)。此外,继续对j2seClassLoader属性赋值,通过遍历获取到了sun.misc.Launcher.ExtClassLoader类加载。

至此,整个Tomcat类加载器初始化流程结束。

工作中遇到的类加载问题

上面我们说了Tomcat的类加载机制。

其中,关于Tomcat的类加载器加载路径,笔者提到了跟/conf/catalina.properties文件有关。

在该文件中,可以自定义common.loader属性,修改此属性后,其他目录下的.jar包、.class文件可以通过Tomcat的common ClassLoader加载进来。

在笔者工作的环境中,Tomcat的此属性就被进行了修改,将应用中maven所有依赖的jar包都放到了common.loader所配置的目录下,这样做的结果就是:common ClassLoader将加载应用中依赖的jar包,而应用本身的WebappClassLoader失去了原本存在的意义。不过,这么做倒没什么关系,只是在代码开发时,会出现莫名的异常。

image

截图中,就是笔者所在公司的项目结构,使用了maven的模块化功能。

将hessian打成war包,进行Tomcat部署,hessian中如果没有servlet的话,基本上没有业务代码。

facade是对外的接口层,core是底层实现。

hessian依赖facade、core模块。

编写测试代码:

在hessian模块下创建servlet类,并调用core模块中的任意一个类。

public class TestClassLoaderServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) 
        throws ServletException, IOException {
        super.service(req, resp);
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
        throws ServletException, IOException {
        super.doGet(req, resp);
        TestUtil.test();
    }
}

在core模块中,类加载hessian模块下的创建servlet类,使用Class.forName("xxxx")即可。

public static void test(){
    try{
        Class clazz =  Class.forName("com.jiaboyan.hessian.TestClassLoaderServlet");
        logger.info("要加载的类为:",clazz);
    }catch (Throwable th){
        logger.error("异常",th);
    }
}

在本地对hessian进行打包,结果如下:

image

项目中的依赖,以及core模块、facade模块都会被打到hessian.war/WEB-INF/lib下。

本地tomcat启动,可以在idea中启动,也可以放到Tomcat目录中去启动也行。

输出结果如下:

要加载的类为:class com.jiaboyan.hessian.TestClassLoaderServlet

一切都是如此的正常。

此时,你的新功能开发完了,自测完了,你需要部署到测试服务器中。利用jenkins进行部署,公司的jenkins进行了修改,在部署构建过程中,会将war包中/WEB-INF/lib下的所有jar包,拷到Tomcat/commonlib目录下,并删除/WEB-INF/lib下的所有jar包。

而我们公司的Tomcat又对/conf/catalina.properties中的common.loader进行了修改:

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

通过common.loader的配置可知,common ClassLoader会加载commonlib目录下的.jar包。

如果此时你发现了问题,那么说明你已经理解了Tomcat的类加载机制。

由此可见,对于core模块、facade模块下的代码,均有common ClassLoader进行加载,而hessian模块中的代码是由WebApp ClassLoader进行加载。并且,common ClassLoader是WebApp ClassLoader的父类加载器,父类加载无法加载子类加载器的资源,当测试服务器中代码执行时候,common ClassLoader无法加载WebApp ClassLoader所拥有的类,结果就是类加载异常。

image

推荐阅读更多精彩内容

  • 可悲的是,子欲养而亲不待。然而更可悲的是,父母还在,你却不想养
    随编简阅读 50评论 0 0