JAVA类的加载(4) ——类之间能够隔离&类占用的资源能回收

一、类加载体系

类加载方式：代理模式 或 双亲委托

例1：

package classloader.system;

public class Example {
    public static void main(String[] args) {
        /*应用的类加载器是AppClassLoader，首先委托父ClassLoder（ExtClassLoder）从他自己的资源池中（jre/lib/ext）找这个类，
         * 在这之前，ExtClassLoder又委托父ClassLoader（BootStrapClassLoader）从jre/lib找这个类；
         * BootStrapClassLoader在jre/lib没找到需要的类，返回到ExtClassLoder；ExtClassLoder在jre/lib/ext没找到需要的类，返回到AppClassLoader
         *AppClassLoader从自己的资源池中查找 c = findClass(name);
         * 
         */
        ClassLoader cl = Example.class.getClassLoader();  
        while (cl != null) {
            System.out.println(cl.toString());
            cl = cl.getParent();
        }
    }
}

结果：

sun.misc.Launcher$AppClassLoader@425224ee
sun.misc.Launcher$ExtClassLoader@1ef6a746

例2：在eclipse中点击例1中的11行ClassLoader，进入ClassLoader类的代码，找到loadClass方法，里面就是详细的类加载代码

 protected synchronized Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
    {
    // First, check if the class has already been loaded
    Class c = findLoadedClass(name);
    if (c == null) {
        try {
        if (parent != null) {
            c = parent.loadClass(name, false); //递归通过父加载器加载
        } else {
            c = findBootstrapClassOrNull(name); //从根加载器的资源池中查找这个类
        }
        } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }
            if (c == null) {
            // If still not found, then invoke findClass in order
            // to find the class.
            c = findClass(name); //应用加载器从自己的资源池中查找这个类
        }
    }
    if (resolve) {
        resolveClass(c);
    }
    return c;
    }

 

为什么要这么做呢？（即为什么要用 代理模式 或 双亲委托）

安全考虑：直接在AppClassLoader写一个String这样的类，如果不是委托父类加载，这个类可能性能不高、有问题，导致加载类的时候出现一些意想不到的错误   通过这样的委托模式，使得JDK自己的类能够优先加载，保证这些类的安全等

 

注意：

ExtClassLoader  ——这个加载器对应的资源池（目录）建议一般不要改，比如jboss的数据库加密安全算法在这里面

自定义的classLoader——配置相关的加载地方

 

二、自定义的classLoader配置相关的资源池（从什么地方加载相关类），模拟了从classpath之外的地方加载类

 

例3：Example.java

package classloader.system2;

import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.io.File;

public class Example {
    public static void main(String[] args) throws Exception {
/*前面假设是一个web容器，web容器通过前面的方式启动起来了；当你扔一个war包进去，war包有自己的ClassLoader以及自己的url，url指向war包里面的lib目录
 * 相当于可以从url里面加载类       用web应用的classloader去加载相关的类，并且调它的初始化方法，就可以让我自己的war包运行起来
 * war包里面都有一个web.xml，web.xml描述了Servlet，相当于描述了全称类名叫什么，我就可以启动相关的Servlet；相关的Servlet启动以后，我就可以接受请求并进行分发，web容器就基本上运行起来了
 * 
 * 
 */
        URL url = new File(args[0]).toURL();
        ClassLoader cl = new URLClassLoader(new URL[]{url});
        Class<?> tvClass = cl.loadClass("classloader.system2.Television");
        Object tv = tvClass.newInstance();  //因为我们当前classpath下是没有Television类的，所以这里定义为Object tv
        
        Object panel = cl.loadClass("classloader.system2.Panel").newInstance();  //load一个面板并实例化
        Method setPanelMethod = tvClass.getMethod("setPanel", Object.class);
        setPanelMethod.invoke(tv, panel);   
        Method playVideoMethod = tvClass.getMethod("playVideo", new Class[]{});
        playVideoMethod.invoke(tv, new Object[]{});
        
        System.out.println("不同的ClassLoader加载。。。");
        ClassLoader cl2 = new URLClassLoader(new URL[]{url});
        Object panel2 = cl2.loadClass("classloader.system2.Panel").newInstance();
        setPanelMethod.invoke(tv, panel2);  //tv是cl加载的，panel2是cl2加载的，两个不同的classload，它们之间的对象是不能直接进行装配的，会认为不一样的
    }
}

//将Panel和Televison两个类拷贝到特定目录并编译，并删除当前classpath下的两个类

//Television.java

package classloader.system2;

public class Television {
    private Panel panel;  //面板
    
    public void playVideo() {
        panel.display();
    }
    
    public void setPanel(Object panel) {
        this.panel = (Panel)panel;
    }
}

//Panel.java

package classloader.system2;

public class Panel {
    public void display() {
        System.out.println("In Panel: display()");
    }
}

运行：

编译好后，将Panel和Televison两个类class文件拷贝到特定目录（如下），并删除当前classpath下的两个类（main的参数String[] args为d:\tmp）



1、ClassLoader cl = new URLClassLoader(new URL[]{url}); 这个classLoader所指向的url在d:\，d:\下Class<?> tvClass = cl.loadClass("classloader.system2.Television");时找不到，所以就报错了



2、填写正确的路径



 classloader.system2.Panel cannot be cast to classloader.system2.Panel报错原因如下：
tv是cl加载的，panel2是cl2加载的，两个不同的classload，它们之间的对象是不能直接进行装配的，会认为不一样的


对象与类的加载 小结：
1、并非所有的类都需要在CLASSPATH中
2、对象的赋值与转换与其ClassLoader相关
3、类在一个ClassLoader中只加载一次

三、与类加载相关的异常

1、ClassNotFoundException
2、NoClassDefFoundError

package classloader.exception;


public class Example {
    public static void main(String[] args) throws Exception {
        Television tv = (Television) Example.class.getClassLoader()
                .loadClass("classloader.exception.Television").newInstance(); //loadClass("classloader.exception.Television1") 就会抛java.lang.ClassNotFoundException:
                                                                              //exception
        tv.playVideo();
    }
}

class Television {
    //private Panel panel; 会报错at classloader.exception.Television.playVideo(Example.java:17)
    private Panel panel = new Panel();  //Televison编译强依赖于Panel，如果编译好后再删除Panel.class，运行时会报java.lang.NoClassDefFoundError: classloader/exception/Panel
                                         //error
    public void playVideo() {
        panel.display();
    }
    
    public void setPanel(Object panel) {
        this.panel = (Panel)panel;
    }
}


class Panel {
    public void display() {
        System.out.println("In Panel: display()");
    }
}

 

四、类的回收
1、ClassLoader加载类，类实例化对象
2、当某个ClassLoader加载的所有类实例化的所有对象都被回收了，则该CL会被回收

类对象实例化业务对象

 web容器放了个war包，当war包被应用服务器加载起来后，应用服务器会为这个war包分配classloader，classloader负责加载这个war包里面的

所有资源，加载完了后开始运行，直到某一时刻，我们觉得这些所有对象都不需要了，里面的所有资源要被回收掉，如Servlet要被销毁等一系列步骤；

当这些类加载出来的对象都被回收后，这个classloader就可以被回收掉了

classloaderA   A1

classloaderB   B1   B1持有A1对象，classloaderA不能被回收

五、类的热替换思路



参考：

http://blog.csdn.net/lantian0802/article/details/8869596

http://blog.csdn.net/java2000_wl/article/details/8222876