Android动态加载入坑指南详解手机开发

package dalvik.system; 
public class PathClassLoader extends BaseDexClassLoader { 
    
    public PathClassLoader(String dexPath, ClassLoader parent) { 
        super(dexPath, null, null, parent); 
    } 
    public PathClassLoader(String dexPath, String libraryPath, ClassLoader parent) { 
        super(dexPath, null, libraryPath, parent); 
    } 
}

可以看到，这两个类加载器都是继承自 BaseDexClassLoader，只是分别实现了自己的构造方法。

• aseDexClassLoader

public BaseDexClassLoader(String dexPath, File optimizedDirectory, String librarySearchPath, ClassLoader parent) { 
        super(parent); 
        this.pathList = new DexPathList(this, dexPath, librarySearchPath, optimizedDirectory); 
}

我们发现BaseDexClassLoader作为一个基类，其构造极其简单，它做了两件事：连接了父加载器；构造了一个 DexPathList 实例保存在 pathList 中。

• 第一个参数指的是我们要加载的 dex 文件的路径，它有可能是多个 dex 路径，取决于我们要加载的 dex 文件的个数，多个路径之间用 : 隔开。
• 第二个参数指的是优化后的 dex 存放目录。实际上，dex 其实还并不能被虚拟机直接加载，它需要系统的优化工具优化后才能真正被利用。优化之后的 dex 文件我们把它叫做 odex （optimized dex，说明这是被优化后的 dex）文件。其实从 class 到 dex 也算是经历了一次优化，这种优化的是机器无关的优化，也就是说不管将来运行在什么机器上，这种优化都是遵循固定模式的，因此这种优化发生在 apk 编译。而从 dex 文件到 odex 文件，是机器相关的优化，它使得 odex 适配于特定的硬件环境，不同机器这一步的优化可能有所不同，所以这一步需要在应用安装等运行时期由机器来完成。需要注意的是，在较早版本的系统中，这个目录可以指定为外部存储中的目录，较新版本的系统为了安全只允许其为应用程序私有存储空间（/data/data/apk-package-name/）下的目录，一般我们可以通过 Context#getDir(String dirName) 得到这个目录。
• 第三个参数的意义是库文件的的搜索路径，一般来说是 .so 库文件的路径，也可以指明多个路径。
• 第四个参数就是要传入的父加载器，一般情况我们可以通过 Context#getClassLoader() 得到应用程序的类加载器然后把它传进去。

好了，到这里就很清楚了，Dalvik 虚拟机要加载的 dex 文件的路径（DexPathList），那么
Dalvik是如何找到Dex的呢？有人会说反射，对，大方向对了。那么我们看看系统究竟是怎么做的。

public DexPathList(ClassLoader definingContext, String dexPath, 
            String librarySearchPath, 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 = makeDexElements(splitDexPath(dexPath), optimizedDirectory, 
                              suppressedExceptions, definingContext); 
 
       // Native libraries may exist in both the system and 
       // application library paths, and we use this search order: 
       // 
       //   1. This class loader's library path for application libraries (librarySearchPath): 
       //   1.1. Native library directories 
       //   1.2. Path to libraries in apk-files 
       //   2. The VM's library path from the system property for system libraries 
       //      also known as java.library.path 
       // 
       // This order was reversed prior to Gingerbread; see http://b/2933456. 
       this.nativeLibraryDirectories = splitPaths(librarySearchPath, false); 
       this.systemNativeLibraryDirectories = 
               splitPaths(System.getProperty("java.library.path"), true); 
       List<File> allNativeLibraryDirectories = new ArrayList<>(nativeLibraryDirectories); 
       allNativeLibraryDirectories.addAll(systemNativeLibraryDirectories); 
 
       this.nativeLibraryPathElements = makePathElements(allNativeLibraryDirectories, 
                                                         suppressedExceptions, 
                                                         definingContext); 
 
       if (suppressedExceptions.size() > 0) { 
           this.dexElementsSuppressedExceptions = 
               suppressedExceptions.toArray(new IOException[suppressedExceptions.size()]); 
       } else { 
           dexElementsSuppressedExceptions = null; 
       } 
}

这里我们主要看如下几行代码：

his.definingContext = definingContext; 
 
       ArrayList<IOException> suppressedExceptions = new ArrayList<IOException>(); 
       // save dexPath for BaseDexClassLoader 
       this.dexElements = makeDexElements(splitDexPath(dexPath), optimizedDirectory, 
                              suppressedExceptions, definingContext); 
 
       // Native libraries may exist in both the system and 
       // application library paths, and we use this search order: 
       // 
       //   1. This class loader's library path for application libraries (librarySearchPath): 
       //   1.1. Native library directories 
       //   1.2. Path to libraries in apk-files 
       //   2. The VM's library path from the system property for system libraries 
       //      also known as java.library.path 
       // 
       // This order was reversed prior to Gingerbread; see http://b/2933456. 
       this.nativeLibraryDirectories = splitPaths(librarySearchPath, false); 
       this.systemNativeLibraryDirectories = 
               splitPaths(System.getProperty("java.library.path"), true); 
       List<File> allNativeLibraryDirectories = new ArrayList<>(nativeLibraryDirectories); 
       allNativeLibraryDirectories.addAll(systemNativeLibraryDirectories); 
 
       this.nativeLibraryPathElements = makePathElements(allNativeLibraryDirectories, 
                                                         suppressedExceptions, 
                                                         definingContext);

这段代码主要是给 dexElements和nativeLibraryPathElements赋值。我们知道Android在通过默认的虚拟机dex后，会继续优化为odex 文件。

private static List<File> splitPaths(String searchPath, boolean directoriesOnly) { 
       List<File> result = new ArrayList<>(); 
 
       if (searchPath != null) { 
           for (String path : searchPath.split(File.pathSeparator)) { 
               if (directoriesOnly) { 
                   try { 
                       StructStat sb = Libcore.os.stat(path); 
                       if (!S_ISDIR(sb.st_mode)) { 
                           continue; 
                       } 
                   } catch (ErrnoException ignored) { 
                       continue; 
                   } 
               } 
               result.add(new File(path)); 
           } 
       } 
 
       return result; 
}

这个方法很简单就是用，分隔的路径分割后保存为 File 类型的列表返回。现在看看 
makeDexElements()
 这个方法：

private static Element[] makeDexElements(List<File> files, File optimizedDirectory, 
                                            List<IOException> suppressedExceptions, 
                                            ClassLoader loader) { 
     return makeElements(files, optimizedDirectory, suppressedExceptions, false, loader); 
}

private static Element[] makeElements(List<File> files, File optimizedDirectory, 
                                          List<IOException> suppressedExceptions, 
                                          boolean ignoreDexFiles, 
                                         ClassLoader loader) { 
       Element[] elements = new Element[files.size()]; 
       int elementsPos = 0; 
       /* 
        * Open all files and load the (direct or contained) dex files 
        * up front. 
        */ 
       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()) { 
               // We support directories for looking up resources and native libraries. 
               // Looking up resources in directories is useful for running libcore tests. 
               elements[elementsPos++] = new Element(file, true, null, null); 
           } else if (file.isFile()) { 
               if (!ignoreDexFiles && name.endsWith(DEX_SUFFIX)) { 
                   // Raw dex file (not inside a zip/jar). 
                   try { 
                       dex = loadDexFile(file, optimizedDirectory, loader, elements); 
                   } catch (IOException suppressed) { 
                       System.logE("Unable to load dex file: " + file, suppressed); 
                       suppressedExceptions.add(suppressed); 
                   } 
               } else { 
                   zip = file; 
 
                   if (!ignoreDexFiles) { 
                       try { 
                           dex = loadDexFile(file, optimizedDirectory, loader, elements); 
                       } catch (IOException suppressed) { 
                           /* 
                            * IOException might get thrown "legitimately" by the DexFile constructor if 
                            * the zip file turns out to be resource-only (that is, no classes.dex file 
                            * in it). 
                            * Let dex == null and hang on to the exception to add to the tea-leaves for 
                            * when findClass returns null. 
                            */ 
                           suppressedExceptions.add(suppressed); 
                       } 
                   } 
               } 
           } else { 
               System.logW("ClassLoader referenced unknown path: " + file); 
           } 
 
           if ((zip != null) || (dex != null)) { 
               elements[elementsPos++] = new Element(dir, false, zip, dex); 
           } 
        } 
       if (elementsPos != elements.length) { 
           elements = Arrays.copyOf(elements, elementsPos); 
       } 
       return elements; 
}

通过代码我们可以大致了解到，这个方法就是将之前的File对象通过重新组合成一个新的Elements对象，然后我们Loader读取的就是Element对象。看一下 loadDexFile() 怎样加载 DexFile 的

private static DexFile loadDexFile(File file, File optimizedDirectory, ClassLoader loader, 
                                      Element[] elements) throws IOException { 
       if (optimizedDirectory == null) { 
           return new DexFile(file, loader, elements); 
       } else { 
           String optimizedPath = optimizedPathFor(file, optimizedDirectory); 
           return DexFile.loadDex(file.getPath(), optimizedPath, 0, loader, elements); 
       } 
}

先说明下无论是 
DexFile(File file, Classloader loader, Elements[] elements)
 还是 DexFile.loadDex() 最终都会调用 
DexFile(String sourceName, String outputName, int flags, ClassLoader loader, DexPathList.Element[] elements)
 这个构造方法。所以这个方法的逻辑就是：如果 
optimizedDirectory
 为 null，那么就直接利用 file 的路径构造一个 
DexFile
；否则就根据要加载的 dex（或者包含了 dex 的 zip） 的文件名和优化后的 dex 存放的目录组合成优化后的 dex（也就是 odex）文件的输出路径，然后利用原始路径和优化后的输出路径构造出一个
DexFile.