关于java:不藏了这些Java反射用法总结都告诉你们

摘要：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_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
        {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.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

对于反射还有十分多的知识点能够解说，比方利用反射技术实现插件的动静加载等。反射的效率问题，能够通过应用高效的第三方反射库，或者退出缓冲机制来解决，这里不再赘述。

点击关注，第一工夫理解华为云陈腐技术~

关于java:不藏了这些Java反射用法总结都告诉你们

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）