java应用反射的时候，性能往往是java程序员担心的地方，那么在大量运用反射的时候，性能的微弱提升，对这个系统而言都是如旱地逢甘霖。
下面用代码简单验证一下反射性能都损耗在哪里。
package littlehow.reflect.demo;
/**
* WorkBean 作为反射性能测试的bean
*
* @author littlehow
* @time 2016-06-13 14:27
*/
public class WorkBean {
/**
* 工作人名称
*/
private String userName;
/**
* 公司名称
*/
private String companyName;
/**
* 工作年限
*/
private int workAge;
/**
* 薪资待遇
*/
private double salary;
/**
* 无参构造
*/
public WorkBean() {
super();
}
/**
* 姓名
* @param userName
*/
public WorkBean(String userName) {
this.userName = userName;
}
/**
* 姓名和公司名称的构造
* @param userName
* @param companyName
*/
public WorkBean(String userName, String companyName) {
this(userName);
this.companyName = companyName;
}
/**
* 工作
*/
public void workAt(boolean flag) {
System.out.println(this.userName+"在"+(flag?"上午":"下午")+"上午工作的时候一直在打瞌睡!");
}
/**
* 工作
* @param flag
* @param message
*/
public void workAt(boolean flag, String message) {
System.out.println(this.userName+"在"+(flag?"上午":"下午")+message);
}
/**
* 工作
*/
public void workAt() {
System.out.println(this.userName+"工作了好久了");
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getCompanyName() {
return companyName;
}
public void setCompanyName(String companyName) {
this.companyName = companyName;
}
public int getWorkAge() {
return workAge;
}
public void setWorkAge(int workAge) {
this.workAge = workAge;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return this.userName + "在" + this.companyName + "工作了" + this.workAge + "年，现在的薪水是" + this.salary;
}
}
然后是测试反射的demo
package littlehow.reflect.demo;
import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* ReflectDemo 反射性能消耗在哪里
*
* @author littlehow
* @time 2016-06-13 14:41
*/
public class ReflectDemo {
/**
* 测试class
*/
static Class<?> clazz = WorkBean.class;
/**
* 公用构造方法缓存
*/
private static final HashMap<String, Constructor<?>> constructors = new HashMap<String, Constructor<?>>();
/**
* 公用method缓存
*/
private static final ConcurrentHashMap<String, MethodCache> methods = new ConcurrentHashMap<String, MethodCache>();
/**
* 不经过优化的构造方法性能测试
*/
@Test
public void constructorNormalTest() {
long start = System.currentTimeMillis();
try {
Object obj = null;
for(int i = 0; i < 1000000; i ++) {
Constructor<?> cons1 = clazz.getConstructor();
obj = cons1.newInstance();
Constructor<?> cons2 = clazz.getConstructor(String.class);
obj = cons2.newInstance("littlehow");
Constructor<?> cons3 = clazz.getConstructor(String.class, String.class);
obj = cons3.newInstance("littlehow", "future company");
}
System.out.println(obj);//littlehow在future company工作了0年，现在的薪水是0.0
} catch (Exception e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("use time : " + (end - start) + "ms");//平均840毫秒左右
}
/**
* 对单一的进行缓存，速度最快，但功用性不够好
* 相对于
* @see constructorNormalTest()方法，性能提升10倍
* 可见反射中对构造方法的获取非一个非常耗时的操作
*/
@Test
public void constrctorBufferOne() {
long start = System.currentTimeMillis();
try {
Constructor<?> cons1 = clazz.getConstructor();
Constructor<?> cons2 = clazz.getConstructor(String.class);
Constructor<?> cons3 = clazz.getConstructor(String.class, String.class);
Object obj = null;
for(int i = 0; i < 1000000; i ++) {
obj = cons1.newInstance();
obj = cons2.newInstance("littlehow");
obj = cons3.newInstance("littlehow", "future company");
}
System.out.println(obj);//littlehow在future company工作了0年，现在的薪水是0.0
} catch (Exception e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("use time : " + (end - start) + "ms");//平均80毫秒左右
}
/**
* key值的计算耗时也比较大，可以再进行优化
* @param clazz
* @param arguClass
* @return
* @throws NoSuchMethodException
*/
private static Constructor<?> getConstrucor(Class<?> clazz, Class<?> ...arguClass) throws NoSuchMethodException {
String key = clazz.getName();
for (Class<?> argu : arguClass) {
key = key + argu.getName();//这里会有编译优化
}
Constructor<?> constructor = constructors.get(key);
if (constructor == null) {
constructor = clazz.getConstructor(arguClass);
constructors.put(key, constructor);
}
return constructor;
}
/**
* 公用缓存，在性能和开发维护中这种处理，在性能要求不是超高的
* 系统中可以选用该方式进行构造方法的缓存，提升开发速度
* 效率相对第一个测试性能也提升了一倍多
*/
@Test
public void constructorBufferAll() {
long start = System.currentTimeMillis();
try {
Constructor<?> cons1 = clazz.getConstructor();
Constructor<?> cons2 = clazz.getConstructor(String.class);
Constructor<?> cons3 = clazz.getConstructor(String.class, String.class);
Object obj = null;
for(int i = 0; i < 1000000; i ++) {
obj = getConstrucor(clazz).newInstance();
obj = getConstrucor(clazz, String.class).newInstance("littlehow");
obj = getConstrucor(clazz, String.class, String.class).newInstance("littlehow", "future company");
}
System.out.println(obj);//littlehow在future company工作了0年，现在的薪水是0.0
} catch (Exception e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("use time : " + (end - start) + "ms");//平均330毫秒左右
}
/**
* 用class直接newInstance
* 直接用class的newInstance方式性能非常高，
* 但是局限于newInstance只能调用无参构造方法;
* 因为newInstance调用的是其内部的cacheConstructor
* 所以实例化的时候非常快
* 所以如果是无参构造方法的话，就不需要单独获取constructor，
* 因为性能相差无几
*/
@Test
public void clazzNewInstance() {
long start = System.currentTimeMillis();
try {
Object obj = null;
for(int i = 0; i < 1000000; i ++) {
obj = clazz.newInstance();
}
System.out.println(obj);//null在null工作了0年，现在的薪水是0.0
} catch (Exception e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("use time : " + (end - start) + "ms");//平均20毫秒左右
}
/**
* 方法反射示例,方法每次都去反射中寻找
*/
@Test
public void methodNormalTest() {
long start = System.currentTimeMillis();
try {
Object obj = getConstrucor(clazz, String.class, String.class).newInstance("littlehow", "old company");
for (int i = 0; i < 1000000; i ++) {
Method m = clazz.getDeclaredMethod("setWorkAge", int.class);
m.invoke(obj, i);
m = clazz.getDeclaredMethod("setSalary", double.class);
m.invoke(obj, 3500.0);
}
System.out.println(obj);//littlehow在old company工作了999999年，现在的薪水是3500.0
} catch (Exception e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("use time : " + (end - start) + "ms");//平均850毫秒左右
}
/**
* 单独缓存方法，大规模反射应用不易管理
* 相对非缓存，性能提高了14倍
*/
@Test
public void methodBufferOne() {
long start = System.currentTimeMillis();
try {
Method m1 = clazz.getDeclaredMethod("setWorkAge", int.class);
Method m2 = clazz.getDeclaredMethod("setSalary", double.class);
Object obj = getConstrucor(clazz, String.class, String.class).newInstance("littlehow", "old company");
for (int i = 0; i < 1000000; i ++) {
m1.invoke(obj, i);
m2.invoke(obj, 3500.0);
}
System.out.println(obj);//littlehow在old company工作了999999年，现在的薪水是3500.0
} catch (Exception e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("use time : " + (end - start) + "ms");//平均56毫秒左右
}
/**
* 获取方法,这里只是最初略的写了个获取的方法
* @param clazz
* @param argus
* @return
*/
private static Method getMethod(Class<?> clazz, String name, Class<?> ...argus) throws NoSuchMethodException {
MethodCache mc = methods.get(clazz.getName());
if (mc == null) {
mc = new MethodCache(clazz);
methods.put(clazz.getName(), mc);
}
return mc.getMethod(name, argus);
}
/**
* 进一步缓存，牺牲内存提升速度，速度提升明显
*/
static class MethodCache {
private Class<?> clazz;
/**
* 缓存
*/
private Map<String, Method> methods = new HashMap<String, Method>();
public MethodCache(Class<?> clazz) {
this.clazz = clazz;
Method[] methodArr = clazz.getDeclaredMethods();
List<String> remove = new ArrayList<String>();
//私有的method不缓存,static方法不缓存
for (Method m : methodArr) {
if (!m.isAccessible() && ((1 & m.getModifiers()) > 0) && ((8 & m.getModifiers()) == 0)) {
Method old = methods.put(m.getName(), m);
//如果old不为空,表示方法多了重载,需要处理特殊处理
if (old != null) {
put(old);
put(m);
remove.add(m.getName());
}
}
}
for (String s : remove) {
methods.remove(s);
}
}
/**
* 按照参数进行put
* @param method
*/
private void put(Method method) {
Type[] types = method.getParameterTypes();
String key = method.getName() + types.length;
for (Type type : types) {
String str = type.toString();
if (str.startsWith("class ")) {
str = str.substring(6);
}
key += str;
}
methods.put(key, method);
}
/**
* 获取方法
* @param name
* @param argus
* @return
* @throws NoSuchMethodException
*/
public Method getMethod(String name, Class<?> ...argus) throws NoSuchMethodException{
Method m = methods.get(name);
if (m == null) {
name = name + argus.length;
for(Class<?> argu : argus) {
name = name + argu.getName();
}
m = methods.get(name);
}
return m;
}
}
/**
* 因为在大规模反射应用中，
* @see methodBufferOne()方法并不容易扩展
* 特别是自己写的动态代理进行aop切入时，
* 对一些方法进行置换处理时，就需要有个管理的缓存
*/
@Test
public void methodBufferAll() {
long start = System.currentTimeMillis();
try {
Object obj = getConstrucor(clazz, String.class, String.class).newInstance("littlehow", "old company");
//测试是否能获取不同的重载方法
getMethod(clazz, "workAt").invoke(obj);//littlehow工作了好久了
getMethod(clazz, "workAt", boolean.class).invoke(obj, false);//littlehow在下午上午工作的时候一直在打瞌睡!
getMethod(clazz, "workAt", boolean.class, String.class).invoke(obj, true, "一直努力解决问题");//littlehow在上午一直努力解决问题
for (int i = 0; i < 1000000; i ++) {
getMethod(clazz, "setWorkAge", int.class).invoke(obj, i);
getMethod(clazz, "setSalary", double.class).invoke(obj, 3500.0);
}
System.out.println(obj);//littlehow在old company工作了999999年，现在的薪水是3500.0
} catch (Exception e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("use time : " + (end - start) + "ms");//平均130毫秒左右
}
}
经过测试，可以发现，反射主要性能损耗是在对方法或变量的获取时，我们可以从这些方面入手，力求做到性能的极致。
因为我这里只是简单的demo，只是验证反射在哪些地方比较耗时，所以在处理性能优化方面没做进一步的改进。
而且从测试上也可以看出，反射其实没有想想中那么损耗性能，所以运用反射，速度上还是可以接受的。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
