一直以来都对Java反射究竟消耗了多少效率很感兴趣，今晚总算有空进行了一下测试
测试被调用的类和方法
package com.spring.scran;
public class TestMethod {
public void test() {
for(int i = 0 ; i < 10; i ++) {
System.out.print("");
}
}
/**
* 下面几个方法没什么用的,就放着模拟几个类
*/
public void test2() {
for(int i = 0 ; i < 10000; i ++) {
System.out.print("");
}
}
public void test3() {
for(int i = 0 ; i < 10000; i ++) {
System.out.print("");
}
}
public void test4() {
for(int i = 0 ; i < 10000; i ++) {
System.out.print("");
}
}
}
测试方法的类
package com.spring.aop.test;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.spring.scran.TestMethod;
public class TestXiao {
private long start;
private int methodCount = 10000000;
private static Map<String, Method> map = new HashMap<>();
@Before
public void before(){
start = System.currentTimeMillis();
}
@After
public void after() {
System.out.println(System.currentTimeMillis() - start);
}
/**
* 普通方法
*/
@Test
public void test1() {
TestMethod method = new TestMethod();
for(int i = 0 ; i < methodCount ; i ++) {
method.test();
}
}
/**
* 反射执行方法
* @throws Exception
*/
@Test
public void test2() throws Exception{
TestMethod method = new TestMethod();
for(int i = 0 ; i < methodCount ; i ++) {
method.getClass().getMethod("test").invoke(method);
}
}
/**
* 模拟将反射得到的 Method 方法放到缓存中
* @throws Exception
*/
@Test
public void test3() throws Exception{
TestMethod testMethod = new TestMethod();
for(int i = 0 ; i < methodCount ; i ++) {
Method method = map.get("test");
if(method != null) {
method.invoke(testMethod);
} else {
method = testMethod.getClass().getMethod("test");
map.put("test", method);
method.invoke(testMethod);
}
}
}
}
测试结果
普通方法 反射方法 反射加模拟缓存
第一次 8730 10368 9111
第二次 8833 10402 9184
第三次 8893 10290 9057
根据测试结果来看，可以看出普通执行的方法确实是比反射快点，当然，这真是一个简单的测试，当反射次数越多，消耗的性能肯定就越大
同时可以看到如果把反射得到的 method 放到缓存中,那么反射执行就和普通方法差不多了，所以尽可能的把Method 放到缓存中。
总结：
反射多少会有性能损耗，但一般可以忽略，而java对javabean方面的反射支持，java底层都有PropertyDescriptor和MethodDescriptor支持，可以一定程度的减少反射消耗。 AOP方面，cglib是通过类的字节码生成其子类去操作的，一旦子类生成就是纯粹的反射调用，不再操作字节码了，而一般AOP调用是在单例上，不会频繁的去用cglib生成子类。
反射用得最多的应该就是赋值注入，像数据库表映射为JavaBean等。
反射多少会有性能损耗，但一般可以忽略，而java对javabean方面的反射支持，java底层都有PropertyDescriptor和MethodDescriptor支持，可以一定程度的减少反射消耗。 AOP方面，cglib是通过类的字节码生成其子类去操作的，一旦子类生成就是纯粹的反射调用，不再操作字节码了，而一般AOP调用是在单例上，不会频繁的去用cglib生成子类。
反射用得最多的应该就是赋值注入，像数据库表映射为JavaBean等。
绝大部分系统的性能瓶颈还远远没有到需要考虑反射这里，逻辑层和数据层上的优化对性能的提升比优化反射高n个数量级。
框架的设计是性能、标准和开发效率等多个方面的权衡。
原文地址：https://www.cnblogs.com/panchanggui/p/10345713.html