本文旨在對Java反射機制有一個全面的介紹，希望通過本文，大家會對Java反射的相關內容有一個全面的了解。
閱讀本文之前，大家可先行參閱《重新理解Java泛型》。
前言
Java反射機制是一個非常強大的功能，在很多大型項目比如Spring, Mybatis都可以看見反射的身影。通過反射機制我們可以在運行期間獲取對象的類型信息，利用這一特性我們可以實現工廠模式和代理模式等設計模式，同時也可以解決Java泛型擦除等令人苦惱的問題。本文我們就從實際應用的角度出發，來應用一下Java的反射機制。
反射基礎
p.s: 本文需要讀者對反射機制的API有一定程度的了解，如果之前沒有接觸過的話，建議先看一下官方文檔的Quick Start。
在應用反射機制之前，首先我們先來看一下如何獲取一個對象對應的反射類Class，在Java中我們有三種方法可以獲取一個對象的反射類。
通過getClass方法
在Java中，每一個Object都有一個getClass方法，通過getClass方法我們可以獲取到這個對象對應的反射類：
|
1
2
|
String s = "ziwenxie";Class<?> c = s.getClass(); |
我們也可以調用Class類的靜態方法forName：
|
1
|
Class<?> c = Class.forName("java.lang.String"); |
使用.class
或者我們也可以直接使用.class：
|
1
|
Class<?> c = String.class; |
獲取類型信息
在文章開頭我們就提到反射的一大好處就是可以允許我們在運行期間獲取對象的類型信息，下面我們通過一個例子來具體看一下。
首先我們在typeinfo.interfacea包下面新建一個接口A：
|
1
2
|
package typeinfo.interfacea;public interface A { void f(); } |
接著我們在typeinfo.packageaccess包下面新建一個接口C，接口C繼承自接口A，并且我們還另外創建了幾個用于測試的方法，注意下面幾個方法的權限都是不同的。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
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()方法中我們用到了幾個新的API，其中getDeclaredMethod()根據方法名用于獲取Class類指代對象的某個方法，然后我們通過調用invoke()方法傳入實際的對象就可以觸發對象的相關方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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); }} |
從輸出結果我們可以看出來，不管是public，default，protect還是pricate方法，通過反射類我們都可以自由調用。當然這里我們只是為了顯示反射的強大威力，在實際開發中這種技巧還是不提倡。
|
1
2
3
4
5
6
|
public C.f()typeinfo.packageaccess.Cpublic C.g()package C.u()protected C.v()private C.w() |
應用實踐
我們有下面這樣一個業務場景，我們有一個泛型集合類List<Class<? extends Pet>>，我們需要統計出這個集合類中每種具體的Pet有多少個。由于Java的泛型擦除，注意類似List<? extends Pet>的做法肯定是不行的，因為編譯器做了靜態類型檢查之后，到了運行期間JVM會將集合中的對象都視為Pet，但是并不會知道Pet代表的究竟是Cat還是Dog，所以到了運行期間對象的類型信息其實全部丟失了。p.s: 關于泛型擦除：我在上一篇文章里面有詳細解釋，感興趣的朋友可以看一看。
為了實現我們上面的例子，我們先來定義幾個類：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
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類的的實現稍微復雜一點，我們實現了Comparable接口，重新自定義了類的比較規則，如果不是很明白的話，也沒有關系，我們已經將它抽象出來了，所以不理解實現原理也沒有關系。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
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)); }} |
下面創建了一個抽象類PetCreator，以后我們通過調用arrayList()方法便可以直接獲取相關Pet類的集合。這里使用到了我們上面沒有提及的newInstance()方法，它會返回Class類所真正指代的類的實例，這是什么意思呢？比如說聲明new Dog().getClass().newInstance()和直接new Dog()是等價的。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
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; }} |
接下來我們來實現上面這一個抽象類，解釋一下下面的代碼，在下面的代碼中，我們聲明了兩個集合類，allTypes和types，其中allTypes中包含了我們呢上面所聲明的所有類，但是我們具體的類型實際上只有兩種即Mutt和EgypianMau，所以我們真正需要new出來的寵物只是types中所包含的類型，以后我們通過調用getTypes()便可以得到types中所包含的所喲類型。
|
1
2
3
4
5
6
7
8
9
10
|
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; }} |
總體的邏輯已經完成了，最后我們實現用來統計集合中相關Pet類個數的TypeCounter類。解釋一下isAssignalbeFrom()方法，它可以判斷一個反射類是某個反射類的子類或者間接子類。而getSuperclass()顧名思義就是得到某個反射類的父類了。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
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(); }} |
總結
以上就是本文關于Java反射機制實例代碼分享的全部內容，希望對大家有所幫助。如有不足之處，歡迎留言指出。感謝朋友們對本站的支持！
原文鏈接：http://www.codeceo.com/article/java-reflection.html
