Android热更新具体步骤

Android大厂面试教学视频
链接：https://pan.baidu.com/s/1k5QaWnjxLC3f2-YhZFss-w?pwd=apo8 
提取码：apo8 
 

kotlin
链接：https://pan.baidu.com/s/1q9_LIwBaNkARJ6Du4H6jcw?pwd=v9vn 
提取码：v9vn 

Android资料2
链接：https://pan.baidu.com/s/18zo-AYWj2TQDoqZbUQcW2A?pwd=7hlm 
提取码：7hlm 
 

下面我将给出一个简单的示例，演示如何使用 **热更新** 和 **Hook 技术** 在 Android 中实现功能修改。

1. 热更新简单示例

假设我们要修复应用中 `MainActivity` 的 `sayHello` 方法，而不需要重新发布整个应用。我们通过生成补丁 dex 文件，并动态加载它来实现。

1.1. 原始代码（未修复）

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 调用 sayHello 方法
        sayHello();
    }

    // 需要修复的方法
    public void sayHello() {
        Log.d("MainActivity", "Hello, world!");
    }
}

1.2. 修复代码（生成补丁）

我们假设修复后的代码如下（即要替换掉原始代码中的 `sayHello` 方法）：

public class MainActivityPatch {
    public void sayHello() {
        Log.d("MainActivity", "Hello, patched world!");
    }
}

将这段代码编译为 `patch.dex` 文件，之后将其上传到服务器，用户下载到本地存储中。

1.3. 热更新实现

在应用运行时，动态加载补丁 dex 并替换原来的方法：

public class HotFixManager {
    private static HotFixManager instance;

    public static HotFixManager getInstance() {
        if (instance == null) {
            instance = new HotFixManager();
        }
        return instance;
    }

    // 加载补丁文件并修复 sayHello 方法
    public void loadPatch(Context context) {
        try {
            // 补丁 dex 文件路径
            String patchPath = context.getFilesDir().getAbsolutePath() + "/patch.dex";
            DexClassLoader dexClassLoader = new DexClassLoader(
                patchPath,
                context.getCacheDir().getAbsolutePath(),
                null,
                context.getClassLoader()
            );

            // 通过反射获取原始 Activity 的 sayHello 方法
            Class<?> mainActivityClass = Class.forName("com.example.app.MainActivity");
            Method originalMethod = mainActivityClass.getDeclaredMethod("sayHello");

            // 获取补丁中的 sayHello 方法
            Class<?> patchClass = dexClassLoader.loadClass("com.example.app.MainActivityPatch");
            Method patchMethod = patchClass.getDeclaredMethod("sayHello");

            // 使用反射修改原始方法实现
            originalMethod.setAccessible(true);
            patchMethod.setAccessible(true);
            originalMethod.invoke(patchClass.newInstance());  // 替换成补丁方法
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在 `MainActivity` 的 `onCreate` 中调用热修复方法：

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

    // 加载补丁
    HotFixManager.getInstance().loadPatch(this);

    // 调用 sayHello（会被修复）
    sayHello();
}

2. Hook 简单示例

我们来演示如何使用 **Hook** 技术来拦截 `Toast.makeText` 方法，并在其调用之前插入自定义逻辑。

 2.1. 原始代码

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 显示 Toast
        Toast.makeText(this, "Hello, world!", Toast.LENGTH_SHORT).show();
    }
}

```

 2.2. Hook 实现

通过反射获取 `Toast.makeText` 方法，并在每次调用之前插入自定义逻辑。

public class HookManager {
    public static void hookToast() {
        try {
            // 获取 Toast 的 makeText 方法
            Method makeTextMethod = Toast.class.getDeclaredMethod("makeText", Context.class, CharSequence.class, int.class);

            // 动态代理拦截 makeText 调用
            InvocationHandler handler = new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    // 在调用 makeText 之前插入自己的逻辑
                    Log.d("HookManager", "Toast is being called with message: " + args[1]);

                    // 调用原始 makeText 方法
                    return method.invoke(null, args);
                }
            };

            // 创建代理
            Object proxy = Proxy.newProxyInstance(
                makeTextMethod.getDeclaringClass().getClassLoader(),
                new Class[]{makeTextMethod.getDeclaringClass()},
                handler
            );

            // 替换原来的 makeText 方法
            Field declaredField = Toast.class.getDeclaredField("makeText");
            declaredField.setAccessible(true);
            declaredField.set(null, proxy);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

在 `MainActivity` 中初始化 Hook：

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

    // Hook Toast.makeText
    HookManager.hookToast();

    // 显示 Toast，应该会触发 Hook
    Toast.makeText(this, "Hello, world!", Toast.LENGTH_SHORT).show();
}

```

2.3. Hook 结果

当用户触发 `Toast.makeText` 时，首先会调用 `HookManager` 中插入的日志逻辑，之后再显示原始的 Toast。这就是通过 Hook 实现对方法的拦截和增强。

---

总结

- **热更新示例**：通过加载补丁 dex 文件，并通过反射替换原始类和方法，动态修复 `sayHello` 方法。
- **Hook 示例**：通过动态代理和反射机制，拦截并增强 `Toast.makeText` 的调用行为。

这两个简单的示例展示了 Android 热更新和 Hook 技术的核心思想和应用场景。