现在开源框架，为了减少代码耦合度，一般用反射的方法来实现对类方法的查找等。但反射的效率究竟比直接取数据有多大差别。今天，做了个小实验。还请各位高手多多指教。直接来代码：

基本类：

1. package test;
2. import java.util.ArrayList;
3. import java.util.List;
4. public class A {
5. private int a ;
6. private String b;
7. private List c;
8. public A(){
9. this.a = 10;
10. this.b = "abcde";
11. c = new ArrayList();
12. c.add("aaa");
13. c.add("bbb");
14. }
15. public int getA() {
16. return a++;
17. }
18. public void setA(int a) {
19. this.a = a;
20. }
21. public String getB() {
22. return b;
23. }
24. public void setB(String b) {
25. this.b = b;
26. }
27. public List getC() {
28. return c;
29. }
30. public void setC(List c) {
31. this.c = c;
32. }
33. }

测试类：（引入beanUtil类）

1. package test;
2. import java.lang.reflect.InvocationTargetException;
3. import org.apache.commons.beanutils.BeanUtils;
4. public class testReflect {
5. public static void main(String[] args){
6. testReflect tr = new testReflect();
7. tr.CommonTest();
8. tr.ReflectTest();
9. }
10. public static void CommonTest(){
11. A a = new A();
12. long timeBegin = System.nanoTime();
13. for(int i =0 ;i<100000;i++){
14. a.getA();
15. }
16. long timeEnd = System.nanoTime();
17. System.out.println((timeEnd - timeBegin)/1000
18. );
19. }
20. public static void ReflectTest(){
21. try {
22. long timeBegin = System.nanoTime();
23. for(int i =0 ;i<100000;i++){
24. BeanUtils.getSimpleProperty(new A(), "a");
25. }
26. long timeEnd = System.nanoTime();
27. System.out.println((timeEnd - timeBegin)/1000
28. );
29. } catch (IllegalAccessException e) {
30. // TODO Auto-generated catch block
31. e.printStackTrace();
32. } catch (InvocationTargetException e) {
33. // TODO Auto-generated catch block
34. e.printStackTrace();
35. } catch (NoSuchMethodException e) {
36. // TODO Auto-generated catch block
37. e.printStackTrace();
38. }
39. }
40. }

一比吓了一跳，效率大概是一百倍左右。怕是由于try块的开销大，本人又把27行注释掉。结论是影响效率的主要是

27行。看来，反射耗资源的说法还真不假。