[[191526]]

引言

Java反射機(jī)制是一個(gè)非常強(qiáng)大的功能，在很多大型項(xiàng)目比如Spring, Mybatis中都可以看見反射的身影。通過反射機(jī)制我們可以在運(yùn)行期間獲取對(duì)象的類型信息，利用這一特性我們可以實(shí)現(xiàn)工廠模式和代理模式等設(shè)計(jì)模式，同時(shí)也可以解決Java泛型擦除等令人苦惱的問題。本文我們就從實(shí)際應(yīng)用的角度出發(fā)，來應(yīng)用一下Java的反射機(jī)制。

反射基礎(chǔ)

p.s: 本文需要讀者對(duì)反射機(jī)制的API有一定程度的了解，如果之前沒有接觸過的話，建議先看一下官方文檔的Quick Start。

在應(yīng)用反射機(jī)制之前，首先我們先來看一下如何獲取一個(gè)對(duì)象對(duì)應(yīng)的反射類Class，在Java中我們有三種方法可以獲取一個(gè)對(duì)象的反射類。

通過getClass方法

在Java中，每一個(gè)Object都有一個(gè)getClass()方法，通過getClass方法我們可以獲取到這個(gè)對(duì)象對(duì)應(yīng)的反射類：

String s = "http://www.ziwenxie.site"; 
 
Class<?> c = s.getClass();  

通過forName方法

我們也可以調(diào)用Class類的靜態(tài)方法forName()：

Class<?> c = Class.forName("java.lang.String"); 

使用.class

或者我們也可以直接使用.class：

Class<?> c = String.class; 

獲取類型信息

在文章開頭我們就提到反射的一大好處就是可以允許我們?cè)谶\(yùn)行期間獲取對(duì)象的類型信息，下面我們通過一個(gè)例子來具體看一下。

首先我們?cè)趖ypeinfo.interfacea包下面新建一個(gè)接口A：

package typeinfo.interfacea; 
 
public interface A { void f(); }  

接著我們?cè)趖ypeinfo.packageaccess包下面新建一個(gè)類C，類C實(shí)現(xiàn)了接口A，并且我們還另外創(chuàng)建了幾個(gè)用于測(cè)試的方法，注意下面幾個(gè)方法的權(quán)限都是不同的。

package typeinfo.packageaccess; 
 
import typeinfo.interfacea.A; 
 
class C implements A { 
    public void f() { System.out.println("public C.f()"); } 
    public void g() { System.out.println("public C.g()"); } 
    protected void v () { System.out.println("protected C.v()"); } 
    void u() { System.out.println("package C.u()"); } 
    private void w() { System.out.println("private C.w()"); } 
 
} 
 
public class HiddenC { 
    public static A makeA() { return new C(); } 
}  

在callHiddenMethod()方法中我們用到了幾個(gè)新的API，其中g(shù)etDeclaredMethod()根據(jù)方法名用于獲取Class類指代對(duì)象自己聲明的某個(gè)方法，然后我們通過調(diào)用invoke()方法就可以觸發(fā)對(duì)象的相關(guān)方法：

package typeinfo; 
 
import typeinfo.interfacea.A; 
import typeinfo.packageaccess.HiddenC; 
 
import java.lang.reflect.Method; 
 
public class HiddenImplementation { 
    public static void main(String[] args) throws Exception { 
        A a = HiddenC.makeA(); 
        a.f(); 
        System.out.println(a.getClass().getName()); 
        // Oops! Reflection still allows us to call g(): 
        callHiddenMethod(a, "g"); 
        // And even methods that are less accessible! 
        callHiddenMethod(a, "u"); 
        callHiddenMethod(a, "v"); 
        callHiddenMethod(a, "w"); 
    } 
 
    static void callHiddenMethod(Object a, String methodName) throws Exception { 
        Method g = a.getClass().getDeclaredMethod(methodName); 
        g.setAccessible(true); 
        g.invoke(a); 
    } 
}  

從輸出結(jié)果我們可以看出來，不管是public，default，protect還是private方法，通過反射類我們都可以自由調(diào)用。當(dāng)然這里我們只是為了顯示反射的強(qiáng)大威力，在實(shí)際開發(fā)中這種技巧還是不提倡。

public C.f() 
typeinfo.packageaccess.C 
public C.g() 
package C.u() 
protected C.v() 
private C.w()  

上面我們只是測(cè)試了Method對(duì)象，感興趣的讀者在熟悉了反射的API之后，不妨測(cè)試一下Filed，這里我們就不重復(fù)了。

利用動(dòng)態(tài)代理實(shí)現(xiàn)面向切面編程

AOP是Spring提供的一個(gè)強(qiáng)大特性之一，AOP的意思是面向切面編程，就是說要分離和業(yè)務(wù)不相關(guān)的代碼，當(dāng)我們需要新增相關(guān)的事務(wù)的時(shí)候，我們不想對(duì)業(yè)務(wù)本身做修改。面向切面編程和面向?qū)ο笞兂上啾鹊降子惺裁春锰幠兀覀兺ㄟ^一個(gè)例子來看一下，對(duì)于新手來說，常常會(huì)寫出下面這樣的代碼：

public class Example1 { 
    public void execute() { 
        // 記錄日志 
        Logger logger = Logger.getLog(...); 
        // 進(jìn)行性能統(tǒng)計(jì) 
        PerformanceUtil.startTimer(...); 
        // 權(quán)限檢查 
        if (!user.hasPrevilege()) { 
            // 拋出異常 
        } 
        // 執(zhí)行真正的業(yè)務(wù) 
        executeTransaction(); 
        PerformanceUtil.endTimer(); 
    } 
}  

雖然我們上面真正要執(zhí)行的業(yè)務(wù)只有executeTransaction()，但是日志，性能，權(quán)限相關(guān)的代碼差不多要將真正的業(yè)務(wù)代碼掩蓋了。而且以后如果我們還有一個(gè)Example2，它同樣需要實(shí)現(xiàn)相同的日志，性能，權(quán)限代碼。這樣當(dāng)以后我們需要新增相關(guān)的邏輯檢查的時(shí)候，我們需要所有Example進(jìn)行重構(gòu)，這顯然不符合面向?qū)ο蟮囊粋€(gè)基本原則-封裝變化。

上面這個(gè)場(chǎng)景利用模板方法和裝飾器模式都可以解決，在Spring中是通過動(dòng)態(tài)代理來實(shí)現(xiàn)的，下面我們通過一個(gè)例子來模擬一下Spring中的AOP實(shí)現(xiàn)。

我們要實(shí)現(xiàn)的業(yè)務(wù)是，統(tǒng)計(jì)員工工資的時(shí)候程序所執(zhí)行的時(shí)間以及檢查用戶的權(quán)限。首先我們先來實(shí)現(xiàn)Salary類，它里面包含一些實(shí)現(xiàn)統(tǒng)計(jì)員工工資的業(yè)務(wù)邏輯：

public interface SalaryInterface { 
    public void doSalary(); 
} 
 
public class Salary implements SalaryInterface { 
    public void doSalary() { 
        ... 
    } 
}  

通過InvocationHandler我們來實(shí)現(xiàn)動(dòng)態(tài)代理，以后當(dāng)我們調(diào)用obj的相關(guān)方法之前，都會(huì)通過invoke方法進(jìn)行代理，而不會(huì)直接調(diào)用obj方法。

public class SimpleProxy implements InvocationHandler { 
    private Object obj; 
    private Object advice; 
 
    // 綁定代理對(duì)象 
    public Object bind(Object obj, Advice advice) { 
        this.obj = obj; 
        this.advice = advice; 
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), 
            obj.getClass().getInterfaces(), this) 
    } 
 
    // 實(shí)現(xiàn)代理 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwalbe { 
        Object result = null; 
        try { 
            advice.before(); 
            result = method.invoke(obj, args); 
            advice.after(); 
        } catch(Exception e) { 
            e.printStackTrace(); 
        } 
        return result 
    } 
}  

模擬Spring中的Advice接口：

public interface Advice { 
    public void before(); 
    public void after(); 
}  

實(shí)現(xiàn)TimeAdvice用于統(tǒng)計(jì)程序的執(zhí)行時(shí)間：

public class TimeAdvice implements Advice { 
    long startTime; 
    long endTime; 
 
    @Override 
    public void before() { 
        startTime = System.nanoTime(); // 獲取開始時(shí)間 
    } 
 
    @Override 
    public void after() { 
        endTime = System.nanoTime(); // 獲取結(jié)束時(shí)間 
    } 
}  

客戶端調(diào)用代碼如下：

public class Client { 
    public static void main(String[] args) { 
        SimpleProxy = new SimpleProxy(); 
        SalaryInterface salaryInterface = 
            (SalaryInterface) simpleProxy.bind(new Salary(), new TimeAdvice()); 
        salaryInterface.doSalary(); 
    } 
}  

如果我們現(xiàn)在需要新增權(quán)限控制，我們來實(shí)現(xiàn)ControlAdvie類：

public class ControlAdvice implements Advice { 
    @Override 
    public void before() { 
        if (...) { 
            ... 
        } else { 
            ... 
        } 
    } 
 
    @Override 
    public void after() { 
        ... 
    } 
}  

而我們客戶端的代碼只需要改成simpleProxy.bind(new Salary(), new ControlAdvie)就行了，而SimpleProxy本身不需要做任何的修改。

與注解相結(jié)合

在單元測(cè)試框架比如Junit中反射機(jī)制也得到了廣泛的應(yīng)用，即通過注解的方式。下面我們簡單地來了解一下如何通過反射機(jī)制來獲取相關(guān)方法的注解信息，比如說我們有下面這樣一個(gè)業(yè)務(wù)場(chǎng)景，當(dāng)用戶在修改自己密碼的時(shí)候，為了保證密碼的安全性，我們要求用戶的新密碼要滿足一些條件，比如說至少要包含一個(gè)非數(shù)字字符，不能與以前的密碼相同之類的條件等。

import java.lang.annotation.* 
 
@Target(ElementType.METHOD) 
@Retention(RetentionPolicy.RUNTIME) 
public @interface UserCase { 
    public int id(); 
    public String description() default "no description"; 
}  

下面是我們檢測(cè)密碼的工具類的實(shí)現(xiàn)：

public class PasswordUtils { 
    @UserCase(id=47, description="Password must contain at least one numeric") 
    public boolean validatePassword(String password) { 
        return (password.matches("\\w*\\d\\w*")); 
    } 
 
    @UserCase(id=48) 
    public String encryptPassword(String password) { 
        return new StringBuilder(password).reverse().toString(); 
    } 
 
    @UserCase(id=49, description="New passwords can't equal previously used ones") 
    public boolean checkForNewPassword(List<String> prevPasswords, String password) { 
        return !prevPasswords.contains(password); 
    } 
}  

利用反射我們可以寫出更加清晰的測(cè)試代碼，其中g(shù)etDeclaredMethods()方法可以獲取相關(guān)對(duì)象自己聲明的相關(guān)方法，而getAnnotation()則可以獲取Method對(duì)象的指定注解。

public class UseCaseTracker { 
    public static void trackUseCases(List<Integer> useCases, Class<?> cl) { 
        for(Method m : cl.getDeclaredMethods()) { 
            UseCase uc = m.getAnnotation(UseCase.class); 
            if(uc != null) { 
                System.out.println("Found Use Case: " + uc.id() + " " + uc.description()); 
                useCases.remove(new Integer(uc.id())); 
            } 
        } 
 
        for(int i : useCases) { 
            System.out.println("Warning: Missing use case-" + i); 
        } 
    } 
 
    public static void main(String[] args) { 
        List<Integer> useCases = new ArrayList<Integer>(); 
        Collections.addAll(useCases, 47, 48, 49, 50); 
        trackUseCases(userCases, PasswordUtils.class); 
    } 
}  

解決泛型擦除

現(xiàn)在有下面這樣一個(gè)業(yè)務(wù)場(chǎng)景，我們有一個(gè)泛型集合類List<Class<? extends Pet>>，我們需要統(tǒng)計(jì)出這個(gè)集合類中每種具體的Pet有多少個(gè)。由于Java的泛型擦除，注意類似List<? extends Pet>的做法肯定是不行的，因?yàn)榫幾g器做了靜態(tài)類型檢查之后，到了運(yùn)行期間JVM會(huì)將集合中的對(duì)象都視為Pet，但是并不會(huì)知道Pet代表的究竟是Cat還是Dog，所以到了運(yùn)行期間對(duì)象的類型信息其實(shí)全部丟失了。p.s: 關(guān)于泛型擦除，我在上一篇文章里面有詳細(xì)解釋，感興趣的朋友可以看一看。

為了實(shí)現(xiàn)我們上面的例子，我們先來定義幾個(gè)類：

public class Pet extends Individual { 
    public Pet(String name) { super(name); } 
    public Pet() { super(); } 
} 
 
public class Cat extends Pet { 
    public Cat(String name) { super(name); } 
    public Cat() { super(); } 
} 
 
public class Dog extends Pet { 
    public Dog(String name) { super(name); } 
    public Dog() { super(); } 
} 
 
public class EgyptianMau extends Cat { 
    public EgyptianMau(String name) { super(name); } 
    public EgyptianMau() { super(); } 
} 
 
public class Mutt extends Dog { 
    public Mutt(String name) { super(name); } 
    public Mutt() { super(); } 
}  

上面的Pet類繼承自Individual，Individual類的的實(shí)現(xiàn)稍微復(fù)雜一點(diǎn)，我們實(shí)現(xiàn)了Comparable接口，重新自定義了類的比較規(guī)則，如果不是很明白的話，也沒有關(guān)系，我們已經(jīng)將它抽象出來了，所以不理解實(shí)現(xiàn)原理也沒有關(guān)系。

public class Individual implements Comparable<Individual> { 
    private static long counter = 0; 
    private final long id = counter++; 
    private String name; // name is optional 
 
    public Individual(String name) { this.name = name; } 
 
    public Individual() {} 
 
    public String toString() { 
        return getClass().getSimpleName() + (name == null ? "" : " " + name); 
    } 
 
    public long id() { return id; } 
 
    public boolean equals(Object o) { 
        return o instanceof Individual && id == ((Individual)o).id; 
    } 
 
    public int hashCode() { 
        int result = 17; 
        if (name != null) { 
            result = 37 * result + name.hashCode(); 
        } 
        result = 37 * result + (int) id; 
        return result; 
    } 
 
    public int compareTo(Individual arg) { 
        // Compare by class name first: 
        String first = getClass().getSimpleName(); 
        String argFirst = arg.getClass().getSimpleName(); 
        int firstCompare = first.compareTo(argFirst); 
        if (firstCompare != 0) { 
            return firstCompare; 
        } 
 
        if (name != null && arg.name != null) { 
            int secendCompare = name.compareTo(arg.name); 
            if (secendCompare != 0) { 
                return secendCompare; 
            } 
        } 
 
        return (arg.id < id ? -1 : (arg.id == id ? 0 : 1)); 
    } 
}  

下面創(chuàng)建了一個(gè)抽象類PetCreator，以后我們通過調(diào)用arrayList()方法便可以直接獲取相關(guān)Pet類的集合。這里使用到了我們上面沒有提及的newInstance()方法，它會(huì)返回Class類所真正指代的類的實(shí)例，這是什么意思呢?比如說聲明new Dog().getClass().newInstance()和直接new Dog()是等價(jià)的。

public abstract class PetCreator { 
    private Random rand = new Random(47); 
 
    // The List of the different getTypes of Pet to create: 
    public abstract List<Class<? extends Pet>> getTypes(); 
 
    public Pet randomPet() { 
        // Create one random Pet 
        int n = rand.nextInt(getTypes().size()); 
 
        try { 
            return getTypes().get(n).newInstance(); 
        } catch (InstantiationException e) { 
            throw new RuntimeException(e); 
        } catch (IllegalAccessException e) { 
            throw new RuntimeException(e); 
        } 
    } 
 
    public Pet[] createArray(int size) { 
        Pet[] result = new Pet[size]; 
 
        for (int i = 0; i < size; i++) { 
           result[i] = randomPet(); 
        } 
        return result; 
    } 
 
    public ArrayList<Pet> arrayList(int size) { 
        ArrayList<Pet> result = new ArrayList<Pet>(); 
        Collections.addAll(result, createArray(size)); 
        return result; 
    } 
}  

接下來我們來實(shí)現(xiàn)上面這一個(gè)抽象類，解釋一下下面的代碼，在下面的代碼中，我們聲明了兩個(gè)集合類，allTypes和types，其中allTypes中包含了我們呢上面所聲明的所有類，但是我們具體的類型實(shí)際上只有兩種即Mutt和EgypianMau，所以我們真正需要new出來的寵物只是types中所包含的類型，以后我們通過調(diào)用getTypes()便可以得到types中所包含的所有類型。

public class LiteralPetCreator extends PetCreator { 
    @SuppressWarnings("unchecked") 
    public static final List<Class<? extends Pet>> allTypes = Collections.unmodifiableList( 
        Arrays.asList(Pet.class, Dog.class, Cat.class, Mutt.class, EgyptianMau.class)); 
 
    private static final List<Class<? extends Pet>> types = allTypes.subList( 
        allTypes.indexOf(Mutt.class), allTypes.size()); 
 
    public List<Class<? extends Pet>> getTypes() { 
        return types; 
    } 
}  

總體的邏輯已經(jīng)完成了，***我們實(shí)現(xiàn)用來統(tǒng)計(jì)集合中相關(guān)Pet類個(gè)數(shù)的TypeCounter類。解釋一下isAssignalbeFrom()方法，它可以判斷一個(gè)反射類是某個(gè)反射類的子類或者間接子類。而getSuperclass()顧名思義就是得到某個(gè)反射類的父類了。

public class TypeCounter extends HashMap<Class<?>, Integer> { 
    private Class<?> baseType; 
 
    public TypeCounter(Class<?> baseType) { 
        this.baseType = baseType; 
    } 
 
    public void count(Object obj) { 
        Class<?> type = obj.getClass(); 
        if (!baseType.isAssignableFrom(type)) { 
            throw new RuntimeException( 
                obj + " incorrect type " + type + ", should be type or subtype of " + baseType); 
        } 
        countClass(type); 
    } 
 
    private void countClass(Class<?> type) { 
        Integer quantity = get(type); 
        put(type, quantity == null ? 1 : quantity + 1); 
        Class<?> superClass = type.getSuperclass(); 
        if (superClass != null && baseType.isAssignableFrom(superClass)) { 
            countClass(superClass); 
        } 
    } 
 
    @Override 
    public String toString() { 
        StringBuilder result = new StringBuilder("{"); 
 
        for (Map.Entry<Class<?>, Integer> pair : entrySet()) { 
            result.append(pair.getKey().getSimpleName()); 
            result.append("="); 
            result.append(pair.getValue()); 
            result.append(", "); 
        } 
 
        result.delete(result.length() - 2, result.length()); 
        result.append("} "); 
        return result.toString(); 
    } 
}  

測(cè)試代碼如下:

public static void main(String[] args) { 
    TypeCounter counter = new TypeCounter(Pet.class); 
    for (Pet pet : Pets.createArray(20)) { 
        System.out.println(pet.getClass().getSimpleName() + " "); 
        counter.count(pet); 
    } 
    System.out.println(counter); 
}  

References

THINKING IN JAVA