动态代理及实际应用

先回顾一下代理模式

代理模式分动态代理和静态代理，写起来也比较简单，先上代码：

public interface Goal {
     
    void sayHello();//定义一个接口，声明好要做的事儿
}

然后实现他，真实的目的

public class RealGoal implements Goal {
     

    @Override
    public void sayHello() {
     
        System.out.println("hello! think you very much!");
    }
}

这时候我们想打印hello! think you very much!，只需要 new RealGoal().sayHello(); 这样只执行代码就可以，但是既然是代理模式，肯定不能这样亲自动手，要找个代理人执行，所以还要创建个代理人

public class ProxyGoal implements Goal {
     

    private Goal goal;

    public ProxyGoal(Goal goal) {
     
        this.goal = goal;
    }

    @Override
    public void sayHello() {
     
        goal.sayHello();
    }
}

如何具体应用呢？

public class Test {
     

    public static void main(String[] args) {
     

        Goal realGoal = new RealGoal();

        Goal proxyGoal = new ProxyGoal(realGoal);
        proxyGoal.sayHello();
    }
}

执行结果：

**刚开始学的时候，不知道你们有没有和我一样，有那种脱裤子放屁多此一举的感觉，既然我们想执行sayHello()，直接用realGoal.sayHello()就完了呗，为什么还要搞一个代理类呢？？？？？？？？**在回答这个问题之前，再来看看动态代理怎么写！

public class GoalHandler implements InvocationHandler {
     

    Object object;

    public GoalHandler(Object object) {
     
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     
        System.out.println("I'm Proxy, I'm invoking...");
        method.invoke(object, args);
        System.out.println("invoke end!");
        return null;
    }
}

执行测试

    public static void main(String[] args) {
     

        Goal realGoal = new RealGoal();

        InvocationHandler goalHandler = new GoalHandler(realGoal);

        Goal dynamicProxyGoal = (Goal) Proxy.newProxyInstance(realGoal.getClass().getClassLoader(), realGoal.getClass().getInterfaces(), goalHandler);
        dynamicProxyGoal.sayHello();
    }

动态代理其实也一样，也多此一举，所以一定要结合使用场景，设计模式才有意义。这个代理模式很简单吧，顾名思义，多出来一个代理人，相当于你从基层员工直接变领导了，比如你想发个快递，本来你要亲自跟快递员打交道，但是代理模式让你拥有了一个小弟(proxy)，有什么事儿你就叫你小弟去办理，然后你小弟再去找快递；当然这个事儿还可以是买烟，具体什么事儿无所谓，重点是多了一个小弟，而且这个小弟完全在你的掌握之中.

使用场景1：动态代理+反射 实现hook技术

hook技术很简单，所谓hook点有点找后门的意思，只要找到hook点，就可以，现在模拟一个场景，android里面有个ActivityManagerNative，这个对象，他是和AMS进行通信的对象，所有的startActivity方法最后都要经过它里面的binder对象发送给AMS，这部分没看过源码的同学可能不懂，不过不要紧这不是重点；重点是这些类 这些对象正常情况下都是遥不可及的，我们无法直接使用他们；但是通过动态代理+反射就可以，这时候我们就可以走后门了，我们可以监听到startActvity的一些信息，从而做自己的手脚，先来写个小demo
代码结构很简单，system下代表系统级别的类，我们正常开发是无法使用的；我们能使用的只有应用层的Activity如图

Activity就是模拟我们android里的android.app.Activity 先来看结构，system下

public interface IActivityManager {
     

    int startActivity(String intent);
}

public class ActivityManagerNative {
     

    public static IActivityManager binder = new ActivityManagerImpl();

    public static IActivityManager gDefault() {
     
        return binder;
    }
}

public class Log {
     

    public static void i(String tag, String value) {
     
        System.out.println(tag+" : "+value);
    }
}

public class ActivityManagerImpl implements IActivityManager {
     
    @Override
    public int startActivity(String intent) {
     
        System.out.println("我是AMS，将要启动activity对象是: "+intent);
        return 0;
    }
}

再来看application包下的activity

public class Activity {
     

    public void statActivity(String i) {
     
        ActivityManagerNative.gDefault().startActivity(i);
    }

}

上面这些都是已经存在的类，我们这时候自定义一个activity，并且执行startActvity方法，告诉系统我们要启动的Activity是哪个

public class MainActivity extends Activity {
     

    public static void main(String[] args) {
     

        MainActivity mainActivity = new MainActivity();
        mainActivity.statActivity("MainActivity");

    }
}

执行结果：

那么问题来了！，我要在不影响正常开发的时候，我要对运行结果进行更改如何做？接着写一个类，里面包含了一个逻辑，检测要启动的activity是否包含NeedLogin，如果包含NeedLogin则直接打印LoginActivity，如果不包含就正常打印，不做改变

import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class HookUtil {
     

    private static final String TAG = "HookUtil";

    /**
     * 获取IActivityManager对象  将其替换掉
     * 这里需要动态代理；
     * 动态代理也是个时髦的技术；
     */
    public void hookActivityStart() {
     
        try {
     
            //获取ActivityManager类
            Class<?> activityManagerClass = Class.forName("com.example.myapplication.system.ActivityManagerNative");
            //获取其IActivityManagerSingleton属性
            Field iActivityManagerSingleton = activityManagerClass.getDeclaredField("binder");
            iActivityManagerSingleton.setAccessible(true);

            Object binder = iActivityManagerSingleton.get(activityManagerClass);

            HookHandler hookHandler = new HookHandler(binder);
            Object proxyInstance = Proxy.newProxyInstance(binder.getClass().getClassLoader(), binder.getClass().getInterfaces(), hookHandler);

            //proxyInstance代理IActivityManager
            iActivityManagerSingleton.set(activityManagerClass, proxyInstance);
        } catch (ClassNotFoundException e) {
     
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
     
            e.printStackTrace();
        } catch (IllegalAccessException e) {
     
            e.printStackTrace();
        }
    }

    class HookHandler implements InvocationHandler {
     

        private Object object;

        public HookHandler(Object object) {
     
            this.object = object;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     
            //拦截startActivity()方法
            String name = method.getName();
            Log.i(TAG, "调用" + name + "方法了");
            if ("startActivity".contains(name)) {
     
//                Log.i(TAG, "调用startActivity方法了");
                //获取intent参数
                for (int i = 0; i < args.length; i++) {
     
                    Object arg = args[i];
                    if (arg instanceof String) {
     
                        if(((String) arg).contains("NeedLogin"))//此处判断逻辑，如果里面包含NeedLogin，则跳转LoginActivity，否则就正常执行
                            args[i] = "LoginActivity";
                    }
                }
            }

            return method.invoke(object, args);
        }
    }

}

然后我们写测试的时候这样写

public class MainActivity extends Activity {
     

    public static void main(String[] args) {
     

        HookUtil hookUtil = new HookUtil();
        hookUtil.hookActivityStart();

        MainActivity mainActivity = new MainActivity();
        mainActivity.statActivity("MainActivity");
        mainActivity.statActivity("MineActivityNeedLogin");

    }
}

执行结果：

我们可以看，字符串里包含NeedLogin的执行结果集完全变了，这就是典型的动态代理+反射 实现的hook结束、一般插件化、热修复或者某些场景都需要用到。

AOP(面向切面编程)

AOP的全称是Aspect-Oriented Programming，即面向切面编程（也称面向方面编程）。它是面向对象编程（OOP）的一种补充，目前已成为一种比较成熟的编程方式。就是一种编程思想。代码注入是AOP中的重要部分：AOP可用于日志埋点、性能监控、动态权限控制、甚至是代码调试等等。实现AOP的一个方式就有动态代理的模式，未完待续…