我有一个采用功能参数的方法,例如一个Runnable
。由于它是一个库方法,我希望它使用从函数参数派生的记录器。对函数参数调用getClass
对正常类很好,对于嵌套或匿名类我可以getEnclosingClass
;但如果它是一个lambda表达式,它会返回一个含有$$Lambda$
的模糊名称,我可以像这样手动剥离:
Class<?> type = runnable.getClass();
String canonical = type.getCanonicalName();
int lambdaOffset = canonical.indexOf("$$Lambda$");
if (lambdaOffset > 0) {
try {
type = Class.forName(canonical.substring(0, lambdaOffset));
} catch (ClassNotFoundException e) {
// strange, but we can stick to the type we already have
}
}
正如您所看到的,这不是很优雅,可能不便携。我已尝试getEnclosingClass
,getEnclosingMethod
和getEnclosingConstructor
,但他们都返回null
。
有什么想法吗?
答案 0 :(得分:7)
正如Tassos Bassoukos已经提到的那样,它是设计的。
Lambda(类)的字节码是在运行时生成的。所以你得到的是班级的实际名称。名称生成为target class name + "$$Lambda$" + a counter
。
找一个小片段进行演示。
package sub.optimal;
import static java.lang.System.out;
public class EnclosingClass {
static class InnerRunnable implements Runnable {
@Override
public void run() {
out.println("--- inner class");
}
}
public static void main(String... args) {
showIdentity(() -> System.out.println("--- lambda 1"));
showIdentity(() -> System.out.println("--- lambda 2"));
showIdentity(new InnerRunnable());
showIdentity(new Runnable() {
@Override
public void run() {
out.println("--- anonymous class");
}
});
}
private static void showIdentity(Runnable runnable) {
runnable.run();
Class<? extends Runnable> clazz = runnable.getClass();
out.printf("class name : %s%n", clazz.getName());
out.printf("class hashcode : %s%n", clazz.hashCode());
out.printf("canonical name : %s%n", clazz.getCanonicalName());
out.printf("enclosing class: %s%n", clazz.getEnclosingClass());
out.println();
}
}
<强>输出强>
--- lambda 1
class name : sub.optimal.EnclosingClass$$Lambda$1/2147972
class hashcode : 2147972
canonical name : sub.optimal.EnclosingClass$$Lambda$1/2147972
enclosing class: null
--- lambda 2
class name : sub.optimal.EnclosingClass$$Lambda$2/10376386
class hashcode : 10376386
canonical name : sub.optimal.EnclosingClass$$Lambda$2/10376386
enclosing class: null
--- inner class
class name : sub.optimal.EnclosingClass$InnerRunnable
class hashcode : 28014437
canonical name : sub.optimal.EnclosingClass.InnerRunnable
enclosing class: class sub.optimal.EnclosingClass
--- anonymous class
class name : sub.optimal.EnclosingClass$1
class hashcode : 19451386
canonical name : null
enclosing class: class sub.optimal.EnclosingClass
答案 1 :(得分:0)
我在benjiweber找到了一个很酷的解决方案。归结为将lamda序列化为AddIdentityServer().AddConfigurationStore(...)
然后得到它的声明类:
java.lang.invoke.SerializedLambda
这是很多代码,但我的机器上的开销大约是0.003毫秒,这对大多数用例来说都没问题。
你可以做其他很酷的事情:
private static final int COUNT = 1_000_000;
private static boolean first = true;
public static void main(String[] args) {
long t = System.currentTimeMillis();
for (int i = 0; i < COUNT; i++) {
showIdentity(() -> {
});
}
String time = NumberFormat.getNumberInstance().format((double) (System.currentTimeMillis() - t) / COUNT);
System.out.println("time per call: " + time + "ms");
}
public interface MethodAwareRunnable extends Runnable, Serializable {}
private static void showIdentity(MethodAwareRunnable consumer) {
consumer.run();
String name = name(consumer);
if (first) {
first = false;
Class<?> clazz = consumer.getClass();
System.out.printf("class name : %s%n", clazz.getName());
System.out.printf("class hashcode : %s%n", clazz.hashCode());
System.out.printf("canonical name : %s%n", clazz.getCanonicalName());
System.out.printf("enclosing class: %s%n", clazz.getEnclosingClass());
System.out.printf("lambda name : %s%n", name);
}
}
private static String name(Object consumer) {
return method(consumer).getDeclaringClass().getName();
}
private static SerializedLambda serialized(Object lambda) {
try {
Method writeMethod = lambda.getClass().getDeclaredMethod("writeReplace");
writeMethod.setAccessible(true);
return (SerializedLambda) writeMethod.invoke(lambda);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static Class<?> getContainingClass(SerializedLambda lambda) {
try {
String className = lambda.getImplClass().replaceAll("/", ".");
return Class.forName(className);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static Method method(Object lambda) {
SerializedLambda serialized = serialized(lambda);
Class<?> containingClass = getContainingClass(serialized);
return Arrays.stream(containingClass.getDeclaredMethods())
.filter(method -> Objects.equals(method.getName(), serialized.getImplMethodName()))
.findFirst()
.orElseThrow(RuntimeException::new);
}