class BootClassLoader extends ClassLoader {

    private static BootClassLoader instance;

    @FindBugsSuppressWarnings("DP_CREATE_CLASSLOADER_INSIDE_DO_PRIVILEGED")
    public static synchronized BootClassLoader getInstance() {
        if (instance == null) {
            instance = new BootClassLoader();
        }

        return instance;
    }
    ...

}  

public class PathClassLoader extends BaseDexClassLoader {

    /**
     * @param dexPath : Dex相關(guān)文件的路徑
     * @param parent  ： 父加載器
     */
    public PathClassLoader(String dexPath, ClassLoader parent) {
        super(dexPath, null, null, parent);
    }

    /**
     * @param dexPath: Dex相關(guān)文件的路徑
     * @param librarySearchPath：包含C/C++庫(kù)的路徑集合
     * @param parent ： 父加載器
     */
    public PathClassLoader(String dexPath, String librarySearchPath, ClassLoader parent) {
        super(dexPath, null, librarySearchPath, parent);
    }
    ...
}

public class ZygoteInit {

    // 創(chuàng)建完system_server進(jìn)程后，會(huì)執(zhí)行此方法
    private static Runnable handleSystemServerProcess(ZygoteArguments parsedArgs) {
        if (systemServerClasspath != null) {
            //...
        } else {
            ClassLoader cl = null;
            // 創(chuàng)建PathClassLoader加載器
            if (systemServerClasspath != null) {
                cl = createPathClassLoader(systemServerClasspath, parsedArgs.mTargetSdkVersion);
            }
        }
    }

    static ClassLoader createPathClassLoader(String classPath, int targetSdkVersion) {
        String libraryPath = System.getProperty("java.library.path");

        // 父加載器是BootClassLoader
        ClassLoader parent = ClassLoader.getSystemClassLoader().getParent();

        // 創(chuàng)建工廠模式創(chuàng)建PathClassLoader
        return ClassLoaderFactory.createClassLoader(classPath, libraryPath, libraryPath,
                parent, targetSdkVersion, true /* isNamespaceShared */, null /* classLoaderName */);
    }

}


public abstract class ClassLoader {

    public static ClassLoader getSystemClassLoader() {
        return SystemClassLoader.loader;
    }

    static private class SystemClassLoader {
        public static ClassLoader loader = ClassLoader.createSystemClassLoader();
    }

    private static ClassLoader createSystemClassLoader() {
        String classPath = System.getProperty("java.class.path", ".");
        String librarySearchPath = System.getProperty("java.library.path", "");
        // 父加載器是BootClassLoader
        return new PathClassLoader(classPath, librarySearchPath, BootClassLoader.getInstance());
    }
}

public class DexClassLoader extends BaseDexClassLoader {

    /**
     *
     * @param dexPath : Dex相關(guān)文件的路徑
     * @param optimizedDirectory: 解壓的dex的存儲(chǔ)路徑
     * @param librarySearchPath：包含C/C++庫(kù)的路徑集合
     * @param parent ： 父加載器
     */
    public DexClassLoader(String dexPath, String optimizedDirectory, String librarySearchPath, ClassLoader parent) {
        super(dexPath, null, librarySearchPath, parent);
    }
}

public abstract class ClassLoader {

   /**
     * 雙親委托機(jī)制
     */
    protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException {
        // 1. 先檢查class是否已經(jīng)加載過(guò)
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            // 沒(méi)有加載過(guò)
            try {
                if (parent != null) {
                    // 先給父ClassLoader加載Class
                    c = parent.loadClass(name, false);
                } else {
                    // 調(diào)用BootClassLoader加載Class
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }


            if (c == null) {
                // 父的ClassLoader都沒(méi)有加載class，則調(diào)用findClass()給此ClassLoader加載
                c = findClass(name);
            }
        }
        return c;
    }


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

public class BaseDexClassLoader extends ClassLoader {

    private final DexPathList pathList;

    public BaseDexClassLoader(String dexPath,
                              String librarySearchPath, ClassLoader parent, ClassLoader[] sharedLibraryLoaders,
                              boolean isTrusted) {
        super(parent);
        this.sharedLibraryLoaders = sharedLibraryLoaders == null
                ? null
                : Arrays.copyOf(sharedLibraryLoaders, sharedLibraryLoaders.length);
        this.pathList = new DexPathList(this, dexPath, librarySearchPath, null, isTrusted);

        reportClassLoaderChain();
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        //  調(diào)用DexPathList.findClass方法查找class
        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;
    }
}

public final class DexPathList {
    private Element[] dexElements;

    DexPathList(ClassLoader definingContext, String dexPath,
                String librarySearchPath, File optimizedDirectory, boolean isTrusted) {
         this.dexElements = makeDexElements(splitDexPath(dexPath), optimizedDirectory,
                suppressedExceptions, definingContext, isTrusted);
    }

    public Class<?> findClass(String name, List<Throwable> suppressed) {
        // 遍歷Element數(shù)組去查詢
        for (Element element : dexElements) {
            Class<?> clazz = element.findClass(name, definingContext, suppressed);
            if (clazz != null) {
                return clazz;
            }
        }

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

}


    /*package*/ static class Element {
        @UnsupportedAppUsage
        private final File path;
    
        private final Boolean pathIsDirectory;

        @UnsupportedAppUsage
        private final DexFile dexFile;

        private ClassPathURLStreamHandler urlHandler;
        private boolean initialized;

        @UnsupportedAppUsage
        public Element(DexFile dexFile, File dexZipPath) {
            if (dexFile == null && dexZipPath == null) {
                throw new NullPointerException("Either dexFile or path must be non-null");
            }
            this.dexFile = dexFile;
            this.path = dexZipPath;
            this.pathIsDirectory = (path == null) ? null : path.isDirectory();
        }

        public Class<?> findClass(String name, ClassLoader definingContext,
                                  List<Throwable> suppressed) {
             //  調(diào)用DexFile.loadClassBinaryName()方法去查找
            return dexFile != null ? dexFile.loadClassBinaryName(name, definingContext, suppressed)
                    : null;
        }
}

public final class DexFile {

    public Class loadClassBinaryName(String name, ClassLoader loader, List<Throwable> suppressed) {
        return defineClass(name, loader, mCookie, this, suppressed);
    }

    private static Class defineClass(String name, ClassLoader loader, Object cookie,
                                     DexFile dexFile, List<Throwable> suppressed) {

        Class result = null;
        try {
            result = defineClassNative(name, loader, cookie, dexFile);
        }
        ...
        return result;
    }

    private static native Class defineClassNative(String name, ClassLoader loader, Object cookie, DexFile dexFile)
        
}