android类加载过程,Android类加载过程解析

最新推荐文章于 2024-08-20 23:56:39 发布
最新推荐文章于 2024-08-20 23:56:39 发布
阅读量263 收藏
点赞数
文章标签： android类加载过程

涉及源码(Android 4.4.2)：

/libcore/libart/src/main/java/java/lang/Class.java

/dalvik/vm/native/java_lang_Class.cpp

/dalvik/vm/native/InternalNative.cpp

/dalvik/vm/oo/Class.cpp

/libcore/libart/src/main/java/java/lang/Class.java

/libcore/libart/src/main/java/java/lang/ClassLoader.java

/libcore/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java

/libcore/dalvik/src/main/java/dalvik/system/DexPathList.java

/libcore/dalvik/src/main/java/dalvik/system/DexFile.java

/dalvik/vm/native/dalvik_system_DexFile.cpp

/dalvik/vm/oo/Class.cpp

/dalvik/libdex/DexFile.cpp

从Class.forName()函数看起。

public static Class> forName(String className) throws ClassNotFoundException {

return forName(className, true, VMStack.getCallingClassLoader());

}

可以看到默认使用的classLoader是调用该函数的类的classLoader。

public static Class> forName(String className, boolean shouldInitialize,

ClassLoader classLoader) throws ClassNotFoundException {

if (classLoader == null) {

classLoader = ClassLoader.getSystemClassLoader();

}

Class> result;

try {

result = classForName(className, shouldInitialize, classLoader);

} catch (ClassNotFoundException e) {

Throwable cause = e.getCause();

if (cause instanceof LinkageError) {

throw (LinkageError) cause;

}

throw e;

}

return result;

}

static native Class> classForName(String className, boolean shouldInitialize,

ClassLoader classLoader) throws ClassNotFoundException;

最终会调用到native方法

/dalvik/vm/native/java_lang_Class.cpp

static void Dalvik_java_lang_Class_classForName(const u4* args, JValue* pResult)

{

StringObject* nameObj = (StringObject*) args[0];

bool initialize = (args[1] != 0);

Object* loader = (Object*) args[2];

RETURN_PTR(dvmFindClassByName(nameObj, loader, initialize));

}

/dalvik/vm/native/InternalNative.cpp

ClassObject* dvmFindClassByName(StringObject* nameObj, Object* loader,

bool doInit)

{

ClassObject* clazz = NULL;

char* name = NULL;

char* descriptor = NULL;

if (nameObj == NULL) {

dvmThrowNullPointerException("name == null");

goto bail;

}

name = dvmCreateCstrFromString(nameObj);

if (!dexIsValidClassName(name, true)) {

ALOGW("dvmFindClassByName rejecting '%s'", name);

dvmThrowClassNotFoundException(name);

goto bail;

}

descriptor = dvmDotToDescriptor(name);

if (descriptor == NULL) {

goto bail;

}

if (doInit)

clazz = dvmFindClass(descriptor, loader);

else

clazz = dvmFindClassNoInit(descriptor, loader);

if (clazz == NULL) {

LOGVV("FAIL: load %s (%d)", descriptor, doInit);

Thread* self = dvmThreadSelf();

Object* oldExcep = dvmGetException(self);

dvmAddTrackedAlloc(oldExcep, self); /* don't let this be GCed */

dvmClearException(self);

dvmThrowChainedClassNotFoundException(name, oldExcep);

dvmReleaseTrackedAlloc(oldExcep, self);

} else {

LOGVV("GOOD: load %s (%d) --> %p ldr=%p",

descriptor, doInit, clazz, clazz->classLoader);

}

bail:

free(name);

free(descriptor);

return clazz;

}

重点关注dvmFindClassNoInit方法。

/dalvik/vm/oo/Class.cpp

ClassObject* dvmFindClassNoInit(const char* descriptor,

Object* loader)

{

assert(descriptor != NULL);

//assert(loader != NULL);

LOGVV("FindClassNoInit '%s' %p", descriptor, loader);

if (*descriptor == '[') {

/*

* Array class. Find in table, generate if not found.

*/

return dvmFindArrayClass(descriptor, loader);

} else {

/*

* Regular class. Find in table, load if not found.

*/

if (loader != NULL) {

return findClassFromLoaderNoInit(descriptor, loader);

} else {

return dvmFindSystemClassNoInit(descriptor);

}

}

}

进入到findClassFromLoaderNoInit方法

static ClassObject* findClassFromLoaderNoInit(const char* descriptor,

Object* loader)

{

Thread* self = dvmThreadSelf();

// 1、首先进行查找是否以及进行了加载

ClassObject* clazz = dvmLookupClass(descriptor, loader, false);

if (clazz != NULL) {

LOGVV("Already loaded: %s %p", descriptor, loader);

return clazz;

} else {

LOGVV("Not already loaded: %s %p", descriptor, loader);

}

char* dotName = NULL;

StringObject* nameObj = NULL;

/* convert "Landroid/debug/Stuff;" to "android.debug.Stuff" */

dotName = dvmDescriptorToDot(descriptor);

if (dotName == NULL) {

dvmThrowOutOfMemoryError(NULL);

return NULL;

}

nameObj = dvmCreateStringFromCstr(dotName);

if (nameObj == NULL) {

assert(dvmCheckException(self));

goto bail;

}

dvmMethodTraceClassPrepBegin();

LOGVV("--- Invoking loadClass(%s, %p)", dotName, loader);

{

// 2、如果没有加载，这里调用java/lang/ClassLoader的loadClass函数来加载类

const Method* loadClass =

loader->clazz->vtable[gDvm.voffJavaLangClassLoader_loadClass];

JValue result;

dvmCallMethod(self, loadClass, loader, &result, nameObj);

clazz = (ClassObject*) result.l;

dvmMethodTraceClassPrepEnd();

Object* excep = dvmGetException(self);

if (excep != NULL) {

#if DVM_SHOW_EXCEPTION >= 2

ALOGD("NOTE: loadClass '%s' %p threw exception %s",

dotName, loader, excep->clazz->descriptor);

#endif

dvmAddTrackedAlloc(excep, self);

dvmClearException(self);

dvmThrowChainedNoClassDefFoundError(descriptor, excep);

dvmReleaseTrackedAlloc(excep, self);

clazz = NULL;

goto bail;

} else if (clazz == NULL) {

ALOGW("ClassLoader returned NULL w/o exception pending");

dvmThrowNullPointerException("ClassLoader returned null");

goto bail;

}

}

/* not adding clazz to tracked-alloc list, because it's a ClassObject */

dvmAddInitiatingLoader(clazz, loader);

LOGVV("--- Successfully loaded %s %p (thisldr=%p clazz=%p)",

descriptor, clazz->classLoader, loader, clazz);

bail:

dvmReleaseTrackedAlloc((Object*)nameObj, NULL);

free(dotName);

return clazz;

}

1、首先调用dvmLookupClass方法在gDvm.loadedClasses中查找是否存在该类，加载过的类都会存放到gDvm.loadedClasses中。

2、如果没有加载过。可以看到最终是调用java/lang/ClassLoader的loadClass函数来加载类，下面来看看ClassLoader的loadClass方法。

/libcore/libart/src/main/java/java/lang/ClassLoader.java

public Class> loadClass(String name) throws ClassNotFoundException {

return loadClass(name, false);

}

protected Class> loadClass(String className, boolean resolve) throws ClassNotFoundException {

// 查看该类是否以及加载

Class> clazz = findLoadedClass(className);

// 委托机制

if (clazz == null) {

ClassNotFoundException suppressed = null;

try {

clazz = parent.loadClass(className, false);

} catch (ClassNotFoundException e) {

suppressed = e;

}

// 最终如果没有找到该类，就自己来查找

if (clazz == null) {

try {

clazz = findClass(className);

} catch (ClassNotFoundException e) {

e.addSuppressed(suppressed);

throw e;

}

}

}

return clazz;

}

查看BaseDexClassLoader的findClass方法。

/libcore/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java

@Override

protected Class> findClass(String name) throws ClassNotFoundException {

List suppressedExceptions = new ArrayList();

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;

}

/libcore/dalvik/src/main/java/dalvik/system/DexPathList.java

public Class findClass(String name, List suppressed) {

// 遍历dexElements数组

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;

}

/libcore/dalvik/src/main/java/dalvik/system/DexFile.java

public Class loadClassBinaryName(String name, ClassLoader loader, List suppressed) {

return defineClass(name, loader, mCookie, suppressed);

}

private static Class defineClass(String name, ClassLoader loader, int cookie,

List 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, int cookie)

throws ClassNotFoundException, NoClassDefFoundError;

/dalvik/vm/native/dalvik_system_DexFile.cpp

static void Dalvik_dalvik_system_DexFile_defineClassNative(const u4* args,

JValue* pResult)

{

StringObject* nameObj = (StringObject*) args[0];

Object* loader = (Object*) args[1];

int cookie = args[2];

ClassObject* clazz = NULL;

DexOrJar* pDexOrJar = (DexOrJar*) cookie;

DvmDex* pDvmDex;

char* name;

char* descriptor;

name = dvmCreateCstrFromString(nameObj);

descriptor = dvmDotToDescriptor(name);

ALOGV("--- Explicit class load '%s' l=%p c=0x%08x",

descriptor, loader, cookie);

free(name);

if (!validateCookie(cookie))

RETURN_VOID();

if (pDexOrJar->isDex)

pDvmDex = dvmGetRawDexFileDex(pDexOrJar->pRawDexFile);

else

pDvmDex = dvmGetJarFileDex(pDexOrJar->pJarFile);

/* once we load something, we can't unmap the storage */

pDexOrJar->okayToFree = false;

clazz = dvmDefineClass(pDvmDex, descriptor, loader);

Thread* self = dvmThreadSelf();

if (dvmCheckException(self)) {

/*

* If we threw a "class not found" exception, stifle it, since the

* contract in the higher method says we simply return null if

* the class is not found.

*/

Object* excep = dvmGetException(self);

if (strcmp(excep->clazz->descriptor,

"Ljava/lang/ClassNotFoundException;") == 0 ||

strcmp(excep->clazz->descriptor,

"Ljava/lang/NoClassDefFoundError;") == 0)

{

dvmClearException(self);

}

clazz = NULL;

}

free(descriptor);

RETURN_PTR(clazz);

}

重点看看dvmDefineClass方法

/dalvik/vm/oo/Class.cpp

ClassObject* dvmDefineClass(DvmDex* pDvmDex, const char* descriptor,

Object* classLoader)

{

assert(pDvmDex != NULL);

return findClassNoInit(descriptor, classLoader, pDvmDex);

}

static ClassObject* findClassNoInit(const char* descriptor, Object* loader,

DvmDex* pDvmDex)

{

ClassObject* clazz;

// 查看是否以及加载

clazz = dvmLookupClass(descriptor, loader, true);

// 如果没有加载，则进行查找加载

if (clazz == NULL) {

if (pDvmDex == NULL) {

pDvmDex = searchBootPathForClass(descriptor, &pClassDef);

} else {

pClassDef = dexFindClass(pDvmDex->pDexFile, descriptor);

}

clazz = loadClassFromDex(pDvmDex, pClassDef, loader);

// 进行缓存

dvmAddClassToHash(clazz);

}

}

下面看看dexFindClass方法。

/dalvik/libdex/DexFile.cpp

const DexClassDef* dexFindClass(const DexFile* pDexFile,

const char* descriptor)

{

const DexClassLookup* pLookup = pDexFile->pClassLookup;

u4 hash;

int idx, mask;

hash = classDescriptorHash(descriptor);

mask = pLookup->numEntries - 1;

idx = hash & mask;

/*

* Search until we find a matching entry or an empty slot.

*/

while (true) {

int offset;

offset = pLookup->table[idx].classDescriptorOffset;

if (offset == 0)

return NULL;

if (pLookup->table[idx].classDescriptorHash == hash) {

const char* str;

str = (const char*) (pDexFile->baseAddr + offset);

if (strcmp(str, descriptor) == 0) {

return (const DexClassDef*)

(pDexFile->baseAddr + pLookup->table[idx].classDefOffset);

}

}

idx = (idx + 1) & mask;

}

}

从DexFile的pClassLookup中进行查找

/dalvik/vm/oo/Class.cpp

bool dvmAddClassToHash(ClassObject* clazz)

{

void* found;

u4 hash;

hash = dvmComputeUtf8Hash(clazz->descriptor);

dvmHashTableLock(gDvm.loadedClasses);

found = dvmHashTableLookup(gDvm.loadedClasses, hash, clazz,

hashcmpClassByClass, true);

dvmHashTableUnlock(gDvm.loadedClasses);

ALOGV("+++ dvmAddClassToHash '%s' %p (isnew=%d) --> %p",

clazz->descriptor, clazz->classLoader,

(found == (void*) clazz), clazz);

//dvmCheckClassTablePerf();

/* can happen if two threads load the same class simultaneously */

return (found == (void*) clazz);

}

已经被加载过的类会存放到gDvm.loadedClasses里面去。

整个流程图基本如下：

23031578e654

dexload3.png

weixin_39921689
关注
Android 类加载机制
zenmela2011的专栏
07-16 3043
1.类加载机制 我们编写的.java文件不是可执行的文件，需要先编译成.class文件才可以被虚拟机执行。而类加载就是指通过类加载器把class文件加载到虚拟机的内存空间，具体来说是方法区。类通常是按需加载，即第一次使用该类时才加载。 Java与Android都是把类加载到虚拟机内存中，然后由虚拟机转换成设备可识别的机器码。由于它们使用的虚拟机不同，所以在类加载方面也有所区别。Java的虚拟机是JVM，Android的虚拟机是dalvik/art(5.0以后虚拟机是art，是对dalvik的一种升级)。
android webview 加载过程,实战:七步完成Android Webview图片加载
weixin_39610956的博客
05-25 1335
【IT168技术】在本教程中，我们将一步步学习如何使用Android中的WebView控件去展现图片，并且进行相关的参数设置，也会学习各种将图片导入到WebView的参数，包括从其他web站点加载图片，以及从移动设备中和应用的目录中加载图片。本文的阅读对象为有初级Android编程经验的开发者，本文的代码可以在如下地址下载：步骤1 创建Android工程首先在eclipse中创建一个Android...
Android类加载流程
yihanss的博客
10-07 617
mirror命名空间下的类是底层对Java层类的映射，比如：mirror::Class类就是对java.lang.Class类的映射，SetAccessFlags就是对Class类的accessFlags字段赋值。LoadMethod函数主要做设置ArtMethod结构的一些属性，比如函数的MethodIdx，CodeItem在dex文件中的偏移，函数的AccessFlag等。遍历所有dexElements，并调用Element类的findClass。SetupClass设置类的一些基本字段信息。
Android类加载机制简介
最新发布
bobolan
08-20 853
随着 Android 技术的不断发展，对其内部机制的探索也日益深入。类加载机制作为 Android 运行时环境的核心组成部分之一，影响着应用的性能、安全性以及可扩展性。通过对 Android 类加载机制的研究，开发者可以更好地优化代码结构、提高应用的启动速度、解决潜在的安全问题，并实现更加灵活的功能扩展。本文旨在对 Android 类加载机制进行简要介绍，帮助读者建立起对这一重要概念的初步认识，为进一步深入学习和实践 Android 开发奠定基础。
Android平台类加载流程源码分析
omnispace的博客
02-25 938
前言 其实大家都知道的Android是使用Java作为开发语言,但是他使用的虚拟机却并不是传统的JVM,在4.4以前Android使用Dalvik虚拟机,之后使用ART(Android Runtime). Dalvik和ART与传统的JVM不同的地方在于,为了更加高效的在移动终端运行,Google重新定义了一套Dalvik字节码,用于在Dalvik和ART虚拟机上运行. 因此如果
android类加载过程,Android类装载机制
weixin_39705069的博客
05-26 208
前言上两篇文章分析了资源的加载和进程，Activity启动相关的内容，这篇是Dex加载相关的内容了，本篇结束，我们也就可以开始对于一些热修复，插件化框架的实现剖析了。Android中ClassLoader上图为Android中ClassLoader的类图，与JVM不同，Dalvik的虚拟机不能用ClassCload直接加载.dex，Android从ClassLoader派生出了两个类：DexCla...
安卓类加载机制
似霰的博客
03-05 1268
安卓类加载机制浅析
Android so加载过程详解
10-13
整个so文件的加载过程是在Android的Runtime类中启动的，它经过Java层和Native层的交互协作完成。在加载过程中，需要关注几个关键函数和方法： - loadLibrary()：负责调用doLoad()来加载so文件。 - doLoad()：进一步...
Android类加载机制、插件化、热修复
10-24
在Android 10.0及以上版本，动态加载的.dex文件不会触发oat过程，因此修复的类可能无法被正确加载。为了应对这个问题，开发者需要采用特殊的技术策略，如提前编译修复的.dex文件，或者使用支持新版本Android的热修复...
详解Android类加载ClassLoader
08-30
Android类加载器(ClassLoader)是Android系统中负责查找和加载类的重要组件。在深入理解Android的ClassLoader之前，我们先回顾一下Java的类加载机制。Java的类加载采用的是双亲委派模型，即当一个类加载器需要加载...
android类加载过程,Android类加载机制
weixin_30388285的博客
05-26 478
ClassLoaderAndroid 中使用PathClassLoader、DexClassLoader等来实现类的加载，这两个类都继承自BaseDexClassLoader，而BaseDexClassLoader继承自ClassLoader。从Android官方文档中可知：PathClassLoader用来加载系统类及已安装的应用程序的类；DexClassLoader用来加载jar、apk、de...
【Vision源文件】类加载流程图
05-29
1. 如果这个类没有被加载和链接，那就先进行加载和链接。 2. 如果这个类存在直接父类，并且这个类还没有初始化（**在一个类加载器中，类只能被初始化一次**），那就先初始化直接父类（不适用于接口）。 3. 加入类中存在的初始化语句（如static变量和static块），那就先执行这些初始化语句。
Android中的动态加载机制
11-22
Android中实现动态加载机制，可以做成插件技术的实现
android 加载过程,Android类加载机制
weixin_39747511的博客
05-26 407
什么是类加载？我们平时编写的.java文件不是可执行文件，需要先编译成.class文件才可以被虚拟机执行。所谓类加载是指通过类加载器把class文件加载到虚拟机的内存空间，具体来说是方法区。类通常是按需加载，即第一次使用该类时才加载。Java与Android类加载的区别首先，Java与Android都是把类加载到虚拟机内存中，然后由虚拟机转换成设备识别的机器码。但是由于二者使用的虚拟机不同，所以在...
Android类加载机制
aylr2015的博客
04-12 714
Android类加载器成因和机制，ClassLoader类加载流程
通过解读源码讲解Android类加载机制
huyinda的博客
03-26 558
https://blog.csdn.net/lmj623565791/article/details/49883661 Android类加载器主要分为PathClassLoader和DexClassLoader，这两个类都是继承BaseDexClassLoader。
Android中的类加载机制
Tiger的专栏
12-22 1738
在类加载进内存以后，Android程序是通过ClassLoader类去加载内存中的类，然后进行解析运行的，在插件化技术中，因为需要我们自己去加载插件，所以要了解系统是怎么通过ClassLoader去加载类的，然后在这个过程中找到突破口，将我们的插件APK也加载进去，这篇文章咱们就说说关于Android中ClassLoader的一些知识。 类加载流程 一个类被加载到虚拟机内存中需要经历几个过程：加载、连接、初始化。其中连接分为三个步骤：验证、准备、解析，下面一个一个说，这个几个阶段虚拟机都干了什么。 加
Android 类加载原理
qq_40053337的博客
04-11 261
Android类加载器原理(一) 什么是类加载器 类加载器是一个用来加载类文件的类。Java源代码通过javac编译器编译成类文件。然后JVM来执行类文件中的字节码来执行程序。类加载器负责加载文件系统、网络或其他来源的类文件 image.png 类加载的过程可以分为以上的5步： 加载：加载指的是把class字节码文件从各个来源通过类加载器装载入内存中 验证：主要是为了保证加载进来的字节流符合虚拟机规范，不会造成安全错误。包括对于文件格式的验证，比如常量中是否有不被支持的常量？文件中是否有不规范的或者附加的其
深入解析Android类加载、插件化、热修复机制
Android系统中的类加载机制是指在应用程序运行时，系统如何加载和查找应用程序所需的类文件。Android的类加载机制主要分为双亲委派模型和插件化热修复机制。 在Android开发中，双亲委派模型是指类加载器在加载类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值