ClassLoader
我們知道Java在運行時加載對應的類是通過ClassLoader來實現的,ClassLoader本身是一個抽象來,Android中使用PathClassLoader類作爲Android的默認的類加載器,
PathClassLoader其實實現的就是簡單的從文件系統中加載類文件。PathClassLoader本身繼承自BaseDexClassLoader,BaseDexClassLoader重寫了findClass方法,
該方法是ClassLoader的核心
@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;
}
看源碼可知,BaseDexClassLoader將findClass方法委託給了pathList對象的findClass方法,pathList對象是在BaseDexClassLoader的構造函數中new出來的,
它的類型是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;
}
直接就是遍歷dexElements列表,然後通過調用element.dexFile對象上的loadClassBinaryName方法來加載類,如果返回值不是null,就表示加載類成功,會將這個Class對象返回。
而dexElements對象是在DexPathList類的構造函數中完成初始化的。
this.dexElements = makeDexElements(splitDexPath(dexPath), optimizedDirectory,
suppressedExceptions);
makeDexElements所做的事情就是遍歷我們傳遞來的dexPath,然後一次加載每個dex文件。
實現
上面分析了Android中的類的加載的流程,可以看出來DexPathList對象中的dexElements列表是類加載的一個核心,一個類如果能被成功加載,那麼它的dex一定
會出現在dexElements所對應的dex文件中,並且dexElements中出現的順序也很重要,在dexElements前面出現的dex會被優先加載,一旦Class被加載成功,
就會立即返回,也就是說,我們的如果想做hotpatch,一定要保證我們的hotpacth dex文件出現在dexElements列表的前面。
要實現熱更新,就需要我們在運行時去更改PathClassLoader.pathList.dexElements,由於這些屬性都是private的,因此需要通過反射來修改。另外,構造我們自己的dex文件
所對應的dexElements數組的時候,我們也可以採取一個比較取巧的方式,就是通過構造一個DexClassLoader對象來加載我們的dex文件,並且調用一次dexClassLoader.loadClass(dummyClassName);
方法,這樣,dexClassLoader.pathList.dexElements中,就會包含我們的dex,通過把dexClassLoader.pathList.dexElements插入到系統默認的classLoader.pathList.dexElements列表前面,就可以讓系統優先加載我們的dex中的類,從而可以實現熱更新了。
熱更新實戰
項目地址:https://github.com/lantian0314/hotFix
一、需要熱更新的方法
package com.blue.testapk;
import android.util.Log;
/**
* Created by xingyatong on 2018/4/9.
*/
public class TestClass {
private static final String TAG = "MainActivity";
public void test1() {
Log.i(TAG, "This is bug class");
}
}
二、熱更新的類
public class DexLoaderUtil {
private static final String TAG = "DexLoaderUtil";
public static final String SECONDARY_DEX_NAME = "app-bug.apk";
public static final String THIRD_DEX_NAME = "app2.apk";
private static final int BUF_SIZE = 8 * 1024;
public static final String TEST_CLASS_NAME = "com.blue.testapk.TestClass";
public static String getDexPath(Context context, String dexName) {
return new File(context.getDir("dex", Context.MODE_PRIVATE), dexName).getAbsolutePath();
}
public static String getOptimizedDexPath(Context context) {
return context.getDir("outdex", Context.MODE_PRIVATE).getAbsolutePath();
}
public static void copyDex(Context context, String dexName) {
File dexInternalStoragePath = new File(context.getDir("dex", Context.MODE_PRIVATE),
dexName);
BufferedInputStream bis = null;
OutputStream dexWriter = null;
try {
bis = new BufferedInputStream(context.getAssets().open(dexName));
dexWriter = new BufferedOutputStream(
new FileOutputStream(dexInternalStoragePath));
byte[] buf = new byte[BUF_SIZE];
int len;
while ((len = bis.read(buf, 0, BUF_SIZE)) > 0) {
dexWriter.write(buf, 0, len);
}
dexWriter.close();
bis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void loadAndCall(Context context, String dexName) {
final File dexInternalStoragePath = new File(context.getDir("dex", Context.MODE_PRIVATE), dexName);
final File optimizedDexOutputPath = context.getDir("outdex", Context.MODE_PRIVATE);
DexClassLoader cl = new DexClassLoader(dexInternalStoragePath.getAbsolutePath(),
optimizedDexOutputPath.getAbsolutePath(),
null,
context.getClassLoader());
call(cl);
}
public static void call(ClassLoader cl) {
Class myClasz = null;
try {
myClasz =
cl.loadClass(TEST_CLASS_NAME);
Object instance = myClasz.getConstructor().newInstance();
myClasz.getDeclaredMethod("test1").invoke(instance);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}
public static synchronized Boolean injectAboveEqualApiLevel14(
String dexPath, String defaultDexOptPath, String nativeLibPath, String dummyClassName) {
Log.i(TAG, "--> injectAboveEqualApiLevel14");
PathClassLoader pathClassLoader = (PathClassLoader) DexLoaderUtil.class.getClassLoader();
DexClassLoader dexClassLoader = new DexClassLoader(dexPath, defaultDexOptPath, nativeLibPath, pathClassLoader);
try {
dexClassLoader.loadClass(dummyClassName);
Object dexElements = combineArray(
getDexElements(getPathList(pathClassLoader)),
getDexElements(getPathList(dexClassLoader)));
Object pathList = getPathList(pathClassLoader);
setField(pathList, pathList.getClass(), "dexElements", dexElements);
} catch (Throwable e) {
e.printStackTrace();
return false;
}
Log.i(TAG, "<-- injectAboveEqualApiLevel14 End.");
return true;
}
private static Object getPathList(Object baseDexClassLoader)
throws IllegalArgumentException, NoSuchFieldException, IllegalAccessException, ClassNotFoundException {
return getField(baseDexClassLoader, Class.forName("dalvik.system.BaseDexClassLoader"), "pathList");
}
private static Object getDexElements(Object paramObject)
throws IllegalArgumentException, NoSuchFieldException, IllegalAccessException {
return getField(paramObject, paramObject.getClass(), "dexElements");
}
private static Object getField(Object obj, Class<?> cl, String field)
throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
Field localField = cl.getDeclaredField(field);
localField.setAccessible(true);
return localField.get(obj);
}
private static void setField(Object obj, Class<?> cl, String field, Object value)
throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
Field localField = cl.getDeclaredField(field);
localField.setAccessible(true);
localField.set(obj, value);
}
private static Object combineArray(Object arrayLhs, Object arrayRhs) {
Class<?> localClass = arrayLhs.getClass().getComponentType();
int i = Array.getLength(arrayLhs);
int j = i + Array.getLength(arrayRhs);
Object result = Array.newInstance(localClass, j);
for (int k = 0; k < j; ++k) {
if (k < i) {
Array.set(result, k, Array.get(arrayLhs, k));
} else {
Array.set(result, k, Array.get(arrayRhs, k - i));
}
}
return result;
}
}
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
new Thread(new Runnable() {
@Override
public void run() {
Log.d(TAG, "------------start");
DexLoaderUtil.copyDex(MainActivity.this, DexLoaderUtil.SECONDARY_DEX_NAME);
DexLoaderUtil.copyDex(MainActivity.this, DexLoaderUtil.THIRD_DEX_NAME);
String secondDexPath = DexLoaderUtil.getDexPath(MainActivity.this, DexLoaderUtil.SECONDARY_DEX_NAME);
String thirdDexPath = DexLoaderUtil.getDexPath(MainActivity.this, DexLoaderUtil.THIRD_DEX_NAME);
final String optimizedDexOutputPath = DexLoaderUtil.getOptimizedDexPath(MainActivity.this);
DexLoaderUtil.injectAboveEqualApiLevel14(thirdDexPath, optimizedDexOutputPath, null, DexLoaderUtil.TEST_CLASS_NAME);
DexLoaderUtil.injectAboveEqualApiLevel14(secondDexPath, optimizedDexOutputPath, null, DexLoaderUtil.TEST_CLASS_NAME);
DexLoaderUtil.call(getClassLoader());
Log.d(TAG, "------------end");
}
}).start();
}
}