如何让父加载器调用子加载器

左手的ㄟ右手 2022-06-09 10:48 191阅读 0赞

我们的影子在花园石径上徘徊，比那些活着的人更具生气。  
\- 双亲委派很好的解决了各个类加载器的基础类的统一问题（越基础的类由越上层的加载器进行加载）。但是如果基础类需要回调用户代码，该怎么办？比如有两个类。《深入理解JVM》一书中给出如下说明。

> 为了解决这个问题，JAVA设计团队只好引入了一个不太优雅的设计：线程上下文类加载器（Thread Context ClassLoader）。这个类加载器可以通过java.lang.Thread类的setContextClassLoader()方法进行设置。有了线程上下文类加载器，就可以做一些舞弊的事情了，JNDI服务使用这个线程上下文类加载器去加载所需要的SPI代码，也就是父类加载器去完成类加载的动作。  
> `Thread.currentThread().getContextClassLoader()`源码注释为：此方法返回Thread的上下文ClassLoader。它由线程的创建者提供，一遍在加载类和资源时在此线程中运行的代码使用。它默认为父线程的Context ClassLoader. 原始线程的Context ClassLoader通常设置为用于加载应用程序的类加载器。如果存在安全管理器，并且调用者的类加载器不为空，并且与上下文类加载器的祖先不一样，则该方法使用RuntimePermission（“getClassLoader”）权限调用安全管理器的checkPermission方法来验证 允许上下文类加载器的检索。

*  一个例子
    
        public class Animal {
            static{ System.out.println("Animal is loaded");}
            static int b =  Cat.a;
        }
        
        public class Cat extends Animal{
            public static int a = 1;
            static{System.out.println("Cat is loaded");}
        }
        
        AnimalLoad.java 
        
        private String filePath = "../Animalpath/";
        
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            System.out.println("AnimalLoad load " + name);
        
            Class<?> result = null;
            if(name.contains("Animal")){
                String fp = filePath + name + ".class";
                try {
                    byte[] bytes = getClassBytes(getClassFile(fp));
                    result = this.defineClass(name, bytes, 0, bytes.length);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        
            if(result == null){
                result = Thread.currentThread().getContextClassLoader().loadClass(name);
            }
            return result;
        }
        
        CatLoad.java
        private String filePath = "../CatPath/";
        
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            System.out.println("CatLoad load " + name);
        
            Class<?> result = null;
            if (name.contains("Cat")) {
                String fp = filePath + name + ".class";
                try {
                    byte[] bytes = getClassBytes(getClassFile(fp));
                    result = this.defineClass(name, bytes, 0, bytes.length);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return result;
        }
        
        protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
            synchronized (getClassLoadingLock(name)) {
                Class<?> c = findLoadedClass(name);
                if (c == null) {
                    //先让子加载器加载所需要的类，否则会形成死循环
                    c = findClass(name);
                    if (c == null && getParent() != null) {c = getParent().loadClass(name);}
                }
                if (resolve) {resolveClass(c);}
                return c;
            }
        }
        
        Test：
        
        AnimalLoad animalLoad = new AnimalLoad();
        CatLoad catLoad = new CatLoad(animalLoad);
        Thread.currentThread().setContextClassLoader(catLoad);
        catLoad.loadClass("Cat").newInstance();
        
        输出：
        
        CatLoad load Cat
        CatLoad load Animal
        AnimalLoad load Animal
        Animal is loaded
        AnimalLoad load Cat
        CatLoad load java.lang.System
        CatLoad load java.io.PrintStream
        Cat is loaded
 *  为什么不让AnimalLoad直接new一个CatLoad呢，因为这是两个不同的加载器，加载出的来的类不是同一个类。
    
    > CatLoad catLoad01 = new CatLoad(); CatLoad catLoad02 = new CatLoad();  
    > System.out.println(catLoad01.loadClass(“Cat”).isAssignableFrom(catLoad02.loadClass(“Cat”)));  
    > 输出：false
 *  如果有类A，类B。A使用了B，B使用了A。A需要放在本地，通过-cp命令指定路径，B需要通过网络动态加载，则如何做呢？
    
    > ClassLoader.getSystemClassLoader()是一个AppClassLoader。这一点可以通过System.out.println（ClassLoader.getSystemClassLoader()）验证。AppClassLoader是URLClassLoader的子类。Bootstrapper通过反射调用URLClassLoader的addURL方法，把B的Class路径添加进去，则系统类加载器可以直接加载A&B。
    
        public class Bootstrapper {
            public static void main(String[] args) throws Exception {
        
                if(args.length < 3){
                    throw new Exception("参数个数异常 ：args.length is " + args.length);
                }
        
                URL[] urls=buildURLs(args[0],args[1]);
        
                Method method = URLClassLoader.class.getDeclaredMethod("addURL", new Class[]{URL.class});
                method.setAccessible(true);
                for(URL url : urls){
                    method.invoke(ClassLoader.getSystemClassLoader(), new Object[]{url});
                }
        
                Class<?> start  = Class.forName(args[2]);
                Method main = start.getMethod("main", String[].class);
        
                String[] mainArgs = new String[0];
                if(args.length > 3){
                    mainArgs = Arrays.copyOfRange(args, 3, args.length);
                }
                main.invoke(null,(Object)mainArgs);
            }
        
            private static URL[] buildURLs(String path, String jarNames) throws MalformedURLException {
                path = "http://" + path;
                String[] loadJars = jarNames.split(";");
        
                URL[] urls = new URL[loadJars.length];
        
                for(int i = 0;i < loadJars.length; ++i){
                    urls[i] = new URL(path + "/" + loadJars[i]);
                }
        
                return urls;
            }
        }