Java反射是一種非常強大的機制，它可以在同一個系統中去檢測内部的類的字段、方法和構造函數。它非常多的Java架構中，都大量應用了反射技術，如Hibernate和Spring。可以說，反射機制的特征讓Java可以建構異常強大，具備柔性的系統。

雖然Java反射機制存在效率低、速度慢和安全性不高等弊端，但在很多場景下，這些特征并不是主要的因素，或者可以通過緩存或者JVM優化等來逐漸提升執行效率。

根據網站

https://docs.oracle.com/javase/tutorial/reflect/index.html

的說法，反射技術能夠檢查或修改在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();
        }
    }    
}

JAVA程式設計不可不知的反射用法總結丨【奔跑吧！JAVA】

jackwangcumt

發表于 2021/05/18 13:36:39

3.7k+ 0 0

編輯删除

【摘要】 Java反射是一種非常強大的機制，它可以在同一個系統中去檢測内部的類的字段、方法和構造函數。它非常多的Java架構中，都大量應用了反射技術，如Hibernate和Spring。可以說，反射機制的特征讓Java可以建構異常強大，具備柔性的系統。

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;
    }
}

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;
    }
}

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程式設計不可不知的反射用法總結丨【奔跑吧！JAVA】

JAVA程式設計不可不知的反射用法總結丨【奔跑吧！JAVA】

繼續閱讀

關于Gradle配置的小結

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method