Android ClassLoader 加载过程源码分析

    protected Class<?> loadClass(String name, boolean resolve)        throws ClassNotFoundException    {            // 首先 检测是否已经加载过            Class<?> c = findLoadedClass(name);            if (c == null) {                try {                    if (parent != null) {                        //去调用父类的loadClass                        c = parent.loadClass(name, false);                    } else {                        c = findBootstrapClassOrNull(name);                    }                } catch (ClassNotFoundException e) {                    // ClassNotFoundException thrown if class not found                    // from the non-null parent class loader                }
                if (c == null) {                    //未找到的情况下，使用findClass在当前dex查找                    c = findClass(name);                }            }            return c;    }
    protected Class<?> findClass(String name) throws ClassNotFoundException {        throw new ClassNotFoundException(name);    }

    protected final Class<?> findLoadedClass(String name) {        ClassLoader loader;        if (this == BootClassLoader.getInstance())            loader = null;        else            loader = this;        return VMClassLoader.findLoadedClass(loader, name);    }

native static Class findLoadedClass(ClassLoader cl, String name);

static jclass VMClassLoader_findLoadedClass(JNIEnv* env, jclass, jobject javaLoader,jstring javaName) {  ....  ObjPtr<mirror::ClassLoader> loader = soa.Decode<mirror::ClassLoader>(javaLoader);  ClassLinker* cl = Runtime::Current()->GetClassLinker();
  ObjPtr<mirror::Class> c = VMClassLoader::LookupClass(cl,                                                       soa.Self(),                                                       descriptor.c_str(),                                                       descriptor_hash,                                                       loader);  if (c != nullptr && c->IsResolved()) {    return soa.AddLocalReference<jclass>(c);  }  ...  if (loader != nullptr) {    // Try the common case.    StackHandleScope<1> hs(soa.Self());    c = VMClassLoader::FindClassInPathClassLoader(cl,                                                  soa,                                                  soa.Self(),                                                  descriptor.c_str(),                                                  descriptor_hash,                                                  hs.NewHandle(loader));    if (c != nullptr) {      return soa.AddLocalReference<jclass>(c);    }  }
  return nullptr;}
  static mirror::Class* LookupClass(ClassLinker* cl,                                    Thread* self,                                    const char* descriptor,                                    size_t hash,                                    ObjPtr<mirror::ClassLoader> class_loader)      REQUIRES(!Locks::classlinker_classes_lock_)      REQUIRES_SHARED(Locks::mutator_lock_) {    return cl->LookupClass(self, descriptor, hash, class_loader);  }  static ObjPtr<mirror::Class> FindClassInPathClassLoader(ClassLinker* cl,                                                          ScopedObjectAccessAlreadyRunnable& soa,                                                          Thread* self,                                                          const char* descriptor,                                                          size_t hash,                                                          Handle<mirror::ClassLoader> class_loader)      REQUIRES_SHARED(Locks::mutator_lock_) {    ObjPtr<mirror::Class> result;    if (cl->FindClassInBaseDexClassLoader(soa, self, descriptor, hash, class_loader, &result)) {      return result;    }    return nullptr;  }

  if (UNLIKELY(IsAotCompiler())) {    class_linker_ = new AotClassLinker(intern_table_);  } else {    class_linker_ = new ClassLinker(intern_table_);  }

mirror::Class* ClassLinker::LookupClass(Thread* self,                                        const char* descriptor,                                        size_t hash,                                        ObjPtr<mirror::ClassLoader> class_loader) {  ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);  ClassTable* const class_table = ClassTableForClassLoader(class_loader);  if (class_table != nullptr) {    ObjPtr<mirror::Class> result = class_table->Lookup(descriptor, hash);    if (result != nullptr) {      return result.Ptr();    }  }  return nullptr;}

 @Override    protected Class<?> findClass(String name) throws ClassNotFoundException {        List<Throwable> suppressedExceptions = new ArrayList<Throwable>();        Class c = pathList.findClass(name, suppressedExceptions);        if (c == null) {            ...            throw cnfe;        }        return c;    }

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

public DexPathList(ClassLoader definingContext, String dexPath,            String librarySearchPath, File optimizedDirectory) {
        ...        this.definingContext = definingContext;        ArrayList<IOException> suppressedExceptions = new ArrayList<IOException>();        // save dexPath for BaseDexClassLoader        this.dexElements = makeDexElements(splitDexPath(dexPath), optimizedDirectory,                                           suppressedExceptions, definingContext);
        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);
        if (suppressedExceptions.size() > 0) {            this.dexElementsSuppressedExceptions =                suppressedExceptions.toArray(new IOException[suppressedExceptions.size()]);        } else {            dexElementsSuppressedExceptions = null;        }    }

DexFile.javaprivate 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);        }    }

private DexFile(String sourceName, String outputName, int flags, ClassLoader loader, DexPathList.Element[] elements) throws IOException {    ...    mCookie = openDexFile(sourceName, outputName, flags, loader, elements);    mInternalCookie = mCookie;    mFileName = sourceName;    ...}
private static Object openDexFile(String sourceName, String outputName, int flags, ClassLoader loader, DexPathList.Element[] elements) throws IOException {    // Use absolute paths to enable the use of relative paths when testing on host.    return openDexFileNative(new File(sourceName).getAbsolutePath(),                              (outputName == null)                              ? null                              : new File(outputName).getAbsolutePath(),                              flags,loader,elements);}
private static native Object openDexFileNative(String sourceName, String outputName, int flags, ClassLoader loader, DexPathList.Element[] elements);

//`dalvik_system_DexFile.cc`static jobject DexFile_openDexFileNative(JNIEnv* env,                                         jclass,                                         jstring javaSourceName,                                         jstring javaOutputName,                                         jint flags ATTRIBUTE_UNUSED,                                         jobject class_loader,                                         jobjectArray dex_elements){  ...  Runtime* const runtime = Runtime::Current();  ClassLinker* linker = runtime->GetClassLinker();    ...
  dex_files = runtime->GetOatFileManager().OpenDexFilesFromOat(sourceName.c_str(), class_loader, dex_elements, /*out*/ &oat_file, /*out*/ &error_msgs);  ....}

    //BaseDexClassLoader.java    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.java  public Class<?> findClass(String name, ClassLoader definingContext,          List<Throwable> suppressed) {      return dexFile != null ? dexFile.loadClassBinaryName(name, definingContext, suppressed): null;  }

  public Class loadClassBinaryName(String name, ClassLoader loader, List<Throwable> suppressed) {      return defineClass(name, loader, mCookie, this, suppressed);  }
  private static Class defineClass(String name, ClassLoader loader, Object cookie, DexFile dexFile, List<Throwable> suppressed) {      Class result = null;      try {          result = defineClassNative(name, loader, cookie, dexFile);      } 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, DexFile dexFile)
//dalvik_system_DexFile.ccstatic jclass DexFile_defineClassNative(JNIEnv* env,                                        jclass,                                        jstring javaName,                                        jobject javaLoader,                                        jobject cookie,                                        jobject dexFile) {  std::vector<const DexFile*> dex_files;  const OatFile* oat_file;  if (!ConvertJavaArrayToDexFiles(env, cookie, /*out*/ dex_files, /*out*/ oat_file)) {    ...    return nullptr;  }
  ScopedUtfChars class_name(env, javaName);  ...
  const std::string descriptor(DotToDescriptor(class_name.c_str()));  const size_t hash(ComputeModifiedUtf8Hash(descriptor.c_str()));  for (auto& dex_file : dex_files) {      ...      ClassLinker* class_linker = Runtime::Current()->GetClassLinker();      ObjPtr<mirror::Class> result = class_linker->DefineClass(soa.Self(),                                                               descriptor.c_str(),                                                                hash,                                                               class_loader,                                                               *dex_file,                                                               *dex_class_def);      // Add the used dex file. This only required for the DexFile.loadClass API since normal      // class loaders already keep their dex files live.      class_linker->InsertDexFileInToClassLoader(soa.Decode<mirror::Object>(dexFile),                                                 class_loader.Get());      ....        return soa.AddLocalReference<jclass>(result);      }    }    ...  return nullptr;}