双亲委派模型-java自定义类加载器

布满荆棘的人生 2022-05-30 10:00 201阅读 0赞

JVM预定义的三种类型类加载器：  
首先classloader 分三个级别，**最上级：**  bootstrap classLoader **中间级：** extension classLoader **最低级：** app classLoader.

## 1.启动（Bootstrap）类加载器： ##

是用本地代码实现的类装入器，它负责将 `<Java_Runtime_Home>/lib`下面的类库加载到内存中（比如rt.jar）。由于引导类加载器涉及到虚拟机本地实现细节，开发者**无法直接获取到启动类加载器的引用**，所以**不允许直接通过引用进行操作**。

## 2.标准扩展（Extension）类加载器： ##

是由 Sun 的 ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将`< Java_Runtime_Home >/lib/ext`或者由系统变量 java.ext.dir指定位置中的类库加载到内存中。**开发者可以直接使用标准扩展类加载器**。

## 3.系统（System）类加载器： ##

是由 Sun 的 AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的。它负责将系统类路径`（CLASSPATH）`中指定的类库加载到内存中。开发者可以直接使用系统类加载器。

> 类加载过程：  
> 当需要加载某个类的时候，会**看看这个类是否已经被加载了**，如果没有，1.会请求app 级来加载，2.app 请求 extension 级 3.extension 请求 bootstrap级， 由最高级来负责加载（这个就是双亲委派，**委托 上两级的loader**来做加载，所以叫双亲委派模型），如果高级的无法加载 则会将人物返回给 下一级 以此类推 最后如果双亲都不行 就由自己来加载。

> 为什么要用这个机制？  
> **1.增加安全性**  
> 比如 java.lang.String 这个类，这个是jdk提供的类， 如果我们自定义个 包名：java.lang 然后在里面创建一个String 类， 当我在用String类的时候，根据前面所说，是由bootstrap级的loader 来进行加载的，这个时候它发现其实已经加载过了jdk的String了，那么就不会去加载自定义的String了，因为程序在创建一个类型之前，首先去缓存中查找是不是已经存在这个自定义的String了，如果存在了就不会再去加载了。  
> **2.防止重复加载**： 防止**内存中出现多份同样的字节码**  
> 比如 java.lang.String 这个类，在很多地方都会用到，如果每一个使用到的地方都重新加载一次的话，系统中就会出现多分 java.lang.String 的实例，就会导致实例的重复。

## 4.线程上下文类加载器： ##

除了以上列举的三种类加载器，还有一种比较特殊的类型 — **线程上下文类加载器**，这个类加载器默认使用的是应用类加载器，线程上下文加载器是打破了双亲加载模型的类加载器。之所以这么说是因为线程上下文可以通过getContextClassLoader()和 setContextClassLoader(ClassLoader cl)方法来获取和设置线程的上下文类加载器，设置类加载器是为了实现自己特殊的一些业务，比如 tomcat 的jar包存在于lib, common,shared 这样好几个不同的目录下，而系统自带的类加载器无法加载这些类，因为他们都有**指定的默认加载路径（详情见上面 1,2,3，启动、标准、系统类加载器解释）**，而其他位置的类路径它们无法加载，因此这个时候就需要自定义加载器来实现特殊类的加载了。

System.out.println(Thread.currentThread().getContextClassLoader());

结果：

sun.misc.Launcher$AppClassLoader@14dad5dc

## 5.自定义类加载器 ##

类加载器与类的唯一性：  
类加载器虽然只用于实现类的加载动作，但是对于任意一个类，都需要由加载它的类加载器和这个类本身共同确立其在Java虚拟机中的唯一性。通俗的说，JVM中两个类是否“相等”，首先就必须是同一个类加载器加载的，否则，即使这两个类来源于同一个Class文件，被同一个虚拟机加载，只要类加载器不同，那么这两个类必定是不相等的。

这里的“相等”，包括代表类的Class对象的equals()方法、isAssignableFrom()方法、isInstance()方法的返回结果，也包括使用instanceof关键字做对象所属关系判定等情况。

以下代码说明了不同的类加载器对instanceof关键字运算的结果的影响：  
**文件类加载器：**

package loadertest;
    
    import com.sun.xml.internal.messaging.saaj.util.ByteOutputStream;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.MalformedURLException;
    import java.net.URI;
    import java.net.URL;
    
    public class FileClassLoader extends ClassLoader { 
        private String rootDir;
    
        public FileClassLoader(String rootDir) {
            this.rootDir = rootDir;
        }
    
        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
            // 获取类的class文件字节数组
            byte[] classData = getClassData(name);
            if (classData == null) {
                throw new ClassNotFoundException();
            } else {
                //直接生成class对象
                return defineClass(name, classData, 0, classData.length);
            }
        }
    
        private byte[] getClassData(String className) {
            String path = classNameToPath(className);
            try {
                InputStream ins = new FileInputStream(path);
                ByteOutputStream baos = new ByteOutputStream();
                int bufferSize = 4096;
                byte[] buffer = new byte[bufferSize];
                int bytesNumRead = 0;
                // 读取类文件的字节码
                while ((bytesNumRead = ins.read(buffer)) != -1) {
                    baos.write(buffer, 0, bytesNumRead);
                }
                return baos.toByteArray();
    
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        private String classNameToPath(String className) { 
            return rootDir + File.separatorChar + className.replace('.', File.separatorChar) + ".class";
        }
    
        public static void main(String[] args) throws ClassNotFoundException, MalformedURLException {
            String rootDir="D:\\workspaces\\idea\\spring-learning\\target\\classes";
            //创建自定义文件类加载器
            FileClassLoader loader = new FileClassLoader(rootDir);
            FileClassLoader loader1 = new FileClassLoader(rootDir);
    
            try {
                //加载指定的class文件
                Class<?> object1=loader.findClass("loadertest.DemoObj");
                Class<?> object2=loader1.findClass("loadertest.DemoObj");
                System.out.println(object1);
                System.out.println(object2);
                System.out.println(object1.hashCode());
                System.out.println(object2.hashCode());
                System.out.println(object1 == object2);
                //输出结果:I am DemoObj
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

打印结果：

class loadertest.DemoObj
    class loadertest.DemoObj
    1229416514
    2016447921
    false

**URL 类加载器：**

package loadertest;
    
    import java.io.File;
    import java.net.*;
    
    public class FileUrlClassLoader extends URLClassLoader { 
    
        public FileUrlClassLoader(URL[] urls, ClassLoader parent) {
            super(urls, parent);
        }
    
        public FileUrlClassLoader(URL[] urls) {
            super(urls);
        }
    
        public FileUrlClassLoader(URL[] urls, ClassLoader parent, URLStreamHandlerFactory factory) {
            super(urls, parent, factory);
        }
    
    
        public static void main(String[] args) throws ClassNotFoundException, MalformedURLException {
            String rootDir="D:\\workspaces\\idea\\spring-learning\\target\\classes";
            //创建自定义文件类加载器
            File file = new File(rootDir);
            //File to URI
            URI uri=file.toURI();
            URL[] urls={uri.toURL()};
    
            FileUrlClassLoader loader = new FileUrlClassLoader(urls);
    
            try {
                //加载指定的class文件
                Class<?> object1=loader.findClass("loadertest.DemoObj");
                System.out.println(object1.newInstance());
    
                //输出结果:I am DemoObj
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }