jvm如何打破双亲委托机制

傷城~ 2023-02-24 15:26 77阅读 0赞

# 打破双亲委托机制 #

## 重写父类ClassLoader的loadClass方法 ##

package com.morris.jvm.classloader;
    
    public class BreakDelegateClassLoader extends MyClassLoader { 
    
        @Override
        protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { 
            // 根据类的全限定名进行加锁，确保一个类在多线程下只被加载一次
            synchronized (getClassLoadingLock(name)) { 
                // 到已加载类的缓存中查看是否已经加载过，如果已加载则直接返回
                Class<?> c = findLoadedClass(name);
                if (null == c) { 
                    // 尝试使用自定义类加载器加载
                    c = this.findClass(name);
                }
    
                if (resolve) { 
                    resolveClass(c);
                }
                return c;
            }
        }
    }

## 是否可以加载自定义java.lang.String类 ##

当我们尝试加载自定义的java.lang.String类时，会抛出如下异常：

Exception in thread "main" java.lang.SecurityException: Prohibited package name: java.lang
    	at java.lang.ClassLoader.preDefineClass(ClassLoader.java:662)
    	at java.lang.ClassLoader.defineClass(ClassLoader.java:761)
    	at java.lang.ClassLoader.defineClass(ClassLoader.java:642)
    	at com.morris.jvm.load.MyClassLoader.findClass(MyClassLoader.java:33)
    	at com.morris.jvm.load.BreakDelegateClassLoader.loadClass(BreakDelegateClassLoader.java:14)
    	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
    	at com.morris.jvm.load.StringClassLoaderTest.main(StringClassLoaderTest.java:7)

JVM出于安全考虑，禁止使用以java开头的包名。以下为相关源码：

摘自jdk1.8 java.lang.ClassLoader

protected final Class<?> defineClass(String name, byte[] b, int off, int len,
                                             ProtectionDomain protectionDomain)
            throws ClassFormatError
        { 
            protectionDomain = preDefineClass(name, protectionDomain);
            String source = defineClassSourceLocation(protectionDomain);
            Class<?> c = defineClass1(name, b, off, len, protectionDomain, source);
            postDefineClass(c, protectionDomain);
            return c;
        }
        
        private ProtectionDomain preDefineClass(String name,
                                                ProtectionDomain pd)
        { 
            if (!checkName(name))
                throw new NoClassDefFoundError("IllegalName: " + name);
    
            // Note: Checking logic in java.lang.invoke.MemberName.checkForTypeAlias
            // relies on the fact that spoofing is impossible if a class has a name
            // of the form "java.*"
            // 以java.开头直接抛出异常
            if ((name != null) && name.startsWith("java.")) { 
                throw new SecurityException
                    ("Prohibited package name: " +
                     name.substring(0, name.lastIndexOf('.')));
            }
            if (pd == null) { 
                pd = defaultDomain;
            }
    
            if (name != null) checkCerts(name, pd.getCodeSource());
    
            return pd;
        }

## 强制使用根加载器加载自定义java.lang.String类 ##

从JDK中复制String.java的源码，添加hello()方法后编译，放入D:\\classloader\\java\\lang目录，在Test方法中调用hello()方法。

public class Test { 
        public static void main(String[] args) { 
            String str = new java.lang.String();
    		str.hello();
        }
    }

使用-Xbootclasspath参数指定自定义java.lang.String的class文件的路径，具体如下：

$ java "-Xbootclasspath/p:D:\classloader" Test
    hello string

在调试过程中可以添加虚拟机参数-XX:+TraceClassLoading来监控类的加载情况。

注意一定要复制JDK中的String.java类，并在其基础上添加方法，否则运行会报错，因为jvm在启动过程中会调用String类的方法，如果自定义的String类没有原生类的方法就会报错。

另外如果我们要加载自定义的java.util.HashMap（不在java.lang包下）类，可以使用endorsed技术，将自己的HashMap类，打包成一个jar包，然后放到-Djava.endorsed.dirs指定的目录中。注意类名和包名，应该和JDK自带的是一样的。

## 命名空间与运行时包 ##

每个类加载器都有自己的命名空间。同一个命名空间内的类是相互可见的，命名空间由该加载器及所有父加载器所加载的类组成。

子加载器的命名空间包含所有父加载器的命名空间。因此由子加载器加载的类能看见父加载器的类。例如系统类加载器加载的类能看见根类加载器加载的类。由父亲加载器加载的类不能看见子加载器加载的类。如果两个加载器之间没有直接或间接的父子关系，那么它们各自加载类相互不可见。

在同一个命名空间中，不会出现类的完整名字（包括类的包名）相同的两个类；在不同的命名空间中，有可能会出现类的完整名字（包括类的包名）相同的两个类。

在类的加载过程中，所有参与的类加载器，即时没有亲自加载过该类，都会被标识为该类的初始类加载器，实际加载类的加载器被称为定义类加载器。

运行时包：由类加载器的命名空间和类的全限定名组成。

package com.morris.jvm.classloader;
    
    // 自定义类加载器必须继承ClassLoader
    public class CustomerClassLoader extends ClassLoader { 
    
        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException { 
            return super.loadClass(name);
        }
    
    }

package com.morris.jvm.classloader;
    
    public class CustomerClassLoaderTest { 
    
        public static void main(String[] args) throws ClassNotFoundException { 
            CustomerClassLoader myClassLoader = new CustomerClassLoader();
            Class<?> clazz = myClassLoader.loadClass("java.lang.String");
            System.out.println(clazz.getClassLoader());
        }
    }

在上面例子中，java.lang.String依次经过了CustomerClassLoader类加载器、系统类加载器、扩展类加载器、根类加载器，这些加载器都是java.lang.String的初始类加载器，而根类加载是java.lang.String的定义类加载器，JVM会在每一个类加载器维护的列表中添加该类型。如下图所示：

![在这里插入图片描述][20200709200515279.png]

### 同一个类加载器实例加载同一个class ###

package com.morris.jvm.classloader;
    
    public class NameSpaceTest1 { 
    
        public static void main(String[] args) throws ClassNotFoundException { 
            // 获取系统类加载器
            ClassLoader classLoader = NameSpaceTest1.class.getClassLoader();
    
            Class<?> aClass = classLoader.loadClass("com.morris.jvm.classloader.HelloWorld");
            Class<?> bClass = classLoader.loadClass("com.morris.jvm.classloader.HelloWorld");
    
            System.out.println(aClass == bClass); // true
        }
    }

使用同一个类加载器实例不论load多少次，都只会返回同一个class对象。

### 不同类加载器加载同一个class ###

package com.morris.jvm.classloader;
    
    public class NameSpaceTest2 { 
    
        public static void main(String[] args) throws ClassNotFoundException { 
            
            ClassLoader classLoader = new MyClassLoader();
            ClassLoader classLoader2 = new BreakDelegateClassLoader();
    
            Class<?> aClass = classLoader.loadClass("com.morris.jvm.classloader.HelloWorld");
            Class<?> bClass = classLoader2.loadClass("com.morris.jvm.classloader.HelloWorld");
    
            System.out.println(aClass == bClass); // false
        }
    }

使用不同的类加载器实例加载同一个class，会在堆内存产生多个class对象。

### 相同类加载器加载同一个class ###

package com.morris.jvm.classloader;
    
    public class NameSpaceTest3 { 
    
        public static void main(String[] args) throws ClassNotFoundException { 
    
            ClassLoader classLoader = new MyClassLoader();
            ClassLoader classLoader2 = new MyClassLoader();
    
            Class<?> aClass = classLoader.loadClass("com.morris.jvm.classloader.HelloWorld");
            System.out.println(aClass.getClassLoader());
            Class<?> bClass = classLoader2.loadClass("com.morris.jvm.classloader.HelloWorld");
            System.out.println(bClass.getClassLoader());
    
            System.out.println(aClass == bClass); // false
        }
    }

使用相同的类加载器实例加载同一个class，会在堆内存产生多个class对象。

更多精彩内容关注本人公众号：架构师升级之路  
![在这里插入图片描述][20200627175030665.jpg]

[20200709200515279.png]: /images/20230209/1e298085be65482b8590e94453fdd31a.png
[20200627175030665.jpg]: https://img-blog.csdnimg.cn/20200627175030665.jpg