类加载器ClassLoader

上篇文章说到，Class类可以通过一个类的全限定名去加载类，那么底层是如何去加载的呢？这就是我们今天要聊的类加载器ClassLoader，其可以通过一个类的全限定名来获取描述此类的二进制字节流，也即是将编译过后的Class文件加载到内存中。

需要注意的是，即使是同一个类，类加载器不一样，就必定不相等。

例如自定义了一个类加载器跟JVM默认加载器进行比对

/**

 *自定义类加载器

 */

class MyClassLoader extends ClassLoader {

    //类加载需要用到包名

    String packageName;

    public MyClassLoader(String packageName) throws ClassNotFoundException {

        this.packageName = packageName;

    }

    @Override

    public Class<?> findClass(String name) throws ClassNotFoundException {

        String filename = name + ".class";

        name = packageName+"."+name.substring(name.lastIndexOf("/")+1);

        InputStream is = null;

        try {

            is = new FileInputStream(new File(filename));

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        }

        if (is == null) {

            return super.findClass(name);

        }

        try {

            byte[] bytes = new byte[is.available()];

            is.read(bytes);

            //根据class对应的二进制文件,调用defineClass

            return defineClass(name,bytes,0,bytes.length);

        } catch (IOException e) {

            e.printStackTrace();

            return null;

        }

    }

}

//参数是包名，类加载需要用到包名

MyClassLoader myClassLoader = new MyClassLoader("com.liusy.lang");

//参数是java文件编译过后的全路径

Object obj = myClassLoader.loadClass("H:/Code/IDEACODE/java_source_code/out/production/java_source_code/com/liusy/lang/ClassSource");

System.out.println(obj);System.out.println(obj instanceof ClassSource);

上述代码执行结果如下

Java的3种类加载器

1、Bootstrap ClassLoader，顶级加载器。

启动类加载器，加载$JAVA_HOME$/jre/lib下的核心类库，也是所有加载器的顶级父类，由c++所写。也可以用JVM参数-Xbootclasspath指定其加载的目录。

//查看其加载的jar包信息

Launcher.getBootstrapClassPath().getURLs()

2、Extension ClassLoader，扩展类加载器

负责加载$JAVA_HOME$/jre/lib/ext目录中的jar文件，是Application ClassLoader的父类。

//查看其加载的jar包信息

URL[] urLs = ((URLClassLoader) ClassLoader.getSystemClassLoader().getParent()).getURLs();

3、Application ClassLoader，应用程序类加载器

系统默认加载器，负责加载用户类所在路径的类信息。可以由ClassLoader.getSystemClassLoader()直接获取。

下图是获取系统类加载器以及获取其父类，可以看到，AppClassLoader的父类就是ExtClassLoader，而ExtClassLoader的父类是null，这是因为顶级加载器BootstrapClassLoader是用C++所写，java无法获取其信息。

JVM的双亲委派模型（保证父类加载器会先加载类）

工作流程：如果一个类加载器收到了类加载的请求，首先不会自己去尝试加载此类，而是把请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求都会传送到顶层的启动类加载器中，只有当父加载器反馈无法完成此类的加载请求时，子加载器才会尝试自己去加载。

就是默认加载器不会一开始就去加载，一直往上抛，抛到最顶层，如果到最顶层了，此时又不能加载类，就会往下抛，直到加载完为止。

具体如下图

这个双亲委派特性体现在ClassLoader类的loadClass方法中

//name：类的全限定名

 //resolve：是否链接到指定的类

 protected Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException{

    synchronized (getClassLoadingLock(name)) {

        //查看是否已被加载，如果是，则直接返回

        Class<?> c = findLoadedClass(name);

        if (c == null) {

            long t0 = System.nanoTime();

            try {

                //parent是父加载器，也就是一直往上抛

                if (parent != null) {

                    c = parent.loadClass(name, false);

                } else {

                    //没有父加载器，直接找顶级加载器

                    c = findBootstrapClassOrNull(name);

                }

            } catch (ClassNotFoundException e) {

            }

            if (c == null) {

                long t1 = System.nanoTime();

                //父类加载器无法加载的时候

                //用自定义加载器去加载

                c = findClass(name);

            }

        }

        if (resolve) {

            //链接到指定的类

            resolveClass(c);

        }

        return c;

    }

}

上面的loadClass方法开头有一个加锁的代码，加锁的对象的getClassLoadingLock是这个方法返回的。

protected Object getClassLoadingLock(String className) {

    Object lock = this;

    //parallelLockMap是一个Map对象

    //parallelLockMap为空，则直接返回当前ClassLoader

    if (parallelLockMap != null) {

        Object newLock = new Object();

        //className作为key，如果存在，则直接返回旧值，如果不存在，

        //则将newLock作为value存入，此时lock就是newLock

        lock = parallelLockMap.putIfAbsent(className, newLock);

        if (lock == null) {

            lock = newLock;

        }

    }

    return lock;

}

而parallelLockMap 是什么东西呢？如下，是一个ConcurrentHashMap对象，文档显示是该类不为null的时候当前加载器就具有并行的功能。

private final ConcurrentHashMap<String, Object> parallelLockMap;

private ClassLoader(Void unused, ClassLoader parent) {

    this.parent = parent;

    //ParallelLoaders是静态内部类

    if (ParallelLoaders.isRegistered(this.getClass())) {

        parallelLockMap = new ConcurrentHashMap<>();

        package2certs = new ConcurrentHashMap<>();

        domains = Collections.synchronizedSet(new HashSet<ProtectionDomain>());

        assertionLock = new Object();

    } else {

        // no finer-grained lock; lock on the classloader instance

        parallelLockMap = null;

        package2certs = new Hashtable<>();

        domains = new HashSet<>();

        assertionLock = this;

    }}


private static class ParallelLoaders {

        private ParallelLoaders() {}

        //拥有并行能力的set集合

        private static final Set<Class<? extends ClassLoader>> loaderTypes =

            Collections.newSetFromMap(

                new WeakHashMap<Class<? extends ClassLoader>, Boolean>());

        static {

            synchronized (loaderTypes) { loaderTypes.add(ClassLoader.class); }

        }

        //往set集合上添加拥有并行能力的ClassLoader

        static boolean register(Class<? extends ClassLoader> c) {

            synchronized (loaderTypes) {

                if (loaderTypes.contains(c.getSuperclass())) {

                    loaderTypes.add(c);

                    return true;

                } else {

                    return false;

                }

            }

        }

        //判断某个ClassLoader是否拥有并行能力

        static boolean isRegistered(Class<? extends ClassLoader> c) {

            synchronized (loaderTypes) {

                return loaderTypes.contains(c);

            }

        }

    }

另外，自定义类加载器官方推荐是重写findClass()方法，这样可以确保是符合双亲委派模型的。

=======================================================

我是Liusy，一个喜欢健身的程序员。

欢迎关注微信公众号【Liusy01】，一起交流Java技术及健身，获取更多干货。

巴特西

类加载器ClassLoader

最新文章

热门文章