java.lang.invoke.MethodHandles Maven / Gradle / Ivy
/*
* Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.lang.invoke;
import java.lang.reflect.*;
/**
* This class consists exclusively of static methods that operate on or return
* method handles. They fall into several categories:
*
* - Lookup methods which help create method handles for methods and fields.
*
- Combinator methods, which combine or transform pre-existing method handles into new ones.
*
- Other factory methods to create method handles that emulate other common JVM operations or control flow patterns.
*
*
* @author John Rose, JSR 292 EG
* @since 1.7
*/
public class MethodHandles {
private MethodHandles() { } // do not instantiate
//// Method handle creation from ordinary methods.
/**
* Returns a {@link Lookup lookup object} with
* full capabilities to emulate all supported bytecode behaviors of the caller.
* These capabilities include private access to the caller.
* Factory methods on the lookup object can create
* direct method handles
* for any member that the caller has access to via bytecodes,
* including protected and private fields and methods.
* This lookup object is a capability which may be delegated to trusted agents.
* Do not store it in place where untrusted code can access it.
*
* This method is caller sensitive, which means that it may return different
* values to different callers.
*
* For any given caller class {@code C}, the lookup object returned by this call
* has equivalent capabilities to any lookup object
* supplied by the JVM to the bootstrap method of an
* invokedynamic instruction
* executing in the same caller class {@code C}.
* @return a lookup object for the caller of this method, with private access
*/
// @CallerSensitive
public static Lookup lookup() {
throw new IllegalStateException("Implement me!");
// return new Lookup(Reflection.getCallerClass());
}
/**
* Returns a {@link Lookup lookup object} which is trusted minimally.
* It can only be used to create method handles to
* publicly accessible fields and methods.
*
* As a matter of pure convention, the {@linkplain Lookup#lookupClass lookup class}
* of this lookup object will be {@link java.lang.Object}.
*
*
* Discussion:
* The lookup class can be changed to any other class {@code C} using an expression of the form
* {@link Lookup#in publicLookup().in(C.class)}.
* Since all classes have equal access to public names,
* such a change would confer no new access rights.
* A public lookup object is always subject to
* security manager checks.
* Also, it cannot access
* caller sensitive methods.
* @return a lookup object which is trusted minimally
*/
public static Lookup publicLookup() {
return Lookup.PUBLIC_LOOKUP;
}
/**
* Performs an unchecked "crack" of a
* direct method handle.
* The result is as if the user had obtained a lookup object capable enough
* to crack the target method handle, called
* {@link java.lang.invoke.MethodHandles.Lookup#revealDirect Lookup.revealDirect}
* on the target to obtain its symbolic reference, and then called
* {@link java.lang.invoke.MethodHandleInfo#reflectAs MethodHandleInfo.reflectAs}
* to resolve the symbolic reference to a member.
*
* If there is a security manager, its {@code checkPermission} method
* is called with a {@code ReflectPermission("suppressAccessChecks")} permission.
* @param the desired type of the result, either {@link Member} or a subtype
* @param target a direct method handle to crack into symbolic reference components
* @param expected a class object representing the desired result type {@code T}
* @return a reference to the method, constructor, or field object
* @exception SecurityException if the caller is not privileged to call {@code setAccessible}
* @exception NullPointerException if either argument is {@code null}
* @exception IllegalArgumentException if the target is not a direct method handle
* @exception ClassCastException if the member is not of the expected type
* @since 1.8
*/
public static T
reflectAs(Class expected, MethodHandle target) {
throw new IllegalStateException();
}
// Copied from AccessibleObject, as used by Method.setAccessible, etc.:
// static final private java.security.Permission ACCESS_PERMISSION =
// new ReflectPermission("suppressAccessChecks");
static Lookup findFor(Class clazz) {
Object o = clazz;
if (o instanceof Class) {
return new Lookup(clazz, Lookup.ALL_MODES);
}
throw new IllegalArgumentException("Expecting class: " + o);
}
/**
* A lookup object is a factory for creating method handles,
* when the creation requires access checking.
* Method handles do not perform
* access checks when they are called, but rather when they are created.
* Therefore, method handle access
* restrictions must be enforced when a method handle is created.
* The caller class against which those restrictions are enforced
* is known as the {@linkplain #lookupClass lookup class}.
*
* A lookup class which needs to create method handles will call
* {@link MethodHandles#lookup MethodHandles.lookup} to create a factory for itself.
* When the {@code Lookup} factory object is created, the identity of the lookup class is
* determined, and securely stored in the {@code Lookup} object.
* The lookup class (or its delegates) may then use factory methods
* on the {@code Lookup} object to create method handles for access-checked members.
* This includes all methods, constructors, and fields which are allowed to the lookup class,
* even private ones.
*
*
Lookup Factory Methods
* The factory methods on a {@code Lookup} object correspond to all major
* use cases for methods, constructors, and fields.
* Each method handle created by a factory method is the functional
* equivalent of a particular bytecode behavior.
* (Bytecode behaviors are described in section 5.4.3.5 of the Java Virtual Machine Specification.)
* Here is a summary of the correspondence between these factory methods and
* the behavior the resulting method handles:
*
* In cases where the given member is of variable arity (i.e., a method or constructor)
* the returned method handle will also be of {@linkplain MethodHandle#asVarargsCollector variable arity}.
* In all other cases, the returned method handle will be of fixed arity.
*
* Discussion:
* The equivalence between looked-up method handles and underlying
* class members and bytecode behaviors
* can break down in a few ways:
*
* - If {@code C} is not symbolically accessible from the lookup class's loader,
* the lookup can still succeed, even when there is no equivalent
* Java expression or bytecoded constant.
*
- Likewise, if {@code T} or {@code MT}
* is not symbolically accessible from the lookup class's loader,
* the lookup can still succeed.
* For example, lookups for {@code MethodHandle.invokeExact} and
* {@code MethodHandle.invoke} will always succeed, regardless of requested type.
*
- If there is a security manager installed, it can forbid the lookup
* on various grounds (see below).
* By contrast, the {@code ldc} instruction on a {@code CONSTANT_MethodHandle}
* constant is not subject to security manager checks.
*
- If the looked-up method has a
* very large arity,
* the method handle creation may fail, due to the method handle
* type having too many parameters.
*
*
* Access checking
* Access checks are applied in the factory methods of {@code Lookup},
* when a method handle is created.
* This is a key difference from the Core Reflection API, since
* {@link java.lang.reflect.Method#invoke java.lang.reflect.Method.invoke}
* performs access checking against every caller, on every call.
*
* All access checks start from a {@code Lookup} object, which
* compares its recorded lookup class against all requests to
* create method handles.
* A single {@code Lookup} object can be used to create any number
* of access-checked method handles, all checked against a single
* lookup class.
*
* A {@code Lookup} object can be shared with other trusted code,
* such as a metaobject protocol.
* A shared {@code Lookup} object delegates the capability
* to create method handles on private members of the lookup class.
* Even if privileged code uses the {@code Lookup} object,
* the access checking is confined to the privileges of the
* original lookup class.
*
* A lookup can fail, because
* the containing class is not accessible to the lookup class, or
* because the desired class member is missing, or because the
* desired class member is not accessible to the lookup class, or
* because the lookup object is not trusted enough to access the member.
* In any of these cases, a {@code ReflectiveOperationException} will be
* thrown from the attempted lookup. The exact class will be one of
* the following:
*
* - NoSuchMethodException — if a method is requested but does not exist
*
- NoSuchFieldException — if a field is requested but does not exist
*
- IllegalAccessException — if the member exists but an access check fails
*
*
* In general, the conditions under which a method handle may be
* looked up for a method {@code M} are no more restrictive than the conditions
* under which the lookup class could have compiled, verified, and resolved a call to {@code M}.
* Where the JVM would raise exceptions like {@code NoSuchMethodError},
* a method handle lookup will generally raise a corresponding
* checked exception, such as {@code NoSuchMethodException}.
* And the effect of invoking the method handle resulting from the lookup
* is exactly equivalent
* to executing the compiled, verified, and resolved call to {@code M}.
* The same point is true of fields and constructors.
*
* Discussion:
* Access checks only apply to named and reflected methods,
* constructors, and fields.
* Other method handle creation methods, such as
* {@link MethodHandle#asType MethodHandle.asType},
* do not require any access checks, and are used
* independently of any {@code Lookup} object.
*
* If the desired member is {@code protected}, the usual JVM rules apply,
* including the requirement that the lookup class must be either be in the
* same package as the desired member, or must inherit that member.
* (See the Java Virtual Machine Specification, sections 4.9.2, 5.4.3.5, and 6.4.)
* In addition, if the desired member is a non-static field or method
* in a different package, the resulting method handle may only be applied
* to objects of the lookup class or one of its subclasses.
* This requirement is enforced by narrowing the type of the leading
* {@code this} parameter from {@code C}
* (which will necessarily be a superclass of the lookup class)
* to the lookup class itself.
*
* The JVM imposes a similar requirement on {@code invokespecial} instruction,
* that the receiver argument must match both the resolved method and
* the current class. Again, this requirement is enforced by narrowing the
* type of the leading parameter to the resulting method handle.
* (See the Java Virtual Machine Specification, section 4.10.1.9.)
*
* The JVM represents constructors and static initializer blocks as internal methods
* with special names ({@code ""} and {@code ""}).
* The internal syntax of invocation instructions allows them to refer to such internal
* methods as if they were normal methods, but the JVM bytecode verifier rejects them.
* A lookup of such an internal method will produce a {@code NoSuchMethodException}.
*
* In some cases, access between nested classes is obtained by the Java compiler by creating
* an wrapper method to access a private method of another class
* in the same top-level declaration.
* For example, a nested class {@code C.D}
* can access private members within other related classes such as
* {@code C}, {@code C.D.E}, or {@code C.B},
* but the Java compiler may need to generate wrapper methods in
* those related classes. In such cases, a {@code Lookup} object on
* {@code C.E} would be unable to those private members.
* A workaround for this limitation is the {@link Lookup#in Lookup.in} method,
* which can transform a lookup on {@code C.E} into one on any of those other
* classes, without special elevation of privilege.
*
* The accesses permitted to a given lookup object may be limited,
* according to its set of {@link #lookupModes lookupModes},
* to a subset of members normally accessible to the lookup class.
* For example, the {@link MethodHandles#publicLookup publicLookup}
* method produces a lookup object which is only allowed to access
* public members in public classes.
* The caller sensitive method {@link MethodHandles#lookup lookup}
* produces a lookup object with full capabilities relative to
* its caller class, to emulate all supported bytecode behaviors.
* Also, the {@link Lookup#in Lookup.in} method may produce a lookup object
* with fewer access modes than the original lookup object.
*
*
*
* Discussion of private access:
* We say that a lookup has private access
* if its {@linkplain #lookupModes lookup modes}
* include the possibility of accessing {@code private} members.
* As documented in the relevant methods elsewhere,
* only lookups with private access possess the following capabilities:
*
* - access private fields, methods, and constructors of the lookup class
*
- create method handles which invoke caller sensitive methods,
* such as {@code Class.forName}
*
- create method handles which {@link Lookup#findSpecial emulate invokespecial} instructions
*
- avoid package access checks
* for classes accessible to the lookup class
*
- create {@link Lookup#in delegated lookup objects} which have private access to other classes
* within the same package member
*
*
* Each of these permissions is a consequence of the fact that a lookup object
* with private access can be securely traced back to an originating class,
* whose bytecode behaviors and Java language access permissions
* can be reliably determined and emulated by method handles.
*
*
Security manager interactions
* Although bytecode instructions can only refer to classes in
* a related class loader, this API can search for methods in any
* class, as long as a reference to its {@code Class} object is
* available. Such cross-loader references are also possible with the
* Core Reflection API, and are impossible to bytecode instructions
* such as {@code invokestatic} or {@code getfield}.
* There is a {@linkplain java.lang.SecurityManager security manager API}
* to allow applications to check such cross-loader references.
* These checks apply to both the {@code MethodHandles.Lookup} API
* and the Core Reflection API
* (as found on {@link java.lang.Class Class}).
*
* If a security manager is present, member lookups are subject to
* additional checks.
* From one to three calls are made to the security manager.
* Any of these calls can refuse access by throwing a
* {@link java.lang.SecurityException SecurityException}.
* Define {@code smgr} as the security manager,
* {@code lookc} as the lookup class of the current lookup object,
* {@code refc} as the containing class in which the member
* is being sought, and {@code defc} as the class in which the
* member is actually defined.
* The value {@code lookc} is defined as not present
* if the current lookup object does not have
* private access.
* The calls are made according to the following rules:
*
* - Step 1:
* If {@code lookc} is not present, or if its class loader is not
* the same as or an ancestor of the class loader of {@code refc},
* then {@link SecurityManager#checkPackageAccess
* smgr.checkPackageAccess(refcPkg)} is called,
* where {@code refcPkg} is the package of {@code refc}.
*
- Step 2:
* If the retrieved member is not public and
* {@code lookc} is not present, then
* {@link SecurityManager#checkPermission smgr.checkPermission}
* with {@code RuntimePermission("accessDeclaredMembers")} is called.
*
- Step 3:
* If the retrieved member is not public,
* and if {@code lookc} is not present,
* and if {@code defc} and {@code refc} are different,
* then {@link SecurityManager#checkPackageAccess
* smgr.checkPackageAccess(defcPkg)} is called,
* where {@code defcPkg} is the package of {@code defc}.
*
* Security checks are performed after other access checks have passed.
* Therefore, the above rules presuppose a member that is public,
* or else that is being accessed from a lookup class that has
* rights to access the member.
*
* Caller sensitive methods
* A small number of Java methods have a special property called caller sensitivity.
* A caller-sensitive method can behave differently depending on the
* identity of its immediate caller.
*
* If a method handle for a caller-sensitive method is requested,
* the general rules for bytecode behaviors apply,
* but they take account of the lookup class in a special way.
* The resulting method handle behaves as if it were called
* from an instruction contained in the lookup class,
* so that the caller-sensitive method detects the lookup class.
* (By contrast, the invoker of the method handle is disregarded.)
* Thus, in the case of caller-sensitive methods,
* different lookup classes may give rise to
* differently behaving method handles.
*
* In cases where the lookup object is
* {@link MethodHandles#publicLookup() publicLookup()},
* or some other lookup object without
* private access,
* the lookup class is disregarded.
* In such cases, no caller-sensitive method handle can be created,
* access is forbidden, and the lookup fails with an
* {@code IllegalAccessException}.
*
* Discussion:
* For example, the caller-sensitive method
* {@link java.lang.Class#forName(String) Class.forName(x)}
* can return varying classes or throw varying exceptions,
* depending on the class loader of the class that calls it.
* A public lookup of {@code Class.forName} will fail, because
* there is no reasonable way to determine its bytecode behavior.
*
* If an application caches method handles for broad sharing,
* it should use {@code publicLookup()} to create them.
* If there is a lookup of {@code Class.forName}, it will fail,
* and the application must take appropriate action in that case.
* It may be that a later lookup, perhaps during the invocation of a
* bootstrap method, can incorporate the specific identity
* of the caller, making the method accessible.
*
* The function {@code MethodHandles.lookup} is caller sensitive
* so that there can be a secure foundation for lookups.
* Nearly all other methods in the JSR 292 API rely on lookup
* objects to check access requests.
*/
public static final
class Lookup {
/** The class on behalf of whom the lookup is being performed. */
private final Class lookupClass;
/** The allowed sorts of members which may be looked up (PUBLIC, etc.). */
private final int allowedModes;
/** A single-bit mask representing {@code public} access,
* which may contribute to the result of {@link #lookupModes lookupModes}.
* The value, {@code 0x01}, happens to be the same as the value of the
* {@code public} {@linkplain java.lang.reflect.Modifier#PUBLIC modifier bit}.
*/
public static final int PUBLIC = Modifier.PUBLIC;
/** A single-bit mask representing {@code private} access,
* which may contribute to the result of {@link #lookupModes lookupModes}.
* The value, {@code 0x02}, happens to be the same as the value of the
* {@code private} {@linkplain java.lang.reflect.Modifier#PRIVATE modifier bit}.
*/
public static final int PRIVATE = Modifier.PRIVATE;
/** A single-bit mask representing {@code protected} access,
* which may contribute to the result of {@link #lookupModes lookupModes}.
* The value, {@code 0x04}, happens to be the same as the value of the
* {@code protected} {@linkplain java.lang.reflect.Modifier#PROTECTED modifier bit}.
*/
public static final int PROTECTED = Modifier.PROTECTED;
/** A single-bit mask representing {@code package} access (default access),
* which may contribute to the result of {@link #lookupModes lookupModes}.
* The value is {@code 0x08}, which does not correspond meaningfully to
* any particular {@linkplain java.lang.reflect.Modifier modifier bit}.
*/
public static final int PACKAGE = Modifier.STATIC;
private static final int ALL_MODES = (PUBLIC | PRIVATE | PROTECTED | PACKAGE);
private static final int TRUSTED = -1;
private static int fixmods(int mods) {
mods &= (ALL_MODES - PACKAGE);
return (mods != 0) ? mods : PACKAGE;
}
/** Tells which class is performing the lookup. It is this class against
* which checks are performed for visibility and access permissions.
*
* The class implies a maximum level of access permission,
* but the permissions may be additionally limited by the bitmask
* {@link #lookupModes lookupModes}, which controls whether non-public members
* can be accessed.
* @return the lookup class, on behalf of which this lookup object finds members
*/
public Class lookupClass() {
return lookupClass;
}
// This is just for calling out to MethodHandleImpl.
private Class lookupClassOrNull() {
return (allowedModes == TRUSTED) ? null : lookupClass;
}
/** Tells which access-protection classes of members this lookup object can produce.
* The result is a bit-mask of the bits
* {@linkplain #PUBLIC PUBLIC (0x01)},
* {@linkplain #PRIVATE PRIVATE (0x02)},
* {@linkplain #PROTECTED PROTECTED (0x04)},
* and {@linkplain #PACKAGE PACKAGE (0x08)}.
*
* A freshly-created lookup object
* on the {@linkplain java.lang.invoke.MethodHandles#lookup() caller's class}
* has all possible bits set, since the caller class can access all its own members.
* A lookup object on a new lookup class
* {@linkplain java.lang.invoke.MethodHandles.Lookup#in created from a previous lookup object}
* may have some mode bits set to zero.
* The purpose of this is to restrict access via the new lookup object,
* so that it can access only names which can be reached by the original
* lookup object, and also by the new lookup class.
* @return the lookup modes, which limit the kinds of access performed by this lookup object
*/
public int lookupModes() {
return allowedModes & ALL_MODES;
}
/** Embody the current class (the lookupClass) as a lookup class
* for method handle creation.
* Must be called by from a method in this package,
* which in turn is called by a method not in this package.
*/
Lookup(Class lookupClass) {
this(lookupClass, ALL_MODES);
// make sure we haven't accidentally picked up a privileged class:
}
private Lookup(Class lookupClass, int allowedModes) {
this.lookupClass = lookupClass;
this.allowedModes = allowedModes;
}
/**
* Creates a lookup on the specified new lookup class.
* The resulting object will report the specified
* class as its own {@link #lookupClass lookupClass}.
*
* However, the resulting {@code Lookup} object is guaranteed
* to have no more access capabilities than the original.
* In particular, access capabilities can be lost as follows:
* - If the new lookup class differs from the old one,
* protected members will not be accessible by virtue of inheritance.
* (Protected members may continue to be accessible because of package sharing.)
*
- If the new lookup class is in a different package
* than the old one, protected and default (package) members will not be accessible.
*
- If the new lookup class is not within the same package member
* as the old one, private members will not be accessible.
*
- If the new lookup class is not accessible to the old lookup class,
* then no members, not even public members, will be accessible.
* (In all other cases, public members will continue to be accessible.)
*
*
* @param requestedLookupClass the desired lookup class for the new lookup object
* @return a lookup object which reports the desired lookup class
* @throws NullPointerException if the argument is null
*/
public Lookup in(Class requestedLookupClass) {
throw new IllegalStateException();
}
/** Version of lookup which is trusted minimally.
* It can only be used to create method handles to
* publicly accessible members.
*/
static final Lookup PUBLIC_LOOKUP = new Lookup(Object.class, PUBLIC);
/** Package-private version of lookup which is trusted. */
static final Lookup IMPL_LOOKUP = new Lookup(Object.class, TRUSTED);
/**
* Displays the name of the class from which lookups are to be made.
* (The name is the one reported by {@link java.lang.Class#getName() Class.getName}.)
* If there are restrictions on the access permitted to this lookup,
* this is indicated by adding a suffix to the class name, consisting
* of a slash and a keyword. The keyword represents the strongest
* allowed access, and is chosen as follows:
*
* - If no access is allowed, the suffix is "/noaccess".
*
- If only public access is allowed, the suffix is "/public".
*
- If only public and package access are allowed, the suffix is "/package".
*
- If only public, package, and private access are allowed, the suffix is "/private".
*
* If none of the above cases apply, it is the case that full
* access (public, package, private, and protected) is allowed.
* In this case, no suffix is added.
* This is true only of an object obtained originally from
* {@link java.lang.invoke.MethodHandles#lookup MethodHandles.lookup}.
* Objects created by {@link java.lang.invoke.MethodHandles.Lookup#in Lookup.in}
* always have restricted access, and will display a suffix.
*
* (It may seem strange that protected access should be
* stronger than private access. Viewed independently from
* package access, protected access is the first to be lost,
* because it requires a direct subclass relationship between
* caller and callee.)
* @see #in
*/
@Override
public String toString() {
String cname = lookupClass.getName();
switch (allowedModes) {
case 0: // no privileges
return cname + "/noaccess";
case PUBLIC:
return cname + "/public";
case PUBLIC|PACKAGE:
return cname + "/package";
case ALL_MODES & ~PROTECTED:
return cname + "/private";
case ALL_MODES:
return cname;
case TRUSTED:
return "/trusted"; // internal only; not exported
default: // Should not happen, but it's a bitfield...
cname = cname + "/" + Integer.toHexString(allowedModes);
assert(false) : cname;
return cname;
}
}
/**
* Produces a method handle for a static method.
* The type of the method handle will be that of the method.
* (Since static methods do not take receivers, there is no
* additional receiver argument inserted into the method handle type,
* as there would be with {@link #findVirtual findVirtual} or {@link #findSpecial findSpecial}.)
* The method and all its argument types must be accessible to the lookup object.
*
* The returned method handle will have
* {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
* the method's variable arity modifier bit ({@code 0x0080}) is set.
*
* If the returned method handle is invoked, the method's class will
* be initialized, if it has not already been initialized.
*
Example:
*
{@code
import static java.lang.invoke.MethodHandles.*;
import static java.lang.invoke.MethodType.*;
...
MethodHandle MH_asList = publicLookup().findStatic(Arrays.class,
"asList", methodType(List.class, Object[].class));
assertEquals("[x, y]", MH_asList.invoke("x", "y").toString());
* }
* @param refc the class from which the method is accessed
* @param name the name of the method
* @param type the type of the method
* @return the desired method handle
* @throws NoSuchMethodException if the method does not exist
* @throws IllegalAccessException if access checking fails,
* or if the method is not {@code static},
* or if the method's variable arity modifier bit
* is set and {@code asVarargsCollector} fails
* @exception SecurityException if a security manager is present and it
* refuses access
* @throws NullPointerException if any argument is null
*/
public
MethodHandle findStatic(Class refc, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {
throw new IllegalStateException();
}
/**
* Produces a method handle for a virtual method.
* The type of the method handle will be that of the method,
* with the receiver type (usually {@code refc}) prepended.
* The method and all its argument types must be accessible to the lookup object.
*
* When called, the handle will treat the first argument as a receiver
* and dispatch on the receiver's type to determine which method
* implementation to enter.
* (The dispatching action is identical with that performed by an
* {@code invokevirtual} or {@code invokeinterface} instruction.)
*
* The first argument will be of type {@code refc} if the lookup
* class has full privileges to access the member. Otherwise
* the member must be {@code protected} and the first argument
* will be restricted in type to the lookup class.
*
* The returned method handle will have
* {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
* the method's variable arity modifier bit ({@code 0x0080}) is set.
*
* Because of the general equivalence between {@code invokevirtual}
* instructions and method handles produced by {@code findVirtual},
* if the class is {@code MethodHandle} and the name string is
* {@code invokeExact} or {@code invoke}, the resulting
* method handle is equivalent to one produced by
* {@link java.lang.invoke.MethodHandles#exactInvoker MethodHandles.exactInvoker} or
* {@link java.lang.invoke.MethodHandles#invoker MethodHandles.invoker}
* with the same {@code type} argument.
*
* Example:
*
{@code
import static java.lang.invoke.MethodHandles.*;
import static java.lang.invoke.MethodType.*;
...
MethodHandle MH_concat = publicLookup().findVirtual(String.class,
"concat", methodType(String.class, String.class));
MethodHandle MH_hashCode = publicLookup().findVirtual(Object.class,
"hashCode", methodType(int.class));
MethodHandle MH_hashCode_String = publicLookup().findVirtual(String.class,
"hashCode", methodType(int.class));
assertEquals("xy", (String) MH_concat.invokeExact("x", "y"));
assertEquals("xy".hashCode(), (int) MH_hashCode.invokeExact((Object)"xy"));
assertEquals("xy".hashCode(), (int) MH_hashCode_String.invokeExact("xy"));
// interface method:
MethodHandle MH_subSequence = publicLookup().findVirtual(CharSequence.class,
"subSequence", methodType(CharSequence.class, int.class, int.class));
assertEquals("def", MH_subSequence.invoke("abcdefghi", 3, 6).toString());
// constructor "internal method" must be accessed differently:
MethodType MT_newString = methodType(void.class); //()V for new String()
try { assertEquals("impossible", lookup()
.findVirtual(String.class, "", MT_newString));
} catch (NoSuchMethodException ex) { } // OK
MethodHandle MH_newString = publicLookup()
.findConstructor(String.class, MT_newString);
assertEquals("", (String) MH_newString.invokeExact());
* }
*
* @param refc the class or interface from which the method is accessed
* @param name the name of the method
* @param type the type of the method, with the receiver argument omitted
* @return the desired method handle
* @throws NoSuchMethodException if the method does not exist
* @throws IllegalAccessException if access checking fails,
* or if the method is {@code static}
* or if the method's variable arity modifier bit
* is set and {@code asVarargsCollector} fails
* @exception SecurityException if a security manager is present and it
* refuses access
* @throws NullPointerException if any argument is null
*/
public MethodHandle findVirtual(Class refc, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {
throw new IllegalStateException();
}
/**
* Produces a method handle which creates an object and initializes it, using
* the constructor of the specified type.
* The parameter types of the method handle will be those of the constructor,
* while the return type will be a reference to the constructor's class.
* The constructor and all its argument types must be accessible to the lookup object.
*
* The requested type must have a return type of {@code void}.
* (This is consistent with the JVM's treatment of constructor type descriptors.)
*
* The returned method handle will have
* {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
* the constructor's variable arity modifier bit ({@code 0x0080}) is set.
*
* If the returned method handle is invoked, the constructor's class will
* be initialized, if it has not already been initialized.
*
Example:
*
{@code
import static java.lang.invoke.MethodHandles.*;
import static java.lang.invoke.MethodType.*;
...
MethodHandle MH_newArrayList = publicLookup().findConstructor(
ArrayList.class, methodType(void.class, Collection.class));
Collection orig = Arrays.asList("x", "y");
Collection copy = (ArrayList) MH_newArrayList.invokeExact(orig);
assert(orig != copy);
assertEquals(orig, copy);
// a variable-arity constructor:
MethodHandle MH_newProcessBuilder = publicLookup().findConstructor(
ProcessBuilder.class, methodType(void.class, String[].class));
ProcessBuilder pb = (ProcessBuilder)
MH_newProcessBuilder.invoke("x", "y", "z");
assertEquals("[x, y, z]", pb.command().toString());
* }
* @param refc the class or interface from which the method is accessed
* @param type the type of the method, with the receiver argument omitted, and a void return type
* @return the desired method handle
* @throws NoSuchMethodException if the constructor does not exist
* @throws IllegalAccessException if access checking fails
* or if the method's variable arity modifier bit
* is set and {@code asVarargsCollector} fails
* @exception SecurityException if a security manager is present and it
* refuses access
* @throws NullPointerException if any argument is null
*/
public MethodHandle findConstructor(Class refc, MethodType type) throws NoSuchMethodException, IllegalAccessException {
throw new IllegalStateException();
}
/**
* Produces an early-bound method handle for a virtual method.
* It will bypass checks for overriding methods on the receiver,
* as if called from an {@code invokespecial}
* instruction from within the explicitly specified {@code specialCaller}.
* The type of the method handle will be that of the method,
* with a suitably restricted receiver type prepended.
* (The receiver type will be {@code specialCaller} or a subtype.)
* The method and all its argument types must be accessible
* to the lookup object.
*
* Before method resolution,
* if the explicitly specified caller class is not identical with the
* lookup class, or if this lookup object does not have
* private access
* privileges, the access fails.
*
* The returned method handle will have
* {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
* the method's variable arity modifier bit ({@code 0x0080}) is set.
*
* (Note: JVM internal methods named {@code ""} are not visible to this API,
* even though the {@code invokespecial} instruction can refer to them
* in special circumstances. Use {@link #findConstructor findConstructor}
* to access instance initialization methods in a safe manner.)
*
Example:
*
{@code
import static java.lang.invoke.MethodHandles.*;
import static java.lang.invoke.MethodType.*;
...
static class Listie extends ArrayList {
public String toString() { return "[wee Listie]"; }
static Lookup lookup() { return MethodHandles.lookup(); }
}
...
// no access to constructor via invokeSpecial:
MethodHandle MH_newListie = Listie.lookup()
.findConstructor(Listie.class, methodType(void.class));
Listie l = (Listie) MH_newListie.invokeExact();
try { assertEquals("impossible", Listie.lookup().findSpecial(
Listie.class, "", methodType(void.class), Listie.class));
} catch (NoSuchMethodException ex) { } // OK
// access to super and self methods via invokeSpecial:
MethodHandle MH_super = Listie.lookup().findSpecial(
ArrayList.class, "toString" , methodType(String.class), Listie.class);
MethodHandle MH_this = Listie.lookup().findSpecial(
Listie.class, "toString" , methodType(String.class), Listie.class);
MethodHandle MH_duper = Listie.lookup().findSpecial(
Object.class, "toString" , methodType(String.class), Listie.class);
assertEquals("[]", (String) MH_super.invokeExact(l));
assertEquals(""+l, (String) MH_this.invokeExact(l));
assertEquals("[]", (String) MH_duper.invokeExact(l)); // ArrayList method
try { assertEquals("inaccessible", Listie.lookup().findSpecial(
String.class, "toString", methodType(String.class), Listie.class));
} catch (IllegalAccessException ex) { } // OK
Listie subl = new Listie() { public String toString() { return "[subclass]"; } };
assertEquals(""+l, (String) MH_this.invokeExact(subl)); // Listie method
* }
*
* @param refc the class or interface from which the method is accessed
* @param name the name of the method (which must not be "<init>")
* @param type the type of the method, with the receiver argument omitted
* @param specialCaller the proposed calling class to perform the {@code invokespecial}
* @return the desired method handle
* @throws NoSuchMethodException if the method does not exist
* @throws IllegalAccessException if access checking fails
* or if the method's variable arity modifier bit
* is set and {@code asVarargsCollector} fails
* @exception SecurityException if a security manager is present and it
* refuses access
* @throws NullPointerException if any argument is null
*/
public MethodHandle findSpecial(Class refc, String name, MethodType type,
Class specialCaller) throws NoSuchMethodException, IllegalAccessException {
throw new IllegalStateException();
}
/**
* Produces a method handle giving read access to a non-static field.
* The type of the method handle will have a return type of the field's
* value type.
* The method handle's single argument will be the instance containing
* the field.
* Access checking is performed immediately on behalf of the lookup class.
* @param refc the class or interface from which the method is accessed
* @param name the field's name
* @param type the field's type
* @return a method handle which can load values from the field
* @throws NoSuchFieldException if the field does not exist
* @throws IllegalAccessException if access checking fails, or if the field is {@code static}
* @exception SecurityException if a security manager is present and it
* refuses access
* @throws NullPointerException if any argument is null
*/
public MethodHandle findGetter(Class refc, String name, Class type) throws IllegalAccessException {
throw new IllegalStateException();
}
/**
* Produces a method handle giving write access to a non-static field.
* The type of the method handle will have a void return type.
* The method handle will take two arguments, the instance containing
* the field, and the value to be stored.
* The second argument will be of the field's value type.
* Access checking is performed immediately on behalf of the lookup class.
* @param refc the class or interface from which the method is accessed
* @param name the field's name
* @param type the field's type
* @return a method handle which can store values into the field
* @throws NoSuchFieldException if the field does not exist
* @throws IllegalAccessException if access checking fails, or if the field is {@code static}
* @exception SecurityException if a security manager is present and it
* refuses access
* @throws NullPointerException if any argument is null
*/
public MethodHandle findSetter(Class refc, String name, Class type) throws IllegalAccessException {
throw new IllegalStateException();
}
/**
* Produces a method handle giving read access to a static field.
* The type of the method handle will have a return type of the field's
* value type.
* The method handle will take no arguments.
* Access checking is performed immediately on behalf of the lookup class.
*
* If the returned method handle is invoked, the field's class will
* be initialized, if it has not already been initialized.
* @param refc the class or interface from which the method is accessed
* @param name the field's name
* @param type the field's type
* @return a method handle which can load values from the field
* @throws NoSuchFieldException if the field does not exist
* @throws IllegalAccessException if access checking fails, or if the field is not {@code static}
* @exception SecurityException if a security manager is present and it
* refuses access
* @throws NullPointerException if any argument is null
*/
public MethodHandle findStaticGetter(Class refc, String name, Class type) throws IllegalAccessException {
throw new IllegalStateException();
}
/**
* Produces a method handle giving write access to a static field.
* The type of the method handle will have a void return type.
* The method handle will take a single
* argument, of the field's value type, the value to be stored.
* Access checking is performed immediately on behalf of the lookup class.
*
* If the returned method handle is invoked, the field's class will
* be initialized, if it has not already been initialized.
* @param refc the class or interface from which the method is accessed
* @param name the field's name
* @param type the field's type
* @return a method handle which can store values into the field
* @throws NoSuchFieldException if the field does not exist
* @throws IllegalAccessException if access checking fails, or if the field is not {@code static}
* @exception SecurityException if a security manager is present and it
* refuses access
* @throws NullPointerException if any argument is null
*/
public MethodHandle findStaticSetter(Class refc, String name, Class type) throws IllegalAccessException {
throw new IllegalStateException();
}
/**
* Produces an early-bound method handle for a non-static method.
* The receiver must have a supertype {@code defc} in which a method
* of the given name and type is accessible to the lookup class.
* The method and all its argument types must be accessible to the lookup object.
* The type of the method handle will be that of the method,
* without any insertion of an additional receiver parameter.
* The given receiver will be bound into the method handle,
* so that every call to the method handle will invoke the
* requested method on the given receiver.
*
* The returned method handle will have
* {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
* the method's variable arity modifier bit ({@code 0x0080}) is set
* and the trailing array argument is not the only argument.
* (If the trailing array argument is the only argument,
* the given receiver value will be bound to it.)
*
* This is equivalent to the following code:
*
{@code
import static java.lang.invoke.MethodHandles.*;
import static java.lang.invoke.MethodType.*;
...
MethodHandle mh0 = lookup().findVirtual(defc, name, type);
MethodHandle mh1 = mh0.bindTo(receiver);
MethodType mt1 = mh1.type();
if (mh0.isVarargsCollector())
mh1 = mh1.asVarargsCollector(mt1.parameterType(mt1.parameterCount()-1));
return mh1;
* }
* where {@code defc} is either {@code receiver.getClass()} or a super
* type of that class, in which the requested method is accessible
* to the lookup class.
* (Note that {@code bindTo} does not preserve variable arity.)
* @param receiver the object from which the method is accessed
* @param name the name of the method
* @param type the type of the method, with the receiver argument omitted
* @return the desired method handle
* @throws NoSuchMethodException if the method does not exist
* @throws IllegalAccessException if access checking fails
* or if the method's variable arity modifier bit
* is set and {@code asVarargsCollector} fails
* @exception SecurityException if a security manager is present and it
* refuses access
* @throws NullPointerException if any argument is null
* @see MethodHandle#bindTo
* @see #findVirtual
*/
public MethodHandle bind(Object receiver, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {
throw new IllegalStateException();
}
/**
* Makes a direct method handle
* to m, if the lookup class has permission.
* If m is non-static, the receiver argument is treated as an initial argument.
* If m is virtual, overriding is respected on every call.
* Unlike the Core Reflection API, exceptions are not wrapped.
* The type of the method handle will be that of the method,
* with the receiver type prepended (but only if it is non-static).
* If the method's {@code accessible} flag is not set,
* access checking is performed immediately on behalf of the lookup class.
* If m is not public, do not share the resulting handle with untrusted parties.
*
* The returned method handle will have
* {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
* the method's variable arity modifier bit ({@code 0x0080}) is set.
*
* If m is static, and
* if the returned method handle is invoked, the method's class will
* be initialized, if it has not already been initialized.
* @param m the reflected method
* @return a method handle which can invoke the reflected method
* @throws IllegalAccessException if access checking fails
* or if the method's variable arity modifier bit
* is set and {@code asVarargsCollector} fails
* @throws NullPointerException if the argument is null
*/
public MethodHandle unreflect(Method m) throws IllegalAccessException {
throw new IllegalStateException();
}
/**
* Produces a method handle for a reflected method.
* It will bypass checks for overriding methods on the receiver,
* as if called from an {@code invokespecial}
* instruction from within the explicitly specified {@code specialCaller}.
* The type of the method handle will be that of the method,
* with a suitably restricted receiver type prepended.
* (The receiver type will be {@code specialCaller} or a subtype.)
* If the method's {@code accessible} flag is not set,
* access checking is performed immediately on behalf of the lookup class,
* as if {@code invokespecial} instruction were being linked.
*
* Before method resolution,
* if the explicitly specified caller class is not identical with the
* lookup class, or if this lookup object does not have
* private access
* privileges, the access fails.
*
* The returned method handle will have
* {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
* the method's variable arity modifier bit ({@code 0x0080}) is set.
* @param m the reflected method
* @param specialCaller the class nominally calling the method
* @return a method handle which can invoke the reflected method
* @throws IllegalAccessException if access checking fails
* or if the method's variable arity modifier bit
* is set and {@code asVarargsCollector} fails
* @throws NullPointerException if any argument is null
*/
public MethodHandle unreflectSpecial(Method m, Class specialCaller) throws IllegalAccessException {
throw new IllegalStateException();
}
/**
* Produces a method handle for a reflected constructor.
* The type of the method handle will be that of the constructor,
* with the return type changed to the declaring class.
* The method handle will perform a {@code newInstance} operation,
* creating a new instance of the constructor's class on the
* arguments passed to the method handle.
*
* If the constructor's {@code accessible} flag is not set,
* access checking is performed immediately on behalf of the lookup class.
*
* The returned method handle will have
* {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
* the constructor's variable arity modifier bit ({@code 0x0080}) is set.
*
* If the returned method handle is invoked, the constructor's class will
* be initialized, if it has not already been initialized.
* @param c the reflected constructor
* @return a method handle which can invoke the reflected constructor
* @throws IllegalAccessException if access checking fails
* or if the method's variable arity modifier bit
* is set and {@code asVarargsCollector} fails
* @throws NullPointerException if the argument is null
*/
public MethodHandle unreflectConstructor(Constructor c) throws IllegalAccessException {
throw new IllegalStateException();
}
/**
* Produces a method handle giving read access to a reflected field.
* The type of the method handle will have a return type of the field's
* value type.
* If the field is static, the method handle will take no arguments.
* Otherwise, its single argument will be the instance containing
* the field.
* If the field's {@code accessible} flag is not set,
* access checking is performed immediately on behalf of the lookup class.
*
* If the field is static, and
* if the returned method handle is invoked, the field's class will
* be initialized, if it has not already been initialized.
* @param f the reflected field
* @return a method handle which can load values from the reflected field
* @throws IllegalAccessException if access checking fails
* @throws NullPointerException if the argument is null
*/
public MethodHandle unreflectGetter(Field f) throws IllegalAccessException {
throw new IllegalStateException();
}
/**
* Produces a method handle giving write access to a reflected field.
* The type of the method handle will have a void return type.
* If the field is static, the method handle will take a single
* argument, of the field's value type, the value to be stored.
* Otherwise, the two arguments will be the instance containing
* the field, and the value to be stored.
* If the field's {@code accessible} flag is not set,
* access checking is performed immediately on behalf of the lookup class.
*
* If the field is static, and
* if the returned method handle is invoked, the field's class will
* be initialized, if it has not already been initialized.
* @param f the reflected field
* @return a method handle which can store values into the reflected field
* @throws IllegalAccessException if access checking fails
* @throws NullPointerException if the argument is null
*/
public MethodHandle unreflectSetter(Field f) throws IllegalAccessException {
throw new IllegalStateException();
}
/**
* Cracks a direct method handle
* created by this lookup object or a similar one.
* Security and access checks are performed to ensure that this lookup object
* is capable of reproducing the target method handle.
* This means that the cracking may fail if target is a direct method handle
* but was created by an unrelated lookup object.
* This can happen if the method handle is caller sensitive
* and was created by a lookup object for a different class.
* @param target a direct method handle to crack into symbolic reference components
* @return a symbolic reference which can be used to reconstruct this method handle from this lookup object
* @exception SecurityException if a security manager is present and it
* refuses access
* @throws IllegalArgumentException if the target is not a direct method handle or if access checking fails
* @exception NullPointerException if the target is {@code null}
* @see MethodHandleInfo
* @since 1.8
*/
// public MethodHandleInfo revealDirect(MethodHandle target) {
// throw new IllegalStateException();
// }
}
}