Java Code Examples for java.lang.invoke.MethodHandles#privateLookupIn()

public FieldValueReaderImpl(PackageOpener packageOpener) {
    this.lookups = new ClassValue<Lookup>() {

        @Override
        protected Lookup computeValue(Class<?> type) {
            if ( !getClass().getModule().canRead( type.getModule() ) ) {
                getClass().getModule().addReads( type.getModule() );
            }

            packageOpener.openPackageIfNeeded(
                    type.getModule(), type.getPackageName(), FieldValueReaderImpl.class.getModule()
            );

            try {
                return MethodHandles.privateLookupIn( type, MethodHandles.lookup() );
            }
            catch (IllegalAccessException e) {
                throw new RuntimeException( e );
            }
        }
    };
}
 

public void testTargetClassInOpenModule() throws Throwable {
    // m1/p1.Type
    Class<?> clazz = Class.forName("p1.Type");
    assertEquals(clazz.getModule().getName(), "m1");

    // ensure that this module reads m1
    Module thisModule = getClass().getModule();
    Module m1 = clazz.getModule();
    thisModule.addReads(clazz.getModule());
    assertTrue(m1.isOpen("p1", thisModule));

    Lookup lookup = MethodHandles.privateLookupIn(clazz, MethodHandles.lookup());
    assertTrue(lookup.lookupClass() == clazz);
    assertTrue(lookup.hasPrivateAccess());

    // get obj field
    MethodHandle mh = lookup.findStaticGetter(clazz, "obj", Object.class);
    Object obj = mh.invokeExact();
}
 

public MethodHandles.Lookup run() {
    try {
        return MethodHandles.privateLookupIn(Thread.class, MethodHandles.lookup());
    } catch (ReflectiveOperationException e) {
        throw new Error(e);
    }
}
 

public MethodHandles.Lookup run() {
    try {
        return MethodHandles.privateLookupIn(Thread.class, MethodHandles.lookup());
    } catch (ReflectiveOperationException e) {
        throw new ExceptionInInitializerError(e);
    }
}
 

@Test(expectedExceptions = {IllegalAccessException.class})
public void testCallerDoesNotRead() throws Throwable {
    // m2/p2.Type
    Class<?> clazz = Class.forName("p2.Type");
    assertEquals(clazz.getModule().getName(), "m2");

    Module thisModule = getClass().getModule();
    Module m2 = clazz.getModule();
    assertFalse(thisModule.canRead(m2));
    assertTrue(m2.isOpen("p2", thisModule));

    Lookup lookup = MethodHandles.privateLookupIn(clazz, MethodHandles.lookup());
}
 

@Test(expectedExceptions = {IllegalAccessException.class})
public void testNotOpenToCaller() throws Throwable {
    // m3/p2.Type
    Class<?> clazz = Class.forName("p3.Type");
    assertEquals(clazz.getModule().getName(), "m3");

    Module thisModule = getClass().getModule();
    Module m3 = clazz.getModule();
    thisModule.addReads(clazz.getModule());
    assertFalse(m3.isOpen("p3", thisModule));

    Lookup lookup = MethodHandles.privateLookupIn(clazz, MethodHandles.lookup());
}
 

/**
 * Loads a class file by {@code java.lang.invoke.MethodHandles.Lookup}.
 * It is obtained by using {@code neighbor}.
 *
 * @param neighbor  a class belonging to the same package that the loaded
 *                  class belogns to.
 * @param bcode     the bytecode.
 * @since 3.24
 */
public static Class<?> toClass(Class<?> neighbor, byte[] bcode)
    throws CannotCompileException
{
    try {
        DefineClassHelper.class.getModule().addReads(neighbor.getModule());
        Lookup lookup = MethodHandles.lookup();
        Lookup prvlookup = MethodHandles.privateLookupIn(neighbor, lookup);
        return prvlookup.defineClass(bcode);
    } catch (IllegalAccessException | IllegalArgumentException e) {
        throw new CannotCompileException(e.getMessage() + ": " + neighbor.getName()
                                         + " has no permission to define the class");
    }
}
 

public WhiteBox() throws ReflectiveOperationException {
    Class<?> qClass = LinkedTransferQueue.class;
    Class<?> nodeClass = Class.forName(qClass.getName() + "$Node");
    MethodHandles.Lookup lookup
        = MethodHandles.privateLookupIn(qClass, MethodHandles.lookup());
    HEAD = lookup.findVarHandle(qClass, "head", nodeClass);
    TAIL = lookup.findVarHandle(qClass, "tail", nodeClass);
    NEXT = lookup.findVarHandle(nodeClass, "next", nodeClass);
    ITEM = lookup.findVarHandle(nodeClass, "item", Object.class);
    SWEEP_THRESHOLD = (int)
        lookup.findStaticVarHandle(qClass, "SWEEP_THRESHOLD", int.class)
        .get();
}
 

WhiteBox() throws ReflectiveOperationException {
    Class<?> qClass = ConcurrentLinkedQueue.class;
    Class<?> nodeClass = Class.forName(qClass.getName() + "$Node");
    MethodHandles.Lookup lookup
        = MethodHandles.privateLookupIn(qClass, MethodHandles.lookup());
    HEAD = lookup.findVarHandle(qClass, "head", nodeClass);
    TAIL = lookup.findVarHandle(qClass, "tail", nodeClass);
    NEXT = lookup.findVarHandle(nodeClass, "next", nodeClass);
    ITEM = lookup.findVarHandle(nodeClass, "item", Object.class);
}
 

static void privateLookupPublicClassApplicationModule() throws Exception {
    Class<?> clazz = Class.forName("p.Type");
    MethodHandles.privateLookupIn(clazz, MethodHandles.lookup());
}
 

static void privateLookupNonPublicClassNonExportedPackage() throws Exception {
    Class<?> clazz = Class.forName("sun.nio.ch.SocketChannelImpl");
    MethodHandles.privateLookupIn(clazz, MethodHandles.lookup());
}
 

static void privateLookupPublicClassNonExportedPackage() throws Exception {
    Class<?> clazz = Class.forName("sun.security.x509.X500Name");
    MethodHandles.privateLookupIn(clazz, MethodHandles.lookup());
}
 

static void privateLookupNonPublicClassExportedPackage() throws Exception {
    Class<?> clazz = Class.forName("java.lang.WeakPairMap");
    MethodHandles.privateLookupIn(clazz, MethodHandles.lookup());
}
 

static void privateLookupPublicClassExportedPackage() throws Exception {
    MethodHandles.privateLookupIn(String.class, MethodHandles.lookup());
}
 

@Test(expectedExceptions = {NullPointerException.class})
public void testNullCaller() throws Exception {
    MethodHandles.privateLookupIn(getClass(), null);
}
 

@Test(expectedExceptions = {NullPointerException.class})
public void testNullTargetClass() throws Exception {
    MethodHandles.privateLookupIn(null, MethodHandles.lookup());
}
 

@Test(expectedExceptions = {IllegalArgumentException.class})
public void testPrimitiveArrayClassAsTargetClass() throws Exception {
    MethodHandles.privateLookupIn(int[].class, MethodHandles.lookup());
}
 

@Test(expectedExceptions = {IllegalArgumentException.class})
public void testArrayClassAsTargetClass() throws Exception {
    MethodHandles.privateLookupIn(PrivateLookupInTests[].class, MethodHandles.lookup());
}
 

@Test(expectedExceptions = {IllegalArgumentException.class})
public void testPrimitiveClassAsTargetClass() throws Exception {
    MethodHandles.privateLookupIn(int.class, MethodHandles.lookup());
}
 

@Test(expectedExceptions = {IllegalAccessException.class})
public void testPublicLookupSameModule() throws Exception {
    Lookup caller = MethodHandles.publicLookup();
    Lookup lookup = MethodHandles.privateLookupIn(publicType, caller);
}