JAVA反射工具类

populace

鉴于android的源码隐藏了部分关键方法不给使用，所以去查了反射机制写了这个工具类。
使用方法：直接调用invoke方法即可。其他的方法应该用不上。

[Java]代码

1. package com.linin.utils;
   
2. 
   
3. import java.lang.reflect.Method;
   
4. 
   
5. /**
   
6. * 反射工具
   
7. *
   
8. * @author linin
   
9. */
   
10. public class ReflectUtil {
    
11. 
    
12.     /**
    
13.      * 根据对象，返回一个class对象，用于获取方法
    
14.      */
    
15.     public static Class<?> getClass(Object obj) {
    
16.         try {
    
17.             return Class.forName(obj.getClass().getName());
    
18.         } catch (Exception e) {
    
19.             e.printStackTrace();
    
20.             return null;
    
21.         }
    
22.     }
    
23. 
    
24.     /**
    
25.      * 根据对象，获取某个方法
    
26.      *
    
27.      * @param obj
    
28.      *            对象
    
29.      * @param methodName
    
30.      *            方法名
    
31.      * @param parameterTypes
    
32.      *            该方法需传的参数类型，如果不需传参，则不传
    
33.      */
    
34.     public static Method getMethod(Object obj, String methodName,
    
35.             Class<?>... parameterTypes) {
    
36.         try {
    
37.             Method method = getClass(obj).getDeclaredMethod(methodName,
    
38.                     parameterTypes);
    
39.             method.setAccessible(true);
    
40.             return method;
    
41.         } catch (Exception e) {
    
42.             e.printStackTrace();
    
43.             return null;
    
44.         }
    
45.     }
    
46. 
    
47.     public static Method getMethod(Class<?> cls, String methodName,
    
48.             Class<?>... parameterTypes) {
    
49.         try {
    
50.             Method method = cls.getDeclaredMethod(methodName, parameterTypes);
    
51.             method.setAccessible(true);
    
52.             return method;
    
53.         } catch (Exception e) {
    
54.             e.printStackTrace();
    
55.             return null;
    
56.         }
    
57.     }
    
58. 
    
59.     /**
    
60.      * 直接传入对象、方法名、参数，即可使用该对象的隐藏方法
    
61.      *
    
62.      * @param obj
    
63.      * @param methodName
    
64.      * @param parameter
    
65.      */
    
66.     public static Object invoke(Object obj, String methodName,
    
67.             Object... parameter) {
    
68.         Class<?>[] parameterTypes = new Class<?>[parameter.length];
    
69.         for (int i = 0; i < parameterTypes.length; i++) {
    
70.             parameterTypes[i] = parameter[i].getClass();
    
71.         }
    
72.         try {
    
73.             return getMethod(obj, methodName, parameterTypes).invoke(obj,
    
74.                     parameter);
    
75.         } catch (Exception e) {
    
76.             e.printStackTrace();
    
77.             return null;
    
78.         }
    
79.     }
    
80. 
    
81.     /**
    
82.      * 直接传入类名、方法名、参数，即可使用该对象的隐藏静态方法
    
83.      *
    
84.      * @param cls
    
85.      * @param methodName
    
86.      * @param parameter
    
87.      */
    
88.     public static Object invoke(Class<?> cls, String methodName,
    
89.             Object... parameter) {
    
90.         Class<?>[] parameterTypes = new Class<?>[parameter.length];
    
91.         for (int i = 0; i < parameterTypes.length; i++) {
    
92.             parameterTypes[i] = parameter[i].getClass();
    
93.         }
    
94.         try {
    
95.             return getMethod(cls, methodName, parameterTypes).invoke(null,
    
96.                     parameter);
    
97.         } catch (Exception e) {
    
98.             e.printStackTrace();
    
99.             return null;
    
100.         }
     
101.     }
     
102. 
     
103. }
     

复制代码

renxiao2003

不错，把Java反射常用的方式集中起来了。