Java-反射性能优化和工具包ReflectASM

不会叫的狼

已于 2022-06-01 14:34:21 修改

阅读量1.2k

点赞数

分类专栏： Java Knowledge-Points 文章标签： java

于 2021-08-29 23:58:37 首次发布

本文链接：https://blog.csdn.net/weixin_40017062/article/details/119987954

版权

Java Knowledge-Points 专栏收录该内容

81 篇文章 1 订阅

订阅专栏

Java反射动态的获取到对象的信息以及灵活的调用对象方法等，但是听说效率很慢，测试下。

普通创建对象对比反射创建对象

public class TestUser {
    private Integer id;
    private String name;

    public String sayHi(){ return "hi";}

    public Integer getId() { return id;}
    public void setId(Integer id) {this.id = id;}
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
}

public class TestDemo {
    public static void main(String[] argv){
        testCommon();
        testReflexNoCache();
    }

    public void testCommon(){
        long start = System.currentTimeMillis();
        TestUser user = null;
        int i = 0;
        while(i<1000000){
            ++i;
            user = new TestUser();
        }
        long end = System.currentTimeMillis();
        System.out.println("普通对象创建耗时："+(end - start ) + "ms");
    }
    
    // 通过反射方式创建TestUser对象
    public void testReflexNoCache() throws Exception {
        long start = System.currentTimeMillis();
        TestUser user = null;
        int i = 0;
        while(i<1000000){
            ++i;
            user = (TestUser) Class.forName("ReflexDemo.TestUser").newInstance();
        }
        long end = System.currentTimeMillis();
        System.out.println("无缓存反射创建对象耗时："+(end - start ) + "ms");
    }
}

输出：
普通对象创建耗时：10ms
无缓存反射创建对象耗时：966ms

创建100W个对象的情况下，反射居然慢了90倍左右！

通过缓存反射方式创建对象

public void testReflexWithCache() throws Exception {
        long start = System.currentTimeMillis();
        TestUser user = null;
        Class rUserClass = Class.forName("RefleDemo.TestUser");
        int i = 0;
        while(i<1000000){
            ++i;
            user = (TestUser) rUserClass.newInstance();
        }
        long end = System.currentTimeMillis();
        System.out.println("通过缓存反射创建对象耗时："+(end - start ) + "ms");
    }

输出：
通过缓存反射创建对象耗时：41ms

通过代码我们可以发现，是Class.forName这个方法比较耗时，它实际上调用了一个本地方法，通过这个方法来要求JVM查找并加载指定的类。

所以我们在项目中使用的时候，可以把Class.forName返回的Class对象缓存起来，下一次使用的时候直接从缓存里面获取，这样就极大的提高了获取Class的效率。同理，在我们获取Constructor、Method等对象的时候也可以缓存起来使用，避免每次使用时再来耗费时间创建。

为什么Java反射性能慢效率低
程序运行期的即时编译器（JIT 编译器，Just In Time Compiler）把字节码文件编译成机器码的过程；其中即时编译器（JIT）在运行期的优化过程对于程序运行来说更重要，Java虚拟机在编译阶段的代码优化就在这里进行，由于反射涉及动态解析的类型，因此无法执行某些Java虚拟机优化。因此，反射操作的性能要比非反射操作慢，因此应该避免在对性能敏感的应用程序中频繁使用Java反射来创建对象。

反射调用方法

public void testReflexMethod() throws Exception {
        long start = System.currentTimeMillis();
        Class testUserClass = Class.forName("RefleDemo.TestUser");
        TestUser testUser = (TestUser) testUserClass.newInstance();
        Method method = testUserClass.getMethod("sayHi");
        int i = 0;
        while(i<100000000){
            ++i;
            method.invoke(testUser);
        }
        long end = System.currentTimeMillis();
        System.out.println("反射调用方法耗时："+(end - start ) + "ms");
    }

输出：
反射调用方法耗时：330ms

通过setAccessible(true)的方式可以关闭安全检查

public void testReflexMethod() throws Exception {
        long start = System.currentTimeMillis();
        Class testUserClass = Class.forName("RefleDemo.TestUser");
        TestUser testUser = (TestUser) testUserClass.newInstance();
        Method method = testUserClass.getMethod("sayHi");
        int i = 0;
        while(i<100000000){
            ++i;
            method.setAccessible(true);
            method.invoke(testUser);
        }
        long end = System.currentTimeMillis();
        System.out.println("setAccessible=true 反射调用方法耗时："+(end - start ) + "ms");
    }

输出：
setAccessible=true 反射调用方法耗时：188ms

查看API可以了解到，jdk在设置获取字段，调用方法的时候会执行安全访问检查，而此类操作会比较耗时，所以通过setAccessible(true)的方式可以关闭安全检查，从而提升反射效率。

高性能反射工具包ReflectASM

ReflectASM通过字节码生成的方式实现了更为高效的反射机制。执行时会生成一个存取类来 set/get 字段，访问方法或创建实例。

依赖：

<!--java 反射工具包 -->
<!-- https://mvnrepository.com/artifact/com.esotericsoftware/reflectasm -->
<dependency>
   <groupId>com.esotericsoftware</groupId>
   <artifactId>reflectasm</artifactId>
   <version>1.11.3</version>
</dependency>

asm框架包依赖：

<dependency>
   <groupId>org.ow2.asm</groupId>
   <artifactId>asm</artifactId>
   <version>9.2</version>
</dependency>

ConstructorAccess反射来调用构造方法

public static ConstructorAccess get(Class type)：生成字节码的方式创建 ConstructorAccess
- public abstract T newInstance()：创建实例。

创建测试类User：

class User {
    public int age;
    public String name;

    public User() {}

    public User(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" + "age=" + age + ", name='" + name + '\'' + '}';
    }
    
    public void update(int age, String name) {
        this.age = age;
        this.name = name;
    }
}

ReflectAsm反射来调用构造方法

public class ReflectAsmDemo {
    public static void main(String[] args) throws Exception {
        testConstructorAccess();
    }

    /**
     * ReflectAsm反射来调用构造方法
     */
    public static void testConstructorAccess() {
        ConstructorAccess<User> constructorAccess = ConstructorAccess.get(User.class);

        User user = constructorAccess.newInstance();
        System.out.println(user);
    }
}

输出：
User{age=0, name='null'}

FieldAccess反射获取属性

public static FieldAccess get(Class type)：生成字节码的方式创建 FieldAccess
- public void set(Object instance, String fieldName, Object value)：设置fieldName属性值。
- public Object get(Object instance, String fieldName)：获取fieldName属性值。
- public int getFieldCount()：获取字段总个数。
- public String[] getFieldNames()：获取字段名称数组。
- public int getIndex(String fieldName)：获取指定字段index。

public class ReflectAsmDemo {
    public static void main(String[] args) throws Exception {
        testFieldAccess();
    }

    /**
     * ReflectAsm反射来set/get字段值
     */
    public static void testFieldAccess() {
        FieldAccess fieldAccess = FieldAccess.get(User.class);


        String[] fieldNames = fieldAccess.getFieldNames();
        for (String fieldName : fieldNames) {
            System.out.println("fieldName=" + fieldName);
        }

        System.out.println("FieldCount=" + fieldAccess.getFieldCount());
        System.out.println("index=" + fieldAccess.getIndex("name"));

        User target = new User(28,"lili");
        fieldAccess.set(target, "age", 1);
        int age = (Integer)fieldAccess.get(target, "age");
        System.out.println(age);
    }
}

输出：
fieldName=age
fieldName=name
FieldCount=2
index=1
1

FieldAccess访问私有字段，会报错Unable to find non-private field: …。
如果想访问私有字段，可以使用反射功能先放开权限。
Field field = Animal.class.getDeclaredField(“id”);
field.setAccessible(true);

MethodAccess反射调用方法

public static MethodAccess get(Class type)：生成字节码的方式创建 MethodAccess
- public String[] getMethodNames()：获取方法名称数组。
- public Object invoke(Object object, String methodName, Object… args)：用方法名定位反射方法
- public int getIndex(String methodName, Class… paramTypes)：用方法和字段的索引定位反射方法，性能高。
- public abstract Object invoke(Object var1, int index, Object… var3)：index是上面函数获取的索引index。

public class ReflectAsmDemo {
    public static void main(String[] args) throws Exception {
        testMethodAccess();
        testMethodIndexAccess();
    }

    /**
     * ReflectAsm反射调用方法
     * 用名称定位反射方法
     */
    public static void testMethodAccess() {
        User target = new User();
        MethodAccess methodAccess = MethodAccess.get(User.class);

        String[] methodNames = methodAccess.getMethodNames();
        for (String methodName : methodNames) {
            System.out.println("methodName=" + methodName);
        }

        methodAccess.invoke(target, "update", 1, "jack");
        System.out.println(target);
    }

    /**
     * ReflectAsm反射调用方法
     * 用方法和字段的索引定位反射方法，性能高
     */
    public static void testMethodIndexAccess() {
        User target = new User();
        MethodAccess methodAccess = MethodAccess.get(User.class);
        int index = methodAccess.getIndex("update", int.class, String.class);

        methodAccess.invoke(target, index, 1, "jack");
        System.out.println(target);
    }
}

输出：
methodName=toString
methodName=update
User{age=1, name='jack'}
User{age=1, name='jack'}

ReflectASM执行效率比对

public class ReflectASMDemo {
    public static void main(String[] args) throws Exception {
        ReflectASMDemo test = new ReflectASMDemo();
        test.testJdkReflect();
        test.testReflectAsmName();
        test.testReflectAsmIndex();
    }

    /**
     * JDK反射调用方法
     * @throws Exception
     */
    public void testJdkReflect() throws Exception {
        User target = new User();
        long start = System.currentTimeMillis();
        Method method = target.getClass().getMethod("update", int.class, String.class);
        for (int i = 0; i < 100000000; i++) {
            method.invoke(target, 1, "jack");
        }
        long end = System.currentTimeMillis();
        System.out.println("timeout=" + (end - start));//418 450 426 430
    }

    /**
     * ReflectAsm反射调用方法
     * 用名称定位反射方法
     */
    public void testReflectAsmName() {
        User target = new User();
        MethodAccess access = MethodAccess.get(User.class);//生成字节码的方式创建UserMethodAccess
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            access.invoke(target, "update", 1, "jack");
        }
        long end = System.currentTimeMillis();
        System.out.println("timeout=" + (end - start));//88 64 66 50
    }

    /**
     * ReflectAsm反射调用方法
     * 用方法和字段的索引定位反射方法，性能高
     */
    public void testReflectAsmIndex() {
        User target = new User();
        MethodAccess access = MethodAccess.get(User.class);
        int index = access.getIndex("update", int.class, String.class);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            access.invoke(target, index, 1, "jack");
        }
        long end = System.currentTimeMillis();
        System.out.println("timeout=" + (end - start));//14 12 11 13
    }

    /**
     * ReflectAsm反射来set/get字段值
     */
    public void testFieldAccess() {
        User target = new User();
        FieldAccess fieldAccess = FieldAccess.get(target.getClass());
        fieldAccess.set(target, "age", 1);
        int age = (Integer)fieldAccess.get(target, "age");
        System.out.println(age);
    }

    /**
     * ReflectAsm反射来调用构造方法
     */
    public void testConstructorAccess() {
        ConstructorAccess<User> constructorAccess = ConstructorAccess.get(User.class);
        User userService = constructorAccess.newInstance();
        System.out.println(userService);
    }

    /**
     * 查找方法的索引
     */
    public void testIndex() {
        User target = new User();
        MethodAccess methodAccess = MethodAccess.get(target.getClass());
        int index = methodAccess.getIndex("update", int.class, String.class);
        System.out.println(index);
    }
}

class User {
    public int age;
    public String name;

    public void update(int age, String name) {

    }
}

结果发现，reflectASM效率明显高于Java反射获取，并且reflectASM提供通过方法名定位索引，然后通过索引调用方法，进一步提升方法调用效率。

通过reflectASM实现对象拷贝

public class BeanUtil {
    /**
     *  大小写可以忽略
     * 下划线 _ 被忽略
     * NULL值和空字符串不会覆盖新值
     *
     * @param source
     * @param target
     * @param <T>
     * @return
     */
    public static <T> T copyPropertiesIgnoreCase(Object source, Object target) {
        Map<String, Field> sourceMap = CacheFieldMap.getFieldMap(source.getClass());
        CacheFieldMap.getFieldMap(target.getClass()).values().forEach((it) -> {
            Field field = sourceMap.get(it.getName().toLowerCase().replace("_", ""));
            if (field != null) {
                it.setAccessible(true);
                field.setAccessible(true);
                try {
                    //忽略null和空字符串
                    if(field.get(source)!=null)
                        it.set(target, field.get(source));
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        });
        System.out.println(target.toString());
        return (T) target;
    }

    private static class CacheFieldMap {
        private static Map<String, Map<String, Field>> cacheMap = new HashMap<>();

        private static Map<String, Field> getFieldMap(Class clazz) {
            Map<String, Field> result = cacheMap.get(clazz.getName());
            if (result == null) {
                synchronized (CacheFieldMap.class) {
                    if (result == null) {
                        Map<String, Field> fieldMap = new HashMap<>();
                        for (Field field : clazz.getDeclaredFields()) {
                            fieldMap.put(field.getName().toLowerCase().replace("_", ""), field);
                        }
                        cacheMap.put(clazz.getName(), fieldMap);
                        result = cacheMap.get(clazz.getName());
                    }
                }
            }
            return result;
        }
    }
}

MapToObjectIgnoreCaseUtil：

package 对象拷贝;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapToObjectIgnoreCaseUtil {

    public static void main(String[] args) throws Exception {
        Map<Object, Object> map = new HashMap<>();

        map.put("fc_id", "TK");
        map.put("fc_merch_id", "123456");
        map.put("fc_merch_name", "中金");

        MerchInfo merchInfo = new MerchInfo();
        System.out.println(merchInfo);

        merchInfo = (MerchInfo) MapToObjectIgnoreCaseUtil.mapToObject(map, merchInfo.getClass());
        System.out.println(merchInfo);

    }
    public static Object mapToObject(Map<Object, Object> map, Class<?> beanClass) throws Exception {
        if (map == null)
            return null;

        Map<Object, Object> map2 = new HashMap<>();
        Set<Object> keySet = map.keySet();
        for(Object key : keySet){
            map2.put(key.toString().toLowerCase().replace("_", ""), map.get(key));
        }
        Object obj = beanClass.newInstance();
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            int mod = field.getModifiers();
            if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) {
                continue;
            }
            field.setAccessible(true);
            if (map2.containsKey(field.getName().toLowerCase().replace("_", ""))) {
                field.set(obj, map2.get(field.getName().toLowerCase().replace("_", "")));
            }
        }
        return obj;
    }
}

class MerchInfo{
    public String fcID;
    public String fcMerchId;
    public String fcMerchName;

    public String getFcID() {
        return fcID;
    }

    public void setFcID(String fcID) {
        this.fcID = fcID;
    }

    public String getFcMerchId() {
        return fcMerchId;
    }

    public void setFcMerchId(String fcMerchId) {
        this.fcMerchId = fcMerchId;
    }

    public String getFcMerchName() {
        return fcMerchName;
    }

    public void setFcMerchName(String fcMerchName) {
        this.fcMerchName = fcMerchName;
    }

    @Override
    public String toString() {
        return "MerchInfo{" +
                "fcID='" + fcID + '\'' +
                ", fcMerchId='" + fcMerchId + '\'' +
                ", fcMerchName='" + fcMerchName + '\'' +
                '}';
    }
}

不会叫的狼

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java-反射性能优化和工具包ReflectASM

1、Class.forName反射方法比较耗时，可以先把Class.forName返回的Class对象缓存起来，下次使用直接读取缓存，提高效率2、ReflectASM通过字节码生成的方式实现了更为高效的反射机制。3、ConstructorAccess反射来调用构造方法、4、FieldAccess反射获取属性5、MethodAccess反射调用方法6、reflectASM效率明显高于Java反射获取
复制链接

扫一扫