Question

正如我们所知，反射是一种灵活但慢方法，用于在运行时维护和修改代码的行为。

但是如果我们必须使用这样的功能，那么与用于动态修改的Reflection API相比，Java中是否有更快的编程技术？这些替代方案对反思的利弊是什么？

Answer 1

Reflection的另一种替代方法是动态生成类文件。这个生成的类应该执行所需的操作，例如调用在运行时发现的方法，并在编译时实现已知的interface，以便可以使用该接口以非反射方式调用生成的方法。有一个问题：如果适用，Reflection会在内部执行相同的操作。这在特殊情况下不起作用，例如调用private方法时，因为无法生成调用它的合法类文件。因此，在Reflection实现中，有不同类型的调用处理程序，使用生成的代码或本机代码。你无法击败它。

但更重要的是，Reflection会对每次调用进行安全检查。因此，只有在加载和实例化时才会检查生成的类，这可能是一个很大的胜利。但是，您也可以在setAccessible(true)实例上调用Method来进行安全检查。然后，只剩下自动装箱和varargs阵列创建的轻微性能损失。

由于 Java 7 ，两者都有替代，MethodHandle。最大的优点是，与其他两个不同，它甚至可以在安全受限的环境中工作。获取MethodHandle时会执行访问检查，但在调用时不会执行。它具有所谓的“多态签名”，这意味着您可以使用任意参数类型调用它，而无需自动装箱或创建阵列。当然，错误的参数类型会创建一个合适的RuntimeException。

（更新）使用 Java 8 ，可以选择在运行时使用lambda表达式的后端和方法引用语言功能。这个后端完全符合开头所描述的内容，动态生成一个类，它实现了一个interface，你的代码可以在编译时知道它直接调用。确切的机制是特定于实现的，因此是未定义的，但您可以假设实现将尽可能快地进行调用。 Oracle JRE的当前实现完美无缺。这不仅可以减轻您生成此类访问者类的负担，还可以执行您从未做过的事情 - 通过生成的代码调用private方法。我已更新示例以包含此解决方案。此示例使用已存在的标准interface，并恰好具有所需的方法签名。如果不存在这样的匹配interface，则必须使用具有正确签名的方法创建自己的访问者功能接口。但是，当然，现在示例代码需要运行Java 8。

这是一个简单的基准示例：

import java.lang.invoke.LambdaMetafactory;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Method;
import java.util.function.IntBinaryOperator;

public class TestMethodPerf
{
  private static final int ITERATIONS = 50_000_000;
  private static final int WARM_UP = 10;

  public static void main(String... args) throws Throwable
  {
 // hold result to prevent too much optimizations
    final int[] dummy=new int[4];

    Method reflected=TestMethodPerf.class
      .getDeclaredMethod("myMethod", int.class, int.class);
    final MethodHandles.Lookup lookup = MethodHandles.lookup();
    MethodHandle mh=lookup.unreflect(reflected);
    IntBinaryOperator lambda=(IntBinaryOperator)LambdaMetafactory.metafactory(
      lookup, "applyAsInt", MethodType.methodType(IntBinaryOperator.class),
      mh.type(), mh, mh.type()).getTarget().invokeExact();

    for(int i=0; i<WARM_UP; i++)
    {
      dummy[0]+=testDirect(dummy[0]);
      dummy[1]+=testLambda(dummy[1], lambda);
      dummy[2]+=testMH(dummy[1], mh);
      dummy[3]+=testReflection(dummy[2], reflected);
    }
    long t0=System.nanoTime();
    dummy[0]+=testDirect(dummy[0]);
    long t1=System.nanoTime();
    dummy[1]+=testLambda(dummy[1], lambda);
    long t2=System.nanoTime();
    dummy[2]+=testMH(dummy[1], mh);
    long t3=System.nanoTime();
    dummy[3]+=testReflection(dummy[2], reflected);
    long t4=System.nanoTime();
    System.out.printf("direct: %.2fs, lambda: %.2fs, mh: %.2fs, reflection: %.2fs%n",
      (t1-t0)*1e-9, (t2-t1)*1e-9, (t3-t2)*1e-9, (t4-t3)*1e-9);

    // do something with the results
    if(dummy[0]!=dummy[1] || dummy[0]!=dummy[2] || dummy[0]!=dummy[3])
      throw new AssertionError();
  }

  private static int testMH(int v, MethodHandle mh) throws Throwable
  {
    for(int i=0; i<ITERATIONS; i++)
      v+=(int)mh.invokeExact(1000, v);
    return v;
  }

  private static int testReflection(int v, Method mh) throws Throwable
  {
    for(int i=0; i<ITERATIONS; i++)
      v+=(int)mh.invoke(null, 1000, v);
    return v;
  }

  private static int testDirect(int v)
  {
    for(int i=0; i<ITERATIONS; i++)
      v+=myMethod(1000, v);
    return v;
  }

  private static int testLambda(int v, IntBinaryOperator accessor)
  {
    for(int i=0; i<ITERATIONS; i++)
      v+=accessor.applyAsInt(1000, v);
    return v;
  }

  private static int myMethod(int a, int b)
  {
    return a<b? a: b;
  }
}

在我的Java 7设置中打印的旧程序：direct: 0,03s, mh: 0,32s, reflection: 1,05s表明MethodHandle是一个不错的选择。现在，在同一台机器上运行在Java 8下运行的更新程序打印direct: 0,02s, lambda: 0,02s, mh: 0,35s, reflection: 0,40s，这清楚地表明反射性能已经提高到可能使得处理MethodHandle不必要的程度，除非您使用它来执行lambda技巧，显然优于所有反射选择，这毫不奇怪，因为它只是一个直接的调用（好吧，几乎：一个间接的水平）。请注意，我制作了目标方法private，以演示有效调用private方法的功能。

与往常一样，我必须指出这个基准的简单性以及它是多么人为的。但我认为，这种趋势清晰可见，甚至更重要，结果令人信服地可以解释。

Answer 2

我创建了一个名为lambda-factory的小型库。它基于LambdaMetafactory，但可以省去查找或创建与该方法匹配的界面的麻烦。

以下是10E8迭代的一些示例运行时（可使用PerformanceTest类重现）：

Lambda：0.02s，Direct：0.01s，反射：4.64s for method（int，int）
Lambda：0.03s，Direct：0.02s，反射：3.23s for method（Object，int）

假设我们有一个名为MyClass的类，它定义了以下方法：

private static String myStaticMethod(int a, Integer b){ /*some logic*/ }
private float myInstanceMethod(String a, Boolean b){ /*some logic*/ }

我们可以像这样访问这些方法：

Method method = MyClass.class.getDeclaredMethod("myStaticMethod", int.class, Integer.class); //Regular reflection call
Lambda lambda = LambdaFactory.create(method);  
String result = (String) lambda.invoke_for_Object(1000, (Integer) 565); //Don't rely on auto boxing of arguments!

Method method = MyClass.class.getDeclaredMethod("myInstanceMethod", String.class, Boolean.class);
Lambda lambda = LambdaFactory.create(method);
float result = lambda.invoke_for_float(new MyClass(), "Hello", (Boolean) null);  //No need to cast primitive results!

请注意，在调用lambda时，必须选择一个在其名称中包含目标方法返回类型的调用方法。 - varargs和自动拳击太贵了。

在上面的示例中，所选的invoke_for_float方法表示我们正在调用一个返回float的方法。如果您尝试访问的方法返回fx字符串，盒装基元（整数，布尔等）或某些自定义对象，则可以调用invoke_for_Object。

该项目是试验LambdaMetafactory的好模板，因为它包含各方面的工作代码：

静态调用和实例调用
访问私有方法和其他包中的方法
'invokeSpecial'逻辑，即创建的实现就是这样，它绕过了动态方法调度。

Answer 3

反射的替代方法是使用Interface。只需从Effective Java by Joshua Bloch.

开始

我们可以获得许多反思的好处，同时招致很少仅以非常有限的形式使用它的成本。对于很多必须使用在编译时不可用的类的程序，在编译时存在适当的接口或超类哪个是指班级。如果是这种情况，您可以创建实例反射并通过他们的界面正常访问它们超类。如果相应的构造函数没有参数，那么你甚至不需要使用java.lang.reflect; Class.newInstance方法提供所需的功能。

仅将反射用于创建对象，即

// Reflective instantiation with interface access
   public static void main(String[] args) {
       // Translate the class name into a Class object
       Class<?> cl = null;
       try {
           cl = Class.forName(args[0]);
       } catch(ClassNotFoundException e) {
           System.err.println("Class not found.");
           System.exit(1);
       }
       // Instantiate the class
       Set<String> s = null;
       try {
           s = (Set<String>) cl.newInstance();
       } catch(IllegalAccessException e) {
           System.err.println("Class not accessible.");
           System.exit(1);
       } catch(InstantiationException e) {
           System.err.println("Class not instantiable.");
           System.exit(1);
       }
       // Exercise the set
       s.addAll(Arrays.asList(args).subList(1, args.length));
       System.out.println(s);
}

虽然这个程序只是一个玩具，但它演示的技术是   很强大。玩具程序很容易变成通用的   set tester，用于验证指定的Set实现   积极地操纵一个或多个实例并检查它们   遵守Set契约。同样，它可以变成通用的   设置性能分析工具。事实上，这项技术已经足够了   强大的实施全面的服务提供商框架。最   当时，这种技术就是你所需要的   反射。

此示例演示了反射的两个缺点。首先，   示例可以生成三个运行时错误，所有这些错误都可以   如果没有使用反射实例化，则是编译时错误。   其次，生成一个实例需要二十行繁琐的代码   从名称的类，而构造函数调用   整齐地适合一条线。然而，这些缺点是，   限制为实例化对象的程序部分。   实例化后，它与任何其他Set无法区分   实例

更快地替代Java的反思

3 个答案: