摘要：Java反射是一种十分弱小的机制，它能够在同一个零碎中去检测外部的类的字段、办法和构造函数。它十分多的Java框架中，都大量利用了反射技术，如Hibernate和Spring。能够说，反射机制的特色让Java能够构建异样弱小，具备柔性的零碎。
本文分享自华为云社区《JAVA编程不可不知的反射用法总结丨【奔跑吧！JAVA】》，原文作者：jackwangcumt 。
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; }}这里再定义一个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(); //打印字段数组内容 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); } } }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 { 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 */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_authorFieldType=varchar(50)FieldName=f_verFieldType=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 { 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(); } } }执行上述示例，输入如下所示。
ReturnType = java.lang.StringParameterizedType = intgetModifiers = 0getName = arg0getType = intret = item2getGenericReturnType = java.lang.Stringtype = java.util.List<java.lang.String>typeArgClass = class java.lang.String对于反射还有十分多的知识点能够解说，比方利用反射技术实现插件的动静加载等。反射的效率问题，能够通过应用高效的第三方反射库，或者退出缓冲机制来解决，这里不再赘述。
点击关注，第一工夫理解华为云陈腐技术~