我想获得对 java.lang.String 包私有(private)构造函数的反射访问。

即，这个:

/*
* Package private constructor which shares value array for speed.
* this constructor is always expected to be called with share==true.
* a separate constructor is needed because we already have a public
* String(char[]) constructor that makes a copy of the given char[].
*/
String(char[] value, boolean share) {
    // assert share : "unshared not supported";
    this.value = value;
}

为其创建MethodHandle 非常简单，调用它也很简单。 直接使用Reflection也是一样。

但是我很好奇是否可以通过函数式接口(interface)直接调用构造函数。

27602758涉及一个有点类似的问题，但提供的解决方案在这种情况下似乎不起作用。

下面的测试用例编译没有问题。一切正常，除了实际的接口(interface)调用。

package test;

import java.lang.invoke.CallSite;
import java.lang.invoke.LambdaMetafactory;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodHandles.Lookup;
import java.lang.invoke.MethodType;
import java.lang.reflect.Field;

public class Test {

    // Creates a new String that shares the supplied char[]
    private static interface StringCreator {

        public String create(char[] value, boolean shared);
    }

    // Creates a new conventional String
    private static String create(char[] value, boolean shared) {
        return String.valueOf(value);
    }

    public static void main(String[] args) throws Throwable {
        // Reflectively generate a TRUSTED Lookup for the calling class
        Lookup caller = MethodHandles.lookup();
        Field modes = Lookup.class.getDeclaredField("allowedModes");
        modes.setAccessible(true);
        modes.setInt(caller, -1);   // -1 == Lookup.TRUSTED

        // create handle for #create()
        MethodHandle conventional = caller.findStatic(
            Test.class, "create", MethodType.methodType(String.class, char[].class, boolean.class)
        );
        StringCreator normal = getStringCreator(caller, conventional);
        System.out.println(
            normal.create("foo".toCharArray(), true)
        // prints "foo"
        );

        // create handle for shared String constructor
        MethodHandle constructor = caller.findConstructor(
            String.class, MethodType.methodType(void.class, char[].class, boolean.class)
        );
        // test directly if the construcor is correctly accessed
        char[] chars = "foo".toCharArray();
        String s = (String) constructor.invokeExact(chars, true);
        chars[0] = 'b'; // modify array contents
        chars[1] = 'a';
        chars[2] = 'r';
        System.out.println(
            s
        // prints "bar"
        );

        // generate interface for constructor
        StringCreator shared = getStringCreator(caller, constructor);
        System.out.println(
            shared.create("foo".toCharArray(), true)
        // throws error
        );
    }

    // returns a StringCreator instance
    private static StringCreator getStringCreator(Lookup caller, MethodHandle handle) throws Throwable {
        CallSite callSite = LambdaMetafactory.metafactory(
            caller,
            "create",
            MethodType.methodType(StringCreator.class),
            handle.type(),
            handle,
            handle.type()
        );
        return (StringCreator) callSite.getTarget().invokeExact();
    }
}

具体说明

shared.create("foo".toCharArray(), true)

抛出以下错误:

Exception in thread "main" java.lang.IllegalAccessError: tried to access method java.lang.String.<init>([CZ)V from class test.Test$$Lambda$2/989110044 at test.Test.main(Test.java:59)

为什么表面上已授予访问权限，但仍会抛出此错误？

谁能解释为什么生成的接口(interface)无法访问其所有组件都可以访问的方法？

是否有一种解决方案或可行的替代方案可以真正适用于这个特定的用例，而无需恢复到纯反射或MethodHandles？

因为我被难住了。

最佳答案

问题是您覆盖了要信任的查找对象，因此它对 String 的 private 方法的访问将通过查找过程和 lambda 元工厂，但是它仍然绑定(bind)到您的 Test 类，因为这是通过 MethodHandles.lookup() 创建查找对象的类，并且生成的类将存在于相同的上下文中。当涉及到这些生成的类时，JVM 在可访问性方面非常慷慨，但显然，从生活在不接受您的应用程序类的上下文。

您可以通过例如获取位于适当上下文中的查找对象MethodHandles.lookup() .in(String.class)(然后将其修补为具有 private 或“可信”访问权限)，但是随后，您将遇到另一个问题:生活在 java.lang.String 上下文中的类(或仅在引导加载程序的上下文中)将无法访问您的自定义 interface StringCreator 并且无法实现它.

唯一的解决方案是使用位于 String 上下文中的查找对象并实现现有的通用 interface 之一，可从引导类加载器访问:

import java.lang.invoke.*;
import java.lang.invoke.MethodHandles.Lookup;
import java.lang.reflect.Field;
import java.util.function.BiFunction;

public class Test {
    public static void main(String[] args) throws Throwable {
        // Reflectively generate a TRUSTED Lookup for the String class
        Lookup caller = MethodHandles.lookup().in(String.class);
        Field modes = Lookup.class.getDeclaredField("allowedModes");
        modes.setAccessible(true);
        modes.setInt(caller, -1);   // -1 == Lookup.TRUSTED
        // create handle for shared String constructor
        MethodHandle constructor = caller.findConstructor(
            String.class, MethodType.methodType(void.class, char[].class, boolean.class)
        );
        // generate interface implementation for constructor
        BiFunction<char[],Boolean,String> shared=getStringCreator(caller, constructor);

        // test if the construcor is correctly accessed
        char[] chars = "foo".toCharArray();
        String s = shared.apply(chars, true);
        chars[0] = 'b'; chars[1] = 'a'; chars[2] = 'r';// modify array contents
        System.out.println(s); // prints "bar"
        chars[0] = '1'; chars[1] = '2'; chars[2] = '3';
        System.out.println(s); // prints "123"
    }
    private static BiFunction<char[],Boolean,String> getStringCreator(
            Lookup caller, MethodHandle handle) throws Throwable {
        CallSite callSite = LambdaMetafactory.metafactory(
            caller,
            "apply",
            MethodType.methodType(BiFunction.class),
            handle.type().generic(),
            handle,
            handle.type()
        );
        return (BiFunction) callSite.getTarget().invokeExact();
    }
}

关于java - Lambda 表达式可以访问其范围之外的类的私有(private)方法吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36184517/