Android热修复手动实现

最新推荐文章于 2023-05-05 23:55:07 发布
最新推荐文章于 2023-05-05 23:55:07 发布
阅读量932 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Small_Lee/article/details/80770450
版权

前言

热修复，简单的说就是在不重新下载安装app的情况下，自动修复现有app的问题，今天来做一个简单的实现。


效果图

点击TEST我们执行下面的方法

 public void test(View view) {
        TestCaculate testCaculate = new TestCaculate();
        testCaculate.caculate(this);
    }
public class TestCaculate {
   public int a = 10;
   public int b = 0;
   
   public void caculate(Context context) {
       Toast.makeText(context, "结果" + a / b, Toast.LENGTH_SHORT).show();
   }
}

很明显，这里会产生一个除数为0的异常，导致app退出。接下来我们就来修复。

热修复的前提是apk中有多个dex,所以我们要先进行multidex的支持，

implementation 'com.android.support:multidex:1.0.3' // 引入multidex库
defaultConfig {
        applicationId "practice.lxn.cn.weather"
        minSdkVersion 15
        targetSdkVersion 22
        versionCode 1
        versionName "1.0"
        multiDexEnabled true
        multiDexKeepFile file('maindexlist.txt') // maindexlist.txt文件指定哪些类在主dex中
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"

    }

    dexOptions {
        javaMaxHeapSize "4g"
        preDexLibraries = false
        additionalParameters = ['--multi-dex', '--main-dex-list='+ project.rootDir.absolutePath + '/maindexlist.txt', '--minimal-main-dex',
                                '--set-max-idx-number=1000']
    }

内容如下

android/support/multidex/MultiDex.class
android/support/multidex/MultiDexApplication.class
android/support/multidex/MultiDexExtractor.class
android/support/multidex/MultiDexExtractor$1.class
android/support/multidex/MultiDex$4.class
android/support/multidex/MultiDex$14.class
android/support/multidex/MultiDex$19.class
android/support/multidex/ZipUtil.class
android/support/multidex/ZipUtil$CentralDirectory.class

practice/lxn/cn/weather/MainActivity.class
practice/lxn/cn/weather/CustomApplication.class

应用的目录如下



这里我们把有问题的类和修复工具打到从dex里，编译打包，我们可以看到两个dex文件，通过dex2jar和JD-GUI可以查看，确实打进去了。


然后我们把问题修复，重新打包

public class TestCaculate {
   public int a = 10;
   public int b = 1;
   
   public void caculate(Context context) {
       Toast.makeText(context, "结果" + a / b, Toast.LENGTH_SHORT).show();
   }
}

接下来把打好的修复包classes2.dex放到外部存储目录，修复的时候我们手动把它拷贝到应用自己的目录下，进行修复，整个过程代码如下

public class MainActivity extends AppCompatActivity {
    public static final String DEX_PATH = Environment.getExternalStorageDirectory().getAbsolutePath();

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

    public void test(View view) {
        TestCaculate testCaculate = new TestCaculate();
        testCaculate.caculate(this);
    }

    public void fix(View view) {
        try {
            // 把dex文件从外部目录复制到应用程序所在目录，方便类加载器加载
            String fileName = "classes2.dex";
            File dir = new File(DEX_PATH + File.separator);
            File file = new File(dir + File.separator + fileName);
            FileInputStream fis = new FileInputStream(file);
            FileOutputStream fos = new FileOutputStream(getDir("dex",MODE_PRIVATE) + fileName);
            int len;
            byte[] bytes = new byte[1024];
            while ((len = fis.read(bytes)) != -1) {
                fos.write(bytes,0,len);
            }
            fis.close();
            fos.close();
            FixUtil.patch(this,file.getAbsolutePath(),"practice.lxn.cn.weather.test.TestCaculate");
            Toast.makeText(this, "修复成功", Toast.LENGTH_SHORT).show();
        } catch (Exception e) {
            Toast.makeText(this, "修复失败" + e.getMessage(), Toast.LENGTH_SHORT).show();
            e.printStackTrace();
        }
    }
}

public class FixUtil {
    private static final String TAG = "FixUtil";
    /**
     * 修复指定的类
     * @param context        上下文对象
     * @param patchDexFile   dex文件
     * @param patchClassName 被修复类名
     */
    public static void patch(Context context, String patchDexFile, String patchClassName) {
        if (patchDexFile != null && new File(patchDexFile).exists()) {
            try {
                if (hasLexClassLoader()) {
                    injectInAliyunOs(context, patchDexFile, patchClassName);
                } else if (hasDexClassLoader()) {
                    injectAboveEqualApiLevel14(context, patchDexFile, patchClassName);
                } else {
                    injectBelowApiLevel14(context, patchDexFile, patchClassName);
                }
            } catch (Throwable th) {
                Log.d(TAG, "patch: " + th.getMessage());
            }
        }
    }

    private static boolean hasLexClassLoader() {
        try {
            Class.forName("dalvik.system.LexClassLoader");
            return true;
        } catch (ClassNotFoundException e) {
            return false;
        }
    }

    private static boolean hasDexClassLoader() {
        try {
            Class.forName("dalvik.system.BaseDexClassLoader");
            return true;
        } catch (ClassNotFoundException e) {
            return false;
        }
    }

    private static void injectInAliyunOs(Context context, String patchDexFile, String patchClassName)
            throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException,
            InstantiationException, NoSuchFieldException {
        PathClassLoader obj = (PathClassLoader) context.getClassLoader();
        String replaceAll = new File(patchDexFile).getName().replaceAll("\\.[a-zA-Z0-9]+", ".lex");
        Class<?> cls = Class.forName("dalvik.system.LexClassLoader");
        Object newInstance =
                cls.getConstructor(String.class, String.class, String.class, ClassLoader.class).newInstance(
                        context.getDir("dex", 0).getAbsolutePath() + File.separator + replaceAll,
                        context.getDir("dex", 0).getAbsolutePath(), patchDexFile, obj);
        cls.getMethod("loadClass", String.class).invoke(newInstance, patchClassName);
        setField(obj, PathClassLoader.class, "mPaths",
                appendArray(getField(obj, PathClassLoader.class, "mPaths"), getField(newInstance, cls, "mRawDexPath")));
        setField(obj, PathClassLoader.class, "mFiles",
                combineArray(getField(obj, PathClassLoader.class, "mFiles"), getField(newInstance, cls, "mFiles")));
        setField(obj, PathClassLoader.class, "mZips",
                combineArray(getField(obj, PathClassLoader.class, "mZips"), getField(newInstance, cls, "mZips")));
        setField(obj, PathClassLoader.class, "mLexs",
                combineArray(getField(obj, PathClassLoader.class, "mLexs"), getField(newInstance, cls, "mDexs")));
    }

    @TargetApi(14)
    private static void injectBelowApiLevel14(Context context, String str, String str2)
            throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        PathClassLoader obj = (PathClassLoader) context.getClassLoader();
        DexClassLoader dexClassLoader =
                new DexClassLoader(str, context.getDir("dex", 0).getAbsolutePath(), str, context.getClassLoader());
        dexClassLoader.loadClass(str2);
        setField(obj, PathClassLoader.class, "mPaths",
                appendArray(getField(obj, PathClassLoader.class, "mPaths"), getField(dexClassLoader, DexClassLoader.class,
                        "mRawDexPath")
                ));
        setField(obj, PathClassLoader.class, "mFiles",
                combineArray(getField(obj, PathClassLoader.class, "mFiles"), getField(dexClassLoader, DexClassLoader.class,
                        "mFiles")
                ));
        setField(obj, PathClassLoader.class, "mZips",
                combineArray(getField(obj, PathClassLoader.class, "mZips"), getField(dexClassLoader, DexClassLoader.class,
                        "mZips")));
        setField(obj, PathClassLoader.class, "mDexs",
                combineArray(getField(obj, PathClassLoader.class, "mDexs"), getField(dexClassLoader, DexClassLoader.class,
                        "mDexs")));
        obj.loadClass(str2);
    }

    private static void injectAboveEqualApiLevel14(Context context, String str, String str2)
            throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        PathClassLoader pathClassLoader = (PathClassLoader) context.getClassLoader();
        Object a = combineArray(getDexElements(getPathList(pathClassLoader)),
                getDexElements(getPathList(
                        new DexClassLoader(str, context.getDir("dex", 0).getAbsolutePath(), str, context.getClassLoader()))));
        // 获取pathList对象
        Object a2 = getPathList(pathClassLoader);
        //新的dexElements对象重新设置回去
        setField(a2, a2.getClass(), "dexElements", a);
        pathClassLoader.loadClass(str2);
    }

    /**
     * 通过反射先获取到pathList对象
     *
     * @param obj
     * @return
     * @throws ClassNotFoundException e
     * @throws NoSuchFieldException e
     * @throws IllegalAccessException e
     */
    private static Object getPathList(Object obj) throws ClassNotFoundException, NoSuchFieldException,
            IllegalAccessException {
        return getField(obj, Class.forName("dalvik.system.BaseDexClassLoader"), "pathList");
    }

    /**
     * 从上面获取到的PathList对象中，进一步反射获得dexElements对象
     *
     * @param obj
     * @return
     * @throws NoSuchFieldException
     * @throws IllegalAccessException
     */
    private static Object getDexElements(Object obj) throws NoSuchFieldException, IllegalAccessException {
        return getField(obj, obj.getClass(), "dexElements");
    }

    private static Object getField(Object obj, Class cls, String str)
            throws NoSuchFieldException, IllegalAccessException {
        Field declaredField = cls.getDeclaredField(str);
        declaredField.setAccessible(true);//设置为可访问
        return declaredField.get(obj);
    }

    private static void setField(Object obj, Class cls, String str, Object obj2)
            throws NoSuchFieldException, IllegalAccessException {
        Field declaredField = cls.getDeclaredField(str);
        declaredField.setAccessible(true);//设置为可访问
        declaredField.set(obj, obj2);
    }

    //合拼dexElements
    private static Object combineArray(Object obj, Object obj2) {
        Class componentType = obj2.getClass().getComponentType();
        int length = Array.getLength(obj2);
        int length2 = Array.getLength(obj) + length;
        Object newInstance = Array.newInstance(componentType, length2);
        for (int i = 0; i < length2; i++) {
            if (i < length) {
                Array.set(newInstance, i, Array.get(obj2, i));
            } else {
                Array.set(newInstance, i, Array.get(obj, i - length));
            }
        }
        return newInstance;
    }

    private static Object appendArray(Object obj, Object obj2) {
        Class componentType = obj.getClass().getComponentType();
        int length = Array.getLength(obj);
        Object newInstance = Array.newInstance(componentType, length + 1);
        Array.set(newInstance, 0, obj2);
        for (int i = 1; i < length + 1; i++) {
            Array.set(newInstance, i, Array.get(obj, i - 1));
        }
        return newInstance;
    }
}

最后给出源码的下载路径

Android热修复实现

欢迎大家在下方评论和留言，有问题一起讨论



lxn_李小牛
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android热修复实现
06-22
手动实现了一个简单的热修复功能，博客链接https://blog.csdn.net/Small_Lee/article/details/80770450
Android学习——手把手教你实现Android热修复
博客
02-01 399
前言 最近一段时间看了一些关于Android热修复的知识，比如Andfix,Tinker,Sophix等，看了这些框架的原理，就想着自己能不能手撸一个简单的demo。下面我们就来自己动手实现Android热修复吧。 热修复实现原理 所谓热修复就是，在我们应用上线后出现小bug需要及时修复时，不用再发新的安装包，只需要发布补丁包，在客户不知不觉之间修复掉bug，JAVA虚拟机JVM在运行时，加载的是.classes的字节码文件。而Android也有自己的虚拟机Dalvik/ART虚拟机，不过他们加载的是
Android热修复实现及原理
贵公子丶笔记
05-05 398
经过对的分析，我们知道，安卓的类加载器在加载一个类时会先从自身对象中的Element数组中获取（）到对应的类，之后再加载。采用的是数组遍历的方式，不过注意，遍历出来的是一个个的dex文件。在 for 循环中，首先遍历出来的是dex文件，然后再是从dex文件中获取class，所以，我们只要让修复好的class打包成一个dex文件，放于Element数组的第一个元素，这样就能保证获取到的class是最新修复好的class了（当然，有bug的class也是存在的，不过是放在了Element。
Android热修复技术-自己动手实现热修复
walk的博客
11-25 739
一、基本概念 定义：动态的修复或者更新app的行为 热修复的好处：在用户没有感知的情况下完成bug修复和一些小功能的更新 流行的热修复技术： QQ空间的超级补丁方案 微信的Tinker 阿里的AndFix 美团的Robust、ele的migo、百度的hotfix 技术对比： ...
Android注入实现Dex热修复
12-19
在Android开发领域，热修复是一种重要的技术，它允许开发者在应用发布后，无需用户手动更新，就能修复已知的Bug或添加新功能。本话题主要关注如何通过反射和Dex注入来实现Android应用的热修复。 Android应用的核心...
深入探索Android热修复
11-20
在移动应用开发领域，Android热修复技术是一种至关重要的技术，它允许开发者在无需用户手动更新应用的情况下，修复应用中的bug或添加新功能。这极大提高了用户体验，同时也减轻了开发团队的维护压力。本文将深入探讨...
阿里Android热修复技术原理
05-31
《阿里Android热修复技术原理》是一本专注于解析Android热修复技术的专业著作，它全面系统地介绍了热修复的核心理念以及阿里Sophix方案的实现细节。在移动应用开发领域，热修复技术已经成为解决线上问题、保障用户...
Android热修复例子
06-02
AndFix（Android Fast Fix）是阿里巴巴开源的一款热修复框架，它基于Dalvik字节码级别进行修复，能够在用户无感知的情况下实现应用的动态修复。 一、AndFix原理 AndFix的核心思想是通过替换应用中存在问题的方法体...
手动实现最简单的Android热修复（最新最全详细小白教程）
黄庆庆的世界
07-14 4303
手动实现最简单的Android热修复 前言 最近了解到了热修复相关的东西，于是很好奇原理，便一番搜索资料，同时为了加深对热修复的理解，便自己照着网上的例子去实现一个热修复，因为基础相对比较差，而且网上很多例子都是过时的，而且很多细节不注意到的话，就是一个坑，而且还五花八门的，于是我觉得将自己的这个实现热修复的例子记录下来事很有必要的，主要是参考并综合了网上很多热修复的例子，自己实现并完成整...
Android热修复方案最简单实现
hongxue8888的博客
09-30 400
文章目录1 反射1.1 Class.forName()和ClassLoader.loadClass()的区别1.2 反射对性能影响1.3 反射中getMethods 与 getDeclaredMethods 的区别?反射工具类 需要结合Android源码进行分析，源码分析请参照这篇文章： https://blog.csdn.net/hongxue8888/article/details/10166...
手动教你如何实现Android热修复！
粉丝交流群：957013433
01-27 312
1.类加载的过程 类加载由ClassLoader的实现类完成。玩过反编译的都知道，我们在解压了apk之后，最终会需要dex格式的文件来搞事，这个dex由class文件打包而成。那么安卓中，要加载dex文件中的class文件，需要用到DexClassLoader或者PathClassLoader。 我们可以直接在AS中点开，但是却无法正常查看，因为这些是系统级的源码。我们可以选择下载源码，或者直...
安卓手写热修复demo
spyfool的博客
02-25 734
安卓手写热修复demo 目录 用[TOC]`来生成目录： 安卓手写热修复demo 目录 预备知识 demo码云地址 实现步骤 1获取系统dexElements 2加载外部Dex文件 3将外部dex文件中的dexElements与系统dexElements合并 修复效果测试 定义测试 建立热修复dex文件 预备知识 了解安卓如何加载类：Android插件化开...
Android热修复原理及简单实现
dsczxcc的博客
11-08 353
文章目录概念第三方框架阿里系腾讯系美团简单实现预期效果准备dex分包实现原理分析ClassLoader相关源码生成dex文件代码实现 概念 我们先假设一个场景，如果一个已经上线的APP中，发现了一些bug，可能你会想直接升级版本就可以了，但是后面如果不断出现bug，难度要用户不断更新吗？这显然不太实际，用户也很难接受。这时“热修复”的概念就油然而生了，我们可以在用户未知或者影响极小的情况下把已知的...
热修复的简单原理
qq_31180471的博客
02-24 192
Android热修复核心——ClassLoader
LVEfrist的博客
07-03 260
背景： 如今比较火的技术中热修复算是一种了。他能够帮助我们在不升级应用版本的情况下修复应用Bug。那么这种技术如何实现呢？这里我们先不急着讲如何去实现热修复，因为能力还达不到。我们先了解一下这个技术的核心：类加载。 一、概念了解：Dalvik和ART (1)什么是Dalvik 上一章我们讲了Java虚拟机JVM。但实际上Java中JVM可以理解为一种虚拟机规范，现实中各家都根据这个规范开发...
Android 热修复
zenmela2011的专栏
07-06 4390
1.Android热修复 热修复，就是对线上版本的静默更新。当APP发布上线之后，如果出现了严重的bug，通常需要重新发版来修复，但是频繁地发版显然不是最佳解决方案，所以出现了热修复，在用户无感知的情况下修复线上bug，避免频繁地发版。 在开发端，通过Gradle插件生成补丁包，并上传到云端，客户端通过判断是否需要下载新的补丁包，并执行热修复。 目前主流的热修复框架有腾讯的Tinker，阿里的AndFix、Sophix，美团的Robust。他们采用的修复方式不同，比如native层hook Jav
Android热补丁动态修复实践，android0基础方法类
m0_64382868的博客
11-26 235
public class BugClass { public String bug() { return “bug class”; } } package com.devilwwj.hotfixdemo; /** com.devilwwj.hotfixdemo Created by devilwwj on 16/3/8. */ public class LoadBugClass { public String getBugString() { BugClass bugClass = new Bu
android SDK热修复技术
最新发布
06-12
热修复技术可以在不需要用户手动更新应用程序的情况下，实现应用程序的功能扩展和问题修复，提高应用程序的稳定性和用户体验。 在Android SDK中，热修复技术通常使用反射机制和动态加载技术实现。具体来说，热修复...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值