华为大佬讲解JAVA编程不可不知的反射用法总结

布满荆棘的人生 2021-07-24 22:04 304阅读 0赞

Java反射是一种非常强大的机制，它可以在同一个系统中去检测内部的类的字段、方法和构造函数。它非常多的Java框架中，都大量应用了反射技术，如Hibernate和Spring。可以说，反射机制的特征让Java可以构建异常强大，具备柔性的系统。

虽然Java反射机制存在效率低、速度慢和安全性不高等弊端，但在很多场景下，这些特征并不是主要的因素，或者可以通过缓存或者JVM优化等来逐步提升执行效率。

反射技术能够检查或修改在JVM中应用程序在运行时的行为，这是一个比较高级的语言特性和一种强大的技术，反射可以使应用程序实现本来不可能的操作。

## 下面对Java反射的基础知识进行说明和总结： ##

首先定义一个MyBase类，其中有私有字段，也有公有字段。同时也有公有方法和私有方法。MyBase类示例如下：

package com.hwdev.demo;
    /** * 基类示例 * @author wangming */
    public class MyBase { 
        //公有字段 
        public int version  = 1;
        //私有字段
        private String date = "2021-05-18" ;
        //公有方法 
        public void say2(String msg){ 
    	System.out.println("Hello " + msg);
        }
        //私有方法
        private String getData(){ 
            return this.date;
        }
    }//加入Java开发交流君样：756584822一起吹水聊天

这里再定义一个Hello类，它继承自MyBase类，通过继承主要用于验证一下反射对于父类、子类的反射用法。

package com.hwdev.demo;
    /**
     *
     * @author wangming
     */
    public class Hello extends MyBase {
        
        public String author = "JackWang" ;
        public int version  = 1;
        private String company = "kzcloud" ;
        
        public void say(String msg){
    	     System.out.println("Hello " + msg);
        }
        public void setAuthor(String author){
    	    this.author = author;
        }
        public String getAuthor(){
            return this.author;
        }
        private int getVersion(){
            return this.version;
        }
    }

关于Java反射，功能强大的就是可以通过字符串配置来动态从系统中调用方法或者修改其中某个对象的字段值，而Class.forName方法即可以通过传入类全路径字符串名称来获取对应的Class对象，非常的方便。另外通过getField方法和GetMethod方法可以获取指定字段和方法，并动态调用。

package com.hwdev.demo;
    import java.lang.reflect.*;
    import java.util.Arrays;
    /** * 反射第一种用法 Class.forName * @author wangming */
    public class ReflectDemo01 { 
        
         public static void Test() { 
            try
            { 
                //通过字符串全路径类名查找Class
                Class helloC = Class.forName("com.hwdev.demo.Hello"); 
                //获取所有公有的字段数组，私有的无法获取 
                Field [] fields = helloC.getFields();
                //打印字段数组内容//加入Java开发交流君样：756584822一起吹水聊天
                System.out.println(Arrays.toString(fields));
                //[public java.lang.String com.hwdev.demo.Hello.author, public int com.hwdev.demo.Hello.version]
                //实例化
                Object obj = helloC.newInstance();
                //获取特定字段，比遍历Field[]效率更高
                Field f = helloC.getField("author");
                if (f != null){ 
                    //关闭安全检查，提高效率
                    f.setAccessible(true);
                    //获取字段author内容
                    String author = (String)f.get(obj);
                    System.out.println("author=" + author);
                    //author=JackWang
                }
                //获取所有公有的方法数组，私有的无法获取 
                Method [] methods = helloC.getMethods();
                //打印方法数组内容,子类等方法也可以获取到
                System.out.println(Arrays.toString(methods));
                //本类所有方法
                Method [] methods2 = helloC.getDeclaredMethods();
                //打印方法数组内容
                System.out.println(Arrays.toString(methods2));
                //获取特定方法，第二个参数String.class为say方法的参数类型
                //say(java.lang.String)
                Method m = helloC.getDeclaredMethod("say",String.class); 
                if (m != null){ 
                    //关闭安全检查，提高效率
                    m.setAccessible(true);
                    //获取字段author内容
                    Object returnValue = m.invoke(obj, new Object[]{ "Java"});
                    //Hello Java
                    if (returnValue!=null){ 
                        System.out.println("returnValue =" + returnValue);    
                    }
                }//加入Java开发交流君样：756584822一起吹水聊天
                
            }catch(ClassNotFoundException | SecurityException ex){ 
                ex.printStackTrace();
            }
            catch(Exception ex){ 
                ex.printStackTrace();
            }
        }    
    }

这里需要注意：xxx.getMethods()方法默认情况下，会返回本类、父类、父接口的公有方法，而xxx.getDeclaredMethods()返回本类的 所有方法，包括私有的方法。同理，反射API中其他getXXX和getDeclaredXXX的用法类似。

package com.hwdev;
    import com.hwdev.demo.ReflectDemo01;
    /** * * @author wangming */
    public class Main { 
    
        /** * @param args the command line arguments */
        public static void main(String[] args) { 
            //反射第一种用法 Class.forName
            ReflectDemo01.Test();
        }    
    }

执行程序，输出的结果如下：

[public java.lang.String com.hwdev.demo.Hello.author, public int com.hwdev.demo.Hello.version, public int com.hwdev.demo.MyBase.version]
    author=JackWang
    [public void com.hwdev.demo.Hello.say(java.lang.String), public void com.hwdev.demo.Hello.setAuthor(java.lang.String), public java.lang.String com.hwdev.demo.Hello.getAuthor(), public void com.hwdev.demo.MyBase.say2(java.lang.String), public final void java.lang.Object.wait() throws java.lang.InterruptedException, public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException, public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException, public boolean java.lang.Object.equals(java.lang.Object), public java.lang.String java.lang.Object.toString(), public native int java.lang.Object.hashCode(), public final native java.lang.Class java.lang.Object.getClass(), public final native void java.lang.Object.notify(), public final native void java.lang.Object.notifyAll()]
    [public void com.hwdev.demo.Hello.say(java.lang.String), public void com.hwdev.demo.Hello.setAuthor(java.lang.String), public java.lang.String com.hwdev.demo.Hello.getAuthor(), private int com.hwdev.demo.Hello.getVersion()]
    Hello Java

从输出结果上来看，`Field [] fields = helloC.getFields();`不但可以获取Hello类的公有字段，还可以获取到父类MyBase的公有字段：`com.hwdev.demo.MyBase.version`

而`Method [] methods2 = helloC.getDeclaredMethods()`;则可以获取本类，即Hello类所有的方法，包括公有的方法和私有的方法。因此，Java反射可以访问类的私有字段和方法，从而暴露内部的信息，这也是Java反射有安全问题的原因。

由于Java方法支持重载，因此同名的方法可以存在多个，即参数不同，因此在用反射调用方法时，需要指定方法的参数类型，这样就可以明确调到的具体是哪个方法签名，如`Method m = helloC.getDeclaredMethod("say",String.class); `调用的是`public void com.hwdev.demo.Hello.say(java.lang.String) `。
    
       除了可以用Class.forName来进行反射外，还可以通过如下方式来获取反射对象：

Hello hello = new Hello();
    Class helloC = hello.getClass();
    Field [] fields = helloC.getFields();
    //
    Class helloC = Hello.class; 
    Field [] fields = helloC.getFields();

下面介绍一下如何用Java反射修改私有字段和调用私有方法的示例：

package com.hwdev.demo;
    import java.lang.reflect.*;
    /** * 反射访问私有字段和方法 * @author wangming */
    public class ReflectDemo02 { 
       //加入Java开发交流君样：756584822一起吹水聊天 
         public static void Test() { 
            try
            { 
                //通过已有类查找Class 
                Class helloC = Hello.class; 
                //实例化
                Object obj = helloC.newInstance();
                //获取特定私有字段
                Field f = helloC.getDeclaredField("company");
                if (f != null){ 
                    //私有必须开启
                    f.setAccessible(true);
                    //设置私有字段值
                    f.set(obj, "newKZ");
                    //获取字段author内容
                    String fv = (String)f.get(obj);
                    System.out.println("company=" + fv);
                    //company=newKZ
                } 
                //获取私有方法
                Method m = helloC.getDeclaredMethod("getVersion", null); 
                if (m != null){ 
                    //私有必须开启
                    m.setAccessible(true);
                    Object returnValue = m.invoke(obj, null);
                    if (returnValue!=null){ 
                        //returnValue =1
                        System.out.println("returnValue =" + returnValue);    
                    }
                }
                
            }catch(SecurityException ex){ 
                ex.printStackTrace();
            }
            catch(Exception ex){ 
                ex.printStackTrace();
            }
        }    
    }

另外，Java反射可以获取注解信息，这个对于ORM框架来讲，用的非常多。

package com.hwdev.demo;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    /** * 注解示例 * @author wangming */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    public @interface ORMAnnotation { 
        public String FieldName();
        public String FieldType();
    }

其中，@Retention(RetentionPolicy.RUNTIME)表示注解可以在运行时通过反射访问。@Target(ElementType.FIELD) 表示这个注解只能用在字段上面。同理，可以把FIELD改为Type或者Method等。

package com.hwdev.demo;
    import java.lang.annotation.Annotation;
    import java.lang.reflect.*;
    /** * 反射或者字段注解 * @author wangming *///加入Java开发交流君样：756584822一起吹水聊天
    public class ReflectDemo03 { 
        
         public static void Test() { 
            try
            { 
            
                Class helloC = Class.forName("com.hwdev.demo.HelloAnnotation");      
                Field[] fields = helloC.getDeclaredFields();
                for(Field f : fields){ 
                     //关闭安全检查，提高效率
                    f.setAccessible(true);
                    Annotation ann = f.getAnnotation(ORMAnnotation.class);
                    if(ann instanceof ORMAnnotation){ 
                        ORMAnnotation ormAnn = (ORMAnnotation) ann;
                        System.out.println("FieldName=" + ormAnn.FieldName());
                        System.out.println("FieldType=" + ormAnn.FieldType());
                    }
                    
                }          
                
            }catch(ClassNotFoundException | SecurityException ex){ 
                ex.printStackTrace();
            }
            catch(Exception ex){ 
                ex.printStackTrace();
            }
        }    
    }

执行此示例，则输出如下：

FieldName=f_author
    FieldType=varchar(50)
    FieldName=f_ver
    FieldType=int

再次，介绍一下如何用反射获取方法参数个数和类型，其中包含泛型的信息获取：

package com.hwdev.demo;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /** * 泛型示例 * @author wangming */
    public class GenericCls { 
       protected List<String> myList = new ArrayList(); 
       public GenericCls(int size){       
           for(int i = 0;i<size;i++){ 
               myList.add("item"+i);
           }
       }
       public  List<String> getList(){  
          return this.myList;
       }
       public String getList(int idx){  
          return this.myList.get(idx);
       }
    }
    package com.hwdev.demo;
    import java.lang.reflect.*;
    /** * 反射获取方法参数 * @author wangming */
    public class ReflectDemo05 { 
        
         public static void Test() { 
            try
            { 
            //加入Java开发交流君样：756584822一起吹水聊天
                Class helloC = Class.forName("com.hwdev.demo.GenericCls"); 
                //构造函数调用
                Object obj = helloC.getConstructor(int.class).newInstance(3);
                Method method = helloC.getMethod("getList", int.class);
                Class<?> returnType = method.getReturnType();
                System.out.println("ReturnType = " + returnType.getName());
                Parameter[] params = method.getParameters();
                for(Parameter p : params){     
                    System.out.println("ParameterizedType = " + p.getParameterizedType());
                    System.out.println("getModifiers = " + p.getModifiers());
                    System.out.println("getName = " + p.getName());
                    System.out.println("getType = " + p.getType());
                }
               //调用方法
               Object ret =  method.invoke(obj, new Object[]{ 2});
               System.out.println("ret = " + ret.toString());
                Method method2 = helloC.getMethod("getList", null);
                Type greturnType = method2.getGenericReturnType();
                System.out.println("getGenericReturnType = " + returnType.getName());
                if(greturnType instanceof ParameterizedType){ 
                    ParameterizedType type = (ParameterizedType) greturnType;
                    System.out.println("type = " + type.getTypeName());
                    Type[] typeArguments = type.getActualTypeArguments();
                    for(Type typeArgument : typeArguments){ 
                        Class typeArgClass = (Class) typeArgument;
                        System.out.println("typeArgClass = " + typeArgClass);
                    }
                }
            }catch(ClassNotFoundException | SecurityException ex){ 
                ex.printStackTrace();
            }
            catch(Exception ex){ 
                ex.printStackTrace();
            }
        }    
    }

执行上述示例，输出如下所示。

R`eturnType = java.lang.String
    ParameterizedType = int
    getModifiers = 0
    getName = arg0
    getType = int
    ret = item2
    getGenericReturnType = java.lang.String
    type = java.util.List<java.lang.String>
    typeArgClass = class java.lang.String

关于反射还有非常多的知识点可以讲解，比如利用反射技术实现插件的动态加载等。反射的效率问题，可以通过使用高效的第三方反射库，或者加入缓冲机制来解决，这里不再赘述。

此文转载自：[https://www.jianshu.com/p/eb59f9a28e04][https_www.jianshu.com_p_eb59f9a28e04]

[https_www.jianshu.com_p_eb59f9a28e04]: https://jq.qq.com/?_wv=1027&k=0IsBuUb0