超级简单的热修复实现步骤详解

      看了热修复好久，大多文章都讲的原理，没有发现有详细的实现步骤，所以自己看完视频之后对自己的实现步骤进行了记录总结，方便自己记忆，也希望对读到这篇文章的童鞋有所帮助，因为对热修复愿意很多大牛的文章已有详细的记录，此处不再班门弄斧，主要记录实现步骤，文章前部分会说明具体实现，文章后部分有完整代码,后期会附上git仓库地址(ps:此处不注重对权限的管理，所以请在运行项目时确保对此APP的读写权限已经开启)
      文章大概分为
      1.编写相应工具方法，并编写使程序崩溃的错误方法进行运行测试
      2.将崩溃方法修复，并手动打出修复的dex包，复制到手机的sd卡目录
      3.将程序修改为崩溃方法，进行重新运行，并进行修复

一.在模块目录的build.gradle文件添加相应配置

      1.在dependencies中添加如下代码

dependencies {
    compile 'com.android.support:multidex:1.0.1'
}

      2.在android的defaultConfig中添加如下代码

defaultConfig {
        multiDexEnabled true
    }

      3.在buildTypes的release下添加如下代码

 release {
            minifyEnabled true
        }

二.在自定义的Application中添加相应方法

      重写attachBaseContext并添加如下代码

@Override
    protected void attachBaseContext(Context base) {
        MultiDex.install(base);
        super.attachBaseContext(base);
    }

三.创建MyConstants类，用于保存应用中用到的常量

      1.声明保存文件的文件名

    /**
     * 创建文件时的文件名
     */
    public static String DEX_DIR = "odex";

四.创建FixDexUtils工具类，用于编写热修复用到的方法

      1.声明loadedDex用于存储读取到的dex文件

private static HashSet loadedDex = new HashSet<>();
    static {
        loadedDex.clear();
    }

      2.添加通过反射给指定类的指定属性赋值的方法

private static void setFiled(Object obj,Class cl,String field,Object value) throws Exception{
        Field localField = cl.getDeclaredField(field);
        localField.setAccessible(true);
        localField.set(obj,value);
    }

      3.添加通过反射获取指定类的指定值的方法

private static Object getFiled(Object obj,Class cl,String field) throws Exception{
        Field localField = cl.getDeclaredField(field);
        localField.setAccessible(true);
        return localField.get(obj);
    }

      4.添加得到类加载器的pathList的方法

 private static Object getPathList(Object baseDexClassLoader) throws Exception{
        return getFiled(baseDexClassLoader,Class.forName("dalvik.system.BaseDexClassLoader"),"pathList");
    }

      5.添加得到dexElements的方法

private static Object getDexElements(Object obj) throws Exception{
        return getFiled(obj,obj.getClass(),"dexElements");
    }

      6.添加合并两个数组的方法

private static Object conbineArray(Object arrayLbs,Object arrayRhs){
        Class localClass = arrayLbs.getClass().getComponentType();
        int i = Array.getLength(arrayLbs);
        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(arrayLbs,k));
            }else{
                Array.set(result,k,Array.get(arrayRhs,k - i));
            }
        }
        return result;
    }

      7.将项目的dex和已修复的dex合并，并赋值给类加载器，进行热修复

private static void doDexInject(final Context appContext,File filesDir,HashSet loadedDex){
        try {
            String optiondexDir = filesDir.getAbsolutePath()+File.separator+"opt_dex";
            File fopt = new File(optiondexDir);
            if(!fopt.exists()){
                fopt.mkdir();
            }
            //1.加载应用程序的dex
            PathClassLoader pathLoader = (PathClassLoader)appContext.getClassLoader();
            for(File dex : loadedDex){
                //2.加载指定的修复的dex文件
                DexClassLoader classLoader = new DexClassLoader(
                        dex.getAbsolutePath(),
                        fopt.getAbsolutePath(),
                        null,
                        pathLoader);
                //3.合并
                Object dexObj = getPathList(classLoader);
                Object pathObj = getPathList(pathLoader);
                Object mDexElementsList = getDexElements(dexObj);
                Object pathDexElementsList = getDexElements(pathObj);
                //将两个list合并为一个
                Object dexElements = conbineArray(mDexElementsList,pathDexElementsList);
                //重写给PathList里面的Element[] dexElements赋值
                Object pathList = getPathList(pathLoader);
                setFiled(pathList,pathList.getClass(),"dexElements",dexElements);
            }
        }catch (Exception e){}
    }

      8.添加加载sd卡中的修复文件，并进行合并，完成修复的方法

public static void loadFixedDex(Context context){
        if(null == context){
            return;
        }
        //遍历所有的修复的dex
        File fileDir = context.getDir(MyConstants.DEX_DIR,Context.MODE_PRIVATE);
        File[] listFiles = fileDir.listFiles();
        for(File file : listFiles){
            if(file.getName().startsWith("classes") || file.getName().endsWith(".dex")){
                loadedDex.add(file);//先将补丁文件放到一个集合里，然后再进行合并
            }
        }
        //dex合并之前的dex
        doDexInject(context,fileDir,loadedDex);
    }

五.创建MyTestClass文件，用于编写测试方法，即会造成程序崩溃的方法，并后期对其进行修复

public void testFix(Context context){
        int i = 10;
        int a = 0;
        Toast.makeText(context,"shit:" + i/a,Toast.LENGTH_SHORT).show();
    };

六.在MainActivity中编写相关方法

      1.添加两个btn，分别为test,和fix,test用于执行测试方法test(View view)，fix用于执行修复方法fix(View view)
      2.添加测试方法(即使程序崩溃的方法)

public void test(View view) {
        MyTestClass myTestClass = new MyTestClass();
        myTestClass.testFix(this);
    }

      3.添加修复方法

 /**
     * 修复的方法
     * @param view
     */
    public void fix(View view) {
        fixBug();
    }

    private void fixBug() {
        //目录 data/data/packageName/odex
        File fileDir = getDir(MyConstants.DEX_DIR, Context.MODE_PRIVATE);
        //该目录下放置修复好的dex文件
        String name = "classes2.dex";
        String filePath = fileDir.getAbsolutePath() + File.separator + name;
        File file = new File(filePath);
        if(file.exists()){
            file.delete();
        }
        //搬家：把下载好的在sd卡里面的修复了的classes2.dex复制到应用目录
        InputStream is = null;
        FileOutputStream os = null;
        try {
            //复制并粘贴文件
            is = new FileInputStream(Environment.getExternalStorageDirectory().getAbsolutePath()+File.separator+name);
            os = new FileOutputStream(filePath);
            int len = 0;
            byte[] buffer = new byte[1024];
            while ((len = is.read(buffer)) != -1){
                os.write(buffer,0,len);
            }

            //粘贴完文件
            File f = new File(filePath);
            if(f.exists()){//文件从sk卡赋值到应用运行目录下，成功则toast提示
                Toast.makeText(this,"dex重写成功",Toast.LENGTH_SHORT).show();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

七.在AndroidManifest.xml中添加读写权限

      tips:因为在修复过程中涉及文件的拷贝，需声明该权限，因权限不是此文章的关注点，故忽略申请权限的部分，请手动开启该测试app的读写权限，并在权限管理中进一步确认

八.在自定义的Application中添加调用修复文件的方法

    @Override
    protected void attachBaseContext(Context base) {
        MultiDex.install(base);
        //加载修复文件，并进行相应操作
        FixDexUtils.loadFixedDex(base);
        super.attachBaseContext(base);
    }

九.手动打包修复bug的dex文件

      此时运行程序点击测试按钮，执行错误代码，会造成程序崩溃，要修复问题，需先将测试代码修改为没有问题的代码，并手动打出dex包，进行修复
      1.调整MyTestClass中的testFix方法为正确代码

 public void testFix(Context context){
        int i = 10;
        int a = 1;
        Toast.makeText(context,"shit:" + i/a,Toast.LENGTH_SHORT).show();
    };

      2.卸载手机安装的应用，然后重新安装应用(即修复testFix方法的应用)

      3.找到编译后的MyTestClass.class文件(在项目名\app\build\intermediates\classes\debug\com\hotfixdemo下，com\hotfixdemo为项目的包名目录，我的文件路径为D:\Project\HotFixDemo\app\build\intermediates\classes\debug\com\hotfixdemo）

MyTestClass.class文件路径.PNG

      4.将MyTestClass.class文件连同包目录拷贝到一个文件夹，如我的为桌面dex文件夹

拷贝文件完成图.png

      5.配置dx.bat打包工具，并手动打包生成classes2.dex(因为项目中指定了该文件名称，所以此处应保持名称一致)
            (1)在project模式下，右键项目名称-Open Moudle Setting查看项目编译时使用的build tools版本，此处为26.0.2

查看tools版本.png

            (2)在sdk所在目录找到相应build tools版本下de.bat所在的路径，复制该地址，并配置到环境变量，此处为D:\ProgramFiles\sdk\andsdk\build-tools\26.0.2

dx.bat所在路径.png

配置dx.bat的环境变量.png

            (3)打开cmd，切换到用于保存MyTestClass.class的(即九-4步骤中的路径，此处为桌面dex文件夹)路径，执行命令行：dx --dex --output=存放生成的dex文件所在的路径\classes2.dex MyTestClass.class包所在路径，此处完整命令行为

dx --dex --output=C:\Users\cuixiaoxiao\Desktop\classes2.dex C:\Users\cuixiaoxiao\Desktop\dex

执行完可在相应输入目录(此处为桌面)找到classes2.dex文件

cmd手动编译产生dex文件.png

            (4)将编译产生的classes2.dex文件复制到手机的sd卡目录下

复制文件到sd卡.png

十.将项目改为使程序崩溃的测试代码，进行热修复的测试

      1.将MyTestClass里面的testFix方法修改为使程序崩溃的方法

  public void testFix(Context context){
        int i = 10;
        int a = 0;
        Toast.makeText(context,"shit:" + i/a,Toast.LENGTH_SHORT).show();
    };

      2.卸载手机的应用，重新安装应用(即会使程序崩溃的应用)
      3.请先手动确认下，开启了该应用对sd的读写权限

开启sd卡读写权限.jpg

      4.此时点击test按钮，程序崩溃

未修复前.png

      5.点击fix按钮，进行热修复

进行文件修复.jpg

      6.退出应用，并清除后台运行，重新开启应用

      7.此时点击test按钮，正常运行，程序不再崩溃，则热修复成功

修复成功，点击test不再崩溃.jpg

附录

1.model的build.gradle文件

apply plugin: 'com.android.application'

android {
    compileSdkVersion 26
    defaultConfig {
        applicationId "com.hotfixdemo"
        minSdkVersion 16
        targetSdkVersion 26
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
        multiDexEnabled true
    }
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
    buildToolsVersion '26.0.2'
}

dependencies {
    implementation fileTree(include: ['*.jar'], dir: 'libs')
    implementation 'com.android.support:appcompat-v7:26.1.0'
    implementation 'com.android.support.constraint:constraint-layout:1.1.0'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.2'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
    compile 'com.android.support:multidex:1.0.1'
}

2.自定义的Application，此处为MyApplication

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    protected void attachBaseContext(Context base) {
        MultiDex.install(base);
        //加载修复文件，并进行相应操作
        FixDexUtils.loadFixedDex(base);
        super.attachBaseContext(base);
    }
}

3.常量存储类MyConstants

public class MyConstants {
    /**
     * 创建文件时的文件名
     */
    public static String DEX_DIR = "odex";
}

4.热修复工具类

import android.content.Context;

import java.io.File;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.HashSet;

import dalvik.system.DexClassLoader;
import dalvik.system.PathClassLoader;

/**
 * Created by cuixiaoxiao on 2018/5/8.
 */

public class FixDexUtils {
    private static HashSet loadedDex = new HashSet<>();
    static {
        loadedDex.clear();
    }

    /**
     * 加载修复文件
     * @param context
     */
    public static void loadFixedDex(Context context){
        if(null == context){
            return;
        }
        //遍历所有的修复的dex
        File fileDir = context.getDir(MyConstants.DEX_DIR,Context.MODE_PRIVATE);
        File[] listFiles = fileDir.listFiles();
        for(File file : listFiles){
            if(file.getName().startsWith("classes") || file.getName().endsWith(".dex")){
                loadedDex.add(file);//先将补丁文件放到一个集合里，然后再进行合并
            }
        }
        //dex合并之前的dex
        doDexInject(context,fileDir,loadedDex);
    }

    /**
     * 将项目的dex和已经修复的dex合并，并赋值给类加载器，进行热修复
     * @param appContext
     * @param filesDir
     * @param loadedDex
     */
    private static void doDexInject(final Context appContext,File filesDir,HashSet loadedDex){
        try {
            String optiondexDir = filesDir.getAbsolutePath()+File.separator+"opt_dex";
            File fopt = new File(optiondexDir);
            if(!fopt.exists()){
                fopt.mkdir();
            }
            //1.加载应用程序的dex
            PathClassLoader pathLoader = (PathClassLoader)appContext.getClassLoader();
            for(File dex : loadedDex){
                //2.加载指定的修复的dex文件
                DexClassLoader classLoader = new DexClassLoader(
                        dex.getAbsolutePath(),
                        fopt.getAbsolutePath(),
                        null,
                        pathLoader);
                //3.合并
                Object dexObj = getPathList(classLoader);
                Object pathObj = getPathList(pathLoader);
                Object mDexElementsList = getDexElements(dexObj);
                Object pathDexElementsList = getDexElements(pathObj);
                //将两个list合并为一个
                Object dexElements = conbineArray(mDexElementsList,pathDexElementsList);
                //重写给PathList里面的Element[] dexElements赋值
                Object pathList = getPathList(pathLoader);
                setFiled(pathList,pathList.getClass(),"dexElements",dexElements);
            }
        }catch (Exception e){}
    }

    /**
     * 得到类加载器的pathList
     * @param baseDexClassLoader
     * @return
     * @throws Exception
     */
    private static Object getPathList(Object baseDexClassLoader) throws Exception{
        return getFiled(baseDexClassLoader,Class.forName("dalvik.system.BaseDexClassLoader"),"pathList");
    }

    /**
     * 通过反射给指定类的指定属性赋值
     * @param obj
     * @param cl
     * @param field
     * @param value
     * @throws Exception
     */
    private static void setFiled(Object obj,Class cl,String field,Object value) throws Exception{
        Field localField = cl.getDeclaredField(field);
        localField.setAccessible(true);
        localField.set(obj,value);
    }

    /**
     * 通过反射调用指定类的方法
     * @param obj
     * @param cl
     * @param field
     * @return
     * @throws Exception
     */
    private static Object getFiled(Object obj,Class cl,String field) throws Exception{
        Field localField = cl.getDeclaredField(field);
        localField.setAccessible(true);
        return localField.get(obj);
    }

    /**
     * 得到dexElements
     * @param obj
     * @return
     * @throws Exception
     */
    private static Object getDexElements(Object obj) throws Exception{
        return getFiled(obj,obj.getClass(),"dexElements");
    }

    /**
     * 合并两个数组
     * @param arrayLbs
     * @param arrayRhs
     * @return
     */
    private static Object conbineArray(Object arrayLbs,Object arrayRhs){
        Class localClass = arrayLbs.getClass().getComponentType();
        int i = Array.getLength(arrayLbs);
        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(arrayLbs,k));
            }else{
                Array.set(result,k,Array.get(arrayRhs,k - i));
            }
        }
        return result;
    }
}

5.测试类MyTestClass

public class MyTestClass {
    /**
     * 测试方法，会导致程序崩溃
     * @param context
     */
    public void testFix(Context context){
        int i = 10;
        int a = 0;
        Toast.makeText(context,"shit:" + i/a,Toast.LENGTH_SHORT).show();
    };
}

6.存在测试按钮的activity

import android.content.Context;
import android.os.Environment;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Toast;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    /**
     * 测试方法(即会导致应用崩溃)
     * @param view
     */
    public void test(View view) {
        MyTestClass myTestClass = new MyTestClass();
        myTestClass.testFix(this);
    }

    /**
     * 修复的方法
     * @param view
     */
    public void fix(View view) {
        fixBug();
    }

    private void fixBug() {
        //目录 data/data/packageName/odex
        File fileDir = getDir(MyConstants.DEX_DIR, Context.MODE_PRIVATE);
        //该目录下放置修复好的dex文件
        String name = "classes2.dex";
        String filePath = fileDir.getAbsolutePath() + File.separator + name;
        File file = new File(filePath);
        if(file.exists()){
            file.delete();
        }
        //搬家：把下载好的在sd卡里面的修复了的classes2.dex复制到应用目录
        InputStream is = null;
        FileOutputStream os = null;
        try {
            //复制并粘贴文件
            is = new FileInputStream(Environment.getExternalStorageDirectory().getAbsolutePath()+File.separator+name);
            os = new FileOutputStream(filePath);
            int len = 0;
            byte[] buffer = new byte[1024];
            while ((len = is.read(buffer)) != -1){
                os.write(buffer,0,len);
            }

            //粘贴完文件
            File f = new File(filePath);
            if(f.exists()){//文件从sk卡赋值到应用运行目录下，成功则toast提示
                Toast.makeText(this,"dex重写成功",Toast.LENGTH_SHORT).show();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

7.AndroidManifest

---

文章为自己总结所得，如有错误的地方欢迎指出，会即使修改，有问题的地方，欢迎提问，如您觉得有可借鉴的地方，欢迎转载，请注明出处，多谢多谢