开发者社区> 问答> 正文

[@徐雷frank][¥20]Java 里的反射机制

已解决

Java的反射实现是委派实现还是动态实现?委派实现和动态实现是按照什么机制去识别实现的?即什么情况下用委派实现,什么情况下动态实现?

展开
收起
brian_106 2018-11-06 22:56:08 132597 0
10 条回答
写回答
取消 提交回答
  • 1.阿里云大学讲师,主讲《微服务Spring Cloud设计与开发实战》《MongoDB高级实战》等课程 2.MongoDB中文社区专家 3.《MongoDB实战》第2版译者 5.吉林大学计算机科学学士、上海交通大学硕士
    采纳回答

    1.Java的反射机制应该都是运行时动态实现的,动态通过元数据获取类型信息,创建对象,实现调用。
    2.动态反射需要知道类名或者非法名关键字,中间够基于哈希搜索,快速定位类型或者非法信息。
    3.Java的反射机制现在应用比较多的是动态代理proxy,主要是在RPC和AOP领域。
    4.委派,你说的意思应该是delegate,也叫委托,一种设计模式,委派方式委派其他对象干活,这个工作自己不了。
    5.动态代理模式,支持的功能几乎和被代理对象一样。
    6.当有严格要求需要代理和被代理类方法一致,例如RPC或者AOP中,基于接口约束,使用反射的动态代理比较好。
    当有特殊的封装,比如要调用一个加密或者日志对象完成其他工作,不需要接口约束,可以使用委托,委托内部可以反射创建对象。

    2019-07-17 23:12:34
    赞同 1 展开评论 打赏
  • 在默认情况下,方法的反射调用为委派实现,委派给本地实现来进行方法调用。在调用超过 15 次之后,委派实现便会将委派对象切换至动态实现。这个动态的字节码是在Java运行过程中通过ASM自动生成的,它将直接使用 invoke 指令来调用目标方法。

    2020-03-30 10:20:47
    赞同 展开评论 打赏
  • java的反射机制在底层是基于虚拟机实现的。一般是运行时根据当时的context(主要是class loader)动态分析与计算出具体被反射的结果。这种时候的context class loader 多半是双亲委派加载方案。

    2019-07-17 23:12:34
    赞同 展开评论 打赏
  • Android系统与应用研发7年,专注于系统性能问题处理、开发流程工具研发、SDK组件研发工作。 服务端研发2年,前后使用Golang, RoR搭建后端服务程序。

    java的反射机制在底层是基于虚拟机实现的。一般是运行时根据当时的context(主要是class loader)动态分析与计算出具体被反射的结果。这种时候的context class loader 多半是双亲委派加载方案。

    2019-07-17 23:12:34
    赞同 展开评论 打赏
  • 反射不分委派不委派吧,反射就是通过动态获取class字节码信息去执行

    2019-07-17 23:12:34
    赞同 展开评论 打赏
  • 我们首先来观察一下Method.invoke()方法。相关源代码在java.lang.reflect包下的Method类中。
    public Object invoke(Object obj, Object... args)

        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException
    {
        // 权限检查,忽略 ...
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, obj, modifiers);
            }
        }
        // 看这里 ...
        MethodAccessor ma = methodAccessor; // read volatile
        if (ma == null) {
            ma = acquireMethodAccessor();
        }
        return ma.invoke(obj, args);
    }
    

    可以看到,这里讲方法的调用,委派给了MethodAccessor类型的ma对象来处理。它是一个接口,有两个实现类。一个委派实现(DelegatingMethodAccessorImpl),一个本地实现(NativeMethodAccessorImpl)。每一个Method实例的第一次调用,都会使用委派实现!,但是委派实现最终委派的实现确实本地实现。下面通过里一个例子观察一下:

    public class HowReflect {

    public static void targetMethod(int i) {
        // 打印调用栈
        new Exception("version " + i)
                .printStackTrace();
    }
    
    public static void main(String[] args) throws Exception {
        Class<?> howReflect = Class.forName("com.ynwa.jvm.HowReflect");
        Method method = howReflect.getMethod("targetMethod", int.class);
        // 执行方法
        method.invoke(null, 0);
    }

    }

    上面的代码运行结果为:
    java.lang.Exception: 版本 0

    at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:13)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    // 4 委派实现又委派给了本地实现
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    // 3 生成委派实现
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    // 2 反射调用方法
    at java.lang.reflect.Method.invoke(Method.java:498)
    // 1 执行main方法
    at com.ynwa.jvm.HowReflect.main(HowReflect.java:21)
    

    上面在结果打印的调用栈中,注释的第3步个第4步,可以看到先用的委派实现,委派实现又委派了本地实现!
    那么问题来了!既然最终要用本地实现,那么为什么中间要加一层委派实现?,那么继续向下看。
    其实这是因为除了以上两种以外,还有一种动态实现,而所谓的委派实现,只不过是为了能够在本地实现和动态实现之间做切换。动态实现是一种字节码技术。
    但是如果只调用一次的话,本地实现要比动态实现块一点儿,这是因为动态实现操作字节码要慢一些。JVM会认为你每次只会很少的进行方法调用(或者说只调用一次),所以它设定了一个阀值:16,如果调用15此以上,也就是说第17次开始,使用动态实现。使用本地实现的时候,因为要经过Java -> c++ -> Java的过程。第17次开始,JVM会利用已经生成的字节码来进行方法调用,所以这无疑就会增速很多!

    2019-07-17 23:12:34
    赞同 展开评论 打赏
  • 学习了

    2019-07-17 23:12:34
    赞同 展开评论 打赏
  • debug下你就明白了, 反射前15次是通过unsafe内置的native方法操作的, 超过15次后会生成对应的java类, 就是相当于正常调用方法实现了

    2019-07-17 23:12:34
    赞同 展开评论 打赏
  • java 数据分析 数据可视化 大数据

    反射机制
    什么是反射机制
    简单来说,放射可以帮助我们在动态运行的时候,对于任意一个类,可以获得其所有的方法(包括 public protected private 默认状态的),所有的变量 (包括 public protected private 默认状态的)。是不是很强大呢。

    反射机制有什么作用呢?
    获取某些类的一些变量,调用某些类的私有方法。(例如在Android开发中我们可以用来开启 WiFi 热点,调用 WifiManager 中的 setWifiApEnabled() 方法 )
    增加代码的灵活性。很多主流框架都使用了反射技术.像ssh框架都采用两种技术 xml做配置文件+反射技术.
    假如有这样一个类 Person,它拥有多个成员变量,country,city,name,province,height,age 等,同时它拥有多个 构造方法,多个方法,这些变量,方法的访问权限既有 public 也有 private 的。下面我们以这个为例子,一起看怎样使用反射获得相应的 Filed,Constructor,Method。

    public class Person {

    public String country;
    public String city;
    private String name;
    private String province;
    private Integer height;
    private Integer age;
    
    public Person() {
        System.out.println("调用Person的无参构造方法");
    }
    
    private Person(String country, String city, String name) {
        this.country = country;
        this.city = city;
        this.name = name;
    }
    
    public Person(String country, Integer age) {
        this.country = country;
        this.age = age;
    }
    
    private String getMobile(String number) {
        String mobile = "010-110" + "-" + number;
        return mobile;
    }
    
    private void setCountry(String country) {
        this.country=country;
    
    }
    
    public void getGenericHelper(HashMap<String, Integer> hashMap) {
    }
    
    public Class getGenericType() {
        try {
            HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
            Method method = getClass().getDeclaredMethod("getGenericHelper",HashMap.class);
            Type[] genericParameterTypes = method.getGenericParameterTypes();
            if (null == genericParameterTypes || genericParameterTypes.length < 1) {
                return null;
            }
    
            ParameterizedType parameterizedType=(ParameterizedType)genericParameterTypes[0];
            Type rawType = parameterizedType.getRawType();
            System.out.println("----> rawType=" + rawType);
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            if (actualTypeArguments==genericParameterTypes || actualTypeArguments.length<1) {
                return null;
            }
    
            for (int i = 0; i < actualTypeArguments.length; i++) {
                Type type = actualTypeArguments[i];
                System.out.println("----> type=" + type);
            }
        } catch (Exception e) {
    
        }
        return null;
    }
    
    @Override
    public String toString() {
        return "Person{" +
                "country='" + country + '\'' +
                ", city='" + city + '\'' +
                ", name='" + name + '\'' +
                ", province='" + province + '\'' +
                ", height=" + height +
                '}';
    }

    }
    使用反射获得所有构造方法(包括私有的,非私有的)
    默认权限的指的是没有修饰符修饰的

    几个重要的方法讲解
    方法 描述
    public Constructor getConstructor(Class… parameterTypes) 获得指定的构造方法,注意只能获得 public 权限的构造方法,其他访问权限的获取不到
    public Constructor getDeclaredConstructor(Class… parameterTypes) 获得指定的构造方法,注意可以获取到任何访问权限的构造方法。
    public Constructor[] getConstructors() throws SecurityException 获得所有 public 访问权限的构造方法
    public Constructor[] getDeclaredConstructors() throws SecurityException 获得所有的构造方法,包括(public, private,protected,默认权限的)
    看了上面的几个方法,其实很好区分

    后缀带 s 的返回对象时数组类型,是可以获得相应权限的所有方法的,如 Constructor getConstructor() 方法 和 Constructor
    获得所有的构造方法
    public static void printConstructor(String className) {

    try {
        Class<?> aClass = Class.forName(className);
        Constructor<?>[] constructors = aClass.getConstructors();
        print(constructors);
        Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
        print(declaredConstructors);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }

    }
    print: private com.example.reflectdemo.Person(java.lang.String,java.lang.String,java.lang.String)

    print: public com.example.reflectdemo.Person()

    print:public com.example.reflectdemo.Person(java.lang.String,java.lang.Integer)

    print:public com.example.reflectdemo.Person(java.lang.String,java.lang.Integer)

    对比 Person 里面所有的构造方法,可以知道我们代码的逻辑是正确的

    获得指定的构造方法
    public static Constructor getConstructor(String className, Class<?>... clzs) {

    try {
        Class<?> aClass = Class.forName(className);
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(clzs);
        print(declaredConstructor);
        //   if Constructor is not public,you should call this
        declaredConstructor.setAccessible(true);
        return declaredConstructor;
    
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    }
    return null;
    

    }

    public class TestHelper {

    public static  final String TAG="xujun";
    public static final String CLASS_NAME = "com.example.reflectdemo.Person";
    public static final String CHINA = "China";
    
    public static void testConstructor(){
        ReflectHelper.printConstructor(CLASS_NAME);
        Constructor constructor = ReflectHelper.getConstructor(CLASS_NAME, String.class, Integer.class);
        try {
            Object meinv = constructor.newInstance(CHINA, 12);
            Person person = (Person) meinv;
            Log.i(TAG, "testConstructor: =" + person.toString());
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    
    }

    }
    我们将可以看到以下的输出结果

    testConstructor: =Person [country=China, city=null, name=null, province=null, height=null, age=12]

    可以看到 country=China,age=12 这说明我们成功通过反射调用 Person 带两个参数的沟改造方法。

    注意事项
    如果该方法,或者该变量不是 public 访问权限的,我们应该调用相应的 setAccessible(true) 方法,才能访问得到

    //if Constructor is not public,you should call this
    declaredConstructor.setAccessible(true);
    1
    2
    使用反射获得所有的 Filed 变量
    获得所有的 Filed 变量
    public static void printFiled(String className) {

    try {
        Class<?> aClass = Class.forName(className);
        Field[] fields = aClass.getFields();
        PrintUtils.print(fields);
        Field[] declaredFields = aClass.getDeclaredFields();
        PrintUtils.print(declaredFields);
    
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }

    }
    获得指定的成员变量
    现在假如我们要获得 Person 中的私有变量 age ,我们可以通过以下的代码获得,同时并打印出所有的成员变量。

    public static Field getFiled(String className, String filedName) {

    Object o = null;
    try {
        Class<?> aClass = Class.forName(className);
    
        Field declaredField = aClass.getDeclaredField(filedName);
        //   if not public,you should call this
        declaredField.setAccessible(true);
        return declaredField;
    
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    }
    return null;
    

    }

    public static void testFiled(){

    ReflectHelper.printFileds(CLASS_NAME);
    Person person = new Person(CHINA, 12);
    Field field = ReflectHelper.getFiled(CLASS_NAME, "age");
    try {
        Integer integer = (Integer) field.get(person);
        PrintUtils.print("integer="+integer);
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    

    }
    我们可以看到以下的输出结果

    print: public java.lang.String com.example.reflectdemo.Person.country

    print: public java.lang.String com.example.reflectdemo.Person.city

    print: public java.lang.String com.example.reflectdemo.Person.country

    print: public java.lang.String com.example.reflectdemo.Person.city

    print: private java.lang.String com.example.reflectdemo.Person.name

    print: private java.lang.String com.example.reflectdemo.Person.province

    print: private java.lang.Integer com.example.reflectdemo.Person.height

    print: private java.lang.Integer com.example.reflectdemo.Person.age

    print:integer=12

    使用反射执行相应的 Method
    主要有以下几个方法,

    public Method[] getDeclaredMethods()
    public Method[] getMethods() throws SecurityException
    public Method getDeclaredMethod()
    public Method getMethod(String name, Class
    获取所有的 Method

    public static void printMethods(String className) {
        try {
            Class<?> aClass = Class.forName(className);
            Method[] declaredMethods = aClass.getDeclaredMethods();
            PrintUtils.print(declaredMethods);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    
    } 

    print: public java.lang.String com.example.reflectdemo.Person.toString()

    print: public java.lang.Class com.example.reflectdemo.Person.getGenericType()

    print: private void com.example.reflectdemo.Person.setCountry(java.lang.String)

    print: public void com.example.reflectdemo.Person.getGenericHelper(java.util.HashMap)

    print: private java.lang.String com.example.reflectdemo.Person.getMobile(java.lang.String)

    对比 Person 里面的所有方法,毫无疑问我们的代码逻辑是正确的。

    获取指定的 Method
    我们可以使用 getDeclaredMethod(String name, Class

    public static void testMethod(){

        ReflectHelper.printMethods(CLASS_NAME);
        Person person=new Person();
        Method method = ReflectHelper.getMethod(CLASS_NAME,
                "setCountry", String.class);
        try {
           // 执行方法,结果保存在 person 中
            Object o = method.invoke(person, CHINA);
           // 拿到我们传递进取的参数 country 的值 China          
            String country=person.country;
            PrintUtils.print(country);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    
    }
    

    public class ReflectHelper {

    private static final String TAG = "ReflectHelper";
    
    public static Method getMethod(String className, String methodName, Class<?>... clzs) {
        try {
            Class<?> aClass = Class.forName(className);
            Method declaredMethod = aClass.getDeclaredMethod(methodName, clzs);
            declaredMethod.setAccessible(true);
            return declaredMethod;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return null;
    }

    }
    执行上面的函数,将可以看到下面的结果

    print:China

    即我们成功利用反射调用 Person 的 setCountry 方法,并将值成功改变。

    使用反射操作数组
    /**

     * 利用反射操作数组
     * 1 利用反射修改数组中的元素
     * 2 利用反射获取数组中的每个元素
     */
    public static void testArrayClass() {
        String[] strArray = new String[]{"5","7","暑期","美女","女生","女神"};
        Array.set(strArray,0,"帅哥");
        Class clazz = strArray.getClass();
        if (clazz.isArray()) {
            int length = Array.getLength(strArray);
            for (int i = 0; i < length; i++) {
                Object object = Array.get(strArray, i);
                String className=object.getClass().getName();
                System.out.println("----> object=" + object+",className="+className);
            }
        }
    } 

    —-> object=帅哥,className=java.lang.String

    —-> object=7,className=java.lang.String

    —-> object=暑期,className=java.lang.String

    —-> object=美女,className=java.lang.String

    —-> object=女生,className=java.lang.String

    —-> object=女神,className=java.lang.String

    从结果可以说明,我们成功通过 Array.set(strArray,0,”帅哥”) 改变数组的值。

    使用反射获得泛型类型
    public static void getGenericHelper(HashMap map) {

    } 

    现在假设我们有这样一个方法,那我们要怎样获得 HashMap 里面的 String,Person 的类型呢?

    对于 Java Type还不熟悉的可以先读这一篇博客 java Type 详解

    public static void getGenericType() {

        try {
            Method method =TestHelper.class.getDeclaredMethod("getGenericHelper",HashMap.class);
            Type[] genericParameterTypes = method.getGenericParameterTypes();
            // 检验是否为空
            if (null == genericParameterTypes || genericParameterTypes.length < 1) {
                return ;
            }
            // 取 getGenericHelper 方法的第一个参数
    
            ParameterizedType parameterizedType=(ParameterizedType)genericParameterTypes[0];
            Type rawType = parameterizedType.getRawType();
            System.out.println("----> rawType=" + rawType);
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            if (actualTypeArguments==genericParameterTypes || actualTypeArguments.length<1) {
                return ;
            }
            //  打印出每一个类型          
            for (int i = 0; i < actualTypeArguments.length; i++) {
                Type type = actualTypeArguments[i];
                System.out.println("----> type=" + type);
            }
        } catch (Exception e) {
    
        }
    
    } 

    执行上面的代码,输出结果

    —-> rawType=class java.util.HashMap

    —-> type=class java.lang.String

    —-> type=class com.example.reflectdemo.Person

    怎样获得 Metho,Field,Constructor 的访问权限 ( public,private,ptotected 等)
    其实很简单,我们阅读文档可以发现他们都有 getModifiers() 方法,该方法放回 int 数字, 我们在利用 Modifier.toString() 就可以得到他们的访问权限

    int modifiers = method.getModifiers();
    Modifier.toString(modifiers);

    2019-07-17 23:12:34
    赞同 4 展开评论 打赏
  • 前一个帐号wangccsy@126.com不知道怎么的就成了企业帐号,改不成个人。所以重新注册了一个个人帐号。老程序员。精通JAVA,C#,数据库,对软件开发过程和流程熟悉。考取系统分析师,项目管理师和系统架构设计师等软件资格考试认证。愿意和大家一起前进。

    动态代理 ,委派实现。

    2019-07-17 23:12:34
    赞同 展开评论 打赏
滑动查看更多
问答分类:
问答标签:
问答地址:
相关产品:
问答排行榜
最热
最新

相关电子书

更多
Spring Cloud Alibaba - 重新定义 Java Cloud-Native 立即下载
The Reactive Cloud Native Arch 立即下载
JAVA开发手册1.5.0 立即下载