热修复

什么是热修复

一般的bug修复都是等下一个版本解决，然后发布新的apk。
热修复可以直接在客户已经安装的程序当中修复bug。
bug一般出现在某个类某个方法，如果我们能够动态的将客户端apk里某个类替换成我们已经修改好的类。

流行技术
  • QQ空间的超级补丁方案
  • 微信的Tinker
  • 阿里的AndFix、dexposed
  • 美团的Robust、ele的migo、百度的hotfix

image

技术选型
  • 我们的需求是什么，需求是恒量一切的标准
  • 能满足需求的条件下，那个学习成本最低
  • 学习成本一样的情况下，优先选择大公司的方案
AndFix
1.基本概念

https://github.com/alibaba/AndFix

AndFix只能完成方法的替换。
截止到写这篇博客时，AndFix最新版本0.5.0，支持Android2.3 to 7.0

2.集成与简单举例
  • 添加依赖
1
implementation 'com.alipay.euler:andfix:0.5.0@aar'
  • 例子代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package cn.gxh.myandfix;

import android.content.Context;
import com.alipay.euler.andfix.patch.PatchManager;

/**
 * 管理AndFix下所有api
 */
public class AndFixPatchManager {

    private static AndFixPatchManager mInstance=null;
    private static PatchManager patchManager;
    public static AndFixPatchManager getInstance(){
        if(mInstance==null){
            synchronized (AndFixPatchManager.class) {
                if(mInstance==null){
                    mInstance=new AndFixPatchManager();
                }
            }
        }

        return mInstance;
    }

    /**
     * 初始化AndFix
     * @param context
     */
    public void initPatchManager(Context context){
        patchManager=new PatchManager(context);
        patchManager.init(AppUtils.getAppVersionName(context));
        patchManager.loadPatch();
    }

    public void addPatch(String path){
        try {
            if(patchManager!=null){
                patchManager.addPatch(path);
            }
        }catch (Exception e){

        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
package cn.gxh.myandfix;

import android.app.Application;
import android.provider.Settings;

public class MyApp extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        AndFixPatchManager.getInstance().initPatchManager(this);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package cn.gxh.myandfix;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;

import java.io.File;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{


    private static final String FILE_END=".apatch";
    private String mPatchDir;
    private TextView tvContent;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        findViewById(R.id.btn_01).setOnClickListener(this);
        findViewById(R.id.btn_02).setOnClickListener(this);
        tvContent = findViewById(R.id.tv_content);

        mPatchDir=getExternalCacheDir().getAbsolutePath()+"/apatch/";
        File file=new File(mPatchDir);
        if(file==null || !file.exists()){
            file.mkdir();
        }
    }

    @Override
    public void onClick(View v) {
        int id=v.getId();
        switch (id){
            case R.id.btn_01:
                showStr();
                break;
            case R.id.btn_02:
                AndFixPatchManager.getInstance().addPatch(getPatchPath());
                break;
        }
    }

    private void showStr(){
        String str=null;
        tvContent.setText(str.hashCode());
    }

    private String getPatchPath(){
        return mPatchDir+"andfix.apatch";
    }
}

这里在MainActivity中有两个Button，一个是产生bug，一个是修复bug，bug代码在showStr方法中，我们先打一个有bug的签名apk，然后修改代码，再打一个修复后的签名apk。

1
2
3
4
5
//修改后的代码，其它没变
private void showStr(){
    String str="abcd";
    tvContent.setText(str.hashCode()+str);
}
  • patch生成
1
2
3
4
5
6
7
8
9
10
//命令说明
usage: apkpatch -f <new> -t <old> -o <output> -k <keystore> -p <***> -a <alias> -e <***>
 -a,--alias <alias>     keystore entry alias.
 -e,--epassword <***>   keystore entry password.
 -f,--from <loc>        new Apk file path.
 -k,--keystore <loc>    keystore path.
 -n,--name <name>       patch name.
 -o,--out <dir>         output dir.
 -p,--kpassword <***>   keystore password.
 -t,--to <loc>          old Apk file path.

AndFix提供了生成补丁文件的工具，可在官网下载。这里我将修改前后两个apk以及签名文件都放在了同目录下，执行命令后生成的apatch文件在output文件夹下：
命令
目录

  • 将apatch文件通过adb push到手机，由于机型不同以及本来路径就不同（这里我们在代码写死了）所以下面这个文件路径因人而异。
1
adb push andfix.apatch /storage/emulated/0/Android/data/cn.gxh.myandfix/cache/apatch/
  • 点击Button修复bug，经测试成功。

注意：实际使用中不可能通过adb push这种方式，也不可能让用户点击按钮操作修复bug。

3.将AndFix组件化

实际项目中，可以在Service中完成热修复。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
package cn.gxh.myandfix;

import android.app.Service;
import android.content.Intent;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.support.annotation.Nullable;

import java.io.File;

/**
 * 1.检查patch文件
 * 2.下载
 * 3.加载
 */
public class AndFixService extends Service{

    private String mPatchFileDir;
    private String mPatchFile;

    //-----------消息相关
    private static final int PATCH_CHECK=0x02;
    private static final int PATCH_DOWN=0x03;
    private Handler mHandler=new Handler(){
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case PATCH_CHECK:
                    checkPatch();
                    break;
                case PATCH_DOWN:
                    downPatch();
                    break;
            }
        }
    };


    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        initFileDir();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        mHandler.sendEmptyMessage(PATCH_CHECK);
        return START_NOT_STICKY;//系统回收后不重启
    }

    //初始化文件目录
    private void initFileDir() {
        mPatchFileDir=getExternalCacheDir().getAbsolutePath()+"/apatch/";
        File patchDir=new File(mPatchFileDir);
        try {
            if(patchDir==null || !patchDir.exists()){
                patchDir.mkdir();
            }
        }catch (Exception e){
            stopSelf();
        }
    }

    //检查是否有apatch文件
    private void checkPatch() {
        //请求服务器，如果有需要下载的apatch文件，则下载
        //如果没有则stopSelf();
    }

    //下载
    private void downPatch() {
        mPatchFile=mPatchFileDir.concat(String.valueOf(System.currentTimeMillis())).concat(".apatch");
        //下载
        // ...
        // 下载失败则stopSelf()，下载成功则将apatch文件添加到AndFix
        AndFixPatchManager.getInstance().addPatch(mPatchFile);

    }

}
1
2
3
4
5
//可以在启动页中开启Service，当然不要忘了清单文件中注册
private void startPatchService(){
    Intent intent=new Intent(this,AndFixService.class);
    startService(intent);
}
4.AndFix源码

通过上面的实践可以得知，主要的方法其实就几个

patchManager=new PatchManager(context);

patchManager.init(AppUtils.getAppVersionName(context));

patchManager.loadPatch();

首先实例化PatchManager对象，其实在PatchManager构造方法中初始化了一些变量：

1
2
3
4
5
6
7
public PatchManager(Context context) {
	mContext = context;
	mAndFixManager = new AndFixManager(mContext);//实例化AndFixManager对象
	mPatchDir = new File(mContext.getFilesDir(), DIR);//mPatchDir是存放patch补丁的目录
	mPatchs = new ConcurrentSkipListSet<Patch>();//mPatchs是存放Patch类对象的集合
	mLoaders = new ConcurrentHashMap<String, ClassLoader>();//存放类对应的类加载器集合
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
public void init(String appVersion) {
	if (!mPatchDir.exists() && !mPatchDir.mkdirs()) {// make directory fail
		Log.e(TAG, "patch dir create error.");
		return;
	} else if (!mPatchDir.isDirectory()) {// not directory
		mPatchDir.delete();
		return;
	}
	SharedPreferences sp = mContext.getSharedPreferences(SP_NAME,
			Context.MODE_PRIVATE);
	String ver = sp.getString(SP_VERSION, null);
	if (ver == null || !ver.equalsIgnoreCase(appVersion)) {
	//首先安装apk或版本更新时，删除mPatchDir下所有补丁文件，并把当前版本保存
		cleanPatch();
		sp.edit().putString(SP_VERSION, appVersion).commit();
	} else {
		initPatchs();
	}
}

//把mPatchDir目录下的补丁文件封装成Patch对象，然后添加到mPatchs集合中
private void initPatchs() {
	File[] files = mPatchDir.listFiles();
	for (File file : files) {
		addPatch(file);
	}
}

/**
 * add patch file
 * 
 * @param file
 * @return patch
 */
private Patch addPatch(File file) {
	Patch patch = null;
	if (file.getName().endsWith(SUFFIX)) {
		try {
			patch = new Patch(file);
			mPatchs.add(patch);
		} catch (IOException e) {
			Log.e(TAG, "addPatch", e);
		}
	}
	return patch;
}

//这个方法是我们调用的，它遍历了mPatchs集合，分别调用了fix修复方法
public void loadPatch() {
	mLoaders.put("*", mContext.getClassLoader());// wildcard
	Set<String> patchNames;
	List<String> classes;
	for (Patch patch : mPatchs) {
		patchNames = patch.getPatchNames();
		for (String patchName : patchNames) {
			classes = patch.getClasses(patchName);
			mAndFixManager.fix(patch.getFile(), mContext.getClassLoader(),
					classes);
		}
	}
}


//这个方法也是我们调用的，添加指定目录下的补丁文件，不过这里把我们的补丁复制一份到mPatchDir目录下，然后在封装成Patch对象，添加到mPatchs集合，然后调用带参数loadPatch方法，修复指定的补丁文件对应的bug
public void addPatch(String path) throws IOException {
	File src = new File(path);
	File dest = new File(mPatchDir, src.getName());
	if(!src.exists()){
		throw new FileNotFoundException(path);
	}
	if (dest.exists()) {
		Log.d(TAG, "patch [" + path + "] has be loaded.");
		return;
	}
	FileUtil.copyFile(src, dest);// copy to patch's directory
	Patch patch = addPatch(dest);
	if (patch != null) {
		loadPatch(patch);
	}
}

private void loadPatch(Patch patch) {
	Set<String> patchNames = patch.getPatchNames();
	ClassLoader cl;
	List<String> classes;
	for (String patchName : patchNames) {
		if (mLoaders.containsKey("*")) {
			cl = mContext.getClassLoader();
		} else {
			cl = mLoaders.get(patchName);
		}
		if (cl != null) {
			classes = patch.getClasses(patchName);
			mAndFixManager.fix(patch.getFile(), cl, classes);
		}
	}
}

所以，不管是修复指定的补丁文件对应的bug，还是之前就存在的补丁文件对应的bug，都是把补丁文件封装成Patch对象，添加到集合mPatchs中，然后调用AndFixManager类的fix方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
public synchronized void fix(File file, ClassLoader classLoader,
		List<String> classes) {
	//判断是否支持，安全检查，读取补丁的dex文件
	if (!mSupport) {
		return;
	}

	if (!mSecurityChecker.verifyApk(file)) {// security check fail
		return;
	}

	try {
		File optfile = new File(mOptDir, file.getName());
		boolean saveFingerprint = true;
		if (optfile.exists()) {
			// need to verify fingerprint when the optimize file exist,
			// prevent someone attack on jailbreak device with
			// Vulnerability-Parasyte.
			// btw:exaggerated android Vulnerability-Parasyte
			// http://secauo.com/Exaggerated-Android-Vulnerability-Parasyte.html
			if (mSecurityChecker.verifyOpt(optfile)) {
				saveFingerprint = false;
			} else if (!optfile.delete()) {
				return;
			}
		}

		final DexFile dexFile = DexFile.loadDex(file.getAbsolutePath(),
				optfile.getAbsolutePath(), Context.MODE_PRIVATE);

		if (saveFingerprint) {
			mSecurityChecker.saveOptSig(optfile);
		}

		ClassLoader patchClassLoader = new ClassLoader(classLoader) {
			@Override
			protected Class<?> findClass(String className)
					throws ClassNotFoundException {
				Class<?> clazz = dexFile.loadClass(className, this);
				if (clazz == null
						&& className.startsWith("com.alipay.euler.andfix")) {
					return Class.forName(className);// annotation’s class
													// not found
				}
				if (clazz == null) {
					throw new ClassNotFoundException(className);
				}
				return clazz;
			}
		};
		Enumeration<String> entrys = dexFile.entries();
		Class<?> clazz = null;
		while (entrys.hasMoreElements()) {
			String entry = entrys.nextElement();
			if (classes != null && !classes.contains(entry)) {
				continue;// skip, not need fix
			}
			clazz = dexFile.loadClass(entry, patchClassLoader);
			if (clazz != null) {
				fixClass(clazz, classLoader);
			}
		}
	} catch (IOException e) {
		Log.e(TAG, "pacth", e);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
private void fixClass(Class<?> clazz, ClassLoader classLoader) {
    //获取该类所有方法
	Method[] methods = clazz.getDeclaredMethods();
	MethodReplace methodReplace;
	String clz;
	String meth;
	//遍历方法，通过注解找到需要修复的方法，因为补丁包工具会给这个方法加上一个注解的
	for (Method method : methods) {
		methodReplace = method.getAnnotation(MethodReplace.class);
		if (methodReplace == null)
			continue;
		clz = methodReplace.clazz();
		meth = methodReplace.method();
		if (!isEmpty(clz) && !isEmpty(meth)) {
			replaceMethod(classLoader, clz, meth, method);
		}
	}
}

private void replaceMethod(ClassLoader classLoader, String clz,
		String meth, Method method) {
	try {
		String key = clz + "@" + classLoader.toString();
		//要被替换的class
		Class<?> clazz = mFixedClass.get(key);
		if (clazz == null) {// class not load
			Class<?> clzz = classLoader.loadClass(clz);
			// initialize target class
			clazz = AndFix.initTargetClass(clzz);
		}
		if (clazz != null) {// initialize class OK
			mFixedClass.put(key, clazz);
			Method src = clazz.getDeclaredMethod(meth,
					method.getParameterTypes());
			//src是要被替换的方法，method是修改后的方法，也就是补丁文件中的
			AndFix.addReplaceMethod(src, method);
		}
	} catch (Exception e) {
		Log.e(TAG, "replaceMethod", e);
	}
}

之后就是调用native方法，会根据dalvik和art的不同，调用不同的方法处理。

赏

谢谢你给的糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

<br>搭建本站的初衷是为了记录生活和工作的点滴，在这个浮躁的社会，希望我们少一些功利主义的追求，多一些不为什么的坚持。<br><br>在北京混日子的程序员一枚，时而无聊时而有趣，时而开心时而抑郁。喜欢旅游和美食。<br><br>喜欢的东西很贵<br>想去的地方很远<br>深爱的人很优秀