利用java反射调用类及父类的的私有方法

      今天和一位朋友谈到父类私有方法的调用问题，本来以为利用反射很轻松就可以实现，因为在反射看来根本不区分是否是private的，没有想到调用本身的私有方法是可以的，但是调用父类的私有方法则不行，后来纠其原因很有可能是因为getDeclaredMethod方法和getMethod方法并不会查找父类的私有方法，于是只好自己写递归了，经过尝试果然如此。把代码放出来方便更多人。这段代码可以解决很多实际问题，不过利用反射来做的话性能不会太好。

[java] view plaincopy

1. package com.syj.util.reflect;  
2.   
3. import java.lang.reflect.Method;  
4.   
5. /** 
6.  * <p> 
7.  * Title: 私有方法调用工具类 
8.  * </p> 
9.  *  
10.  * <p> 
11.  * Description:利用java反射调用类的的私有方法 
12.  * </p> 
13.  *  
14.  * <p> 
15.  * Copyright: Copyright (c) 2007 
16.  * </p> 
17.  *  
18.  * @author 孙钰佳 
19.  * @main [e-mail] 
20.  * @date Jun 1, 2008 10:18:58 PM 
21.  */  
22. public class PrivateUtil {  
23.     /** 
24.      * 利用递归找一个类的指定方法，如果找不到，去父亲里面找直到最上层Object对象为止。 
25.      *  
26.      * @param clazz 
27.      *            目标类 
28.      * @param methodName 
29.      *            方法名 
30.      * @param classes 
31.      *            方法参数类型数组 
32.      * @return 方法对象 
33.      * @throws Exception 
34.      */  
35.     public static Method getMethod(Class clazz, String methodName,  
36.             final Class[] classes) throws Exception {  
37.         Method method = null;  
38.         try {  
39.             method = clazz.getDeclaredMethod(methodName, classes);  
40.         } catch (NoSuchMethodException e) {  
41.             try {  
42.                 method = clazz.getMethod(methodName, classes);  
43.             } catch (NoSuchMethodException ex) {  
44.                 if (clazz.getSuperclass() == null) {  
45.                     return method;  
46.                 } else {  
47.                     method = getMethod(clazz.getSuperclass(), methodName,  
48.                             classes);  
49.                 }  
50.             }  
51.         }  
52.         return method;  
53.     }  
54.   
55.     /** 
56.      *  
57.      * @param obj 
58.      *            调整方法的对象 
59.      * @param methodName 
60.      *            方法名 
61.      * @param classes 
62.      *            参数类型数组 
63.      * @param objects 
64.      *            参数数组 
65.      * @return 方法的返回值 
66.      */  
67.     public static Object invoke(final Object obj, final String methodName,  
68.             final Class[] classes, final Object[] objects) {  
69.         try {  
70.             Method method = getMethod(obj.getClass(), methodName, classes);  
71.             method.setAccessible(true);// 调用private方法的关键一句话  
72.             return method.invoke(obj, objects);  
73.         } catch (Exception e) {  
74.             throw new RuntimeException(e);  
75.         }  
76.     }  
77.   
78.     public static Object invoke(final Object obj, final String methodName,  
79.             final Class[] classes) {  
80.         return invoke(obj, methodName, classes, new Object[] {});  
81.     }  
82.   
83.     public static Object invoke(final Object obj, final String methodName) {  
84.         return invoke(obj, methodName, new Class[] {}, new Object[] {});  
85.     }  
86.   
87.     /** 
88.      * 测试反射调用 
89.      *  
90.      * @param args 
91.      */  
92.     public static void main(String[] args) {  
93.         PrivateUtil.invoke(new B(), "printlnA", new Class[] { String.class },  
94.                 new Object[] { "test" });  
95.         PrivateUtil.invoke(new B(), "printlnB");  
96.     }  
97. }  
98.   
99. class A {  
100.     private void printlnA(String s) {  
101.         System.out.println(s);  
102.     }  
103. }  
104.   
105. class B extends A {  
106.     private void printlnB() {  
107.         System.out.println("b");  
108.     }  
109. }  

 

程序的输出结果为
test
b
说明private方法调用成功了不管是自己的私有方法还是父类的私有方法。