作者：Seven_Nee

來源：https://segmentfault.com/a/1190000010162647

近期在維護公司專案的時候遇到一個問題，因為實體類中的 set 方法涉及到了業務邏輯，因此在給物件賦值的過程中不能夠使用 set 方法，為了實現功能，所以採用了反射的機制給物件屬性賦值，藉此機會也瞭解了反射的一些具體用法和使用場景，分以下兩點對反射進行分析：

• 反射的優勢和劣勢
• 反射的應用場景

反射的優勢和劣勢

個人理解，反射機制實際上就是上帝模式，如果說方法的呼叫是 Java 正確的開啟方式，那反射機制就是上帝偷偷開的後門，只要存在對應的class，一切都能夠被呼叫。

那上帝為什麼要開啟這個後門呢？

這涉及到了靜態和動態的概念：

• 靜態編譯：在編譯時確定型別，繫結物件
• 動態編譯：執行時確定型別，繫結物件

兩者的區別在於，動態編譯可以最大程度地支援多型，而多型最大的意義在於降低類的耦合性，因此反射的優點就很明顯了：解耦以及提高程式碼的靈活性。

因此，反射的優勢和劣勢分別在於：

優勢

執行期型別的判斷，動態類載入：提高程式碼靈活度

劣勢

效能瓶頸：反射相當於一系列解釋操作，通知 JVM 要做的事情，效能比直接的java程式碼要慢很多

反射的應用場景

在我們平時的專案開發過程中，基本上很少會直接使用到反射機制，但這不能說明反射機制沒有用，實際上有很多設計、開發都與反射機制有關，例如模組化的開發，通過反射去呼叫對應的位元組碼。

動態代理設計模式也採用了反射機制，還有我們日常使用的 Spring／Hibernate 等框架，也是利用CGLIB 反射機制才得以實現，下面就舉例最常見的兩個例子，來說明反射機制的強大之處：

JDBC 的資料庫的連線

在JDBC 的操作中，如果要想進行資料庫的連線，則必須按照以上的幾步完成

1. 通過Class.forName()載入資料庫的驅動程式 （通過反射載入，前提是引入相關了Jar包）
2. 通過 DriverManager 類進行資料庫的連線，連線的時候要輸入資料庫的連線地址、使用者名稱、密碼
3. 通過Connection 介面接收連線

public class ConnectionJDBC {  
  
    /** 
     * @param args 
     */  
    //驅動程式就是之前在classpath中配置的JDBC的驅動程式的JAR 包中  
    public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
    //連線地址是由各個資料庫生產商單獨提供的，所以需要單獨記住  
    public static final String DBURL = "jdbc:mysql://localhost:3306/test";  
    //連線資料庫的使用者名稱  
    public static final String DBUSER = "root";  
    //連線資料庫的密碼  
    public static final String DBPASS = "";  
      
      
    public static void main(String[] args) throws Exception {  
        Connection con = null; //表示資料庫的連線物件  
        Class.forName(DBDRIVER); //1、使用CLASS 類載入驅動程式 ,反射機制的體現 
        con = DriverManager.getConnection(DBURL,DBUSER,DBPASS); //2、連線資料庫  
        System.out.println(con);  
        con.close(); // 3、關閉資料庫  
    }  
 

Spring 框架的使用

在 Java的反射機制在做基礎框架的時候非常有用，行內有一句這樣的老話：反射機制是Java框架的基石。一般應用層面很少用，不過這種東西，現在很多開源框架基本都已經封裝好了，自己基本用不著寫。

典型的除了hibernate之外，還有spring也用到很多反射機制。最經典的就是xml的配置模式。

Spring 通過 XML 配置模式裝載 Bean 的過程：

1. 將程式內所有 XML 或 Properties 配置檔案載入入記憶體中
2. Java類裡面解析xml或properties裡面的內容，得到對應實體類的位元組碼字串以及相關的屬性資訊
3. 使用反射機制，根據這個字串獲得某個類的Class例項
4. 動態配置例項的屬性

Spring這樣做的好處是：

• 不用每一次都要在程式碼裡面去new或者做其他的事情
• 以後要改的話直接改配置檔案，程式碼維護起來就很方便了
• 有時為了適應某些需求，Java類裡面不一定能直接呼叫另外的方法，可以通過反射機制來實現

模擬 Spring 載入 XML 配置檔案：

public class BeanFactory {
       private Map<String, Object> beanMap = new HashMap<String, Object>();
       /**
       * bean工廠的初始化.
       * @param xml xml配置檔案
       */
       public void init(String xml) {
              try {
                     //讀取指定的配置檔案
                     SAXReader reader = new SAXReader();
                     ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
                     //從class目錄下獲取指定的xml檔案
                     InputStream ins = classLoader.getResourceAsStream(xml);
                     Document doc = reader.read(ins);
                     Element root = doc.getRootElement();  
                     Element foo;
                    
                     //遍歷bean
                     for (Iterator i = root.elementIterator("bean"); i.hasNext();) {  
                            foo = (Element) i.next();
                            //獲取bean的屬性id和class
                            Attribute id = foo.attribute("id");  
                            Attribute cls = foo.attribute("class");
                           
                            //利用Java反射機制，通過class的名稱獲取Class物件
                            Class bean = Class.forName(cls.getText());
                           
                            //獲取對應class的資訊
                            java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);
                            //獲取其屬性描述
                            java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();
                            //設定值的方法
                            Method mSet = null;
                            //建立一個物件
                            Object obj = bean.newInstance();
                           
                            //遍歷該bean的property屬性
                            for (Iterator ite = foo.elementIterator("property"); ite.hasNext();) {  
                                   Element foo2 = (Element) ite.next();
                                   //獲取該property的name屬性
                                   Attribute name = foo2.attribute("name");
                                   String value = null;
                                  
                                   //獲取該property的子元素value的值
                                   for(Iterator ite1 = foo2.elementIterator("value"); ite1.hasNext();) {
                                          Element node = (Element) ite1.next();
                                          value = node.getText();
                                          break;
                                   }
                                  
                                   for (int k = 0; k < pd.length; k++) {
                                          if (pd[k].getName().equalsIgnoreCase(name.getText())) {
                                                 mSet = pd[k].getWriteMethod();
                                                 //利用Java的反射極致呼叫物件的某個set方法，並將值設定進去
                                                 mSet.invoke(obj, value);
                                          }
                                   }
                            }
                           
                            //將物件放入beanMap中，其中key為id值，value為物件
                            beanMap.put(id.getText(), obj);
                     }
              } catch (Exception e) {
                     System.out.println(e.toString());
              }
       }
      
       //other codes
}

近期熱文推薦：

1.1,000+ 道 Java面試題及答案整理(2021最新版)

2.別在再滿屏的 if/ else 了，試試策略模式，真香！！

3.臥槽！Java 中的 xx ≠ null 是什麼新語法？

4.Spring Boot 2.5 重磅釋出，黑暗模式太炸了！

5.《Java開發手冊（嵩山版）》最新發布，速速下載！

覺得不錯，別忘了隨手點贊+轉發哦！