转载

Android 热修复 AndFix 原理，看这篇就够了

点击 紫雾凌寒 关注，星标或置顶我们一起成长

前言

之前写过一篇热修复的文章，那时候刚开始接触，照猫画虎画的还算比较成功。但是那种修复需要重新启动APP，也就是在JAVA层实现的热修复。我们知道目前Android主流的修复还有在Native层实现修复的，就是在Native层替换方法，不用重新启动APP。今天写了个Demo，下面主要分享一下它的主要原理。

一、热修复简介

目前，热修复的原理主要有两种技术,一是不需要启动APP就能实现修复，在Native层实现的。一种时需要启动APP，在JAVA层实现的。

  • Native层:andfix sophix  （即时修复  不重启APP）

  • JAVA层:Tinker robust等（需要启动APP）

出现异常的根源在于方法

我们的程序出现异常(BUG)的根源是什么？为什么会出现异常呢，要出现异常肯定是我们程序中的 某个方法 抛出了异常，所以异常的根源是 方法 。那么我们修复包的目的就是去替换异常的方法所在的包名类名下的方法。我们需要准确的找到这个方法，那么我们怎么去找这个方法呢？

如何替换已经运行的APK ？

是直接替换运行时的APK加载的有bug的类吗？显然不行，因为 Java的懒加载机制，在不启动APP时新类不能替换老的类 。class类只被ClassLoader加载一次，所以已经有bug的类,再不启动APP的情况下我们不能直接再虚拟机中替换。那我们要怎么去做呢？我们根据JAVA的内存运行机制来寻找有没有突破口。

二、class加载(内存运行机制)

Java虚拟机（JVM）在java程序运行的过程中，会将它所管理的内存划分为若干个不同的数据区域，这些区域有的随着JVM的启动而创建，有的随着用户线程的启动和结束而建立和销毁。一个基本的JVM运行时内存模型如下所示：

Android 热修复 AndFix 原理，看这篇就够了
img

我们分别看下它的运行时数据区

  • 方法区：class会被加载到方法区，当JVM使用类加载器定位class文件，并将其载入到内存中，会提取class文件的类型信息，并将这些信息存储到方法区中，同时，放入方法区中的还有该类型中的类静态变量。【方法表，静态变量，】

  • 堆区：Java程序在运行时创建的所有类型对象和数组都存储在堆中/JVM会根据new指令在堆中开辟一个确定类型的对象内存空间。但是堆中开辟对象的空间并没有任何人工指令可以回收，而是通过JVM的垃圾回收器负责回收。

  • 栈区：方法的执行是在虚拟机，Java方法执行存储在栈区，每个Java方法对应一个栈帧。每启动一个线程，JVM都会为它分配一个Java栈，用于存放方法中的 局部变量，操作数以及异常数据 等。当线程调用某个方法时，JVM会根据方法区中该方法的字节码组建一个栈帧，并将该栈帧压入Java栈中，方法执行完毕时，JVM会弹出该方法栈并释放掉。

  • 本地方法栈(Native 堆)：本地方法栈的功能和特点类似于虚拟机栈，不同的是，本地方法栈服务的对象是JVM执行的native方法，而虚拟机栈服务的是JVM执行的java方法。

  • 程序计数器(PC寄存器)： 程序计数器是一个记录着当前线程所执行的字节码的行号指示器。 JAVA代码编译后的字节码在未经过JIT（实时编译器）编译前，其执行方式是通过“字节码解释器”进行解释执行。简单的工作原理为解释器读取装载入内存的字节码，按照顺序读取字节码指令。读取一个指令后，将该指令“翻译”成固定的操作，并根据这些操作进行分支、循环、跳转等流程。

当手指触摸APP ICON启动APP的流程如下：

Android 热修复 AndFix 原理，看这篇就够了
在这里插入图片描述

类加载之前有个，int型符号变量指向class内存区域，即将要加载class类信息。（字节码文件内有方法、成员变量）

加载过程由文件变成内存的过程

  1. 加载ActivityThread 生成方法表

  2. 加载main()函数

  3. 虚拟机将main()函数压栈，生成一个栈帧，压入栈区。

  4. 加载Application.class,生成它的方法表。

  5. 创建Application的对象，存放在堆区。每个对象都指向一个符号变量（类）

  6. Object.getClass()得到变量对应的类,最终是通过native方法，最终执行调用 klass 变量，他存放在堆区，指向符号变量，符号变量指向对象所在的内存区域（方法表，成员表）。

  7. 执行 Application 的 onCreate() 方法，他是一个对象方法，执行一个对象方法他会从对象出发，去发送一个事件。根据符号变量找打方法表，找到 onCreate() 方法，并生成一个 onCreate() 栈帧，压入栈区。

类什么时候被加载到内存？ 

1、Application app   
2、=  new Application();

执行到第一行在方法区开辟一个符号变量，这个符号变量为int类型。并不会将 Application 类加载到内存。当执行第二行时才会被加载到内存。 类的初始化只有在主动引用这时候才会被加载到内存，如new创建 | 反射 Class.fromName()|JNI.findClass()、序列化

如何实现替换有bug的方法？

  1. 根据以上原理我们明白，Java层不能实现方法的替换，那么我们另辟蹊径，通过 Native层操控虚拟机内存 ,这就是我们前面所说的突破口。

  2. 由于java对象可以创建多个，我们不能替换某一个对象而不替换其他对象的方法，所以我们需要找打一个方法替换所有对象的方法。那就是需要在方法表中替换有bug 的方法。

  3. 方法在虚拟机中叫 ArtMethod 结构体，它是Native层的。方法表其实就是一个List集合。方法最终是转换为 ArtMethod 结构体被执行。一个方法被压栈多次这个方法就是递归调用。

  4. FindClass(实现父委托机制，bootstrapClassLoad) 调用 LookUpClass --->DefineClass(定义一个Class类型，定义klass，所有类型全部置空，之后再加载类)--->LinkClass(加载类信息。从/data/app/包名，Apk中的dex文件中来)--->LinkSuperClass(父类先被加载到内存)--->LinkMethods(父类加载方法){LinkInterfaceMethods 拿到方法数，形成方法表，实例一个ArrayList<`ArtMethod`>,每个方法实例一个 ArtMethod 结构体}

类是抽象的,必须要有一个内存载体{klass,每个类都有一个，并且是唯一的.}

三、手写实现Andfix

写一个bug类

首先我们要自己写一个bug类， BugClass 的 test() 方法抛出一个异常 

/**
 * bug测试类
 */
public class BugClass {
    public int test(){
        //测试bug
        throw new RuntimeException("这是一个异常！");
    }
}

在Activity中调用异常的方法

比如说点击某个按钮，这里就不写了。

实现修复

我们实现修复，也就是之前说的替换虚拟机中内存中的方法表里的方法，那么怎么替换呢？一个APK中有成千上万个方法，就某一个有异常，我们怎么区分呢？那就是用注解来区分。

1.定义注解 

package com.example.bthvi.mycloassloaderapplication;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Replace {
    //修复哪一个class
    String clazz();
    //修复哪一个方法
    String method();
}

2.修复对应方法所，并给他加上注解 

import com.example.bthvi.mycloassloaderapplication.Replace;

/**
 * bug测试类
 */
public class BugClass {

    @Replace(clazz = "com.example.bthvi.mycloassloaderapplication.xxx.BugClass",method = "test")
    public int test(){
        return 1;
    }
}

3.生成dex文件查分包

怎么生成dex文件，前面一篇文章以及说过了:Android学习——手把手教你实现Android热修复,这里就不多做说明了。

4.实现修复工具类

  • 首先我们要拿到对应的已经修复的dex文件，项目中我们肯定是从网络和获取，这里我们之还是定义在本地文件夹下。

  • 其次我们加载这个Dex文件，拿到它的所有的类，遍历类中的方法，根据注解得到哪些方法时候需要修复的。

  • 再根据注解中的类名方法名通过反射得到已经加载的有bug的方法。

  • 调用Native方法替换有bug的方法。

package com.example.bthvi.mycloassloaderapplication;
import android.content.Context;
import android.os.Environment;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Enumeration;

import dalvik.system.DexFile;
/**
 *@author bthvi
 *@time 2019/7/20
 *@desc 不用启动APP实现热修复
 */
public class FixDexManager {
    private final static String TAG = "FixDexUtil";
    private static final String DEX_SUFFIX = ".dex";
    private static final String APK_SUFFIX = ".apk";
    private static final String JAR_SUFFIX = ".jar";
    private static final String ZIP_SUFFIX = ".zip";
    public static final String DEX_DIR = "odex";
    private static final String OPTIMIZE_DEX_DIR = "optimize_dex";
    private Context context;

    public FixDexManager(Context context) {
        this.context = context;
    }

    public void isGoingToFix() {
        File externalStorageDirectory = Environment.getExternalStorageDirectory();

        // 遍历所有的修复dex , 因为可能是多个dex修复包
        File fileDir = externalStorageDirectory != null ?
                new File(externalStorageDirectory,"007"):
                new File(context.getFilesDir(), DEX_DIR);// data/data/包名/files/odex（这个可以任意位置）

        File[] listFiles = fileDir.listFiles();
        if (listFiles != null){
            System.out.println("TAG==目录下文件数量="+listFiles.length);
            for (File file : listFiles) {
                System.out.println("TAG==文件名称="+file.getName());
                if (file.getName().startsWith("fix") &&
                        (file.getName().endsWith(DEX_SUFFIX))) {
                    loadDex(file);// 开始修复
                    //有目标dex文件, 需要修复
                }
            }
        }
    }
    /**
     * 加载Dex文件
     * @param file
     */
    public void loadDex(File file) {
        try {
            DexFile dexFile = DexFile.loadDex(file.getAbsolutePath(),
                    new File(context.getCacheDir(), "opt").getAbsolutePath(), Context.MODE_PRIVATE);
            //当前的dex里面的class 类名集合
            Enumeration<String> entry=dexFile.entries();
            while (entry.hasMoreElements()) {
                //拿到Class类名
                String clazzName= entry.nextElement();
                //通过加载得到类  这里不能通过反射，因为当前的dex没有加载到虚拟机内存中
                Class realClazz= dexFile.loadClass(clazzName, context.getClassLoader());
                if (realClazz != null) {
                    fixClazz(realClazz);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 修复有bug的方法
     * @param realClazz
     */
    private void fixClazz(Class realClazz) {
        //得到类中所有方法
        Method[] methods=realClazz.getMethods();
        //遍历方法 通过注解 得到需要修复的方法
        for (Method rightMethod : methods) {
            //拿到注解
            Replace replace = rightMethod.getAnnotation(Replace.class);
            if (replace == null) {
                continue;
            }
            //得到类名
            String clazzName=replace.clazz();
            //得到方法名
            String methodName=replace.method();
            try {
                //反射得到本地的有bug的方法的类
                Class wrongClazz=  Class.forName(clazzName);
                //得到有bug的方法（注意修复包中的方法参数名和参数列表必须一致）
                Method wrongMethod = wrongClazz.getDeclaredMethod(methodName, rightMethod.getParameterTypes());
                //调用native方法替换有bug的方法
                replace(wrongMethod, rightMethod);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }



    }

    public native static void replace(Method wrongMethod, Method rightMethod) ;
}

5.实现Native方法替换

我们前面说了，方法在虚拟机中是以 ArtMethod 结构体存在的，那么我们替换就是要去替换旧的方法的 ArtMethod 对象的所有属性。 

#include <jni.h>
#include <string>
#include "art_method.h"

extern "C"
JNIEXPORT void JNICALL
Java_com_example_bthvi_mycloassloaderapplication_FixDexManager_replace(JNIEnv *env, jclass type, jobject wrongMethod,
                                             jobject rightMethod) {

    //ArtMethod存在于Android 系统源码中，只需要导入我们需要的部分（art_method.h）
    art::mirror::ArtMethod *wrong=  (art::mirror::ArtMethod *)env->FromReflectedMethod(wrongMethod);
    art::mirror::ArtMethod *right=  (art::mirror::ArtMethod *)env->FromReflectedMethod(rightMethod);
    //    method   --->class ----被加载--->ClassLoader
    //错误的成员变量替换为正确的成员变量
    wrong->declaring_class_ = right->declaring_class_;
    wrong->dex_cache_resolved_methods_ = right->dex_cache_resolved_methods_;
    wrong->access_flags_ = right->access_flags_;
    wrong->dex_cache_resolved_types_ = right->dex_cache_resolved_types_;
    wrong->dex_code_item_offset_ = right->dex_code_item_offset_;
    //    这里   方法索引的替换
    wrong->method_index_ = right->method_index_;
    wrong->dex_method_index_ = right->dex_method_index_;

}

这里由于要用到 ArtMethod 所以我们要从源码中拿到 ArtMethod ,源码中 ArtMethod 引用太多的系统源码我们这里简化一下，只要声明我们需要的变量即可。 

namespace art {
    namespace mirror {
        class Object{
            // The Class representing the type of the object.
            uint32_t klass_;
            // Monitor and hash code information.
            uint32_t monitor_;

        };
        //简化ArtMethod  只需要关注我们需要的，只需要成员变量声明
        class ArtMethod : public Object {
        public:

            uint32_t access_flags_;
            uint32_t dex_code_item_offset_;
            // Index into method_ids of the dex file associated with this method
            //方法再dex中的索引
            uint32_t method_dex_index_;
            uint32_t dex_method_index_;
            //在方法表的索引
            uint32_t method_index_;
            const void *native_method_;

            const uint16_t *vmap_table_;
            // Short cuts to declaring_class_->dex_cache_ member for fast compiled code access.
            uint32_t dex_cache_resolved_methods_;
            //方法 自发
            // Short cuts to declaring_class_->dex_cache_ member for fast compiled code access.
            uint32_t dex_cache_resolved_types_;


            // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
            // The class we are a part of.
            //所属的函数
            uint32_t declaring_class_;
        };
    }
}

这里还用到了 Object 所以我们还是要声明 Object 这个的源码太多这里就不复制了，我们也不需要特意去搞懂这些底层源码，只需要关注我们需要的就行。到这里我们就实现了Native层的热修复。

Andfix的兼容性

前面我们说的就是Andfix的原理及简单实现，但是 Andfix兼容性比较差 。它的兼容性差是为什么呢？我们这里主要的原理是替换 ArtMethod 结构体的成员变量，这个结构体是初始化方法表时虚拟机创建的， Google对于不同的系统版本 ArtMethod 结构体的成员变量都有做变动 如下：我们看下Android 6.0和7.0中 ArtMethod 的不同点[简单找一两个]。 

//  Android 6.0系统源码中ArtMethod 精简版  去掉注释
class ArtMethod {
public:
    uint32_t declaring_class_;
    uint32_t dex_cache_resolved_methods_;
    uint32_t dex_cache_resolved_types_;
    uint32_t access_flags_;
    uint32_t dex_code_item_offset_;
    uint32_t dex_method_index_;
    uint32_t method_index_;

    struct PtrSizedFields {
        // Method dispatch from the interpreter invokes this pointer which may cause a bridge into
        // compiled code.
        void* entry_point_from_interpreter_;
        // Pointer to JNI function registered to this method, or a function to resolve the JNI function.
        void* entry_point_from_jni_;
        // Method dispatch from quick compiled code invokes this pointer which may cause bridging into
        // the interpreter.
        void* entry_point_from_quick_compiled_code_;
    } ptr_sized_fields_;
};

//  Android 7.0系统源码中ArtMethod 精简版  去掉注释
class ArtMethod {
public:

    uint32_t declaring_class_;
    uint32_t access_flags_;
    uint32_t dex_code_item_offset_;
    uint32_t dex_method_index_;
    uint16_t method_index_;
    uint16_t hotness_count_;
    struct PtrSizedFields {
        // Short cuts to declaring_class_->dex_cache_ member for fast compiled code access.
        ArtMethod** dex_cache_resolved_methods_;

        // Short cuts to declaring_class_->dex_cache_ member for fast compiled code access.
        void* dex_cache_resolved_types_;

        // Pointer to JNI function registered to this method, or a function to resolve the JNI function,
        // or the profiling data for non-native methods, or an ImtConflictTable.
        void* entry_point_from_jni_;

        // Method dispatch from quick compiled code invokes this pointer which may cause bridging into
        // the interpreter.
        void* entry_point_from_quick_compiled_code_;
    } ptr_sized_fields_;

};

从上面的源码中我们明显看到 ArtMethod 结构体中成员变量的改变，如 method_index_ 在6.0是32位在7.0中就是16位了。还有 PtrSizedFields 结构体的成员变量也有修改。所以这就使的AndFix的兼容性很差，要想兼容所有版本就得对不同版本去做兼容适配。

由于AndFix的兼容性和它是免费开源的,阿里在sophix出来之后就以及不再维护AndFix了。 Sophix 它的方案可以说是比较完美了，它是结合了JAVA层和Native层的两者的有点，它的原理介绍大家可以看看这本书：《深入探索Android热修复技术原理》

技术交流，欢迎加我微信：ezglumes ，拉你入技术交流群。

Android 热修复 AndFix 原理，看这篇就够了

扫码关注公众号【音视频开发进阶】，一起学习多媒体音视频开发~~~

Android 热修复 AndFix 原理，看这篇就够了

喜欢就点个 「在看」 吧  ▽

原文  http://mp.weixin.qq.com/s?__biz=MzA4MjU1MDk3Ng==&mid=2451526974&idx=1&sn=bcb3bf4d44beb2ae99e53512cfb22c33
正文到此结束
所属分类： 编程技术 Java

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 springcloud-demo Hive教程 Ant教程 ANTLR教程 SpringCloud java实例教程 XStream教程 Hazelcast教程 Elastic-Job-Lite 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 solr教程 Hadoop教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 java-demo Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 如何将Spring Cloud Task发布Data Flow上执行？
  2. 2 Spring Cloud Data Flow快速入门Demo
  3. 3 Spring Cloud Consul实现选举机制
  4. 4 Spring Boot集成ShedLock实现分布式定时任务
  5. 5 利用oss进行数据库和网站图片备份
  6. 6 Spring Cloud Stream实现数据流处理
  7. 7 Python3访问MySQL数据库快速入门Demo
  8. 8 Github开源项目作者可以免费申请 JetBrains 全家桶
  9. 9 Spring Cloud Vault快速入门Demo
  10. 10 Spring Cloud Gateway快速入门Demo
网站信息
  • 文章总数：82,716 篇
  • 文件总数：284,297 个
  • 标签总数：2,396 个
  • 分类总数：85 个
  • 留言数量：2,560 条
  • 在线人数：649 人
  • 运行天数：4,411天
  • 最后更新：2024年11月24日11点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG