Java源码解析之ClassLoader

一、前言

一个完整的Java应用程序，当程序在运行时，即会调用该程序的一个入口函数来调用系统的相关功能，而这些功能都被封装在不同的class文件当中，所以经常要从这个class文件中要调用另外一个class文件中的方法，如果另外一个文件不存在的，则会引发系统异常。而程序在启动的时候，并不会一次性加载程序所要用的所有class文件，而是根据程序的需要，通过Java的类加载机制（ClassLoader）来动态加载某个class文件到内存当中的，从而只有class文件被载入到了内存之后，才能被其它class所引用。所以ClassLoader就是用来动态加载class文件到内存当中用的。

Android平台上虚拟机运行的是Dex字节码,一种对class文件优化的产物,传统Class文件是一个Java源码文件会生成一个.class文件，而Android是把所有Class文件进行合并，优化，然后生成一个最终的class.dex,目的是把不同class文件重复的东西只需保留一份,如果我们的Android应用不进行分dex处理,最后一个应用的apk只会有一个dex文件。

二、java 中的 ClassLoader

BootstrapClassLoader
负责加载 JVM 运行时的核心类，比如 JAVA_HOME/lib/rt.jar 等等

ExtensionClassLoader
负责加载 JVM 的扩展类，比如 JAVA_HOME/lib/ext 下面的 jar 包

AppClassLoader
负责加载 classpath 里的 jar 包和目录

三、Android 中的 ClassLoader

BootClassLoader

负责 Android系统启动时会使用BootClassLoader来预加载常用类，与Java中的Bootstrap ClassLoader不同的是，它并不是由C/C++代码实现，而是由Java实现的。BootClassLoader是ClassLoader的一个内部类。
PathClassLoader

负责加载已经安装的Apk，也就是/data/app/package 下的apk文件，也可以加载/vendor/lib, /system/lib下的nativeLibrary

DexClassLoader

负责加载可以加载一个未安装的apk文件。

四、双亲委派机制

每一个 ClassLoader 中都有一个 parent 对象，代表的是父类加载器，在加载一个类的时候，会先使用父类加载器去加载，如果在父类加载器中没有找到，自己再进行加载，如果 parent 为空，那么就用系统类加载器来加载。通过这样的机制可以保证系统类都是由系统类加载器加载的。 下面是 ClassLoader 的 loadClass 方法的具体实现。

protected 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) {
                    // 没有找到，再自己加载
                    c = findClass(name);
                }
            }
            return c;
    }

五、源码分析

1.现在我们看下 BaseDexClassLoader 继承自ClassLoader

public class BaseDexClassLoader extends ClassLoader{

	...

	//存放需要加载的dexList
	private final DexPathList pathList;

	/**
     *
     * @param dexPath   需要加载的dex文件所在的路径
     * @param optimizedDirectory  Android系统将dex文件进行优化后所生成的ODEX文件的存放路径，该路径必须是一个内部存储路径。
     * @param librarySearchPath   目标类所使用的c、c++库存放的路径
     * @param parent  该加载器的父加载器，一般为当前执行类的加载器
     */
    public BaseDexClassLoader(String dexPath, File optimizedDirectory,
            String librarySearchPath, ClassLoader parent) {
        this(dexPath, optimizedDirectory, librarySearchPath, parent, false);
    }

	/**
     *
     * @param dexPath
     * @param optimizedDirectory
     * @param librarySearchPath
     * @param parent
     * @param isTrusted   是否已信任，关系到是否可调用隐藏API
     */
    public BaseDexClassLoader(String dexPath, File optimizedDirectory,
            String librarySearchPath, ClassLoader parent, boolean isTrusted) {
        super(parent);
        this.pathList = new DexPathList(this, dexPath, librarySearchPath, null, isTrusted);

        ...
    }

	 /**
     *
     * @param dexFiles 字节缓存数组的dex文件
     * @param parent   该加载器的父加载器
     */
	public BaseDexClassLoader(ByteBuffer[] dexFiles, ClassLoader parent) {
        // TODO We should support giving this a library search path maybe.
        super(parent);
        this.pathList = new DexPathList(this, dexFiles);
    }

	/**
     * 通过完整的类名寻找对应的类
     * @param name  传入一个完整的类名
     * @return
     * @throws ClassNotFoundException
     */
	@Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
		//1 在pathList中寻找name对应的类
        Class c = pathList.findClass(name, suppressedExceptions);
		// 如果未找到此类，则抛出异常
        if (c == null) {
            ClassNotFoundException cnfe = new ClassNotFoundException(
                    "Didn't find class \"" + name + "\" on path: " + pathList);
            for (Throwable t : suppressedExceptions) {
                cnfe.addSuppressed(t);
            }
            throw cnfe;
        }
        return c;
    }
}

PathClassLoader 和DexClassLoader: 继承自BaseDexClassLoader

public class PathClassLoader extends BaseDexClassLoader {

     /**
     *
     * @param dexPath   dex文件路径集合
     * @param parent    父加载器
     */
    public PathClassLoader(String dexPath, ClassLoader parent) {
        //调用父类BaseDexClassLoader 四参构造方法
        super(dexPath, null, null, parent);
    }

    /**
     *
     * @param dexPath   dex文件路径集合
     * @param librarySearchPath    包含 C/C++库的路径集合，多个路径用文件分隔符分隔分割，可以为null
     * @param parent    父加载器
     */
    public PathClassLoader(String dexPath, String librarySearchPath, ClassLoader parent) {
        //调用父类BaseDexClassLoader 四参构造方法
        super(dexPath, null, librarySearchPath, parent);
    }
}

public class DexClassLoader extends BaseDexClassLoader {

	 /**
     *
     * @param dexPath      dex文件路径集合，多个路径用文件分隔符分隔，默认文件分隔符为":"
     * @param optimizedDirectory   解压的dex文件存储路径，这个路径必须是一个内部存储路径，一般情况下使用当前应用程序的私有路径
     * @param librarySearchPath   包含 C/C++ 库的路径集合，多个路径用文件分隔符分隔分割，可以为null
     * @param parent       父加载器
     */
    public DexClassLoader(String dexPath, String optimizedDirectory,
            String librarySearchPath, ClassLoader parent) {

		// 调用父类BaseDexClassLoader 四参构造方法，在API26以上，librarySearchPath参数已弃用，使用此方法
        super(dexPath, null, librarySearchPath, parent);

		// API26及以下使用此方法
		// super(dexPath, new File(optimizedDirectory), librarySearchPath, parent);
    }
}

我们看1 处 pathList 的 findClass 是如何查找的

/*package*/ final class DexPathList {
    private static final String DEX_SUFFIX = ".dex";
    private static final String zipSeparator = "!/";

    private final ClassLoader definingContext;

	// dex/resource 存放dex的数组
    private Element[] dexElements;

	// 存放本地库文件的列表
    private final List<File> nativeLibraryDirectories;

	// 存放系统本地库文件的列表
    private final List<File> systemNativeLibraryDirectories;

	// 存放创建dexElement列表时引发异常的列表
    private IOException[] dexElementsSuppressedExceptions;

	DexPathList(ClassLoader definingContext, String dexPath,
            String librarySearchPath, File optimizedDirectory, boolean isTrusted) {
        ...

        this.definingContext = definingContext; //BaseDexClassLoader构造器中会传入其本身

        ArrayList<IOException> suppressedExceptions = new ArrayList<IOException>();
        // 通过dexPath路径使用分隔符将其转换成dexElements列表
        this.dexElements = makeDexElements(splitDexPath(dexPath), optimizedDirectory,
                                           suppressedExceptions, definingContext, isTrusted);

        ...
    }

	 // 为本地库搜索路径生成一个directory/zip path元素数组
	 private static Element[] makeDexElements(List<File> files, File optimizedDirectory,
            List<IOException> suppressedExceptions, ClassLoader loader, boolean isTrusted) {
      Element[] elements = new Element[files.size()];
      int elementsPos = 0;

      for (File file : files) {
          if (file.isDirectory()) { //如果是文件夹，则直接添加至elements
              elements[elementsPos++] = new Element(file);
          } else if (file.isFile()) { //如果是文件

              String name = file.getName();
              DexFile dex = null;
              //是否为 .dex 文件
              if (name.endsWith(DEX_SUFFIX)) {
                  // Raw dex file (not inside a zip/jar).
                  try {
                      //如果是 dex 文件，则加载这个文件
                      dex = loadDexFile(file, optimizedDirectory, loader, elements);
                      if (dex != null) {
                          //将dex 文件保存,注意第二个参数传的底 null
                          elements[elementsPos++] = new Element(dex, null);
                      }
                  } catch (IOException suppressed) {
                      System.logE("Unable to load dex file: " + file, suppressed);
                      suppressedExceptions.add(suppressed);
                  }
              } else {
                  //如果不是目录且不是 .dex 结尾的，那么他可能是 jar。加载这个文件
                      dex = loadDexFile(file, optimizedDirectory, loader, elements);
                  if (dex == null) {
                      elements[elementsPos++] = new Element(file);
                  } else {
                      // 保存dex 文件 和 当前的 file，这种情况下可能是 jar，具体可以看这个构造方法
                      elements[elementsPos++] = new Element(dex, file);
                  }

              if (dex != null && isTrusted) { //如果dex对象不为空且是允许信任状态
                dex.setTrusted(); // 将此dex对象设置为已信任，它可以访问平台的隐藏api
              }
          } else {
              System.logW("ClassLoader referenced unknown path: " + file);
          }
      }
      if (elementsPos != elements.length) {
          elements = Arrays.copyOf(elements, elementsPos);
      }
      return elements;
    }

	public Class<?> findClass(String name, List<Throwable> suppressed) {
		// 遍历dex列表
        for (Element element : dexElements) {
            //2
            Class<?> clazz = element.findClass(name, definingContext, suppressed);
			//如果找到我们需要的name类，直接返回当前clazz
            if (clazz != null) {
                return clazz;
            }
        }

        if (dexElementsSuppressedExceptions != null) {
            suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
        }
        return null;
    }
}

看注释2处 此时会通过makeDexElements方法生成一个Element数组，紧接着当前类中的findClass方法又会调用DexPathList中的Element类的findClass方法。

static class Element {

        private final File path;

        private final DexFile dexFile;

        private ClassPathURLStreamHandler urlHandler;
        private boolean initialized;

		...

		...

        public Class<?> findClass(String name, ClassLoader definingContext,List<Throwable> suppressed) {
			// 3 通过loadClassBinaryName方法寻找name类，找到即返回它，否则返回null
            return dexFile != null ? dexFile.loadClassBinaryName(name, definingContext, suppressed)
                    : null;
        }

    }

注释3 处   通过loadClassBinaryName 最后调用native层 defineClassNative的方法 分析到这里可以看出，最终进行Class字节码的加载操作，是通过底层的native方法来完成的。

到此这篇关于Java源码解析之ClassLoader的文章就介绍到这了,更多相关Java ClassLoader内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！