java.lang.reflect.Method （java反射机制）

公司Vac方法过滤器使用到反射机制，读取xml配置文件过滤用户访问的方法名是否合法。

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
HttpServletRequest httpRequest = (HttpServletRequest) request;
@SuppressWarnings("unchecked")
Map<Object, Object> requestData = (Map<Object, Object>) httpRequest.getAttribute("requestData");
String methodName = (String) requestData.get(METHOD);
//获得bean的配置
String beanName = mapProtocol.get(methodName).get(BEAN);
// 去除.符号
methodName = getMethod(methodName);
//从spring context中获得bean
Object instance = getContext(filterConfig).getBean(beanName);
Class<? extends Object> clazz = instance.getClass();
Object resultContent = null;
try {
Method method = clazz
.getDeclaredMethod(methodName, getParamTypes());
Map params = removeSysParams(requestData);
resultContent = method.invoke(instance, params);
} catch (InvocationTargetException e) {
if (e.getTargetException() instanceof BusinessException) {
BusinessException serviceExp = (BusinessException) e
.getTargetException();
Assert.throwBPException(serviceExp.getMessageKey(),
serviceExp.getMessage());
}
e.printStackTrace();
Assert.throwBPException(INVOCATION_TARGET_EXP, e);
} catch (NoSuchMethodException e) {
e.printStackTrace();
Assert.throwBPException(ILLEGAL_ARGUMENT_EXP, e);

}
catch (IllegalAccessException e) {
e.printStackTrace();
Assert.throwBPException(ILLEGAL_ARGUMENT_EXP, e);

}
Enumeration enumeration = httpRequest.getAttributeNames();
while (enumeration.hasMoreElements()) {
String name = enumeration.nextElement().toString();
httpRequest.removeAttribute(name);
}
httpRequest.setAttribute(RESPONSEDATA, resultContent);

}

下面是Method类的源代码及说明：

1. packagejava.lang.reflect;
3. importsun.reflect.MethodAccessor;
4. importsun.reflect.Reflection;
6. /**
7. *
8. *描述方法的类
9. *
10. *注意使用反射的方式是首先通过
11. *Class.getMethod(Stringname,Class[]parameterTypes)获得一个Method对象
12. *String表示方法名,parameterTypes表示参数列表中的每个参数对应的类型,这时先获得
13. *Class对象中Method对象,与实际的操作对象无关,然后调用此方法,是通过Method.(Objectobj,Object[]args)
14. *这里obj指调用方法的对象,args表示每个参数对应的值
15. *
16. *例子,一下两种方式的效果是一样的(当然性能不同)
17. *Stringost="lqtest";
18. *Stringnst=ost.substring(2,6);
19. *
20. *Stringost2="lqtest";
21. *Class[]types={int.class,int.class};
22. *Methodmed=String.class.getMethod("substring",types);
23. *Object[]values={newInteger(2),newInteger(6)};
24. *Stringnst2=(String)med.invoke(ost2,values);
25. *
26. *使用反射一切都是变化的,类名,方法名,参数列表,都是变量,而不是写死的,他们
27. *在运行时才知道具体值,而不是编译期
28. *
29. *commentbyliqiang
30. *
31. *@authorKennethRussell
32. *@authorNakulSaraiya
33. */
34. publicfinal
35. classMethodextendsAccessibleObjectimplementsMember{
36. //定义此方法的类对象
37. privateClassclazz;
38. privateintslot;
39. //方法名,从1.4开始它变成intern的形式
40. privateStringname;
41. //返回类型
42. privateClassreturnType;
43. //参数列表
44. privateClass[]parameterTypes;
45. //异常列表
46. privateClass[]exceptionTypes;
47. //方法的描述符
48. privateintmodifiers;
49. //处理方法的实际对象
50. privatevolatileMethodAccessormethodAccessor;
51. //如果当前对象是通过拷贝得到的,则root指向拷贝前的对象
52. privateMethodroot;
54. //调用对象的安全检查的缓存,保存上一个通过检查的调用对象,如果当前的调用对象
55. //不是上一个调用对象则做安全检查
56. privatevolatileClasssecurityCheckTargetClassCache;
58. //构造函数
59. Method(ClassdeclaringClass,
60. Stringname,
61. Class[]parameterTypes,
62. ClassreturnType,
63. Class[]checkedExceptions,
64. intmodifiers,
65. intslot)
66. {
67. this.clazz=declaringClass;
68. this.name=name;
69. this.parameterTypes=parameterTypes;
70. this.returnType=returnType;
71. this.exceptionTypes=checkedExceptions;
72. this.modifiers=modifiers;
73. this.slot=slot;
74. }
76. //通过本对象的数据生成一个新对象
77. Methodcopy(){
78. //通过本对象的数据生成一个新对象
79. Methodres=newMethod(clazz,name,parameterTypes,returnType,
80. exceptionTypes,modifiers,slot);
81. //新对象的root指向原对象
82. res.root=this;
83. //新对象与原对象公用一个MethodAccessor
84. res.methodAccessor=methodAccessor;
85. returnres;
86. }
88. //返回声明此函数的类
89. publicClassgetDeclaringClass(){
90. returnclazz;
91. }
93. //返回方法名
94. publicStringgetName(){
95. returnname;
96. }
98. //返回描述符
99. publicintgetModifiers(){
100. returnmodifiers;
101. }
103. //取得返回类型
104. publicClassgetReturnType(){
105. returnreturnType;
106. }
108. //返回参数列表
109. publicClass[]getParameterTypes(){
110. returncopy(parameterTypes);
111. }
113. //返回异常列表
114. publicClass[]getExceptionTypes(){
115. returncopy(exceptionTypes);
116. }
118. //判断obj是否与当前方法对象相等
119. publicbooleanequals(Objectobj){
120. if(obj!=null&&objinstanceofMethod){//如果是方法对象
121. //转型
122. Methodother=(Method)obj;
124. //定义此方法的类和方法名相等
125. if((getDeclaringClass()==other.getDeclaringClass())
126. &&(getName()==other.getName())){
128. /*Avoidunnecessarycloning*/
129. Class[]params1=parameterTypes;
130. Class[]params2=other.parameterTypes;
132. //比较参数列表
133. if(params1.length==params2.length){
134. for(inti=0;i<params1.length;i++){
135. if(params1[i]!=params2[i])
136. returnfalse;
137. }
138. returntrue;
139. }
141. }
142. }
143. returnfalse;
144. }
146. //返回hashCode
147. publicinthashCode(){
148. returngetDeclaringClass().getName().hashCode()^getName().hashCode();
149. }
151. //方法对象的字符串表示
152. publicStringtoString(){
153. try{
154. StringBuffersb=newStringBuffer();
155. intmod=getModifiers();
156. if(mod!=0){
157. //标志符
158. sb.append(Modifier.toString(mod)+"");
159. }
160. //注意它这里用的是Field方法中显示类的名字,这个方法显示数组类型跟Class.getName()不同
161. //添加返回类型
162. sb.append(Field.getTypeName(getReturnType())+"");
163. //添加类名
164. sb.append(Field.getTypeName(getDeclaringClass())+".");
165. //添加方法名
166. sb.append(getName()+"(");
168. //参数列表
169. Class[]params=parameterTypes;//avoidclone
170. for(intj=0;j<params.length;j++){
171. sb.append(Field.getTypeName(params[j]));
172. if(j<(params.length-1))
173. sb.append(",");
174. }
175. sb.append(")");
177. //异常列表
178. Class[]exceptions=exceptionTypes;//avoidclone
179. if(exceptions.length>0){
180. sb.append("throws");
181. for(intk=0;k<exceptions.length;k++){
182. sb.append(exceptions[k].getName());
183. if(k<(exceptions.length-1))
184. sb.append(",");
185. }
186. }
187. returnsb.toString();
188. }catch(Exceptione){
189. return"<"+e+">";
190. }
191. }
193. /**
194. *
195. *注意使用反射的方式是首先通过
196. *Class.getMethod(Stringname,Class[]parameterTypes)获得一个Method对象
197. *String表示方法名,parameterTypes表示参数列表中的每个参数对应的类型,这时先获得
198. *Class对象中Method对象,与实际的操作对象无关,然后调用此方法,是通过Method.(Objectobj,Object[]args)
199. *如果调用的方法是static的则obj对象为null,如果方法没有参数,则args的长度为0或为null
200. *如果返回值是原始类型则返回它的封装类,如果返回值是void则返回null
201. */
202. publicObjectinvoke(Objectobj,Object[]args)
203. throwsIllegalAccessException,IllegalArgumentException,
204. InvocationTargetException
205. {
206. if(!override){
207. if(!Reflection.quickCheckMemberAccess(clazz,modifiers)){
208. //获得调用对象的Class对象
209. Classcaller=Reflection.getCallerClass(1);
211. ClasstargetClass=((obj==null||!Modifier.isProtected(modifiers))
212. ?clazz
213. :obj.getClass());
214. //调用此操作的对象或方法调用作用的对象与缓存不同,则做安全检查
215. if(securityCheckCache!=caller||
216. targetClass!=securityCheckTargetClassCache){
217. Reflection.ensureMemberAccess(caller,clazz,obj,modifiers);
218. securityCheckCache=caller;
219. //通过安全检查的调用对象,缓存它供下次调用时使用
220. securityCheckTargetClassCache=targetClass;
221. }
222. }
223. }
225. if(methodAccessor==null)acquireMethodAccessor();
226. returnmethodAccessor.invoke(obj,args);
227. }
229. //如果此对象是由copy生成的,则对象与生成此对象的对象使用同一个MethodAccessor
230. privatevoidacquireMethodAccessor(){
231. MethodAccessortmp=null;
233. if(root!=null)tmp=root.getMethodAccessor();
234. if(tmp!=null){
235. methodAccessor=tmp;
236. return;
237. }
239. //不是由copy得来创建MethodAccessor对象
240. tmp=reflectionFactory.newMethodAccessor(this);
241. setMethodAccessor(tmp);
242. }
244. //返回MethodAccessor对象
245. MethodAccessorgetMethodAccessor(){
246. returnmethodAccessor;
247. }
249. //设置MethodAccessor对象
250. voidsetMethodAccessor(MethodAccessoraccessor){
251. methodAccessor=accessor;
252. if(root!=null){//如果此对象是由copy的来
253. //递归调用其上级
254. root.setMethodAccessor(accessor);
255. }
256. }
258. //生成一个新的Class数组并将原数组内容考到新数组中
259. staticClass[]copy(Class[]in){
260. intl=in.length;
262. if(l==0)
263. returnin;
265. Class[]out=newClass[l];
266. for(inti=0;i<l;i++)
267. out[i]=in[i];
269. returnout;
270. }
271. }