我命由我不由天 --哪吒

建議101：注意Class類的特殊性

建議102：適時選擇getDeclaredXXX和getXXX

建議103：反射訪問屬性或方法時Accessible設定為true

建議104：使用forName動態載入類檔案

建議105：動態載入不適合陣列

建議106：動態代理可以使代理模式更加靈活

建議107：使用反射增加修飾模式的普適性

建議108：反射讓模板方法模式更強大

建議109：不需要太多關注反射效率

建議101：注意Class類的特殊性

Java語言是先把Java原始檔編譯成字尾為class的位元組碼檔案，然後通過classLoader機制把這些類載入到記憶體中。最後生成例項執行。

class類是Java的反射入口，只有在獲得一個類的描述物件後才能動態的載入、呼叫，一般獲得class物件的三種方法：

1、類屬性載入：如String.class

2、物件的getClass方法：如new String.getClass()

3、forName方法載入：如Class.forName("java.lang.String")

獲得class物件之後，就可以通過getAnnotation()獲得註解，通過getMethods()獲得方法，通過getConstructors()獲得建構函式等。

建議102：適時選擇getDeclaredXXX和getXXX

getMethod方法獲得的是所有public訪問級別的方法，包括從父類繼承的方法。

getDeclaredMethod獲得的是自身類的方法，包括公用的(public)方法、私有(private)方法，而且不受限於訪問許可權。

建議103：反射訪問屬性或方法時Accessible設定為true

Java中通過反射執行一個方法：獲取一個方法物件，然後根據isAccessible返回值確定是否能夠執行，如果返回false，則呼叫setAccessible(true)，然後再呼叫invoke執行方法：

 

Method method= ...;
//檢查是否可以訪問
if(!method.isAccessible()){
     method.setAccessible(true);
}
//執行方法
method.invoke(obj, args);
 

通過反射方法執行方法時，必須在invoke之前檢查Accessible屬性。

建議104：使用forName動態載入類檔案

動態載入是指程式執行時載入需要的類庫檔案，對Java程式來說，雷哥類檔案在啟動時或首次初始化時會被載入到記憶體中，而反射則可以在執行時再決定是否需要載入。

動態載入的意義在於：載入一個類表示要初始化該類的static變數，特別是static程式碼塊，在這裡可以做大量的工作，比如註冊，初始化環境等等。

對於動態載入最經典的應用就是資料庫驅動程式的載入片段，程式碼如下：

//載入驅動
Class.forName("com.mysql..jdbc.Driver");
String url="jdbc:mysql://localhost:3306/db?user=&password=";
Connection conn =DriverManager.getConnection(url);
Statement stmt =conn.createStatement();

當程式動態載入該驅動時，也就是執行到Class.forName("com.mysql..jdbc.Driver")時，Driver類會被載入到記憶體中，於是static程式碼塊開始執行，也就是把自己註冊到DriverManager中。

forName只是把一個類載入到記憶體中，並不保證由此產生一個例項物件，也不會執行任何方法，之所以會初始化static程式碼，那是由類載入機制所決定的，而不是forName方法決定的。也就是說，如果沒有static屬性或static程式碼塊，forName就是載入類，沒有任何的執行行為。

總而言之，forName只是把一個類載入到記憶體中，然後初始化static程式碼。

建議105：動態載入不適合陣列

建議106：動態代理可以使代理模式更加靈活

Java的反射框架提供了動態代理（Dynamic Proxy）機制，允許在執行期對目標類生成代理，避免重複開發。我們知道一個靜態代理是通過主題角色（Proxy）和具體主題角色（Real Subject）共同實現主題角色（Subkect）的邏輯的，只是代理角色把相關的執行邏輯委託給了具體角色而已，一個簡單的靜態代理如下所示：

interface Subject {
    // 定義一個方法
    public void request();
}

// 具體主題角色
class RealSubject implements Subject {
    // 實現方法
    @Override
    public void request() {
        // 實現具體業務邏輯
    }

}

class Proxy implements Subject {
    // 要代理那個實現類
    private Subject subject = null;

    // 預設被代理者
    public Proxy() {
        subject = new RealSubject();
    }

    // 通過建構函式傳遞被代理者
    public Proxy(Subject _subject) {
        subject = _subject;
    }

    @Override
    public void request() {
        before();
        subject.request();
        after();
    }

    // 預處理
    private void after() {
        // doSomething
    }

    // 善後處理
    private void before() {
        // doSomething
    }
}

這是一個簡單的靜態代理。Java還提供了java.lang.reflect.Proxy用於實現動態代理：只要提供一個抽象主題角色和具體主題角色，就可以動態實現其邏輯的，其例項程式碼如下：

interface Subject {
    // 定義一個方法
    public void request();
}

// 具體主題角色
class RealSubject implements Subject {
    // 實現方法
    @Override
    public void request() {
        // 實現具體業務邏輯
    }

}

class SubjectHandler implements InvocationHandler {
    // 被代理的物件
    private Subject subject;

    public SubjectHandler(Subject _subject) {
        subject = _subject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // 預處理
        System.out.println("預處理...");
        //直接呼叫被代理的方法
        Object obj = method.invoke(subject, args);
        // 後處理
        System.out.println("後處理...");
        return obj;
    }
}

注意這裡沒有代理主題角色，取而代之的是SubjectHandler作為主要的邏輯委託處理，其中invoke方法是介面InvocationHandler定義必須實現的，它完成了對真實方法的呼叫。

通過InvocationHandler介面的實現類來實現，所有的方法都是有該Handler進行處理的，即所有被代理的方法都是由InvocationHandler接管實際的處理任務。

程式碼如下：

public static void main(String[] args) {
    //具體主題角色，也就是被代理類
    Subject subject = new RealSubject();
    //代理例項的處理Handler
    InvocationHandler handler =new SubjectHandler(subject);
    //當前載入器
    ClassLoader cl = subject.getClass().getClassLoader();
    //動態代理
    Subject proxy = (Subject) Proxy.newProxyInstance(cl,subject.getClass().getInterfaces(),handler);
    //執行具體主題角色方法
    proxy.request();
}

此時實現了不用顯示建立代理類即實現代理的功能，例如可以在被代理的角色執行前進行許可權判斷，或者執行後進行資料校驗。

動態代理很容易實現通用的代理類，只要在InvocationHandler的invoke方法中讀取持久化的資料即可實現，而且還能實現動態切入的效果。

建議107：使用反射增加修飾模式的普適性

裝飾模式（Decorator Pattern）的定義是“動態的給一個物件新增一些額外的職責。就增加功能來說，裝飾模式相比於生成子類更加靈活“，不過，使用Java的動態代理也可以實現修飾模式的效果，而且其靈活性、適應性會更強。

我們以卡通片《貓和老鼠》(Tom and Jerry)為例，看看如何包裝小Jerry讓它更強大。首先定義Jerry的類：老鼠（Rat類），程式碼如下：　

interface Animal{
    public void doStuff();
}

class Rat implements Animal{
    @Override
    public void doStuff() {
        System.out.println("Jerry will play with Tom ......");
    }
}

接下來，我們要給Jerry增加一些能力，比如飛行，鑽地等能力，當然使用繼承也很容易實現，但我們這裡只是臨時的為Rat類增加這些能力，使用裝飾模式更符合此處的場景，首先定義裝飾類，程式碼如下：

//定義某種能力
interface Feature{
    //載入特性
    public void load();
}
//飛行能力
class FlyFeature implements Feature{

    @Override
    public void load() {
        System.out.println("增加一對翅膀...");
    }
}
//鑽地能力
class DigFeature implements Feature{
    @Override
    public void load() {
        System.out.println("增加鑽地能力...");
    }   
}

此處定義了兩種能力：一種是飛行，另一種是鑽地，我們如果把這兩種屬性賦予到Jerry身上，那就需要一個包裝動作類了，程式碼如下：　

class DecorateAnimal implements Animal {
    // 被包裝的動物
    private Animal animal;
    // 使用哪一個包裝器
    private Class<? extends Feature> clz;

    public DecorateAnimal(Animal _animal, Class<? extends Feature> _clz) {
        animal = _animal;
        clz = _clz;
    }

    @Override
    public void doStuff() {
        InvocationHandler handler = new InvocationHandler() {
            // 具體包裝行為
            @Override
            public Object invoke(Object proxy, Method method, Object[] args)
                    throws Throwable {
                Object obj = null;
                if (Modifier.isPublic(method.getModifiers())) {
                    obj = method.invoke(clz.newInstance(), args);
                }
                animal.doStuff();
                return obj;
            }
        };
        //當前載入器
        ClassLoader cl = getClass().getClassLoader();
        //動態代理，又handler決定如何包裝
        Feature proxy = (Feature) Proxy.newProxyInstance(cl, clz.getInterfaces(), handler);
        proxy.load();
    }
}

注意看doStuff方法，一個修飾型別必然是抽象構建（Component）的子型別，它必須實現doStuff方法，此處的doStuff方法委託了動態代理執行，並且在動態代理的控制器Handler中還設定了決定修飾方式和行為的條件（即程式碼中InvocationHandler匿名類中的if判斷語句），當然，此處也可以通過讀取持久化資料的方式進行判斷，這樣就更加靈活了。

編寫客戶端進行呼叫了，程式碼如下：　

public static void main(String[] args) {
    //定義Jerry這隻老鼠
    Animal jerry = new Rat();
    //為Jerry增加飛行能力
    jerry = new DecorateAnimal(jerry, FlyFeature.class);
    //jerry增加挖掘能力
    jerry = new DecorateAnimal(jerry, DigFeature.class);
    //Jerry開始戲弄毛了
    jerry.doStuff();
}

此類程式碼只是一個比較通用的裝飾模式，只需要定義被裝飾的類及裝飾類即可，裝飾行為由動態代理實現，實現了對裝飾類和被裝飾類的完全解耦，提供了系統的擴充套件性。

建議109：不需要太多關注反射效率

反射的效率相對於正常的程式碼執行確實低很多，但它是一個非常有效的執行期工具類，只要程式碼結構清晰、可讀性好那就先開發出來，等到進行效能測試時有問題再優化。

最基本的編碼規則："Don't  Repeat Yourself"

 

編寫高質量程式碼：改善Java程式的151個建議@目錄

相關推薦