2016-07-30-Android中的类加载器及类加载流程
Android中的类加载器及类加载流程
Android中的类加载器有三种，
DexClassLoader、PathClassLoader、BootClassLoader。
其中BootClassLoader是系统启动时预加载常用类的，一般使用不到。DexClassLoader、PathClassLoader都是继承自BaseDexClassLoader。
但DexClassLoader和PathClassLoader并没有重写BaseDexClassLoader中的任何方法，所以源码只需要看BaseDexClassLoader即可。由于Android SDK并没有包含
BaseDexClassLoader，所以需要到源码查询网站查询源码，如下：/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package dalvik.system; import static android.annotation.SystemApi.Client.MODULE_LIBRARIES; import android.annotation.SystemApi; import android.compat.annotation.UnsupportedAppUsage; import java.io.File; import java.io.IOException; import java.net.URL; import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Enumeration; import java.util.HashMap; import java.util.List; import java.util.Map; import libcore.util.NonNull; import libcore.util.Nullable; import sun.misc.CompoundEnumeration; /** * Base class for common functionality between various dex-based * {@link ClassLoader} implementations. */ public class BaseDexClassLoader extends ClassLoader { /** * Hook for customizing how dex files loads are reported. * * This enables the framework to monitor the use of dex files. The * goal is to simplify the mechanism for optimizing foreign dex files and * enable further optimizations of secondary dex files. * * The reporting happens only when new instances of BaseDexClassLoader * are constructed and will be active only after this field is set with * {@link BaseDexClassLoader#setReporter}. */ /* @NonNull */ private static volatile Reporter reporter = null; private final DexPathList pathList; /** * Array of ClassLoaders that can be used to load classes and resources that the code in * {@code pathList} may depend on. This is used to implement Android's * <a href=https://developer.android.com/guide/topics/manifest/uses-library-element> * shared libraries</a> feature. * <p>The shared library loaders are always checked before the {@code pathList} when looking * up classes and resources. * * <p>{@code null} if the class loader has no shared library. * * @hide */ protected final ClassLoader[] sharedLibraryLoaders; /** * Constructs an instance. * Note that all the *.jar and *.apk files from {@code dexPath} might be * first extracted in-memory before the code is loaded. This can be avoided * by passing raw dex files (*.dex) in the {@code dexPath}. * * @param dexPath the list of jar/apk files containing classes and * resources, delimited by {@code File.pathSeparator}, which * defaults to {@code ":"} on Android. * @param optimizedDirectory this parameter is deprecated and has no effect since API level 26. * @param librarySearchPath the list of directories containing native * libraries, delimited by {@code File.pathSeparator}; may be * {@code null} * @param parent the parent class loader */ public BaseDexClassLoader(String dexPath, File optimizedDirectory, String librarySearchPath, ClassLoader parent) { this(dexPath, librarySearchPath, parent, null, false); } /** * @hide */ public BaseDexClassLoader(String dexPath, File optimizedDirectory, String librarySearchPath, ClassLoader parent, boolean isTrusted) { this(dexPath, librarySearchPath, parent, null, isTrusted); } /** * @hide */ public BaseDexClassLoader(String dexPath, String librarySearchPath, ClassLoader parent, ClassLoader[] libraries) { this(dexPath, librarySearchPath, parent, libraries, false); } /** * BaseDexClassLoader implements the Android * <a href=https://developer.android.com/guide/topics/manifest/uses-library-element> * shared libraries</a> feature by changing the typical parent delegation mechanism * of class loaders. * <p> Each shared library is associated with its own class loader, which is added to a list of * class loaders this BaseDexClassLoader tries to load from in order, immediately checking * after the parent. * The shared library loaders are always checked before the {@code pathList} when looking * up classes and resources. * * @hide */ public BaseDexClassLoader(String dexPath, String librarySearchPath, ClassLoader parent, ClassLoader[] sharedLibraryLoaders, boolean isTrusted) { super(parent); // Setup shared libraries before creating the path list. ART relies on the class loader // hierarchy being finalized before loading dex files. this.sharedLibraryLoaders = sharedLibraryLoaders == null ? null : Arrays.copyOf(sharedLibraryLoaders, sharedLibraryLoaders.length); this.pathList = new DexPathList(this, dexPath, librarySearchPath, null, isTrusted); // Run background verification after having set 'pathList'. this.pathList.maybeRunBackgroundVerification(this); reportClassLoaderChain(); } /** * Reports the current class loader chain to the registered {@code reporter}. * * @hide */ @SystemApi(client = MODULE_LIBRARIES) @libcore.api.CorePlatformApi(status = libcore.api.CorePlatformApi.Status.STABLE) public void reportClassLoaderChain() { if (reporter == null) { return; } String[] classPathAndClassLoaderContexts = computeClassLoaderContextsNative(); if (classPathAndClassLoaderContexts.length == 0) { return; } Map<String, String> dexFileMapping = new HashMap<>(classPathAndClassLoaderContexts.length / 2); for (int i = 0; i < classPathAndClassLoaderContexts.length; i += 2) { dexFileMapping.put(classPathAndClassLoaderContexts[i], classPathAndClassLoaderContexts[i + 1]); } reporter.report(Collections.unmodifiableMap(dexFileMapping)); } /** * Computes the classloader contexts for each classpath entry in {@code pathList.getDexPaths()}. * * Note that this method is not thread safe, i.e. it is the responsibility of the caller to * ensure that {@code pathList.getDexPaths()} is not modified concurrently with this method * being called. * * @return A non-null array of non-null strings of length * {@code 2 * pathList.getDexPaths().size()}. Every even index (0 is even here) is a dex file * path and every odd entry is the class loader context used to load the previously listed dex * file. E.g. a result might be {@code { "foo.dex", "PCL[]", "bar.dex", "PCL[foo.dex]" } }. */ private native String[] computeClassLoaderContextsNative(); /** * Constructs an instance. * * dexFile must be an in-memory representation of a full dexFile. * * @param dexFiles the array of in-memory dex files containing classes. * @param librarySearchPath the list of directories containing native * libraries, delimited by {@code File.pathSeparator}; may be {@code null} * @param parent the parent class loader * * @hide */ public BaseDexClassLoader(ByteBuffer[] dexFiles, String librarySearchPath, ClassLoader parent) { super(parent); this.sharedLibraryLoaders = null; this.pathList = new DexPathList(this, librarySearchPath); this.pathList.initByteBufferDexPath(dexFiles); // Run background verification after having set 'pathList'. this.pathList.maybeRunBackgroundVerification(this); } @Override protected Class<?> findClass(String name) throws ClassNotFoundException { // First, check whether the class is present in our shared libraries. if (sharedLibraryLoaders != null) { for (ClassLoader loader : sharedLibraryLoaders) { try { return loader.loadClass(name); } catch (ClassNotFoundException ignored) { } } } // Check whether the class in question is present in the dexPath that // this classloader operates on. 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; } /** * Adds a new dex path to path list. * * @param dexPath dex path to add to path list * * @hide */ @SystemApi(client = MODULE_LIBRARIES) @libcore.api.CorePlatformApi(status = libcore.api.CorePlatformApi.Status.STABLE) public void addDexPath(@Nullable String dexPath) { addDexPath(dexPath, false /*isTrusted*/); } /** * @hide */ public void addDexPath(String dexPath, boolean isTrusted) { pathList.addDexPath(dexPath, null /*optimizedDirectory*/, isTrusted); } /** * Adds additional native paths for consideration in subsequent calls to * {@link #findLibrary(String)}. * * @param libPaths collection of paths to be added to path list * * @hide */ @SystemApi(client = MODULE_LIBRARIES) @libcore.api.CorePlatformApi(status = libcore.api.CorePlatformApi.Status.STABLE) public void addNativePath(@NonNull Collection<String> libPaths) { pathList.addNativePath(libPaths); } @Override protected URL findResource(String name) { if (sharedLibraryLoaders != null) { for (ClassLoader loader : sharedLibraryLoaders) { URL url = loader.getResource(name); if (url != null) { return url; } } } return pathList.findResource(name); } @Override protected Enumeration<URL> findResources(String name) { Enumeration<URL> myResources = pathList.findResources(name); if (sharedLibraryLoaders == null) { return myResources; } Enumeration<URL>[] tmp = (Enumeration<URL>[]) new Enumeration<?>[sharedLibraryLoaders.length + 1]; // This will add duplicate resources if a shared library is loaded twice, but that's ok // as we don't guarantee uniqueness. for (int i = 0; i < sharedLibraryLoaders.length; i++) { try { tmp[i] = sharedLibraryLoaders[i].getResources(name); } catch (IOException e) { // Ignore. } } tmp[sharedLibraryLoaders.length] = myResources; return new CompoundEnumeration<>(tmp); } @Override public String findLibrary(String name) { return pathList.findLibrary(name); } /** * Returns package information for the given package. * Unfortunately, instances of this class don't really have this * information, and as a non-secure {@code ClassLoader}, it isn't * even required to, according to the spec. Yet, we want to * provide it, in order to make all those hopeful callers of * {@code myClass.getPackage().getName()} happy. Thus we construct * a {@code Package} object the first time it is being requested * and fill most of the fields with fake values. The {@code * Package} object is then put into the {@code ClassLoader}'s * package cache, so we see the same one next time. We don't * create {@code Package} objects for {@code null} arguments or * for the default package. * * <p>There is a limited chance that we end up with multiple * {@code Package} objects representing the same package: It can * happen when when a package is scattered across different JAR * files which were loaded by different {@code ClassLoader} * instances. This is rather unlikely, and given that this whole * thing is more or less a workaround, probably not worth the * effort to address. * * @param name the name of the class * @return the package information for the class, or {@code null} * if there is no package information available for it */ @Override protected synchronized Package getPackage(String name) { if (name != null && !name.isEmpty()) { Package pack = super.getPackage(name); if (pack == null) { pack = definePackage(name, "Unknown", "0.0", "Unknown", "Unknown", "0.0", "Unknown", null); } return pack; } return null; } /** * Returns colon-separated set of directories where libraries should be * searched for first, before the standard set of directories. * * @return colon-separated set of search directories * * @hide */ @SystemApi(client = MODULE_LIBRARIES) @libcore.api.CorePlatformApi(status = libcore.api.CorePlatformApi.Status.STABLE) public @NonNull String getLdLibraryPath() { StringBuilder result = new StringBuilder(); for (File directory : pathList.getNativeLibraryDirectories()) { if (result.length() > 0) { result.append(':'); } result.append(directory); } return result.toString(); } @Override public String toString() { return getClass().getName() + "[" + pathList + "]"; } /** * Sets the reporter for dex load notifications. * Once set, all new instances of BaseDexClassLoader will report upon * constructions the loaded dex files. * * @param newReporter the new Reporter. Setting {@code null} will cancel reporting. * @hide */ @SystemApi(client = MODULE_LIBRARIES) @libcore.api.CorePlatformApi(status = libcore.api.CorePlatformApi.Status.STABLE) public static void setReporter(@Nullable Reporter newReporter) { reporter = newReporter; } /** * @hide */ public static Reporter getReporter() { return reporter; } /** * Reports the construction of a {@link BaseDexClassLoader} and provides opaque * information about the class loader chain. * * @hide */ @SystemApi(client = MODULE_LIBRARIES) @libcore.api.CorePlatformApi(status = libcore.api.CorePlatformApi.Status.STABLE) public interface Reporter { /** * Reports the construction of a BaseDexClassLoader and provides opaque information about * the class loader chain. For example, if the childmost ClassLoader in the chain: * {@quote BaseDexClassLoader { foo.dex } -> BaseDexClassLoader { base.apk } * -> BootClassLoader } was just initialized then the load of {@code "foo.dex"} would be * reported with a classLoaderContext of {@code "PCL[];PCL[base.apk]"}. * * @param contextsMap A map from dex file paths to the class loader context used to load * each dex file. * * @hide */ @SystemApi(client = MODULE_LIBRARIES) @libcore.api.CorePlatformApi(status = libcore.api.CorePlatformApi.Status.STABLE) void report(@NonNull Map<String, String> contextsMap); } }复制这个java文件到对应源码文件夹下就可以在Android Studio中查看了。
通过调试可以看到，Android中普通类的加载器其实是
PathClassLoader。追踪PathClassLoader.findClass方法，即可获取Android的类加载过程：PathClassLoader.findClass -- 继承自 --> BaseDexClassLoader.findClass()
-> BaseDexClassLoader.pathList.findClass()
-> DexPathList.dexElements.foreach { element.findClass() }
-> Element.findClass()
-> Element.dexFile.loadClassBinaryName()
-> DexFile.defineClass()即类加载过程通过
BaseDexClassLoader.findClass、DexPathList.findClass、Element.findClass、DexFile.loadClassBinaryName，最终会落到DexFile.defineClass方法中，然后就交给native层了。其中需要注意的是，在
BaseDexClassLoader.findClass的开头有这么一段：if (sharedLibraryLoaders != null) { for (ClassLoader loader : sharedLibraryLoaders) { try { return loader.loadClass(name); } catch (ClassNotFoundException ignored) { } } }这段是在Android 10新加入的，据称是为了实现shared library功能的，在之前的版本中没有这一段。
通过替换DexPathList实现热修复
在上一节中知道了，类加载的流程如下：
BaseDexClassLoader.findClass() ->
BaseDexClassLoader.pathList.findClass() ->
DexPathList.dexElements.foreach { element.findClass() } ->
Element.findClass() -> ...看
DexPathList.findClass方法：private Element[] dexElements; public Class<?> findClass(String name, List<Throwable> suppressed) { 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; }可以发现，
DexPathList加载类的方法是遍历dexElements数组依次加载，知道获取到值为止。所以可以通过修改这个数组，把新的dex文件放在数组的前面，使其加载修改后的类，从而实现热修复。根据以上原理，写下这个工具类，有效性待验证：
public class HotFix { private static final String TAG = "HotFix"; private static final ReflectUtil ReflectUtil = ReflectUtilKt.INSTANCE; /** * 传入热修复的dex文件位置，优先加载其中的类。 * * @param context the context * @param dexFilePath dex文件的位置 */ @SuppressWarnings("ConstantConditions") public static void fix(Context context, String dexFilePath) throws Exception { ClassLoader classLoader = context.getClassLoader(); Log.d(TAG, "createClassLoader: " + classLoader.getClass().getSimpleName()); // BaseDexClassLoader.pathList Field pathListField = ReflectUtil.getField(BaseDexClassLoader.class, "pathList"); pathListField.setAccessible(true); Object pathList = pathListField.get(classLoader); // DexPathList.dexElements Field dexElementsField = ReflectUtil.getField(pathListField.getType(), "dexElements"); dexElementsField.setAccessible(true); Object dexElements = dexElementsField.get(pathList); // 处理Element数组 Class<?> elementType = dexElements.getClass().getComponentType(); int length = Array.getLength(dexElements); Log.d(TAG, "createClassLoader: dexElements = " + dexElements + ", length = " + length); Object newDexElements = Array.newInstance(elementType, length + 1); // 旧的element依次往后挪一位 for (int i = 0; i < length; i++) { Array.set(newDexElements, i + 1, Array.get(dexElements, i)); } // 新的element插入到第0项 DexFile dexFile = loadDex(context, dexFilePath); // todo create dex file Object insertedElement = elementType .getConstructor(DexFile.class) .newInstance(dexFile); Array.set(newDexElements, 0, insertedElement); // 替换dexElements dexElementsField.set(pathList, newDexElements); } private static DexFile loadDex(Context context, String path) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { Class<DexFile> clazz = DexFile.class; Method loadDexMethod = clazz.getDeclaredMethod("loadDex", String.class, String.class, int.class); loadDexMethod.setAccessible(true); return (DexFile) loadDexMethod.invoke(null, path, context.getCacheDir().getAbsolutePath(), 0); } }https://upload-images.jianshu.io/upload_images/3171298-8848cd3fb5d0c403.png
作者：littlefogcat
链接：https://www.jianshu.com/p/80bcf2b90305
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
