Java Lambda 表达式和匿名类在作为隐藏类加载时不起作用

您不能将任意类转换为隐藏类.

documentation of defineHiddenClass包含这样的句子

• 在try 解析运行时常量池中由this_class指示的条目时，符号引用被认为解析为C，解析总是立即成功.

它没有明确说明的是，这是唯一一个类型解析在隐藏类中结束的地方.

但在bug report JDK-8222730年里，它被明确地说过:

对于隐藏类，其指定的隐藏名称只能通过隐藏类的"this_class"常量池条目访问.

即使在隐藏类中，也不应该通过在方法或字段签名中指定其原始名称来访问该类.

我们可以查一下.即使是像这样一个简单的 case

public class HiddenClassLambdaTest {

    public static void main(String[] args) throws Throwable {
        byte[] classFileContents = HiddenClassLambdaTest.class
            .getResourceAsStream("HiddenClassLambdaTest$LambdaRunner.class")
            .readAllBytes();
        var hidden = MethodHandles.lookup()
            .defineHiddenClass(classFileContents, true, ClassOption.NESTMATE);
        Runnable lambdaRunnerInstance = (Runnable)hidden.findConstructor(
            hidden.lookupClass(), MethodType.methodType(void.class)).invoke();
        lambdaRunnerInstance.run();
    }

    static class LambdaRunner implements Runnable {
        LambdaRunner field = this;

        @Override
        public void run() {
        }
    }
}

已经失败了.请注意，这是一种特殊情况，try 解析隐藏类中的原始类名LambdaRunner不会失败，因为您使用现有类作为模板.因此，由于隐藏类和现有的LambdaRunner类之间不匹配，您会得到IncompatibleClassChangeError或VerifierError.当您不使用现有类的类定义时，您会得到NoClassDefFoundError.

同样的道理也适用于

    static class LambdaRunner implements Runnable {
        static void method(LambdaRunner arg) {
        }

        @Override
        public void run() {
            method(this);
        }
    }

正如引用的bug报告所说，字段和方法都不能在其签名中引用隐藏类.

一个不太直观的例子是

    static class LambdaRunner implements Runnable {
        @Override
        public void run() {
            System.out.println("" + this);
        }
    }

这将根据编译器和选项而失败，因为当使用StringConcatFactory时，行为类似于调用一个方法，该方法将所有非常数部分作为参数并返回String.这是将隐藏类放在方法签名中的另一种情况.

Lambda表达式是特殊的，像这样的类

    static class LambdaRunner implements Runnable {
        @Override
        public void run() {
            Runnable runnable = () -> System.out.println("Success");
            runnable.run();
        }
    }

编译的方式类似于

    static class LambdaRunner implements Runnable {
        @Override
        public void run() {
            Runnable runnable = LambdaRunner::lambdaBody;
            runnable.run();
        }
        private static void lambdaBody() {
            System.out.println("Success");
        }
    }

它在方法签名中没有隐藏类，但必须引用将lambda表达式主体作为MethodReference的方法.在常量池中，此方法的描述引用了其使用this_class项声明的类.因此它被重定向到文档中描述的隐藏类.

但作为MethodReference的一部分构造MethodType并不像类文字那样使用这些信息来加载Class.相反，它试图通过定义类加载器加载隐藏的类，但在您发布的NoClassDefFoundError中失败.

这似乎与JDK-8130087有关，这表明普通的方法解析与MethodType的工作方式不同，在只调用方法就可以工作的情况下，MethodType可能会导致MethodType失败.

但可以证明，即使解决了这个问题，也无法解决一般问题:

    static class LambdaRunner implements Runnable {
        @Override
        public void run() {
            var lookup = MethodHandles.lookup();
            var noArgVoid = MethodType.methodType(void.class);
            try {
                MethodHandle mh = LambdaMetafactory.metafactory(lookup, "run",
                    MethodType.methodType(Runnable.class), noArgVoid,
                    lookup.findStatic(LambdaRunner.class, "lambdaBody", noArgVoid),
                    noArgVoid).getTarget();
                System.out.println("got factory");
                Runnable runnable = (Runnable)mh.invokeExact();
                System.out.println("got runnable");
                runnable.run();
            }
            catch(RuntimeException|Error e) {
                throw e;
            }
            catch(Throwable e) {
                throw new AssertionError(e);
            }
        }
        private static void lambdaBody() {
            System.out.println("Success");
        }
    }

这会绕过上述问题，并手动调用LambdaMetafactory.当被重新定义为隐藏类时，它将打印:

got factory
got runnable
Exception in thread "main" java.lang.NoClassDefFoundError: test/HiddenClassLambdaTest$LambdaRunner/0x0000000800c01400
    at test/test.HiddenClassLambdaTest.main(HiddenClassLambdaTest.java:15)
Caused by: java.lang.ClassNotFoundException: test.HiddenClassLambdaTest$LambdaRunner.0x0000000800c01400
    at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:641)
    at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188)
    at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:521)
    ... 1 more

这表明所有的障碍都被绕过了，但是当涉及到从生成的Runnable到保存lambda主体的方法的实际调用时，它将失败，因为目标类是hidden.一个急于解析符号引用的JVM可能会更早失败，也就是说，该示例可能不会打印got runnable.

与旧的JVM匿名类不同，无法链接到隐藏类，甚至不能从另一个隐藏类链接.

底线是，正如一开始所说，不能将任意类转换为隐藏类.Lambda表达式并不是唯一不使用隐藏类的功能.试着感到惊讶不是个好主意.隐藏类只能与字节码生成器结合使用，必须小心地使用已知有效的功能.