Android类加载机制学习
1、Android类加载机制
Android系统的Dalvik虚拟机如同其他Java虚拟机一样，在运行程序时首先需要将对应的类加载到内存中。
在Java标准的虚拟机中，类加载可以从.class文件中读取，也可以是其他形式的二进制流，因此，Java程序开发常常利用这一点，在程序运行时手动加载Class，从而达到代码动态加载执行的目的。
然而Dalvik虚拟机毕竟不算是标准的Java虚拟机，因此在类加载机制上,他们是不同的。例如，Android的类加载不能直接从.class文件中读取，而是从.dex文件中读取；此外，在使用标准Java虚拟机时，我们经常自定义继承自ClassLoader的类加载器。然后通过defineClass()方法来从一个二进制流中加载Class。然而，这在Android里是行不通的，参看源码我们知道，Android中ClassLoader的defineClass()方法除了抛出一个“UnsupportedOperationException”之外，什么都没做。
• Dalvik虚拟机类加载机制
在Dalvik虚拟机里，defineClass()方法被弃用，我们如何实现动态加载类呢？
Android为我们从ClassLoader派生出了两个类：DexClassLoader和PathClassLoader，并且在ClassLoader中定义了loadClass()方法。
DexClassLoader和PathClassLoader这两个继承自BaseDexClassLoader，BaseDexClassLoader继承自ClassLoader，BaseDexClassLoader本质上是覆写了ClassLoader的findClass()方法。Android中，ClassLoader用loadClass()方法来加载我们需要的类，我们可以参看ClassLoader部分源码：
protected Class<?> loadClass(String className, boolean resolve) throws ClassNotFoundException {
//检查本ClassLoader是否已经加载
Class<?> clazz = findLoadedClass(className);
//如果本ClassLoader没有加载
if (clazz == null) {
ClassNotFoundException suppressed = null;
//从父ClassLoader中查找
try {
clazz = parent.loadClass(className, false);
} catch (ClassNotFoundException e) {
suppressed = e;
}
if (clazz == null) {
//调用findClass来加载
try {
clazz = findClass(className);
} catch (ClassNotFoundException e) {
e.addSuppressed(suppressed);
throw e;
}
}
}
return clazz;
}DexClassLoader和PathClassLoader都属于符合双亲委派模型的类加载器（因为它们没有重载loadClass()方法）。
其特点如下：
会先查询当前ClassLoader实例是否加载过此类，有就返回
如果没有，查询Parent是否已经加载过此类，如果已经加载过，就直接返回Parent加载的类
如果parent路线上的ClassLoader都没有加载，才调用findClass执行类的加载工作
ClassLoader与PathClassLoader和DexClassLoader的类图关系如下图所示:
• BaseDexClassLoader的findClass加载类过程
findClass加载类过程示意图如下:
findClass方法类加载的过程如下：
1、生成Element数组dexElements，生成pathList
BaseDexClassLoader的构造方法如下：
public BaseDexClassLoader(String dexPath, File optimizedDirectory,
String libraryPath, ClassLoader parent) {
super(parent);
this.pathList = new DexPathList(this, dexPath, libraryPath, optimizedDirectory);
}BaseDexClassLoader中的构造方法包含4个参数，他们分别是：
(1) dexPath : 指目标类所在的APK或jar文件的路径.类装载器将从该路径中寻找指定的目标类,该类必须是APK或jar的全路径.如果要包含多个路径,路径之间必须使用特定的分割符分隔,分隔符为File.pathSeparator(“:”).
(2) optimizedDirectory : 由于dex文件被包含在APK或者Jar文件中,因此在装载目标类之前需要先从APK或Jar文件中解压出dex文件,该参数就是指定解压出的dex文件存放的路径.
(3) libraryPath : 指目标类中所使用的C/C++库存放的路径
(4) parent : 是指该装载器的父装载器
在BaseDexClassLoader中生成DexPathList类的对象pathList,在DexPathList的构造方法中调用DexPathList类中的makePathElements()方法，在makePathElements()方法中会调用splitDexPath()方法，如果dexPath包含多个路径，splitDexPath()方法能够提取出File.pathSeparator分隔的多个路径，并将多个路径放入List中返回，然后makePathElements()方法会调用loadDexFile()方法遍历List中每个包含dex的文件生成DexFile,用生成的DexFile生成Element对象，用这些Element对象构成Element数组dexElements。
DexPathList.java中的loadDexFile()方法源码如下：
private static DexFile loadDexFile(File file, File optimizedDirectory)
throws IOException {
if (optimizedDirectory == null) {
return new DexFile(file);
} else {
String optimizedPath = optimizedPathFor(file, optimizedDirectory);
return DexFile.loadDex(file.getPath(), optimizedPath, 0);
}
}一个应用程序中所有类加载到内存中，就是在makePathElements执行loadDexFile()方法来实现的。
optimizedDirectory是一个内部存储路径，用来缓存我们需要加载的dex文件的。DexClassLoader可以指定自己的optimizedDirectory，所以它可以加载外部的dex，因为这个dex会被复制到内部路径的optimizedDirectory；而PathClassLoader没有optimizedDirectory，所以它只能加载内部的dex，这些大都是存在系统中已经安装过的apk里面的。
它们的不同之处总结如下是：
DexClassLoader可以加载jar/apk/dex，可以从SD卡中加载未安装的apk；
PathClassLoader只能加载系统中已经安装过的apk，Android中大部分类的加载默认采用此类
2、pathList调用BaseDexClassLoader中的findClass()方法
调用BaseDexClassLoader的findClass()方法，在此方法，pathList调用DexPathList中的findClass()方法，BaseDexClassLoader的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;
}3、调用DexPathList中的findClass()方法
pathList是DexPathList类型的一个对象，DexPathList中的findClass()方法源码如下：
public Class findClass(String name, List<Throwable> suppressed) {
for (Element element : dexElements) {
DexFile dex = element.dexFile;
if (dex != null) {
Class clazz = dex.loadClassBinaryName(name, definingContext, suppressed);
if (clazz != null) {
return clazz;
}
}
}
if (dexElementsSuppressedExceptions != null) {
suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
}
return null;
}DexPathList的findClass()方法，遍历dexElements元素的DexFile实例，也就是遍历所有加载过的dex文件，一个个调用loadClassBinaryName()方法，看能不能找到我们想要的类，如果可以，返回这个类。
DexFile.java中的loadClassBinaryName()方法：
public Class loadClassBinaryName(String name, ClassLoader loader, List<Throwable> suppressed) {
return defineClass(name, loader, mCookie, suppressed);
}
private static Class defineClass(String name, ClassLoader loader, Object cookie,
List<Throwable> suppressed) {
Class result = null;
try {
result = defineClassNative(name, loader, cookie);
} catch (NoClassDefFoundError e) {
if (suppressed != null) {
suppressed.add(e);
}
} catch (ClassNotFoundException e) {
if (suppressed != null) {
suppressed.add(e);
}
}
return result;
}
private static native Class defineClassNative(String name,
ClassLoader loader, Object cookie) throws ClassNotFoundException, NoClassDefFoundError;4、返回
将加载的类返回ClassLoader类的loadClass()方法。
总结
当加载一个类的时候，需要首先获取类加载器，调用类加载器的loadClass方法，在loadClass方法中先查询当前ClassLoader实例是否加载过此类，有就返回；如果没有，查询parent指定的类加载器是否已经加载过此类，如果已经加载过，就直接返回parent加载的类；如果parent路线上的ClassLoader都没有加载，才调用findClass执行类的加载工作。BaseDexClassLoader的findClass方法调用之前，首先在BaseDexClassLoader的构造方法中生成了DexPathList类的对象pathList，在DexPathList类的构造方法中，利用loadDexFile()方法将dex文件中的类加载到内存中，并生成对应的DexFile对象，进而生成Element对象，用这些Element对象构成Element数组dexElements。在BaseDexClassLoader的findClass方法中，调用了DexPathList类的findClass方法，在DexPathList类的findClass方法里，遍历dexElements元素的DexFile实例，一个个调用loadClassBinaryName()方法，看能不能找到我们想要的类，如果可以，返回这个类。
2、类加载器的生成
在应用程序第一次启动时，都会首先创建Application对象。会调用ActivityThread.java中的handleBindApplication()方法，handleBindApplication()方法调用getPackageInfoNoCheck()方法生成LoadedApk对象data.info，它们的源代码如下：
ActivityThread.java中的handleBindApplication()方法:
private void handleBindApplication(AppBindData data) {
LoadedApk data.info = getPackageInfoNoCheck(data.appInfo, data.compatInfo);
......
//调用LoadedApk.java中makeApplication()方法
Application app = data.info.makeApplication(data.restrictedBackupMode, null);
......
}ActivityThread.java中getPackageInfoNoCheck()方法:
public final LoadedApk getPackageInfoNoCheck(ApplicationInfo ai, CompatibilityInfo compatInfo) {
return getPackageInfo(ai, compatInfo, null, false, true, false);
}getPackageInfoNoCheck()方法调用了getPackageInfo()方法，getPackageInfo()方法的源代码如下：
private LoadedApk getPackageInfo(ApplicationInfo aInfo, CompatibilityInfo compatInfo,ClassLoader baseLoader,
boolean securityViolation, boolean includeCode,boolean registerPackage) {
final boolean differentUser = (UserHandle.myUserId() != UserHandle.getUserId(aInfo.uid));
synchronized (mResourcesManager) {
WeakReference<LoadedApk> ref;
if (differentUser) {
// Caching not supported across users
ref = null;
} else if (includeCode) {
//
ref = mPackages.get(aInfo.packageName);
} else {
ref = mResourcePackages.get(aInfo.packageName);
}
LoadedApk packageInfo = ref != null ? ref.get() : null;
if (packageInfo == null || (packageInfo.mResources != null
&& !packageInfo.mResources.getAssets().isUpToDate())) {
if (localLOGV) Slog.v(TAG, (includeCode ? "Loading code package "
: "Loading resource-only package ") + aInfo.packageName
+ " (in " + (mBoundApplication != null
? mBoundApplication.processName : null)
+ ")");
//生成LoadedApk类的对象packageInfo
packageInfo = new LoadedApk(this, aInfo, compatInfo, baseLoader,
securityViolation, includeCode &&
(aInfo.flags&ApplicationInfo.FLAG_HAS_CODE) != 0, registerPackage);
if (mSystemThread && "android".equals(aInfo.packageName)) {
packageInfo.installSystemApplicationInfo(aInfo,
getSystemContext().mPackageInfo.getClassLoader());
}
if (differentUser) {
// Caching not supported across users
} else if (includeCode) {
//将生成的packageInfo存入到WeakReference<LoadedApk> mPackages中
mPackages.put(aInfo.packageName,
new WeakReference<LoadedApk>(packageInfo));
} else {
mResourcePackages.put(aInfo.packageName,
new WeakReference<LoadedApk>(packageInfo));
}
}
return packageInfo;
}
}第一次调用getPackageInfo()方法，WeakReference mPackages为null，利用new LoadedApk()生成LoadedApk类的对象packageInfo，并将生成的packageInfo存入到WeakReference mPackages中。当第二次调用getPackageInfo()方法时，WeakReference mPackages不为null，直接返回WeakReference mPackages中存储的LoadedApk对象。可以看到同一个应用程序中，类加载所使用的LoadedApk对象都是同一个。
生成LoadedApk对象data.info后，在ActivityThread.java中的handleBindApplication()方法中调用了makeApplication()方法生成Application类的对象，makeApplication()方法在LoadedApk.java文件中定义的，其源码为:
public Application makeApplication(boolean forceDefaultAppClass, Instrumentation instrumentation) {
try {
java.lang.ClassLoader cl = getClassLoader();
......
//调用ContextImpl类的createAppContext()方法
ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
app = mActivityThread.mInstrumentation.newApplication(cl, appClass, appContext);
appContext.setOuterContext(app);
} catch (Exception e) {
if (!mActivityThread.mInstrumentation.onException(app, e)) {
throw new RuntimeException(
"Unable to instantiate application " + appClass
+ ": " + e.toString(), e);
}
}
return app;
}Instrumentation.java中newApplication()方法：
public Application newApplication(ClassLoader cl, String className, Context context)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
return newApplication(cl.loadClass(className), context);
}
static public Application newApplication(Class<?> clazz, Context context)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
Application app = (Application)clazz.newInstance();
app.attach(context);
return app;
}可见，调用newApplication()方法之前，第一次调用了LoadedApk的getClassLoader()方法，其源码如下：
public ClassLoader getClassLoader() {
synchronized (this) {
if (mClassLoader != null) {
return mClassLoader;
}
if (mIncludeCode && !mPackageName.equals("android")) {
......
//调用了ApplicationLoaders.java里面的getClassLoader()方法
mClassLoader = ApplicationLoaders.getDefault().getClassLoader(zip, lib,mBaseClassLoader);
StrictMode.setThreadPolicy(oldPolicy);
} else {
if (mBaseClassLoader == null) {
mClassLoader = ClassLoader.getSystemClassLoader();
} else {
mClassLoader = mBaseClassLoader;
}
}
return mClassLoader;
}
}当第一次调用LoadedApk的getClassLoader()方法，mClassLoader==null，会调用ApplicationLoaders.java里面的getClassLoader()方法生成mClassLoader；当再次调用LoadedApk的getClassLoader()方法，mClassLoader！=null，则将第一次生成的mClassLoader直接返回。可见，getClassLoader()返回的ClassLoader也是同一个。
调用了ApplicationLoaders.java里面的getClassLoader()方法,源码如下：
public ClassLoader getClassLoader(String zip, String libPath, ClassLoader parent)
{
ClassLoader baseParent = ClassLoader.getSystemClassLoader().getParent();
synchronized (mLoaders) {
if (parent == null) {
parent = baseParent;
}
if (parent == baseParent) {
ClassLoader loader = mLoaders.get(zip);
if (loader != null) {
return loader;
}
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, zip);
PathClassLoader pathClassloader = new PathClassLoader(zip, libPath, parent);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
mLoaders.put(zip, pathClassloader);
return pathClassloader;
}
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, zip);
PathClassLoader pathClassloader = new PathClassLoader(zip, parent);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
return pathClassloader;
}
}在这个方法中调用了生成了PathClassLoader对象，根据前面的讲解，可以知道在PathClassLoader的构造方法中，调用了makePathElements()方法，完成了所有的类加载到内存中。这个PathClassLoader就是我们应用程序中类加载所用的类加载器。
总结
类加载器生成的流程图:
在应用程序启动时，会创建Application对象，在创建Application的过程中，完成了应用程序中所有类的加载到内存。当再使用这个程序中其他类的时候，再次调用ActivityThread.java中的getPackageInfo()方法，此方法不会再new一个新的LoadedApk对象，而是返回创建Application时的那个LoadedApk对象，即同一个LoadedApk对象，用这个对象调用getClassLoader获得的加载器也都是同一个，不会重复加载类，生成类的实例的形式一般为：
getClassLoader().loadClass(className).newInstance();
Android常用的类包括Activity、Service、BroadcastReceiver、Fragment，都采用了同样的方式用同一个类加载器生成类的实例。
比如：
① 使用Fragment时，在Fragment.java文件的instantiate()方法中调用了loadClass()方法。
/**
* Create a new instance of a Fragment with the given class name. This is
* the same as calling its empty constructor.
*/
public static Fragment instantiate(Context context, String fname, @Nullable Bundle args) {
try {
Class<?> clazz = sClassMap.get(fname);
if (clazz == null) {
// Class not found in the cache, see if it's real, and try to add it
clazz = context.getClassLoader().loadClass(fname);
if (!Fragment.class.isAssignableFrom(clazz)) {
throw new InstantiationException("Trying to instantiate a class "
+ fname + " that is not a Fragment", new ClassCastException());
}
sClassMap.put(fname, clazz);
}
//生成Fragment类的单例
Fragment f = (Fragment)clazz.newInstance();
if (args != null) {
args.setClassLoader(f.getClass().getClassLoader());
f.mArguments = args;
}
return f;
} catch (ClassNotFoundException e) {
} catch (java.lang.InstantiationException e) {
} catch (IllegalAccessException e) {
}
}② 在使用BroadcastReceiver时，在ActivityThread.java的handleReceiver()方法中调用了loadClass()方法。
private void handleReceiver(ReceiverData data) {
// If we are getting ready to gc after going to the background, well
// we are back active so skip it.
unscheduleGcIdler();
String component = data.intent.getComponent().getClassName();
LoadedApk packageInfo = getPackageInfoNoCheck(
data.info.applicationInfo, data.compatInfo);
IActivityManager mgr = ActivityManagerNative.getDefault();
BroadcastReceiver receiver;
try {
java.lang.ClassLoader cl = packageInfo.getClassLoader();
data.intent.setExtrasClassLoader(cl);
data.intent.prepareToEnterProcess();
data.setExtrasClassLoader(cl);
receiver = (BroadcastReceiver)cl.loadClass(component).newInstance();
} catch (Exception e) {
......
}
......
}③ 在使用Service时，在ActivityThread.java的handleCreateService()方法中调用了loadClass()方法。
private void handleCreateService(CreateServiceData data) {
// If we are getting ready to gc after going to the background, well
// we are back active so skip it.
unscheduleGcIdler();
LoadedApk packageInfo = getPackageInfoNoCheck(
data.info.applicationInfo, data.compatInfo);
Service service = null;
try {
java.lang.ClassLoader cl = packageInfo.getClassLoader();
service = (Service) cl.loadClass(data.info.name).newInstance();
} catch (Exception e) {
......
}
......
}④ 在Activity的使用过程中，在Instrumentation.java的newActivity()方法中调用了loadClass()方法。
public Activity newActivity(ClassLoader cl, String className,
Intent intent)throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
return (Activity)cl.loadClass(className).newInstance();
}这些类调用getClassLoader方法所获得的类加载器是同一个，用loadClass获取到对应的Class，采用newInstance()生成实例。
406
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
