java 动态代理

前言

前两天看了一个插件化的相关视频，在其中用到了很多反射和动态代理的相关知识，之前也学习过相关的知识但是没有理解。然后一直觉得反射和动态代理没啥用，但学习了插件化后觉得这个两个技术还真是厉害。

首先如果有基础基础知识欠缺的先看看相关文章
反射的使用
动态代理

实现需求

在android插件化hook的过程中，当要直接启动一个插件Activity的时候是不行的，插件Activity是要宿主App中进行注册。那么为了能启动插件Activity，首先需要在宿主APP中添加Activity代理,在要启动插件Activity的时候去启动代理Activity（这里需要替换Intent参数），要去骗过AMS的检测，当经过AMS的验证后再将代理Activity替换回插件Activity.
那么上述的过程就需要用到反射获取系统类，还需要用到动态代理去更改参数。
那么我基于上面的要求能不能实现一个功能：使用动态代理修改接口B中的一个方法参数，再使用反射将A类中的B接口进行替换

实现

下面的实现就是当调用person.onSubmit("工资流水在此")的时候会将你传入的参数进行替换为工资流水在此,还有社保

public interface ILawSuit {
    void submit(String proof);

    String defend();
}

在Person类中设置一个ILawSuit接口，这里设置为静态，当我们在业务场景中需要获取一个对象中的值的时候，尽量去取是静态属性类或者是单利的类，这样的类在初始化后一般不容易改变。

public class Person {
    private static ILawSuit iLawSuit;

    public Person(ILawSuit iLawSuit) {
        this.iLawSuit = iLawSuit;
    }

    public void onSubmit(String proof) {
        if (iLawSuit != null) {
            iLawSuit.submit(proof);
        }
    }
}

这里是代理类实现实现InvocationHandler接口
这里要注意invoke的三个参数

1. proxy： 调用该方法的代理实例
2. method：该代理类实例所拥有的方法
3. args：方法所对应的参数

这里可以去看一下动态代理为什么必须要接口，这个与java不能多继承有关，为了通过实现的方式来建立与我们需要代理的类的联系，所以这里必须用到接口。可以深入的理解下这里。

对于method.invoke(iActivityManager, args) 方法你可以理解是调用iActivityManager的method方法，这个方法的参数是args，这样去确定是哪一个方法。

public class SuitProxy implements InvocationHandler {


    private Object iActivityManager;

    public SuitProxy(Object iActivityManager) {
        this.iActivityManager = iActivityManager;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法名称：" + method.getName());

        if (method.getName().equals("submit")) {
            //动态代理修改方法参数
            for (int i = 0; i < args.length; i++) {
                if (args[i].equals("工资流水在此")) {
                    args[i] = "工资流水在此,还有社保";
                    break;
                }
            }
        }
        Object result = method.invoke(iActivityManager, args);
        System.out.println("\n" + "方法名称返回值：" + result);
        return result;
    }
}

hook() 方法是最关键的， 首先要声明下Person中的ILawSuit是静态的，如果不是静态那么要这么写呢？我们先看静态的。
下面的关键地方是
Object myProxy = Proxy.newProxyInstance(c.getClassLoader(), new Class[]{c}, new SuitProxy(iLawSuit));

这里一定要理解newProxyInstance的三个参数

1. ClassLoader 一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
2. Class<?>[] 一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
3. 一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上

再看我传递的newProxyInstance中的三个参数就明白了

然后使用反射替换Person中的接口，fieldILawSuit.set(c, myProxy);

public class HookUtil {
   /**
     * Person 里 ILawSuit静态的
     */
    public static void hook() {
        //首先等获取实例person,因为测试时时你需要自己创建一个，去替换你创建的实例中的要代理的对象
        try {
            Class clazz = Class.forName("com.hongliang.design.demo.proxy2.Person");
            //获取实例中的某一个成员变量Field
            Field fieldILawSuit = clazz.getDeclaredField("iLawSuit");
            //设置作用域
            fieldILawSuit.setAccessible(true);
            //获取到这个类
            Object iLawSuit = fieldILawSuit.get(null);

            //发射生成你要代理的类，代理是必须要接口的，这个就是一个接口类
            Class c = Class.forName("com.hongliang.design.demo.proxy.ILawSuit");
            //newProxyInstance的三个参数：第一个获取一个classLoader,需要代理的接口，代理的时候要执行的InvocationHandler
            //后面三个参数很关键 Thread.currentThread().getContextClassLoader()
            Object myProxy = Proxy.newProxyInstance(c.getClassLoader(), new Class[]{c}, new SuitProxy(iLawSuit));
            fieldILawSuit.set(c, myProxy);

        } catch (NoSuchFieldException | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

测试的时候注意HookUtil.hook();是在new Person之后调用，不然反射获取clazz.getDeclaredField("iLawSuit")的时候是获取不到的Person里面的接口。
我们也需要理解静态接口为什么就能直接反射获取。所以我们需要知道虚拟机加载流程，同时问一个问题Class.forName和ClassLoaderd都能加载类，这个两个有什么区别，可以去了解。

	public class Test {
     Person person = new Person(new ILawSuit() {
            @Override
            public void submit(String proof) {
                Log.d("==" + proof);
            }

            @Override
            public String defend() {
                return null;
            }
        });
        HookUtil.hook();
        person.onSubmit("工资流水在此");
}

如果你看完上面类容，相信你应该对动态代理和反射有一定理解了，那如果Person类中的private static ILawSuit iLawSuit;不是静态，那上面的hook还可以成功吗？你可以改写一下
如果是非静态的需要你传入你new的Person

 /**
     * Person 里 ILawSuit是非静态的
     *
     * @param person
     */
    public static void hook(Person person) {
        //首先等获取实例person,因为测试时时你需要自己创建一个，去替换你创建的实例中的要代理的对象

        try {
            //   Class clazz = Class.forName("com.hongliang.design.demo.proxy2.Person");

            Class<?> clazz = person.getClass();
            //获取实例中的某一个成员变量Field
            Field fieldILawSuit = clazz.getDeclaredField("iLawSuit");
            //设置作用域
            fieldILawSuit.setAccessible(true);
            //获取到这个类
            Object iLawSuit = fieldILawSuit.get(person);

            //发射生成你要代理的类，代理是必须要接口的，这个就是一个接口类
            Class c = Class.forName("com.hongliang.design.demo.proxy.ILawSuit");
            //newProxyInstance的三个参数：第一个获取一个classLoader,需要代理的接口，代理的时候要执行的InvocationHandler
            //后面三个参数很关键 Thread.currentThread().getContextClassLoader()
            Object myProxy = Proxy.newProxyInstance(c.getClassLoader(), new Class[]{c}, new SuitProxy(iLawSuit));
            fieldILawSuit.set(person, myProxy);

        } catch (NoSuchFieldException | IllegalAccessException | ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

Class.forName和ClassLoaderd的区别