Java – lambda Metafactory variable capture

Use methodhandles How do you capture variables when you manually create Lambdas such as lookup, methodhandles, methodtypes, etc?

For example, no capture:

public Intsupplier foo() {
    return this::fortyTwo;
}
/**
 *  Would not normally be virtual,but oh well.
 */
public int fortyTwo() {
    return 42;
}

And its bulky form, using Java Things in lang.invoke:

public Intsupplier foo() {
    MethodHandles.Lookup lookup = MethodHandles.lookup();
    MethodType methodType = MethodType.methodType(int.class),lambdaType = MethodType.methodType(Intsupplier.class);
    MethodHandle methodHandle = lookup.findVirtual(getClass(),"fortyTwo",methodType);
    CallSite callSite = LambdaMetafactory.Metafactory(lookup,"getAsInt",lambdaType,methodType,methodHandle,methodType);
    return (Intsupplier) callSite.getTarget().invokeExact();
}
/**
 *  Would not normally be virtual,but oh well.
 */
public int fortyTwo() {
    return 42;
}

It will return a simple and meaningless intsupplier, which will return 42 when called, but what if you want to capture something?

Solution

The third parameter of the bootstrap method (named lambdatype) is the invocation type of the associated invokedynamic instruction (usually populated by the JVM) Its semantics is defined by the bootstrap method. In the case of lambdametafactory, it specifies the function interface as the return type (the type of object to be constructed), and specifies the value to be captured as the parameter type (the type of value to be used) to construct a lambda instance

Therefore, in order to capture it, you must add this type to the type you call and pass it as a parameter to the invokeexact call:

public class Test {
    public static void main(String... arg) throws Throwable {
        System.out.println(new test().foo().getAsInt());
    }
    public Intsupplier foo() throws Throwable {
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        MethodType methodType  = MethodType.methodType(int.class),invokedType = MethodType.methodType(Intsupplier.class,Test.class);
        MethodHandle methodHandle = lookup.findVirtual(getClass(),methodType);
        CallSite callSite = LambdaMetafactory.Metafactory(lookup,invokedType,methodType);
        return (Intsupplier) callSite.getTarget().invokeExact(this);
    }
    public int fortyTwo() {
        return 42;
    }
}

If you want to capture more values, you must add them to the signature in the correct order For example, capture another int value:

public class Test {
    public static void main(String... arg) throws Throwable {
        System.out.println(new test().foo(100).getAsInt());
    }
    public Intsupplier foo(int capture) throws Throwable {
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        MethodType methodType = MethodType.methodType(int.class,int.class),functionType = MethodType.methodType(int.class),Test.class,int.class);
        MethodHandle methodHandle=lookup.findVirtual(getClass(),"addFortyTwo",functionType,functionType);
        return (Intsupplier) callSite.getTarget().invokeExact(this,capture);
    }
    public int addFortyTwo(int valueToAdd) {
        return 42+valueToAdd;
    }
}

The target method will have a signature consisting of this type (if not static), followed by all parameter types The captured value will map from left to right to the type of this signature. The other parameter types (if any) contribute to the function signature, so they must match the parameter types of the interface method

This means that when there is no captured value and the target method is not static, the method receiver type may be associated with the function signature of the first type, as shown in tointfunction < string > F = string:: length