知识总结之 插件化基础 java反射与代理

Java平台的反射机制是代码动态加载和调用的基本途径，在安卓系统源码中也用到了大量的反射动态加载类。反射也是安卓平台插件化实现的必要掌握的基础知识。代理是客户端灵活操作对象，间接的低耦合度操作对象的有效途径，也是插件化必要掌握知识。

安卓插件化基础 java反射与代理

一、反射

java中反射机理比较常用，这里主要以代码实例展示其用法。

什么是反射？

指程序运行时 加载、获取一个未知类（已知类名）及类属性和方法的java技术机理。加载完成后会在虚拟机中产生一个class对象，一个类只有一个class对象，这个class对象包含了类的相关结构信息。
这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

Class对象如何获取？

• 1. 运用Class.forName(String className)动态加载类；
• 1. .class 属性（轻量级）；
• 1. getClass()方法；

对象的创建

• 使用Class对象的newInstance()方法来创建该Class对象对应类的实例，这种方式要求该Class对象的对应类有默认构造器。
• 先使用Class对象获取指定的Constructor对象, 再调用Constructor对象的newInstance()。通过这种方式可以选择指定的构造器来创建实例。

//Class 类 newInstance源码  @CallerSensitive    public T newInstance()        throws InstantiationException, IllegalAccessException    {        if (System.getSecurityManager() != null) {            checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);        }        // NOTE: the following code may not be strictly correct under        // the current Java memory model.        // Constructor lookup        if (cachedConstructor == null) {            if (this == Class.class) {                throw new IllegalAccessException(                    "Can not call newInstance() on the Class for java.lang.Class"                );            }            try {                Class<?>[] empty = {};                final Constructor<T> c = getConstructor0(empty, Member.DECLARED);//默认构造器                // Disable accessibility checks on the constructor                // since we have to do the security check here anyway                // (the stack depth is wrong for the Constructor's                // security check to work)                java.security.AccessController.doPrivileged(                    new java.security.PrivilegedAction<Void>() {                        public Void run() {                                c.setAccessible(true);                                return null;                            }                        });                cachedConstructor = c;            } catch (NoSuchMethodException e) {                throw (InstantiationException)                    new InstantiationException(getName()).initCause(e);            }        }        Constructor<T> tmpConstructor = cachedConstructor;        // Security check (same as in java.lang.reflect.Constructor)        int modifiers = tmpConstructor.getModifiers();        if (!Reflection.quickCheckMemberAccess(this, modifiers)) {            Class<?> caller = Reflection.getCallerClass();            if (newInstanceCallerCache != caller) {                Reflection.ensureMemberAccess(caller, this, null, modifiers);                newInstanceCallerCache = caller;            }        }        // Run constructor        try {            return tmpConstructor.newInstance((Object[])null);        } catch (InvocationTargetException e) {            Unsafe.getUnsafe().throwException(e.getTargetException());            // Not reached            return null;        }    }

相关Api相关实例

先定义一个bean类作为反射对象

 public class CankingBean extends Canking implements ICanking {    private String name;    private int id;    public CankingBean() {        //Nothing    }    public CankingBean(int id, String name) {        this.id = id;        this.name = name;    }    public String getName() {        return name;    }    public void setName(String n) {        this.name = n;    }    public int getId() {        return id;    }    public void setId(int i) {        this.id = i;    }    @Override    public void createApp() {        //nothing    } }

1.对象实例化

     CankingBean bean = null, bean1 = null;        Class test = null;        try {            test = Class.forName("com.canking.CankingBean");        } catch (Exception e) {            e.printStackTrace();        }        Constructor cons[] = test.getConstructors();        System.out.println("cons.len:" + cons.length + " name:" + test.getName() + " simpleName:" + test.getSimpleName() + " Canonical:" + test.getCanonicalName() + " type:" + test.getTypeName());        try {            bean = (CankingBean) cons[0].newInstance();            bean1 = (CankingBean) cons[1].newInstance(1, "canking");        } catch (Exception e) {            e.printStackTrace();        }        System.out.println("bean.id:" + bean.getId() + " bean.name:" + bean.getName() + " b1.id:" + bean1.getId() + " b1.name:" + bean1.getName());

2. 获取实现接口列表

    Class<?> intes[]=test.getInterfaces();  

3.获取父类

 Class<?> temp=demo.getSuperclass();  

4.获取类属性

  Field[] fields = test.getDeclaredFields();//本类属性        for (Field f : fields) {            int modifier = f.getModifiers();//修饰符            String modiStr = Modifier.toString(modifier);            Class type = f.getType();            System.out.println(f.getName() + " || modifier:" + modiStr + " type:" + type.getName());        }        System.out.println("\n");        Field[] fieldsAll = test.getFields();//接口中属性        for (Field f : fieldsAll) {            int modifier = f.getModifiers();//修饰符            String modiStr = Modifier.toString(modifier);            Class type = f.getType();            System.out.println(f.getName() + " || modifier:" + modiStr + " type:" + type.getName());        }

想要获取父类中属性怎么办？getSuperclass()先获取父类实例，然后调用getDeclaredFields（）获取。可以依次遍历super类，获得全部继承关系中的属性。

5.获取类方法

  Method method[] = test.getMethods(); //获取类及继承关系中的所有类方法        for(Method m : method){            Class<?> returnType = m.getReturnType();            Class<?> para[] = m.getParameterTypes();            int temp = m.getModifiers();            System.out.println(m.getName()+" returnType:"+returnType+" modifiers:"+Modifier.toString(temp));            for(Class c : para){                System.out.println(" c name:"+c.getName());            }        }

6.方法及属性的操作

       try {            Method ms = test.getMethod("setName", String.class);            Method mg = test.getMethod("getName");            Object obj = test.newInstance();            ms.invoke(obj, "New name");            System.out.println("name:" + mg.invoke(obj));            Field canking = test.getDeclaredField("name");            canking.setAccessible(true);//禁用权限检测            canking.set(obj, "Name Modified!");            System.out.println("name:" + canking.get(obj));        } catch (Exception e) {            e.printStackTrace();        }

二、代理

什么是java代理模式？

代理用到类反射的知识，这里进一步单独讲解加深理解。

对某个对象提供一个代理对象，使得我们可以通过代理对象间接的操作原对象。

静态代理：代码层通过设计类获得一个中间层代理，是在编译时已经实现好的，可以说是一个class文件。
动态代理：代理类是在运行时由java机理产生。起到动态调用和操作代码的目的。

由于静态代理比较简单，易于理解，本文主要讲解动态代理。

基本概念

InvocationHandler接口
代理类调用任何方法都会经过这个调用处理器类的invoke方法。

Proxy
主要用于产生代理类，通过 Proxy 类生成的代理类都继承了 Proxy 类。newProxyInstance方法封装了获取代理对象。

newProxyInstance(ClassLoader loader, Class

动态代理实现方法

个人学习习惯，学习新知识，先了解大概，然后就是代码，最后看原理，有精力的话就写点东西分享出来。这里就先看下代码如何实现一个动态代理。

只要一个类满足代理条件，即可实现代理。

 public class CankingProxyHandler implements InvocationHandler {    private Object object;    public CankingProxyHandler(Object obj){        this.object= obj;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        System.out.println("Proxy method in");        if ("setName".equals(method.getName())) {            return method.invoke(object, "Proxy");        }        return method.invoke(object, args);    } }

        CankingProxyHandler proxyHandler = new CankingProxyHandler(bean1);        ICanking cProxy = (ICanking) Proxy.newProxyInstance(CankingBean.class.getClassLoader(), CankingBean.class.getInterfaces(), proxyHandler);        cProxy.createApp();

代理类的每次方法调用，都会触发proxyHandler的invoke方法，这样我们就可以在此时做一些自己的事情。

android系统中有些类也是满足代理条件的，这样我们同样可以做一个代理类，来实现hook系统部分方法的目的。

实现原理

首先来看下newProxyInstance源码

    @CallerSensitive    public static Object newProxyInstance(ClassLoader loader,                                          Class<?>[] interfaces,                                          InvocationHandler h)        throws IllegalArgumentException    {        Objects.requireNonNull(h);        final Class<?>[] intfs = interfaces.clone();        final SecurityManager sm = System.getSecurityManager();        if (sm != null) {            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);        }        /*         * Look up or generate the designated proxy class.         */        Class<?> cl = getProxyClass0(loader, intfs); //代理类生成关键方法        /*         * Invoke its constructor with the designated invocation handler.         */        try {            if (sm != null) {                checkNewProxyPermission(Reflection.getCallerClass(), cl);            }            final Constructor<?> cons = cl.getConstructor(constructorParams);            final InvocationHandler ih = h;            if (!Modifier.isPublic(cl.getModifiers())) {                AccessController.doPrivileged(new PrivilegedAction<Void>() {                    public Void run() {                        cons.setAccessible(true);                        return null;                    }                });            }            return cons.newInstance(new Object[]{h});        } catch (IllegalAccessException|InstantiationException e) {            throw new InternalError(e.toString(), e);        } catch (InvocationTargetException e) {            Throwable t = e.getCause();            if (t instanceof RuntimeException) {                throw (RuntimeException) t;            } else {                throw new InternalError(t.toString(), t);            }        } catch (NoSuchMethodException e) {            throw new InternalError(e.toString(), e);        }    }

可以看出getProxyClass0()方法为生成代理类关键方法

    /**     * Generate a proxy class.  Must call the checkProxyAccess method     * to perform permission checks before calling this.     */    private static Class<?> getProxyClass0(ClassLoader loader,                                           Class<?>... interfaces) {        if (interfaces.length > 65535) {            throw new IllegalArgumentException("interface limit exceeded");        }        // If the proxy class defined by the given loader implementing        // the given interfaces exists, this will simply return the cached copy;        // otherwise, it will create the proxy class via the ProxyClassFactory        return proxyClassCache.get(loader, interfaces);    }

看到源码注释，如果代理类在传入的classloader中已经加载则直接返回，否则会在ProxyClassFactory中生成。

proxyClassCache.get方法中有以下代码

        // create subKey and retrieve the possible Supplier<V> stored by that        // subKey from valuesMap        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));        Supplier<V> supplier = valuesMap.get(subKey);

结合代码和注释可以大概看出subKeyFactory.apply(key, parameter)返回的就是代理类

那我们具体看看apply是怎么生产我们的代理类的：

        @Override        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);            for (Class<?> intf : interfaces) {                /*                 * Verify that the class loader resolves the name of this                 * interface to the same Class object.                 */                Class<?> interfaceClass = null;                try {                    interfaceClass = Class.forName(intf.getName(), false, loader);//加载原始接口                } catch (ClassNotFoundException e) {                }                if (interfaceClass != intf) {                    throw new IllegalArgumentException(                        intf + " is not visible from class loader");                }                /*                 * Verify that the Class object actually represents an                 * interface.                 */                if (!interfaceClass.isInterface()) {                    throw new IllegalArgumentException(                        interfaceClass.getName() + " is not an interface");                }                /*                 * Verify that this interface is not a duplicate.                 */                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {                    throw new IllegalArgumentException(                        "repeated interface: " + interfaceClass.getName());                }            }            String proxyPkg = null;     // package to define proxy class in            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;            /*             * Record the package of a non-public proxy interface so that the             * proxy class will be defined in the same package.  Verify that             * all non-public proxy interfaces are in the same package.             */            for (Class<?> intf : interfaces) {//解析原始接口                int flags = intf.getModifiers();                if (!Modifier.isPublic(flags)) {                    accessFlags = Modifier.FINAL;                    String name = intf.getName();                    int n = name.lastIndexOf('.');                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));                    if (proxyPkg == null) {                        proxyPkg = pkg;                    } else if (!pkg.equals(proxyPkg)) {                        throw new IllegalArgumentException(                            "non-public interfaces from different packages");                    }                }            }            if (proxyPkg == null) {                // if no non-public proxy interfaces, use com.sun.proxy package                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";            }            /*             * Choose a name for the proxy class to generate.             */            long num = nextUniqueNumber.getAndIncrement();            String proxyName = proxyPkg + proxyClassNamePrefix + num;//构造代理类名            /*             * Generate the specified proxy class.             */            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(                proxyName, interfaces, accessFlags);//生产代理类            try {                return defineClass0(loader, proxyName,                                    proxyClassFile, 0, proxyClassFile.length);            } catch (ClassFormatError e) {                /*                 * A ClassFormatError here means that (barring bugs in the                 * proxy class generation code) there was some other                 * invalid aspect of the arguments supplied to the proxy                 * class creation (such as virtual machine limitations                 * exceeded).                 */                throw new IllegalArgumentException(e.toString());            }        }

最终ProxyGenerator.generateProxyClass方法中产生类代理类并写入磁盘。这种操作代码的代码java总称为元编程，java SOURCE级别的注解中也会大量用到。

代理类最终生产的样子如下：

public final class $Proxy1 extends Proxy implements Subject{    private InvocationHandler h;    private $Proxy1(){}    public $Proxy1(InvocationHandler h){        this.h = h;    }    public int request(int i){        Method method = Subject.class.getMethod("method", new Class[]{int.class});    //创建method对象        return (Integer)h.invoke(this, method, new Object[]{new Integer(i)}); //调用了invoke方法    }}

从代理来结构，可以看出为什么每次方法的调用都会掉到invocationHandler的invoke方法。

——————
欢迎转载，请标明出处：常兴E站 www.canking.win