应用在Google市场上架之前会经过安全扫描，包含病毒的应用无法上架。目前安卓应用可以通过下载并动态加载dex/jar/elf/的方式，进行升级，以达到以下目的：问题修复，版本升级等。这都是热补丁的正常使用方式。除此之外，个别恶意应用利用热补丁技术，故意使上架检测版本和实际运行版本不一致，恶意绕过上架检测机制。
提供的动态加载接口有Dexclassloader、Desfile.loadDex、System.load、System.loadlibrary，它们底层在虚拟机的实现接口是openDexFileNative和JVM_NativeLoad，分别用于加载dex/jar和so格式的文件，应用通过调用这些接口实现动态加载。
那么热补丁插件的实现方式大概有以下几种：
Android中间件
插件化
http://weishu.me/2016/01/28/understand-plugin-framework-overview/
https://github.com/wangwangheng/BestBlogReprinted_AndroidNotes/tree/master/%E6%8F%92%E4%BB%B6%E5%BC%8F%E5%BC%80%E5%8F%91/weishu%E7%B3%BB%E5%88%97
http://blog.csdn.net/ganyao939543405/article/details/76146760
https://cloud.tencent.com/developer/article/1038868
http://www.10tiao.com/html/227/201703/2650239063/1.html
https://github.com/tiann/understand-plugin-framework
http://www.10tiao.com/html/227/201703/2650239063/1.html
https://github.com/prife/VirtualAppDoc
热修复
http://www.androidchina.net/6213.html
https://github.com/Tencent/tinker/wiki
https://www.cnblogs.com/popfisher/p/8543973.html
深入探索Android热修复技术原理 by 阿里 pdf
AndFix原理 https://blog.csdn.net/jiangwei0910410003/article/details/53099390
Hook框架
http://www.snowdream.tech/2016/09/02/android-install-xposed-framework/
https://jaq.alibaba.com/community/art/show?articleid=809
VirtualXposed 和epic
https://github.com/android-hacker/VirtualXposed
https://github.com/tiann/epic
http://weishu.me/2017/12/02/non-root-xposed/
classLoader的问题
https://blog.csdn.net/xiangzhihong8/article/details/52880327
http://weishu.me/2016/04/05/understand-plugin-framework-classloader/
插件的原理
https://github.com/wangwangheng/BestBlogReprinted_AndroidNotes/blob/master/%E6%8F%92%E4%BB%B6%E5%BC%8F%E5%BC%80%E5%8F%91/weishu%E7%B3%BB%E5%88%97/1.Android%E6%8F%92%E4%BB%B6%E5%8C%96%E5%8E%9F%E7%90%86%E8%A7%A3%E6%9E%90%E2%80%94%E2%80%94%E6%A6%82%E8%A6%81.md
首先要明白静态代理/动态代理/hook原理机制，静态代理在程序运行前，代理类的.class文件就已经存在了。动态代理类：在程序运行时，运用JDK本身反射机制动态创建而成，如果复杂可能要用cglib；创建出来的对象都集成的相同的接口。动态代理主要设计以下几个方法
Shopping women = new ShoppingImpl();
// 正常购物
System.out.println(Arrays.toString(women.doShopping(100)));
// 招代理
women = (Shopping) Proxy.newProxyInstance(Shopping.class.getClassLoader(),
women.getClass().getInterfaces(), new ShoppingHandler(women));
System.out.println(Arrays.toString(women.doShopping(100)));
public class ShoppingHandler implements InvocationHandler {
Object base;
public ShoppingHandler(Object base) {
this.base = base;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if ("doShopping".equals(method.getName())) {
System.out.println(String.format("花了%s块钱", readCost));
Object[] things = (Object[]) method.invoke(base, readCost);
} else if {}
}
}
但是hook相当于直接改变已有类的静态成员或者单例，hook常用发射的方法，来替换成员达到修改相关类的效果。如下方法：
public static void attachContext() throws Exception{
// 先获取到当前的ActivityThread对象
Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");
Method currentActivityThreadMethod = activityThreadClass.getDeclaredMethod("currentActivityThread");
currentActivityThreadMethod.setAccessible(true);
//currentActivityThread是一个static函数所以可以直接invoke，不需要带实例参数
Object currentActivityThread = currentActivityThreadMethod.invoke(null);
// 拿到原始的 mInstrumentation字段
Field mInstrumentationField = activityThreadClass.getDeclaredField("mInstrumentation");
mInstrumentationField.setAccessible(true);
Instrumentation mInstrumentation = (Instrumentation) mInstrumentationField.get(currentActivityThread);
// 创建代理对象
Instrumentation evilInstrumentation = new EvilInstrumentation(mInstrumentation);
// 偷梁换柱
mInstrumentationField.set(currentActivityThread, evilInstrumentation);
}
binder的hook，可以通过ServiceManager修改掉相关的其中的sCache这个变量即可，然后填相关service。
final String CLIPBOARD_SERVICE = "clipboard";
// 下面这一段的意思实际就是: ServiceManager.getService("clipboard");
// 只不过 ServiceManager这个类是@hide的
Class<?> serviceManager = Class.forName("android.os.ServiceManager");
Method getService = serviceManager.getDeclaredMethod("getService", String.class);
// ServiceManager里面管理的原始的Clipboard Binder对象
// 一般来说这是一个Binder代理对象
IBinder rawBinder = (IBinder) getService.invoke(null, CLIPBOARD_SERVICE);
// Hook 掉这个Binder代理对象的 queryLocalInterface 方法
// 然后在 queryLocalInterface 返回一个IInterface对象, hook掉我们感兴趣的方法即可.
IBinder hookedBinder = (IBinder) Proxy.newProxyInstance(serviceManager.getClassLoader(),
new Class<?>[] { IBinder.class },
new BinderProxyHookHandler(rawBinder));
// 把这个hook过的Binder代理对象放进ServiceManager的cache里面
// 以后查询的时候 会优先查询缓存里面的Binder, 这样就会使用被我们修改过的Binder了
Field cacheField = serviceManager.getDeclaredField("sCache");
cacheField.setAccessible(true);
Map<String, IBinder> cache = (Map) cacheField.get(null);
cache.put(CLIPBOARD_SERVICE, hookedBinder);
binder的ams hook也是通过类似的方法，替换掉了ActivityManagerNative的gDefault变量来替换。
Class<?> activityManagerNativeClass = Class.forName("android.app.ActivityManagerNative");
// 获取 gDefault 这个字段, 想办法替换它
Field gDefaultField = activityManagerNativeClass.getDeclaredField("gDefault");
gDefaultField.setAccessible(true);
Object gDefault = gDefaultField.get(null);
// 4.x以上的gDefault是一个 android.util.Singleton对象; 我们取出这个单例里面的字段
Class<?> singleton = Class.forName("android.util.Singleton");
Field mInstanceField = singleton.getDeclaredField("mInstance");
mInstanceField.setAccessible(true);
// ActivityManagerNative 的gDefault对象里面原始的 IActivityManager对象
Object rawIActivityManager = mInstanceField.get(gDefault);
// 创建一个这个对象的代理对象, 然后替换这个字段, 让我们的代理对象帮忙干活
Class<?> iActivityManagerInterface = Class.forName("android.app.IActivityManager");
Object proxy = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
new Class<?>[] { iActivityManagerInterface },
new IActivityManagerHandler(rawIActivityManager));
mInstanceField.set(gDefault, proxy);
热修复和冷修复的原理
动态加载某一个dex或者jar包，替换有问题的类或者方法或者变量，以达到热修复的功能。热修复行不通的情况下，那么就要等待重新启动，冷启动修复对应的dex的方法或类。那么如何替换呢？
目前有两种方式，参考sophix，热修复第一种方法是底层替换原理，直接替换调ARTMethod结构体，需要适配每一个版本，比较复杂。另外一种是类加载冷启动的多dex全量替换方式，替换dexElements这个dex文件的list使得虚拟机能优先加载修复过的类，从而达到修复效果。
There are three injection points for a given method: before, after, replace.
Example 1: Attach a piece of code before and after all occurrences of Activity.onCreate(Bundle).
// Target class, method with parameter types, followed by the hook callback (XC_MethodHook).
DexposedBridge.findAndHookMethod(Activity.class, "onCreate", Bundle.class, new XC_MethodHook() {
// To be invoked before Activity.onCreate().
@Override protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
// "thisObject" keeps the reference to the instance of target class.
Activity instance = (Activity) param.thisObject;
// The array args include all the parameters.
Bundle bundle = (Bundle) param.args[0];
Intent intent = new Intent();
// XposedHelpers provide useful utility methods.
XposedHelpers.setObjectField(param.thisObject, "mIntent", intent);
// Calling setResult() will bypass the original method body use the result as method return value directly.
if (bundle.containsKey("return"))
param.setResult(null);
}
// To be invoked after Activity.onCreate()
@Override protected void afterHookedMethod(MethodHookParam param) throws Throwable {
XposedHelpers.callMethod(param.thisObject, "sampleMethod", 2);
}
});
Example 2: Replace the original body of the target method.
DexposedBridge.findAndHookMethod(Activity.class, "onCreate", Bundle.class, new XC_MethodReplacement() {
@Override protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
// Re-writing the method logic outside the original method context is a bit tricky but still viable.
...
}
});
Android开源框架源码解析
反射
https://blog.csdn.net/yongjian1092/article/details/7364451
三、JAVA反射机制提供了什么功能
Java反射机制提供如下功能：
在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判段任意一个类所具有的成员变量和方法
在运行时调用任一个对象的方法
在运行时创建新类对象
动态代理
代理：
- 隐藏委托类的实现
- 解耦，不改变委托类代码情况下做一些额外处理，比如添加初始判断及其他公共操作
静态：代理类在程序运行前已经存在的代理方式称为静态代理。静态代理可以理解为对象的组合。
实现动态代理包括三步：
(1). 新建委托类；
(2). 实现InvocationHandler接口，这是负责连接代理类和委托类的中间类必须实现的接口；
(3). 通过Proxy类新建代理类对象。
public class TimingInvocationHandler implements InvocationHandler {
private Object target;
public TimingInvocationHandler() {}
public TimingInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
long start = System.currentTimeMillis();
Object obj = method.invoke(target, args);
System.out.println(method.getName() + " cost time is:" + (System.currentTimeMillis() - start));
return obj;
}
}
public class Main {
public static void main(String[] args) {
// create proxy instance
TimingInvocationHandler timingInvocationHandler = new TimingInvocationHandler(new OperateImpl());
Operate operate = (Operate)(Proxy.newProxyInstance(Operate.class.getClassLoader(), new Class[] {Operate.class},
timingInvocationHandler));
// call method of proxy instance
operate.operateMethod1();
System.out.println();
operate.operateMethod2();
System.out.println();
operate.operateMethod3();
}
}
public Object invoke(Object proxy, Method method, Object[] args)
函数需要去实现，参数：
proxy表示下面2.3 通过 Proxy.newProxyInstance() 生成的代理类对象。
method表示代理对象被调用的函数。
args表示代理对象被调用的函数的参数。
调用代理对象的每个函数实际最终都是调用了InvocationHandler的invoke函数。这里我们在invoke实现中添加了开始结束计时，其中还调用了委托类对象target的相应函数，这样便完成了统计执行时间的需求。
invoke函数中我们也可以通过对method做一些判断，从而对某些函数特殊处理。
这里我们先将委托类对象new OperateImpl()作为TimingInvocationHandler构造函数入参创建timingInvocationHandler对象；
然后通过Proxy.newProxyInstance(…)函数新建了一个代理对象，实际代理类就是在这时候动态生成的。我们调用该代理对象的函数就会调用到timingInvocationHandler的invoke函数(是不是有点类似静态代理)，而invoke函数实现中调用委托类对象new OperateImpl()相应的 method(是不是有点类似静态代理)。
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
loader表示类加载器
interfaces表示委托类的接口，生成代理类时需要实现这些接口
h是InvocationHandler实现类对象，负责连接代理类和委托类的中间类
我们可以这样理解，如上的动态代理实现实际是双层的静态代理，开发者提供了委托类 B，程序动态生成了代理类 A。开发者还需要提供一个实现了InvocationHandler的子类 C，子类 C 连接代理类 A 和委托类 B，它是代理类 A 的委托类，委托类 B 的代理类。用户直接调用代理类 A 的对象，A 将调用转发给委托类 C，委托类 C 再将调用转发给它的委托类 B。
public final class $Proxy0 extends Proxy
implements Operate
{
private static Method m4;
private static Method m1;
private static Method m5;
private static Method m0;
private static Method m3;
private static Method m2;
public $Proxy0(InvocationHandler paramInvocationHandler)
throws
{
super(paramInvocationHandler);
}
public final void operateMethod1()
throws
{
try
{
h.invoke(this, m4, null);
return;
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
从中我们可以看出动态生成的代理类是以$Proxy为类名前缀，继承自Proxy，并且实现了Proxy.newProxyInstance(…)第二个参数传入的所有接口的类。
如果代理类实现的接口中存在非 public 接口，则其包名为该接口的包名，否则为com.sun.proxy。
其中的operateMethod1()、operateMethod2()、operateMethod3()函数都是直接交给h去处理，h在父类Proxy中定义为
protected InvocationHandler h;
即为Proxy.newProxyInstance(…)第三个参数。
所以InvocationHandler的子类 C 连接代理类 A 和委托类 B，它是代理类 A 的委托类，委托类 B 的代理类。
Anotation注解
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Inherited
public @interface MethodInfo {
String author() default "trinea@gmail.com";
String date();
int version() default 1;
}
public class App {
@MethodInfo(
author = “trinea.cn+android@gmail.com”,
date = "2014/02/14",
version = 2)
public String getAppName() {
return "trinea";
}
}
public static void main(String[] args) {
try {
Class cls = Class.forName("cn.trinea.java.test.annotation.App");
for (Method method : cls.getMethods()) {
MethodInfo methodInfo = method.getAnnotation(
MethodInfo.class);
if (methodInfo != null) {
System.out.println("method name:" + method.getName());
System.out.println("method author:" + methodInfo.author());
System.out.println("method version:" + methodInfo.version());
System.out.println("method date:" + methodInfo.date());
}
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
依赖注入
通过 @Inject 注解了构造函数之后，在 Activity 中的 Boss 属性声明之前也添加 @Inject 注解。像这种在属性前添加的 @Inject 注解的目的是告诉 Dagger 哪些属性需要被注入。
public class MainActivity extends Activity {
@Inject Boss boss;
...
}
最后，我们在合适的位置(例如 onCreate() 函数中)调用 ObjectGraph.inject() 函数，Dagger 就会自动调用上面 (1) 中的生成方法生成依赖的实例，并注入到当前对象(MainActivity)。
public class MainActivity extends Activity {
@Inject Boss boss;
@Override
protected void onCreate(Bundle savedInstanceState) {
ObjectGraph.create(AppModule.class).inject(this);
}
...
}
具体怎么注入即设置的过程后面会详细介绍，这里简单透露下，APT 会在 MainActivity 所在 package 下生成一个辅助类 MainActivity$$InjectAdapter，这个类有个 injectMembers() 函数，代码类似：
public void injectMembers(MainActivity paramMainActivity) {
paramMainActivity.boss = ((Boss)boss.get());
……
}
上面我们已经通过 ObjectGraph.inject() 函数传入了 paramMainActivity，并且 boss 属性是 package 权限，所以 Dagger 只需要调用这个辅助类的 injectMembers() 函数即可完成依赖注入，这里的 boss.get() 会调用 Boss 的生成函数。
到此为止，使用 Dagger 的 @Inject 方式将一个 Boss 对象注入到 MainActivity 的流程就完成了。
public class Human {
...
@Inject Father father;
...
public Human() {
}
}
public class Human {
...
Father father;
...
public Human() {
father = new Father();
}
}
网友评论