public classLambdaMetafactoryextendsObject
Methods to facilitate the creation of simple "function objects" that implement one or more interfaces by delegation to a providedMethodHandle, possibly after type adaptation and partial evaluation of arguments. These methods are typically used asbootstrap methods forinvokedynamic call sites, to support thelambda expression andmethod reference expression features of the Java Programming Language.
Indirect access to the behavior specified by the providedMethodHandle proceeds in order through three phases:
CallSite whose target can be used to create suitable function objects. Linkage may involve dynamically loading a new class that implements the target interface. TheCallSite can be considered a "factory" for function objects and so these linkage methods are referred to as "metafactories".CallSite's target is invoked, typically through aninvokedynamic call site, producing a function object. This may occur many times for a single factoryCallSite. Capture may involve allocation of a new function object, or may return an existing function object. The behaviorMethodHandle may have additional parameters beyond those of the specified interface method; these are referred to ascaptured parameters, which must be provided as arguments to theCallSite target, and which may be early-bound to the behaviorMethodHandle. The number of captured parameters and their types are determined during linkage.MethodHandle is invoked with the captured arguments and any additional arguments provided on invocation, as if byMethodHandle.invoke(Object...).It is sometimes useful to restrict the set of inputs or results permitted at invocation. For example, when the generic interfacePredicate<T> is parameterized asPredicate<String>, the input must be aString, even though the method to implement allows anyObject. At linkage time, an additionalMethodType parameter describes the "instantiated" method type; on invocation, the arguments and eventual result are checked against thisMethodType.
This class provides two forms of linkage methods: a standard version (metafactory(MethodHandles.Lookup, String, MethodType, MethodType, MethodHandle, MethodType)) using an optimized protocol, and an alternate versionaltMetafactory(MethodHandles.Lookup, String, MethodType, Object...)). The alternate version is a generalization of the standard version, providing additional control over the behavior of the generated function objects via flags and additional arguments. The alternate version adds the ability to manage the following attributes of function objects:
FLAG_BRIDGES indicates that a list of additionalMethodTypes will be provided, each of which will be implemented by the resulting function object. These methods will share the same name and instantiated type.FLAG_MARKERS indicates that a list of additional interfaces will be provided, each of which should be implemented by the resulting function object.FLAG_SERIALIZABLE can be used to indicate that the function objects should be serializable. Serializable function objects will use, as their serialized form, instances of the classSerializedLambda, which requires additional assistance from the capturing class (the class described by theMethodHandles.Lookup parametercaller); seeSerializedLambda for details.Assume the linkage arguments are as follows:
invokedType (describing theCallSite signature) has K parameters of types (D1..Dk) and return type Rd;samMethodType (describing the implemented method type) has N parameters, of types (U1..Un) and return type Ru;implMethod (theMethodHandle providing the implementation has M parameters, of types (A1..Am) and return type Ra (if the method describes an instance method, the method type of this method handle already includes an extra first argument corresponding to the receiver);instantiatedMethodType (allowing restrictions on invocation) has N parameters, of types (T1..Tn) and return type Rt.Then the following linkage invariants must hold:
implMethod is adirect method handlesamMethodType andinstantiatedMethodType have the same arity N, and for i=1..N, Ti and Ui are the same type, or Ti and Ui are both reference types and Ti is a subtype of UiFurther, at capture time, ifimplMethod corresponds to an instance method, and there are any capture arguments (K > 0), then the first capture argument (corresponding to the receiver) must be non-null.
A type Q is considered adaptable to S as follows:
| Q | S | Link-time checks | Invocation-time checks |
|---|---|---|---|
| Primitive | Primitive | Q can be converted to S via a primitive widening conversion | None |
| Primitive | Reference | S is a supertype of the Wrapper(Q) | Cast from Wrapper(Q) to S |
| Reference | Primitive | for parameter types: Q is a primitive wrapper and Primitive(Q) can be widened to S for return types: If Q is a primitive wrapper, check that Primitive(Q) can be widened to S | If Q is not a primitive wrapper, cast Q to the base Wrapper(S); for example Number for numeric types |
| Reference | Reference | for parameter types: S is a supertype of Q for return types: none | Cast from Q to S |
The argument list of the implementation method and the argument list of the interface method(s) may differ in several ways. The implementation methods may have additional arguments to accommodate arguments captured by the lambda expression; there may also be differences resulting from permitted adaptations of arguments, such as casting, boxing, unboxing, and primitive widening. (Varargs adaptations are not handled by the metafactories; these are expected to be handled by the caller.)
Invokedynamic call sites have two argument lists: a static argument list and a dynamic argument list. The static argument list is stored in the constant pool; the dynamic argument is pushed on the operand stack at capture time. The bootstrap method has access to the entire static argument list (which in this case, includes information describing the implementation method, the target interface, and the target interface method(s)), as well as a method signature describing the number and static types (but not the values) of the dynamic arguments and the static return type of the invokedynamic site.
| Modifier and Type | Field | Description |
|---|---|---|
static int | FLAG_BRIDGES | Flag for alternate metafactories indicating the lambda object requires additional bridge methods |
static int | FLAG_MARKERS | Flag for alternate metafactories indicating the lambda object implements other marker interfaces besides Serializable |
static int | FLAG_SERIALIZABLE | Flag for alternate metafactories indicating the lambda object must be serializable |
| Constructor | Description |
|---|---|
LambdaMetafactory() |
| Modifier and Type | Method | Description |
|---|---|---|
staticCallSite | altMetafactory(MethodHandles.Lookup caller,String invokedName,MethodType invokedType,Object... args) | Facilitates the creation of simple "function objects" that implement one or more interfaces by delegation to a provided MethodHandle, after appropriate type adaptation and partial evaluation of arguments. |
staticCallSite | metafactory(MethodHandles.Lookup caller,String invokedName,MethodType invokedType,MethodType samMethodType,MethodHandle implMethod,MethodType instantiatedMethodType) | Facilitates the creation of simple "function objects" that implement one or more interfaces by delegation to a provided MethodHandle, after appropriate type adaptation and partial evaluation of arguments. |
public static final int FLAG_SERIALIZABLE
public static final int FLAG_MARKERS
public static final int FLAG_BRIDGES
public static CallSite metafactory(MethodHandles.Lookup caller,String invokedName,MethodType invokedType,MethodType samMethodType,MethodHandle implMethod,MethodType instantiatedMethodType) throwsLambdaConversionException
MethodHandle, after appropriate type adaptation and partial evaluation of arguments. Typically used as abootstrap method forinvokedynamic call sites, to support thelambda expression andmethod reference expression features of the Java Programming Language.This is the standard, streamlined metafactory; additional flexibility is provided byaltMetafactory(MethodHandles.Lookup, String, MethodType, Object...). A general description of the behavior of this method is providedabove.
When the target of theCallSite returned from this method is invoked, the resulting function objects are instances of a class which implements the interface named by the return type ofinvokedType, declares a method with the name given byinvokedName and the signature given bysamMethodType. It may also override additional methods fromObject.
caller - Represents a lookup context with the accessibility privileges of the caller. When used withinvokedynamic, this is stacked automatically by the VM.invokedName - The name of the method to implement. When used withinvokedynamic, this is provided by theNameAndType of theInvokeDynamic structure and is stacked automatically by the VM.invokedType - The expected signature of theCallSite. The parameter types represent the types of capture variables; the return type is the interface to implement. When used withinvokedynamic, this is provided by theNameAndType of theInvokeDynamic structure and is stacked automatically by the VM. In the event that the implementation method is an instance method and this signature has any parameters, the first parameter in the invocation signature must correspond to the receiver.samMethodType - Signature and return type of method to be implemented by the function object.implMethod - A direct method handle describing the implementation method which should be called (with suitable adaptation of argument types, return types, and with captured arguments prepended to the invocation arguments) at invocation time.instantiatedMethodType - The signature and return type that should be enforced dynamically at invocation time. This may be the same assamMethodType, or may be a specialization of it.invokedTypeLambdaConversionException - If any of the linkage invariants describedabove are violatedpublic static CallSite altMetafactory(MethodHandles.Lookup caller,String invokedName,MethodType invokedType,Object... args) throwsLambdaConversionException
MethodHandle, after appropriate type adaptation and partial evaluation of arguments. Typically used as abootstrap method forinvokedynamic call sites, to support thelambda expression andmethod reference expression features of the Java Programming Language.This is the general, more flexible metafactory; a streamlined version is provided bymetafactory(java.lang.invoke.MethodHandles.Lookup, String, MethodType, MethodType, MethodHandle, MethodType). A general description of the behavior of this method is providedabove.
The argument list for this method includes three fixed parameters, corresponding to the parameters automatically stacked by the VM for the bootstrap method in aninvokedynamic invocation, and anObject[] parameter that contains additional parameters. The declared argument list for this method is:
CallSite altMetafactory(MethodHandles.Lookup caller, String invokedName, MethodType invokedType, Object... args)but it behaves as if the argument list is as follows:
CallSite altMetafactory(MethodHandles.Lookup caller, String invokedName, MethodType invokedType, MethodType samMethodType, MethodHandle implMethod, MethodType instantiatedMethodType, int flags, int markerInterfaceCount, // IF flags has MARKERS set Class... markerInterfaces, // IF flags has MARKERS set int bridgeCount, // IF flags has BRIDGES set MethodType... bridges // IF flags has BRIDGES set )Arguments that appear in the argument list formetafactory(MethodHandles.Lookup, String, MethodType, MethodType, MethodHandle, MethodType) have the same specification as in that method. The additional arguments are interpreted as follows:
flags indicates additional options; this is a bitwise OR of desired flags. Defined flags areFLAG_BRIDGES,FLAG_MARKERS, andFLAG_SERIALIZABLE.markerInterfaceCount is the number of additional interfaces the function object should implement, and is present if and only if theFLAG_MARKERS flag is set.markerInterfaces is a variable-length list of additional interfaces to implement, whose length equalsmarkerInterfaceCount, and is present if and only if theFLAG_MARKERS flag is set.bridgeCount is the number of additional method signatures the function object should implement, and is present if and only if theFLAG_BRIDGES flag is set.bridges is a variable-length list of additional methods signatures to implement, whose length equalsbridgeCount, and is present if and only if theFLAG_BRIDGES flag is set.Each class named bymarkerInterfaces is subject to the same restrictions asRd, the return type ofinvokedType, as describedabove. EachMethodType named bybridges is subject to the same restrictions assamMethodType, as describedabove.
When FLAG_SERIALIZABLE is set inflags, the function objects will implementSerializable, and will have awriteReplace method that returns an appropriateSerializedLambda. Thecaller class must have an appropriate$deserializeLambda$ method, as described inSerializedLambda.
When the target of theCallSite returned from this method is invoked, the resulting function objects are instances of a class with the following properties:
invokedType and any interfaces named bymarkerInterfacesinvokedName, and the signature given bysamMethodType and additional signatures given bybridgesObject, and may implement methods related to serialization.caller - Represents a lookup context with the accessibility privileges of the caller. When used withinvokedynamic, this is stacked automatically by the VM.invokedName - The name of the method to implement. When used withinvokedynamic, this is provided by theNameAndType of theInvokeDynamic structure and is stacked automatically by the VM.invokedType - The expected signature of theCallSite. The parameter types represent the types of capture variables; the return type is the interface to implement. When used withinvokedynamic, this is provided by theNameAndType of theInvokeDynamic structure and is stacked automatically by the VM. In the event that the implementation method is an instance method and this signature has any parameters, the first parameter in the invocation signature must correspond to the receiver.args - AnObject[] array containing the required argumentssamMethodType,implMethod,instantiatedMethodType,flags, and any optional arguments, as describedaltMetafactory(MethodHandles.Lookup, String, MethodType, Object...) above}invokedTypeLambdaConversionException - If any of the linkage invariants describedabove are violated