java反射如何提升性能

原创 2016年06月12日 20:30:50

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,只是验证反射在哪些地方比较耗时,所以在处理性能优化方面没做进一步的改进。

而且从测试上也可以看出,反射其实没有想想中那么损耗性能,所以运用反射,速度上还是可以接受的。

版权声明:本文为博主原创文章,未经博主允许不得转载。

JAVA反射会降低你的程序性能吗?

JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能(www.111cn.net)够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的...
  • baidu_18607183
  • baidu_18607183
  • 2015年06月04日 23:41
  • 1594

大数据计算优化:Java 反射为什么慢?

最近在看Flink中一个新feature:使用CodeGen来优化序列化器。 Flink中会根据用户定义的输入输出信息,生成相应的序列化器,这种定制化的序列化器比起Kryo性能要高很多,因为不用写类型...
  • lzljs3620320
  • lzljs3620320
  • 2016年04月10日 08:29
  • 3710

JAVA-提高反射效率

JAVA-提高反射效率  功能说明: 从事java开发的都知道反射的运行速度慢,所以很多java的开发者都对反射机制的使用望而却步(包括BME组件SDO)。我想知道,究竟反射机制慢在哪里?有没有改进...
  • huoyunshen88
  • huoyunshen88
  • 2013年09月26日 17:22
  • 12920

Java反射三种方式的效率对比

Java反射三种方式的效率对比 field, method, BeanUtils
  • aitcax
  • aitcax
  • 2016年09月28日 22:04
  • 1964

java反射机制及性能优化问题

Java 语言的反射机制 在Java运行时环境中,对于任意一个类,可以知道这个类有哪些属性和方法。对于任意一个对象,可以调用它的任意一个方法。 这种动态获取类的信息以及动态调用对象的方法的功能...
  • u010747691
  • u010747691
  • 2015年03月20日 10:44
  • 2719

java反射的性能问题

很多IOC,还有框架都使用反射。特别是在通过反射调用方法的时候,与普通方法调用的性能相差数百倍(本机测出来是300倍以上)。 反射的确方便了编程,代码更合理更美观。300倍在一般应用上面也算不得什么...
  • hejiangtao
  • hejiangtao
  • 2012年01月10日 01:21
  • 2390

java反射机制及性能优化问题

Java 语言的反射机制 在Java运行时环境中,对于任意一个类,可以知道这个类有哪些属性和方法。对于任意一个对象,可以调用它的任意一个方法。 这种动态获取类的信息以及动态调用对象的方法的功能...
  • u010747691
  • u010747691
  • 2015年03月20日 10:44
  • 2719

JAVA反射会降低你的程序性能吗?

JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能(www.111cn.net)够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的...
  • baidu_18607183
  • baidu_18607183
  • 2015年06月04日 23:41
  • 1594

在钱柜娱乐开户中使用反射到底有多慢?

在钱柜娱乐开户中使用反射到底有多慢? 反射(Reflection)在Java和安卓开发过程中非常有用,但是反射的使用往往是APP严重性能问题的根本原因。下面我们通过分析几个真实的案例来帮助我们更直...
  • wangjigaoyi
  • wangjigaoyi
  • 2016年07月15日 09:15
  • 2656

java中提升性能对代码作的建议

  • 2012年08月08日 13:48
  • 35KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java反射如何提升性能
举报原因:
原因补充:

(最多只允许输入30个字)