Android 类加载器

客官°小女子只卖身不卖艺 2022-11-17 05:27 151阅读 0赞

## 前言 ##

我们知道`Java`存在双亲委托模型，具体可以参考[Java虚拟机详解（十一）------双亲委派模型][Java_------]。本文将讲解`Android`下的类加载.

本文将以5.0作为源码讲解。

我们知道在标准的`Java程序`中有一个`Bootstrap ClassLoader`和`Application ClassLoader`.

而对应于Android的中`java.lang.BootClassLoader`和`dalvik.system.PathClassLoader`.

我们首先看如下例子：

class MainActivity : AppCompatActivity() {
        
        override fun onCreate(savedInstanceState: Bundle?) {
        
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
            val appClassLoader = MainActivity::class.java.classLoader
            val bootClassLoader = Activity::class.java.classLoader
    
            log("MainActivity::::"+appClassLoader.javaClass.canonicalName)
            log("Activity:::"+bootClassLoader.javaClass.canonicalName)
            log("appClassLoader的父委托器:::"+appClassLoader.parent)
        }
    
    
        fun log(msg:String){
        
            Log.e("ClassLoader","msg:[${msg}]")
        }
    
    
    }

msg:[MainActivity::::dalvik.system.PathClassLoader]
    msg:[Activity:::java.lang.BootClassLoader]
    msg:[appClassLoader的父委托器:::java.lang.BootClassLoader@fe1e14b]

我们可以得到以下结论：  
`BootClassLoader` 加载系统级别的类如`Activity`等,等价于`java程序`的`Bootstrap ClassLoader`.

`PathClassLoader` 加载系统级别的类如依赖库`Gson，自定义的Class`等,等价于`java程序`的`Application ClassLoader`.

`PathClassLoader`的父加载器为`BootClassLoader`.

# 类加载器加载类源码分析 #

我们首先看下继承图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]  
关于`DexClassLoader`和`PathClasLoader`的区别可以参考文献,我们以`DexClassLoader`为例看下如何加载一个`Apk/dex/zip`中的代码。

class MainActivity : AppCompatActivity() {
        
        override fun onCreate(savedInstanceState: Bundle?) {
        
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
    
            //这里classLoader指向的是PathClassLoader
            //我们先从构造函数入手
            val dexClassLoader = DexClassLoader("", "", null, classLoader)
            dexClassLoader.loadClass("xxx.xxx.yyy")
    
        }
    }

public class DexClassLoader extends BaseDexClassLoader {
        
        /**
         * @param dexPath jar/apk 文件路径，如果有多个请用 {@code File.pathSeparator}分割，默认是“:” 。比如 "xxxx/yy/zz.apk:www/eee/aa.apk"
         * @param optimizedDirectory 优化dex生成odex的生成目录
         * @param libraryPath 动态库/静态库的加载器地址，如果有多个请用 {@code File.pathSeparator}分割
         * @param parent 父加载器
         */
        public DexClassLoader(String dexPath, String optimizedDirectory,
                String libraryPath, ClassLoader parent) {
        
            super(dexPath, new File(optimizedDirectory), libraryPath, parent);
        }
    }

//BaseDexClassLoader.java
    public class BaseDexClassLoader extends ClassLoader {
        
    	
        private final DexPathList pathList;
        
        public BaseDexClassLoader(String dexPath, File optimizedDirectory,
                String libraryPath, ClassLoader parent) {
        
            super(parent);
            this.pathList = new DexPathList(this, dexPath, libraryPath, optimizedDirectory);
        }
     }

//ClassLoader.java
    class ClassLoader{
        
     //到这里即可在追下去没多大意义
      protected ClassLoader(ClassLoader parent) {
        
            this(checkCreateClassLoader(), parent);
        }
    }

我们看下`BaseDexClassLoader`构造函数中有一个`DexPathList`对象，我们首先简单了解下。

final class DexPathList {
        
      
      
        private final Element[] dexElements;
       
        public DexPathList(ClassLoader definingContext, String dexPath,
                String libraryPath, File optimizedDirectory) {
        
      
            this.dexElements = makeDexElements(splitDexPath(dexPath), optimizedDirectory, suppressedExceptions);
            
        }
    
    	//这里比较简单就是将我们传进来的apk地址解析为若干个dex文件路径。（apk存在多个dex文件）
        private static ArrayList<File> splitDexPath(String path) {
        
            return splitPaths(path, null, false);
        }
    
    
     	//将每一个文件路径的dex转化为Element数组，Element对象内部包含一个dex具体的信息
        private static Element[] makeDexElements(ArrayList<File> files, File optimizedDirectory,
                                                 ArrayList<IOException> suppressedExceptions) {
        
            ArrayList<Element> elements = new ArrayList<Element>();
           /**
           * 遍历传入的dex文件列表
           **/
            for (File file : files) {
        
                File zip = null;
                DexFile dex = null;
                String name = file.getName();
    
                if (file.isDirectory()) {
        
                	//如果是目录内部也会处理
                    elements.add(new Element(file, true, null, null));
                } else if (file.isFile()){
        
                	//如果当前是dex后缀文件
                    if (name.endsWith(DEX_SUFFIX)) {
        
                            dex = loadDexFile(file, optimizedDirectory);
                    } else {
        
    					//其他类型照样按dex读取
                        zip = file;
                        dex = loadDexFile(file, optimizedDirectory);
                    }
                } 
    			//将其加入数组中
                if ((zip != null) || (dex != null)) {
        
                    elements.add(new Element(file, false, zip, dex));
                }
            }
    
            return elements.toArray(new Element[elements.size()]);
        }

上面的逻辑可以过多，只需要简单记住构造`DexClassLoader`对象时，父类将传入的多个`dex`文件转化为一个`Element数组`,而`Element`对象包含具体`dex`文件的信息.

我们接着看下面的代码

dexClassLoader.loadClass("xxx.xxx.yyy")

class ClassLoader{
        
    
     public Class<?> loadClass(String name) throws ClassNotFoundException {
        
            return loadClass(name, false);
        }
          protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException
        {
        
               //检查是否已经加载过类。这个函数实现不需要关心
                Class<?> c = findLoadedClass(name);
                //如果加载过直接返回
              
                if (c == null) {
        
                    try {
        
                    	//首先从父加载器加载
                        if (parent != null) {
        
                        	//父委托加载
                            c = parent.loadClass(name, false);
                        } else {
        
                        	//这里Android直接返回null，这个函数毫无意义
                        	//因为android的BosstrapClassLoader是java实现的，所以可以一层层
                        	//通过双亲委托模型向上查找到,而java进程BosstrapClassLoader是C++实现的，所以为了妥协这里会存在这个函数
                            c = findBootstrapClassOrNull(name);
                        }
                    } catch (ClassNotFoundException e) {
        
                       
                    }
    				//如果父加载器没有找到那就自己来加载
                    if (c == null) {
        
                    	//这里的实现是在BaseDexClassLoader
                        c = findClass(name);
                    }
                }
                return c;
        }
    }

//BaseDexClassLoader.java
    public class BaseDexClassLoader extends ClassLoader {
        
        private final DexPathList pathList;
    
        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException {
        
            List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
            //继续跟入，DexPathList 还记得这个类内部有一个Element数组吗？
            //每个Element存放一个dex具体信息
            Class c = pathList.findClass(name, suppressedExceptions);
          
            return c;
        }
    
    }

//DexPathList.java
    class DexPathList{
        
      public Class findClass(String name, List<Throwable> suppressed) {
        
          for (Element element : dexElements) {
        
              DexFile dex = element.dexFile;
    
              if (dex != null) {
        
              	 //内部是一个native函数这里我们可以不用关心
                  Class clazz = dex.loadClassBinaryName(name, definingContext, suppressed);
                  if (clazz != null) {
        
                      return clazz;
                  }
              }
          }
         
          return null;
      }
    }

总结：

`Android`双亲委托核心在`DexPathList`的`findClass`函数中，我们可以通过反射修改`Element数组`实现热修复等

# 参考 #

[谈谈 Android 中的 PathClassLoader 和 DexClassLoader][Android _ PathClassLoader _ DexClassLoader]

[Java_------]: https://www.cnblogs.com/ysocean/p/11878803.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]: /images/20221022/7b6eec568a3b4aff811e6c07805547fa.png
[Android _ PathClassLoader _ DexClassLoader]: https://juejin.cn/post/6844903929562529800