一.Java中的ClassLoader。

80a46038ad7f148edef4bd2116d2ed21.png

二.Android中的ClassLoader详解.

1.android中ClassLoader的种类。
a.BootClassLoader：主要用来加载android FrameWork层的一些class字节码文件。
b.PathClassLoader：主要用来加载已经安装到系统中的APK 文件中的class（与java中的AppClassLoader类似）。
c.DexClassLoader：用来加载指定目录下的class字节码文件（与java中的自定义ClassLoader类似）。
d.BaseDexClassLoader：父类，PathClassLoader和DexClassLoader都是它的子类。
2.android中ClassLoader的特点和作用。
特点：
双亲代理模式加载class字节码。
双亲代理模式：ClassLoader在加载一个字节码时，首先会询问 当前的
ClassLoader是否已经加载过此类，如果已经加载过就直接返回，不在重复的去
加载，如果没有的话，会查询它的parent是否已经加载过此类，如果加载过那
么就直接返回parent加载过的字节码文件，如果整个继承线路上都没有加载过
此类，最后由子ClassLoader执行真正的加载。这样做的好处：如果一个类被位
于树中的任意ClassLoader节点加载过，就会缓存在内存里，那么在以后的整个
系统的生命周期中这个类都不会在被重新加载，大大提高了加载类的效率。
作用：
类加载共享功能
类加载的隔离功能：不同继承线路上加载的类肯定不是同一个类，避免用户自己
去写一些代码，冒充我们核心的类库。
问题：怎么样的类才被认为是同一个类？
包名和类名相同就可以吗？不是，还要再加上是被同一个ClassLoader加载的。
三个条件都满足，才能说是同一个类。
3.ClassLoader源码。
我们首先看一下ClassLoader中的最核心的方法loadClass。

public Class<?> loadClass(String className) throws ClassNotFoundException {
       return loadClass(className, false);
}

protected Class<?> loadClass(String className, boolean resolve) throws ClassNotFoundException {
        Class<?> clazz = findLoadedClass(className);
        if (clazz == null) {
            ClassNotFoundException suppressed = null;
            try {
                clazz = parent.loadClass(className, false);
            } catch (ClassNotFoundException e) {
                suppressed = e;
            }

            if (clazz == null) {
                try {
                    clazz = findClass(className);
                } catch (ClassNotFoundException e) {
                    e.addSuppressed(suppressed);
                    throw e;
                }
            }
        }
    return clazz;
}

1.首先调用findLoadedClass查看自身是否加载过该name的类文件。
2.如果没有，调用父ClassLoader的loadClass看是否加载过类文件。
3.如果父classLoader也没有加载过，表明我们这个类从来没有没加载过，则调用自身的findClass方法去dex文件中查找这个类。
4.以上就是双亲委托模式，首先看自己加载过没有，如果没有就看父classLoader加载过没有。
接下来看一下findClass方法是如何实现的。

protected Class<?> findClass(String className) throws ClassNotFoundException {
       throw new ClassNotFoundException(className);
}

该方法是个空实现，这样做的意义是交给他的子类去实现，这样子类就可以定义不同的查找行为。
接下来看一下子类的实现。
DexClassLoader：

public DexClassLoader(String dexPath, String optimizedDirectory,
            String libraryPath, ClassLoader parent) {
        super(dexPath, new File(optimizedDirectory), libraryPath, parent);
}

DexClassLoader实现非常简单，只有一个构造方法，该ClassLoader可以加载来自jar和apk中的dex文件中的类，因此DexClassLoader可以加载一些并没有安装到系统应用中的一些类 所以说DexClassLoader是我们动态加载的核心。
dexPath：指定要加载的dex文件的路径，包含多个路径用File.pathSeparator间隔开,在Android上默认是 ":" 。
optimizedDirectory：从apk中解析出dex文件存储的路径，一般是应用程序内部路径 。
libraryPath：目标类中使用的C/C++库的列表,每个目录用File.pathSeparator间隔开; 可以为 null。
parent：该类装载器的父装载器，一般用当前执行类的装载器。
接下来看一下同样继承BaseDexClassLoader类的PathClassLoader。
PathClassLoader同样很简单，有两个构造方法。

public PathClassLoader(String dexPath, ClassLoader parent) {
        super(dexPath, null, null, parent);
}

 public PathClassLoader(String dexPath, String libraryPath,
            ClassLoader parent) {
        super(dexPath, null, libraryPath, parent);
}

我们主要看一下第二个构造方法。
与DexClassLoader构造方法唯一的区别就是少了要拷贝的dex文件的路径，因此PathClassLoader只能加载安装到系统中的APK文件。
接下来看一下这两个类的父类BaseDexClassLoader是如何完成类的查找的。

private final DexPathList pathList;

BaseDexClassLoader类里面定义了一个DexPathList，存储的是dex的集合，因为apk是可以dex分包，它里面含有一个DexElement的集合，每一个Element就对应一个dex文件，先看一下核心的方法findClass。

@Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
        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;
     }

它是通过成员变量pathList的findClass方法 ，传入我们要查找的类名，来寻找我们的class字节码 ，所以说BaseDexClassLoader也不是真正查找类的地方，接下来就到DexPathList中去看一下类是如何查找的。
我们首先看一下它的一些成员变量。

private static final String DEX_SUFFIX = ".dex";
private final ClassLoader definingContext;
private final Element[] dexElements;

DEX_SUFFIX：表示要加载的文件都是.dex后缀。
definingContext：在构造方法中传入的 。
dexElements：Element是DexPathList中的一个内部类，里面最核心的就是DexFile。
接下来看一下构造方法：

public DexPathList(ClassLoader definingContext, String dexPath,
                       String libraryPath, File optimizedDirectory) {

        if (definingContext == null) {
            throw new NullPointerException("definingContext == null");
        }

        if (dexPath == null) {
            throw new NullPointerException("dexPath == null");
        }

        if (optimizedDirectory != null) {
            if (!optimizedDirectory.exists()) {
                throw new IllegalArgumentException(
                        "optimizedDirectory doesn't exist: "
                                + optimizedDirectory);
            }

            if (!(optimizedDirectory.canRead()
                    && optimizedDirectory.canWrite())) {
                throw new IllegalArgumentException(
                        "optimizedDirectory not readable/writable: "
                                + optimizedDirectory);
            }
        }

        this.definingContext = definingContext;

        ArrayList<IOException> suppressedExceptions = new ArrayList<IOException>();
        // save dexPath for BaseDexClassLoader
        this.dexElements = makePathElements(splitDexPath(dexPath), optimizedDirectory,suppressedExceptions);

        this.nativeLibraryDirectories = splitPaths(libraryPath, false);
        this.systemNativeLibraryDirectories =
                splitPaths(System.getProperty("java.library.path"), true);
        List<File> allNativeLibraryDirectories = new ArrayList<>(nativeLibraryDirectories);
        allNativeLibraryDirectories.addAll(systemNativeLibraryDirectories);

        this.nativeLibraryPathElements = makePathElements(allNativeLibraryDirectories, null,
                suppressedExceptions);

        if (suppressedExceptions.size() > 0) {
            this.dexElementsSuppressedExceptions =
                    suppressedExceptions.toArray(new IOException[suppressedExceptions.size()]);
        } else {
            dexElementsSuppressedExceptions = null;
        }
    }

初始化一些成员变量，this.definingContext赋值，最重要的就是this.dexElements = makePathElements(splitDexPath(dexPath), optimizedDirectory,suppressedExceptions);这行代码，来初始化Element数组，下面看下该方法的实现。

private static Element[] makePathElements(List<File> files, File optimizedDirectory, List<IOException> suppressedExceptions) {
        List<Element> elements = new ArrayList<>();

        for (File file : files) {
            File zip = null;
            File dir = new File("");
            DexFile dex = null;
            String path = file.getPath();
            String name = file.getName();

            if (path.contains(zipSeparator)) {
                String split[] = path.split(zipSeparator, 2);
                zip = new File(split[0]);
                dir = new File(split[1]);
            } else if (file.isDirectory()) {
                ng up resources in directories is useful for running libcore tests.
                        elements.add(new Element(file, true, null, null));
            } else if (file.isFile()) {
                if (name.endsWith(DEX_SUFFIX)) {               // Raw dex file (not inside a zip/jar).
                    try {
                        dex = loadDexFile(file, optimizedDirectory);
                    } catch (IOException ex) {
                        System.logE("Unable to load dex file: " + file, ex);
                    }
                } else {
                    zip = file;
                    try {
                        dex = loadDexFile(file, optimizedDirectory);
                    } catch (IOException suppressed) {
                        suppressedExceptions.add(suppressed);
                    }
                }
            } else {
                System.logW("ClassLoader referenced unknown path: " + file);
            }
            if ((zip != null) || (dex != null)) {
                elements.add(new Element(dir, false, zip, dex));
            }
        }
        return elements.toArray(new Element[elements.size()]);
    }

该方法就是解析dex文件成对应的DexElement
1.遍历所有的dex文件。
2.将dex文件转化成对应的DexFile对象。
3.如果是.dex结尾（针对PathClassLoader处理），调用loadDexFile方法。
4.如果.dex .jar .apk 结尾 （针对DexClassLoader处理） ，调用loadDexFile方法。

三.Android中的动态加载比一般Java程序复杂在哪里

1.有许多组件类需要注册才能使用（Activity、Service需要在AndroidManifest中注
   册后才能使用）。
2.资源的动态加载比较复杂。（资源也需要注册）
总结来说就是android的动态加载需要一个上下文环境。