Java反射影响程序执行效率吗

短命女 2022-12-11 03:25 199阅读 0赞

**真的影响！！！**

## 什么是反射 ##

回忆下初学java时的场景：  
一切皆对象！new出对象后，直接用对象点方法执行，完成一次调用！（当然也可以用类直接点方法，执行静态方法）

直到学习了jdbc,第一步就是Class.forName(String className).当时老师说，这是为了加载驱动0.0，如果不执行这一句直接获取jdbc连接，会报找不到类（后来的版本改为自动加载，不需要显示的调用Class.forName了）。这里就用到了反射。那么反射到底是什么？

有反就有正，正常情况是：已知一个类，可以通过类名调用静态方法及静态属性，或者new出对象调用实例方法及实例属性。而对于一个未知的类，通过Reflection(反射)动态解析获取类的属性和方法并使用，这就是反射。

反射是java的一个非常重要的高级特性，使用反射可以完全解析程序中的任何类并使用，使程序拥有了动态特性。

举个简单例子，sql查出来的字段如何自动填充到bean中？（此处有个前提，db字段和bean属性有规律，或者存在一个映射关系，且bean实现了属性的get/set方法）  
1.sql查出来的结果集转化为map（k-v : 字段名-值）  
2.通过反射解析bean获取属性(Field)及方法(Method)  
3.通过map key对应到属性及方法，如 user\_name，对应bean属性userName，方法setUserName  
4.创建一个bean实例A（getInstance），执行方法Method 的invoke方法，传入map value，相当于执行A.setUserName(value)  
这样我们就可以处理所有符合上述情况的查询，而不是在程序中写死只能处理一个具体的类，orm框架就是大量用到了反射。

## 反射为什么影响效率 ##

开局一句话，剩下全靠编！  
反射这么好用，真的影响效率吗，还能愉快使用吗？  
使用反射真的没有直接调用快，但是该用还是要用，影响效率的原因搞清楚了，尽可能避免就是了。下面来看看，反射怎么影响效率了 。

测试反射是否影响效率，思路如下：  
1.创建一个Student类，属性包含姓名、年龄、性别，方法say返回属性拼接  
2.创建一个数据初始化方法，可以返回指定数量的Student集合，Student名字固定，年龄性别可以给随机值  
3.创建正常遍历Student集合的方法test  
4.创建反射遍历Student集合的方法testReflect，此方法在遍历开始前反射得到Student say方法的Method  
5.创建反射遍历Student集合的方法testReflectOne，此方法在遍历开始后每次遍历时反射得到Student say方法的Method  
6.创建反射遍历Student集合的方法testReflectPre，此方法提前反射获取Student say方法的Method，多次遍历不会重复使用反射  
7.循环多次调用3/4/5/6方法，打印平均及总耗时，对比效率

代码如下：

import lombok.Data;
    
    /** * <p></p> * * @author 0.0 * @since 2020-09-27 16:52 */
    @Data
    public class Student { 
    
        private String name;
    
        private int age;
    
        private int sex;// 男/女/位置：0/1/-1
    
        public String say() { 
            StringBuffer sb = new StringBuffer();
            sb.append("我的名字叫[").append(name).append("], 年龄[").append(age).append("], 性别[").append(this.getSexDisplay()).append("]");
            return sb.toString();
        }
    
        private String getSexDisplay() { 
            switch (sex) { 
                case 0: return "男";
                case 1: return "女";
                case -1: return "未知";
                default: return "未知";
            }
        }
    }

import java.lang.reflect.Method;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Random;
    
    /** * <p></p> * * @author 0.0 * @since 2020-09-27 16:52 */
    public class MainTest { 
    
        private static final Random RANDOM = new Random();
        // 初始化数据的总数
        private static final int DATA_INIT_TOTAL = 4000000;
        private static final List<Long> COST = new ArrayList<>();
        private static final List<Long> REFLECT_COST = new ArrayList<>();
        private static final List<Long> REFLECT_PRE_COST = new ArrayList<>();
        private static final List<Long> REFLECT_MORE_COST = new ArrayList<>();
    
        public static void main(String[] args) throws Exception { 
    
            // 执行次数
            int total = 15;
            Method sayMethod = Student.class.getDeclaredMethod("say");
            List<Student> studentList = initData(DATA_INIT_TOTAL);
            for (int i = 0; i < total; i++) { 
                test(i, studentList);
                testReflectPre(i, sayMethod, studentList);
                testReflect(i, studentList);
                testReflectOne(i, studentList);
                System.out.println("-----");
            }
    
            System.out.println("平均直接调用耗时：" + COST.stream().mapToLong(Long::longValue).sum() / COST.size() + "ms");
            System.out.println("平均预反射调用耗时：" + REFLECT_PRE_COST.stream().mapToLong(Long::longValue).sum() / COST.size() + "ms");
            System.out.println("平均反射(一次)调用耗时：" + REFLECT_COST.stream().mapToLong(Long::longValue).sum() / COST.size() + "ms");
            System.out.println("平均反射(每次)调用耗时：" + REFLECT_MORE_COST.stream().mapToLong(Long::longValue).sum() / COST.size() + "ms");
        }
    
        /** * 直接调用方法 * @param total * @throws Exception */
        private static void test(int total, List<Student> studentList) throws Exception { 
            long beginProcessTime = beginTime();
            for (Student student : studentList) { 
                student.say();
            }
    
            long costTime = costTime(beginProcessTime);
            COST.add(costTime);
            System.out.println("第[" + total + "]直接处理总耗时:" + costTime + "ms");
        }
    
        /** * 只获取一次反射Method * @param total * @throws Exception */
        private static void testReflect(int total, List<Student> studentList) throws Exception { 
            long beginProcessTime = beginTime();
            Method sayMethod = Student.class.getDeclaredMethod("say");
            for (Student student : studentList) { 
                sayMethod.invoke(student, null).toString();
            }
    
            long costTime = costTime(beginProcessTime);
            REFLECT_COST.add(costTime);
            System.out.println("第[" + total + "]反射(一次)处理总耗时:" + costTime + "ms");
        }
    
        /** * 每次执行时反射获取Method * @param total * @throws Exception */
        private static void testReflectOne(int total, List<Student> studentList) throws Exception { 
            long beginProcessTime = beginTime();
            for (Student student : studentList) { 
                Method sayMethod = Student.class.getDeclaredMethod("say");
                sayMethod.invoke(student, null).toString();
            }
    
            long costTime = costTime(beginProcessTime);
            REFLECT_MORE_COST.add(costTime);
            System.out.println("第[" + total + "]反射(每次)处理总耗时:" + costTime + "ms");
        }
    
        /** * 预先获取反射方法，此处只执行invoke * @param total * @param sayMethod * @throws Exception */
        private static void testReflectPre(int total, Method sayMethod, List<Student> studentList) throws Exception { 
            long beginProcessTime = beginTime();
            int i = 0;
            //double totalCost = 0d;
            for (Student student : studentList) { 
                i++;
                long startTime = beginTime();
                sayMethod.invoke(student, null).toString();
                long totalTime = costTime(startTime);
                //totalCost += totalTime;
                /*if (i % 10000 == 0) { System.out.println("totalCost:" + totalCost + "ms"); System.out.println("totalCost avg:" + String.format("%.5f", totalCost / i) + "ms"); }*/
            }
            long costTime = costTime(beginProcessTime);
            REFLECT_PRE_COST.add(costTime);
            System.out.println("第[" + total + "]预反射处理总耗时:" + costTime + "ms");
        }
    
        private static long beginTime() { 
            long beginTime = System.currentTimeMillis();
            return beginTime;
        }
    
        private static long costTime(long beginTime) { 
            long endTime = System.currentTimeMillis();
            return (endTime - beginTime);
        }
    
        public static List<Student> initData(int size) { 
            List<Student> studentList = new ArrayList<>();
            for (int i = 0; i < size; i++) { 
                Student tmp = new Student();
                tmp.setName("张三");
                tmp.setAge(RANDOM.nextInt(100));
                tmp.setSex((i + RANDOM.nextInt(5)) % 2);
                studentList.add(tmp);
            }
    
            return studentList;
        }
    }

看下执行结果：

第[0]直接处理总耗时:587ms
    第[0]预反射处理总耗时:502ms
    第[0]反射(一次)处理总耗时:377ms
    第[0]反射(每次)处理总耗时:780ms
    -----
    第[1]直接处理总耗时:292ms
    第[1]预反射处理总耗时:373ms
    第[1]反射(一次)处理总耗时:280ms
    第[1]反射(每次)处理总耗时:686ms
    -----
    第[2]直接处理总耗时:274ms
    第[2]预反射处理总耗时:294ms
    第[2]反射(一次)处理总耗时:279ms
    第[2]反射(每次)处理总耗时:647ms
    -----
    第[3]直接处理总耗时:273ms
    第[3]预反射处理总耗时:295ms
    第[3]反射(一次)处理总耗时:284ms
    第[3]反射(每次)处理总耗时:645ms
    -----
    第[4]直接处理总耗时:269ms
    第[4]预反射处理总耗时:302ms
    第[4]反射(一次)处理总耗时:278ms
    第[4]反射(每次)处理总耗时:644ms
    -----
    第[5]直接处理总耗时:276ms
    第[5]预反射处理总耗时:296ms
    第[5]反射(一次)处理总耗时:280ms
    第[5]反射(每次)处理总耗时:647ms
    -----
    ...

再来一次

第[0]直接处理总耗时:600ms
    第[0]预反射处理总耗时:480ms
    第[0]反射(一次)处理总耗时:376ms
    第[0]反射(每次)处理总耗时:795ms
    -----
    第[1]直接处理总耗时:283ms
    第[1]预反射处理总耗时:374ms
    第[1]反射(一次)处理总耗时:282ms
    第[1]反射(每次)处理总耗时:704ms
    -----
    第[2]直接处理总耗时:274ms
    第[2]预反射处理总耗时:299ms
    第[2]反射(一次)处理总耗时:284ms
    第[2]反射(每次)处理总耗时:660ms
    -----
    第[3]直接处理总耗时:277ms
    第[3]预反射处理总耗时:298ms
    第[3]反射(一次)处理总耗时:285ms
    第[3]反射(每次)处理总耗时:658ms
    -----
    第[4]直接处理总耗时:270ms
    第[4]预反射处理总耗时:303ms
    第[4]反射(一次)处理总耗时:285ms
    第[4]反射(每次)处理总耗时:656ms
    -----
    ...

400W对象的遍历，能说明一定问题，反射后**只是使用method.invoke方法，执行效率和直接调用差不多！，频繁使用getDeclaredMethod方法会极大地影响程序执行效率！**

进入getDeclaredMethod方法，可以看到，先检查，然后查找  
检查啥：“Check if client is allowed to access members. If access is denied”，方法是否允许访问。修饰符，包等  
查找啥：遍历类的所有方法，根据名字和入参匹配唯一一个返回

@CallerSensitive
    public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
        throws NoSuchMethodException, SecurityException { 
        checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true);
        Method method = searchMethods(privateGetDeclaredMethods(false), name, parameterTypes);
        if (method == null) { 
            throw new NoSuchMethodException(getName() + "." + name + argumentTypesToString(parameterTypes));
        }
        return method;
    }

所以 这是一个比较复杂的操作，执行的多了，必然耗时。  
**但是，一个类的属性和方法是有限的，没必要每次都反射获取吧？所以，如果可能，提前反射好，后面直接用，效率影响不大**