Java反射效率

来源：互联网发布：华三交换机进入端口编辑：程序博客网时间：2024/06/05 19:39

最近一个项目需要设计一个松散的Connector框架，要求可以灵活扩展。本来可以使用JCA，但我想到JCA又有点重了。于是想用反射自己做一个Connector简单设计。但是，问题就来了，反射的效率到底如何呢？

为了得到这个问题的答案，自己写了个简单的代码去论证。

TestClass.java

class TestClass{
    long num;

    public long getNum() {
        return num;
    }

    public void setNum(long num) {
        this.num = num;
    }
}

ReflectTest.java

import java.lang.reflect.Method;


public class ReflectTest {
    
    private final int ROUND = 500000;
    private TestClass t = new TestClass();
    
    long sum =0;
    
    public long test(int option) {
        long beginTime = System.currentTimeMillis();
        switch(option)
        {
        case 1:
            System.out.println("Direct test:");
            directTest();
            break;
        case 2:
            System.out.println("Standard reflect:");
            standardReflect();
            break;
        case 3:
            System.out.println("Cached reflect:");
            cachedReflect();
            break;
        default:
            System.out.println("Wrong option!");
        }
        long endTime = System.currentTimeMillis();
        return (endTime-beginTime);
    }

    private void cachedReflect() {
        sum = 0;
        try {
            Class<?> c = Class.forName("TestClass");
            Class<?>[] argType = new Class[1];
            argType[0] = long.class;
            Method m = c.getMethod("setNum", argType);
            for(int i=0;i<ROUND;i++)
            {
                m.invoke(t, i);
                sum += t.getNum();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    private void standardReflect() {
        sum = 0;
        for(int i=0;i<ROUND;i++)
        {
            try {
                Class<?> c = Class.forName("TestClass");
                Class<?>[] argType = new Class[1];
                argType[0] = long.class;
                Method m = c.getMethod("setNum", argType);
                m.invoke(t, i);
                sum += t.getNum();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


    private void directTest()
    {
        sum = 0;
        for(int i=0;i<ROUND;i++)
        {
            t.setNum(i);
            sum += t.getNum();
        }
    }

    public static void main(String[] args) {
        ReflectTest t =new ReflectTest();
        
        for(int i=1;i<4;i++)
        {
            System.out.println(t.test(i));
        }
        
    }
}

测试结果：

Direct test:

Standard reflect:

1847

Cached reflect:

340

可以得出以下结论：

1. 反射主要花时间的还是ClassForName这里，寻找并返回Class实例；

2. JDK1.7优化反射做的不错，基本上在30倍左右，如果不是大量使用，时间开销其实还可以接受。当然，高并发情况下可能就不能用了。