Android热更新二:理解Java反射

很早之前就想深入的研究和学习一下热修复,由于时间的原因一直拖着,现在才执笔弄起来。

Android而更新系列:
Android热更新一:JAVA的类加载机制
Android热更新二:理解Java反射
Android热更新三:Android类加载机制
Android热更新四:热修复机制
Android热更新五:四大热修复方案分析
Android热更新六:Qzone热更新原理
Android热更新七:Tinker热更新原理
Android热更新八:AndFix热更新原理
Android热更新九:Robust热更新原理
Android热更新十:自己写一个Android热修复

既然本次主题是热修复,在深入研究之前,要先搞清楚它涉及到的关键技术

类加载机制
Java反射

正所谓磨刀不误砍柴工,我们这个笔记将对Java反射进行初步学习和理解。
学习Java反射之前,我们应该先了解JAVA的类加载机制

三. 反射

1. 运行时类型信息

要想理解反射的原理,首先要了解什么是类型信息。

并不是所有的Class都能在编译时明确,因此在某些情况下需要在运行时再发现和确定类型信息(比如:基于构建编程,),这就是RTTI(Runtime Type Information,运行时类型信息)。

在java中,有两种RTTI的方式,

  • 一种是传统的,即假设在编译时已经知道了所有的类型;
  • 还有一种,是利用反射机制,在运行时再尝试确定类型信息。

严格的说,反射也是一种形式的RTTI,不过,一般的文档资料中把RTTI和反射分开,因为一般的,大家认为RTTI指的是传统的RTTI,通过继承和多态来实现,在运行时通过调用超类的方法来实现具体的功能(超类会自动实例化为子类,或使用instance of)。

2. 反射及实现方式

那到底什么是反射(Reflection)呢?反射有时候也被称为内省(Introspection),事实上,反射,就是一种内省的方式,Java不允许在运行时改变程序结构或类型变量的结构,但它允许在运行时去探知、加载、调用在编译期完全未知的class,可以在运行时加载该class,生成实例对象(instance object),调用method,或对field赋值。这种类似于“看透”了class的特性被称为反射(Reflection),我们可以将反射直接理解为:可以看到自己在水中的倒影,这种操作与直接操作源代码效果相同,但灵活性高得多。

关于Java的反射API,没必要去记忆,可以在任何JDK API中查询即可:

Class类:http://www.ostools.net/uploads/apidocs/jdk-zh/java/lang/Class.html

reflect包:http://www.ostools.net/uploads/apidocs/jdk-zh/java/lang/reflect/package-summary.html

实现方式
package myblog.rtti;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class ToyReflection {
    public static void printInfo(String info, Object obj) {
        if (obj.getClass().isArray()) {
            System.out.println(info + ": ");
            int length = Array.getLength(obj);
            System.out.println("Array Size: " + length);
            for (int i = 0; i < length; i++) {
                System.out.print("Array[" + i + "]: " + Array.get(obj, i) + ", ");
            }
            if (length != 0)
                System.out.println();
        }
        System.out.println(info + ": " + obj.toString());
    }

    public static void main(String[] args) {
        try { // 获得类对象
            Class<?> c = Class.forName("myblog.rtti.Toy");
            printInfo("获得类对象", c); // 获得超类
            Class<?> superClass = c.getSuperclass();
            printInfo("获得超类", superClass); // 获得所有父接口
            Class<?>[] interfaces = c.getInterfaces();
            printInfo("获得所有父接口", interfaces); // 实例化
            Toy toy = (Toy) c.newInstance();
            printInfo("实例化", toy); // 获得访问属性为public的构造方法
            Constructor<?>[] constructors = c.getConstructors();
            printInfo("获得构造方法", constructors); // 获得指定参数的构造方法
            Constructor<?> constructor = c.getDeclaredConstructor(String.class, String.class, int.class);
            printInfo("获得指定构造方法", constructor); // 获得方法,getMethod只能获得public方法,包括父类和接口继承的方法
            Method method = c.getMethod("playToy", String.class);
            printInfo("获得公有方法", method); // 调用方法
            method.invoke(toy, "张三"); // 获得修饰符,包括private/public/protect,static
            String modifier = Modifier.toString(method.getModifiers());
            printInfo("获得修饰符", modifier); // 获得参数类型
            Class<?>[] paramTypes = method.getParameterTypes();
            printInfo("获得参数类型", paramTypes); // 获得返回值类型
            Class<?> returnType = method.getReturnType();
            printInfo("获得返回值类型", returnType); // 获得异常类型
            Class<?>[] excepTypes = method.getExceptionTypes();
            printInfo("获得异常类型", excepTypes); // 调用私有方法,getDeclaredMethod获得类自身的方法,包括public,protect,private方法
            Method method2 = c.getDeclaredMethod("buildMsg", String.class);
            method2.setAccessible(true);
            String result = (String) method2.invoke(toy, "李四");
            printInfo("获得私有方法", result); // 获得全部属性
            Field[] fields = c.getFields();
            printInfo("获得全部属性", fields); // 获得类自身定义的指定属性
            Field field = c.getDeclaredField("name");
            printInfo("获得自身属性", field); // 获得类及其父类,父接口定义的public属性
            Field field2 = c.getField("color");
            printInfo("获得公有属性", field2); // 获得权限修饰符,包括private/public/protect,static,final
            String fieldModifier = Modifier.toString(field.getModifiers());
            printInfo("获得权限修饰符", fieldModifier); // 操作数组
            int[] exampleArray = {1, 2, 3, 4, 5}; // 获得数组类型
            Class<?> componentType = exampleArray.getClass().getComponentType();
            printInfo("数组类型", componentType.getName()); // 获得长度
            printInfo("数组长度", Array.getLength(exampleArray)); // 获得指定元素
            printInfo("获得数组元素", Array.get(exampleArray, 2)); // 修改指定元素
            Array.set(exampleArray, 2, 6);
            printInfo("修改数组元素", exampleArray); // 获得当前的类加载器
            printInfo("获得当前类加载器", toy.getClass().getClassLoader().getClass().getName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }

    }
}

通过上面的代码,可以清晰的理解如何“在水中看到自己”,不过需要注意的有几点:

  • 1,在java的反射机制中,getDeclaredMethod得到的是全部方法,getMethod得到的是公有方法;
  • 2,反射机制的setAccessible可能会破坏封装性,可以任意访问私有方法和私有变量;
  • 3,setAccessible并不是将private改为public,事实上,public方法的accessible属性也是false的,setAccessible只是取消了安全访问控制检查,所以通过设置setAccessible,可以跳过访问控制检查,执行的效率也比较高。参考:http://blog.csdn.net/devilkin64/article/details/7766792

3. 反射的性能

反射机制给予Java开发很大的灵活性,但反射机制本身也有缺点,代表性的缺陷就是反射的性能,一般来说,通过反射调用方法的效率比直接调用的效率要至少慢一倍以上。

关于性能的问题,可以参考这篇博客http://blog.csdn.net/l_serein/article/details/6219897

4. 反射与设计模式

反射的一个很重要的作用,就是在设计模式中的应用,包括在工厂模式和代理模式中的应用。

动态代理

代理模式是为了提供额外或不同的操作,而插入的用来替代”实际”对象的对象,这些操作涉及到与”实际”对象的通信,因此代理通常充当中间人角色。Java的动态代理比代理的思想更前进了一步,它可以动态地创建并代理并动态地处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理器上,它的工作是揭示调用的类型并确定相应的策略。以下是一个动态代理示例:

接口和实现类:

  public interface Interface {
        void doSomething();

        void somethingElse(String arg);
    }

    public class RealObject implements Interface {
        public void doSomething() {
            System.out.println("doSomething.");
        }

        public void somethingElse(String arg) {
            System.out.println("somethingElse " + arg);
        }
    }

动态代理对象处理器:

    public class DynamicProxyHandler implements InvocationHandler {
        private Object proxyed;

        public DynamicProxyHandler(Object proxyed) {
            this.proxyed = proxyed;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
            System.out.println("代理工作了.");
            return method.invoke(proxyed, args);
        }
    }

测试类:

    public class Main {
        public static void main(String[] args) {
            RealObject real = new RealObject();
            Interface proxy = (Interface) Proxy.newProxyInstance(
                    Interface.class.getClassLoader(), new Class[]{Interface.class}, new DynamicProxyHandler(real));

            proxy.doSomething();
            proxy.somethingElse("luoxn28");
        }
    }

输出结果如下:

代理工作了.
doSomething.
代理工作了.
somethingElse luoxn28

通过调用Proxy静态方法Proxy.newProxyInstance()可以创建动态代理,这个方法需要得到一个类加载器,一个你希望该代理实现的接口列表(不是类或抽象类),以及InvocationHandler的一个实现类。动态代理可以将所有调用重定向到调用处理器,因此通常会调用处理器的构造器传递一个”实际”对象的引用,从而将调用处理器在执行中介任务时,将请求转发。

四. 结语

JAVA的反射就学习到这里,以后会更加深入的去研究这个课题,毕竟他是Java非常重要的一门技术。

    原文作者:雨纷纷__
    原文地址: https://www.jianshu.com/p/156f4b5337e2
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞