时间戳

首页 > 解决方案 > 如何通过反射从静态方法中获取 Predicate？

java - 如何通过反射从静态方法中获取 Predicate？

问题描述

给定一个由静态谓词方法组成的类，我想通过反射访问它们并将它们转换为Predicate<Object>类型。

public class MyPredicates {
    public static boolean isNull(Object obj) {
        return obj == null;
    }

    public static boolean hasNegativeHashcode(Object obj) {
        return obj.hashCode() < 0;
    }
}

通常，我会编写以下代码来获取谓词：

Predicate<Object> isNull = MyPredicates::isNull;

但是，我不知道如何使用反射来做到这一点。我的意图是为这些方法创建一个注释，并通过反射获取它们，从而为我的框架创建一个可用谓词列表。

我想到了三种可能的方法，但对我来说都不是很好。

  1. 我可以留下它Method，调用invoke()并投射返回Object给boolean。但是，这将很难阅读，这意味着我无法在运行时检查类型。
  2. 我可以将反射调用包装起来，Predicate但这会涉及额外的开销。
  3. 我可以让用户分别注册每个方法（添加/删除许多方法时很难维护）。

无论如何，我担心直接使用反射会增加更多开销并减慢程序的速度。

所以，我的问题是：

  1. 我可以Predicate直接获得通过反射吗？
  2. 如果不是，那么在不增加太多开销的情况下访问这些方法的适当方法是什么，同时拥有可用的 API（例如通过涉及Predicate）？

标签： javareflectionpredicate

解决方案

TL;DR：直接从静态方法返回Predicate并将其存储以供将来使用（可能在以方法名称作为键的映射中）以消除反射访问的速度瓶颈。

public static Predicate<Object> isNull() {
    return obj -> obj == null;
}

首先，了解 JVM 如何处理方法引用很重要。在另一个问题中有一个很好的解释。查看lambda 翻译文档- 特别是Method reference capture部分。

list.filter(String::isEmpty)

被翻译为

list.filter(indy(MH(metaFactory), MH(invokeVirtual Predicate.apply), MH(invokeVirtual String.isEmpty))()))

这意味着Predicate除非您在代码中编写它，否则它在运行时不存在。可能有一种方便的方法可以通过反射 API 获取它，但据我所知，没有。您也许可以使用动态代理编写类似的东西；但是，我认为这会给代码增加不必要的复杂性。

这是实现所需行为的 4 种不同方法的基准，包括问题中提到的方法：

Benchmark                                     Mode  Cnt    Score    Error   Units
MyBenchmark.testNormal                       thrpt   30  362.782 ± 13.521  ops/us
MyBenchmark.testReflectionInvoke             thrpt   30   60.440 ±  1.394  ops/us
MyBenchmark.testReflectionWrappedPredicate   thrpt   30   62.948 ±  0.846  ops/us
MyBenchmark.testReflectionReturnedPredicate  thrpt   30  381.780 ±  5.265  ops/us
  1. testNormal::通过运算符访问谓词
  2. testReflectionInvoke直接使用invoke()方法
  3. testReflectionWrappedPredicate将invoke()方法包装到Precicate
  4. testReflectionReturnedPredicate使用返回的方法Predicate，因此反射只被调用一次

出于本示例的目的，谓词已被缓存，因为我们不是在测试获取谓词的速度，而是假设它只会执行一次。

从结果可以看出，反射比正常访问谓词慢 6 倍。因此，在我看来，最干净/最可维护的方法是使用不带参数的方法返回Predicatetype而不是boolean.

public static Predicate<Object> isNull() {
    return obj -> obj == null;
}

基准测试已使用 3 次分叉、4 次预热迭代和 10 次迭代完成。

这是我用于测试的代码，如果您想自己运行基准测试（使用 JMH 框架进行基准测试）：

public class MyBenchmark {
    public static Predicate<Object> normal = MyBenchmark::isNull;
    public static Method reflectionInvoke;
    public static Predicate<Object> reflectionWrappedPredicate;
    public static Predicate<Object> reflectionReturnedPredicate;

    static {
        try {
            Method m1 = MyBenchmark.class.getMethod("isNull", Object.class);
            reflectionInvoke = m1;
            reflectionWrappedPredicate = a -> {
                try {
                    return (boolean)m1.invoke(null, a);
                }
                catch(IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
                    return false;
                }
            };

            Method m2 = MyBenchmark.class.getMethod("isNull");
            reflectionReturnedPredicate = (Predicate)m2.invoke(null);
        }
        catch(IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException ex) {
            ex.printStackTrace();
        };
    }

    @Benchmark
    @OutputTimeUnit(TimeUnit.MICROSECONDS)
    public boolean testNormal() {
        Predicate<Object> p = normal;
        return p.test(this) | p.test(null);
    }

    @Benchmark
    @OutputTimeUnit(TimeUnit.MICROSECONDS)
    public boolean testReflectionInvoke() {
        try {
            Method m = reflectionInvoke;
            return (boolean)m.invoke(null, this) | (boolean)m.invoke(null, (Object)null);
        }
        catch(IllegalAccessException | IllegalArgumentException | InvocationTargetException | SecurityException ex) {
            ex.printStackTrace();
            return false;
        }
    }

    @Benchmark
    @OutputTimeUnit(TimeUnit.MICROSECONDS)
    public boolean testReflectionWrappedPredicate() {
        Predicate<Object> p = reflectionWrappedPredicate;
        return p.test(this) | p.test(null);
    }

    @Benchmark
    @OutputTimeUnit(TimeUnit.MICROSECONDS)
    public boolean testReflectionReturnedPredicate() {
        Predicate<Object> p = reflectionReturnedPredicate;
        return p.test(this) | p.test(null);
    }

    public static boolean isNull(Object obj) {
        return obj == null;
    }

    public static Predicate<Object> isNull() {
        return obj -> obj == null;
    }
}

推荐阅读