深入分析Java反射(八)-优化反射调用性能

Java反射的API在JavaSE1.7的时候已经基本完善，但是本文编写的时候使用的是Oracle JDK11，因为JDK11对于sun包下的源码也上传了，可以直接通过IDE查看对应的源码和进行Debug。

前一篇文章已经介绍了反射调用的底层原理，其实在实际中对大多数Java使用者来说更关系的是如何提升反射调用的性能，本文主要提供几个可行的方案。另外，由于方法调用时频率最高的反射操作，会着重介绍方法的反射调用优化。

方法一：选择合适的API

选择合适的API主要是在获取反射相关元数据的时候尽量避免使用遍历的方法，例如：

• 获取Field实例：尽量避免频繁使用Class#getDeclaredFields()或者Class#getFields()，应该根据Field的名称直接调用Class#getDeclaredField()或者Class#getField()。
• 获取Method实例：尽量避免频繁使用Class#getDeclaredMethods()或者Class#getMethods()，应该根据Method的名称和参数类型数组调用Class#getDeclaredMethod()或者Class#getMethod()。
• 获取Constructor实例：尽量避免频繁使用Class#getDeclaredConstructors()或者Class#getConstructors()，应该根据Constructor参数类型数组调用Class#getDeclaredConstructor()或者Class#getConstructor()。

其实思路很简单，除非我们想要获取Class的所有Field、Method或者Constructor，否则应该避免使用返回一个集合或者数组的API，这样子能减少遍历或者判断带来的性能损耗。

方法二：缓存反射操作相关元数据

使用缓存机制缓存反射操作相关元数据的原因是因为反射操作相关元数据的实时获取是比较耗时的，这里列举几个相对耗时的场景：

• 获取Class实例：Class#forName()，此方法可以查看源码，耗时相对其他方法高得多。
• 获取Field实例：Class#getDeclaredField()、Class#getDeclaredFields()、Class#getField()、Class#getFields()。
• 获取Method实例：Class#getDeclaredMethod()、Class#getDeclaredMethods()、Class#getMethod()、Class#getMethods()。
• 获取Constructor实例：Class#getDeclaredConstructor()、Class#getDeclaredConstructors()、Class#getConstructor()、Class#getConstructors()。

这里举个简单的例子，需要反射调用一个普通JavaBean的Setter和Getter方法：

// JavaBean
@Data
public class JavaBean {

    private String name;
}

public class Main {

	private static final Map<Class<?>, List<ReflectionMetadata>> METADATA = new HashMap<>();
	private static final Map<String, Class<?>> CLASSES = new HashMap<>();

	// 解析的时候尽量放在<cinit>里面
	static {
		Class<?> clazz = JavaBean.class;
		CLASSES.put(clazz.getName(), clazz);
		List<ReflectionMetadata> metadataList = new ArrayList<>();
		METADATA.put(clazz, metadataList);
		try {
			for (Field f : clazz.getDeclaredFields()) {
				ReflectionMetadata metadata = new ReflectionMetadata();
				metadataList.add(metadata);
				metadata.setTargetClass(clazz);
				metadata.setField(f);
				String name = f.getName();
				Class<?> type = f.getType();
				metadata.setReadMethod(clazz.getDeclaredMethod(String.format("get%s%s", Character.toUpperCase(name.charAt(0)), name.substring(1))));
				metadata.setWriteMethod(clazz.getDeclaredMethod(String.format("set%s%s", Character.toUpperCase(name.charAt(0)), name.substring(1)), type));
			}
		} catch (Exception e) {
			throw new IllegalStateException(e);
		}
	}

	public static void main(String[] args) throws Exception {
		String fieldName = "name";
		Class<JavaBean> javaBeanClass = JavaBean.class;
		JavaBean javaBean = new JavaBean();
		invokeSetter(javaBeanClass, javaBean, fieldName , "Doge");
		System.out.println(invokeGetter(javaBeanClass,javaBean, fieldName));
		invokeSetter(javaBeanClass.getName(), javaBean, fieldName , "Throwable");
		System.out.println(invokeGetter(javaBeanClass.getName(),javaBean, fieldName));
	}

	private static void invokeSetter(String className, Object target, String fieldName, Object value) throws Exception {
		METADATA.get(CLASSES.get(className)).forEach(each -> {
			Field field = each.getField();
			if (field.getName().equals(fieldName)) {
				try {
					each.getWriteMethod().invoke(target, value);
				} catch (Exception e) {
					throw new IllegalStateException(e);
				}
			}
		});
	}

	private static void invokeSetter(Class<?> clazz, Object target, String fieldName, Object value) throws Exception {
		METADATA.get(clazz).forEach(each -> {
			Field field = each.getField();
			if (field.getName().equals(fieldName)) {
				try {
					each.getWriteMethod().invoke(target, value);
				} catch (Exception e) {
					throw new IllegalStateException(e);
				}
			}
		});
	}

	private static Object invokeGetter(String className, Object target, String fieldName) throws Exception {
		for (ReflectionMetadata metadata : METADATA.get(CLASSES.get(className))) {
			if (metadata.getField().getName().equals(fieldName)) {
				return metadata.getReadMethod().invoke(target);
			}
		}
		throw new IllegalStateException();
	}

	private static Object invokeGetter(Class<?> clazz, Object target, String fieldName) throws Exception {
		for (ReflectionMetadata metadata : METADATA.get(clazz)) {
			if (metadata.getField().getName().equals(fieldName)) {
				return metadata.getReadMethod().invoke(target);
			}
		}
		throw new IllegalStateException();
	}

	@Data
	private static class ReflectionMetadata {

		private Class<?> targetClass;
		private Field field;
		private Method readMethod;
		private Method writeMethod;
	}
}

简单来说，解析反射元数据进行缓存的操作最好放在静态代码块或者首次调用的时候(也就是懒加载)，这样能够避免真正调用的时候总是需要重新加载一次反射相关元数据。

方法三：反射操作转变为直接调用

"反射操作转变为直接调用"并不是完全不依赖于反射的类库，这里的做法是把反射操作相关元数据直接放置在类的成员变量中，这样就能省去从缓存中读取反射相关元数据的消耗，而所谓"直接调用"一般是通过继承或者实现接口实现。有一些高性能的反射类库也会使用一些创新的方法：例如使用成员属性缓存反射相关元数据，并且把方法调用通过数字建立索引[Number->Method]或者建立索引类(像CGLIB的FastClass)，这种做法在父类或者接口方法比较少的时候会有一定的性能提升，但是实际上性能评估需要从具体的场景通过测试分析结果而不能盲目使用，使用这个思想的类库有CGLIB、ReflectASM等。"反射操作转变为直接调用"的最典型的实现就是JDK的动态代理，这里翻出之前动态代理那篇文章的例子来说：

// 接口
public interface Simple {

    void sayHello(String name);
}
// 接口实现
public class DefaultSimple implements Simple {

    @Override
    public void sayHello(String name) {
        System.out.println(String.format("%s say hello!", name));
    }
}
// 场景类
public class Main {

    public static void main(String[] args) throws Exception {
        Simple simple = new DefaultSimple();
        Object target = Proxy.newProxyInstance(Main.class.getClassLoader(), new Class[]{Simple.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("Before say hello...");
                method.invoke(simple, args);
                System.out.println("After say hello...");
                return null;
            }
        });
        Simple proxy = (Simple) target;
        proxy.sayHello("throwable");
    }
}

// 代理类
public final class $Proxy0 extends Proxy implements Simple {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void sayHello(String var1) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("club.throwable.jdk.sample.reflection.proxy.Simple").getMethod("sayHello", Class.forName("java.lang.String"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

这样做的话Simple接口实例虽然最终是通过反射调用sayHello(String var1)方法，但是相关元数据在静态代码块中创建并且已经缓存在类成员属性中，那么反射调用方法的性能已经优化到极致，剩下的都只是Native方法的耗时，这一点使用者在编码层面已经没有办法优化，只能通过升级JVM(JDK)、使用JIT编译器等非编码层面的手段提升反射性能。

小结

本文主要从编码层面分析反射操作一些性能优化的可行经验或者方案，或许有其他更好的优化方案，具体还是需要看使用场景。

个人博客

• Throwable's Blog

(本文完 e-a-20181216 c-2-d)