java.lang.invoke.MethodHandles.Lookup#lookupClass ( )源码实例Demo

下面列出了java.lang.invoke.MethodHandles.Lookup#lookupClass ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。

源代码1 项目： nashorn 文件： AbstractCallSiteDescriptor.java

private static boolean lookupsEqual(Lookup l1, Lookup l2) {
    if(l1 == l2) {
        return true;
    }
    if(l1.lookupClass() != l2.lookupClass()) {
        return false;
    }
    return l1.lookupModes() == l2.lookupModes();
}

源代码2 项目： openjdk-8-source 文件： AbstractCallSiteDescriptor.java

private static boolean lookupsEqual(Lookup l1, Lookup l2) {
    if(l1 == l2) {
        return true;
    }
    if(l1.lookupClass() != l2.lookupClass()) {
        return false;
    }
    return l1.lookupModes() == l2.lookupModes();
}

源代码3 项目： TencentKona-8 文件： AbstractCallSiteDescriptor.java

private static boolean lookupsEqual(final Lookup l1, final Lookup l2) {
    if(l1 == l2) {
        return true;
    }
    if(l1.lookupClass() != l2.lookupClass()) {
        return false;
    }
    return l1.lookupModes() == l2.lookupModes();
}

源代码4 项目： hottub 文件： AbstractCallSiteDescriptor.java

private static boolean lookupsEqual(final Lookup l1, final Lookup l2) {
    if(l1 == l2) {
        return true;
    }
    if(l1.lookupClass() != l2.lookupClass()) {
        return false;
    }
    return l1.lookupModes() == l2.lookupModes();
}

源代码5 项目： groovy 文件： IndyInterface.java

/**
 * backing bootstrap method with all parameters
 */
private static CallSite realBootstrap(Lookup caller, String name, int callID, MethodType type, boolean safe, boolean thisCall, boolean spreadCall) {
    // since indy does not give us the runtime types
    // we produce first a dummy call site, which then changes the target to one when INDY_OPTIMIZE_THRESHOLD is reached,
    // that does the method selection including the direct call to the
    // real method.
    CacheableCallSite mc = new CacheableCallSite(type);
    final Class<?> sender = caller.lookupClass();
    MethodHandle mh = makeAdapter(mc, sender, name, callID, type, safe, thisCall, spreadCall);
    mc.setTarget(mh);
    mc.setDefaultTarget(mh);
    mc.setFallbackTarget(makeFallBack(mc, sender, name, callID, type, safe, thisCall, spreadCall));

    return mc;
}

源代码6 项目： openjdk-jdk8u-backup 文件： AbstractCallSiteDescriptor.java

private static boolean lookupsEqual(final Lookup l1, final Lookup l2) {
    if(l1 == l2) {
        return true;
    }
    if(l1.lookupClass() != l2.lookupClass()) {
        return false;
    }
    return l1.lookupModes() == l2.lookupModes();
}

源代码7 项目： openjdk-jdk9 文件： DropLookupModeTest.java

/**
 * Starting with a full power Lookup, use dropLookupMode to create new Lookups
 * with reduced access.
 */
public void testReducingAccess() {
    Lookup lookup = MethodHandles.lookup();
    final Class<?> lc = lookup.lookupClass();
    assertTrue(lookup.lookupModes() == (PUBLIC|MODULE|PACKAGE|PROTECTED|PRIVATE));

    lookup = lookup.dropLookupMode(PROTECTED);
    assertTrue(lookup.lookupClass() == lc);
    assertTrue(lookup.lookupModes() == (PUBLIC|MODULE|PACKAGE|PRIVATE));

    lookup = lookup.dropLookupMode(PRIVATE);
    assertTrue(lookup.lookupClass() == lc);
    assertTrue(lookup.lookupModes() == (PUBLIC|MODULE|PACKAGE));

    lookup = lookup.dropLookupMode(PACKAGE);
    assertTrue(lookup.lookupClass() == lc);
    assertTrue(lookup.lookupModes() == (PUBLIC|MODULE));

    lookup = lookup.dropLookupMode(MODULE);
    assertTrue(lookup.lookupClass() == lc);
    assertTrue(lookup.lookupModes() == PUBLIC);

    lookup = lookup.dropLookupMode(PUBLIC);
    assertTrue(lookup.lookupClass() == lc);
    assertTrue(lookup.lookupModes() == 0);

    // repeat with lookup has no access
    lookup = lookup.dropLookupMode(PUBLIC);
    assertTrue(lookup.lookupClass() == lc);
    assertTrue(lookup.lookupModes() == 0);
}

源代码8 项目： jdk8u_nashorn 文件： AbstractCallSiteDescriptor.java

private static boolean lookupsEqual(final Lookup l1, final Lookup l2) {
    if(l1 == l2) {
        return true;
    }
    if(l1.lookupClass() != l2.lookupClass()) {
        return false;
    }
    return l1.lookupModes() == l2.lookupModes();
}

源代码9 项目： jdk8u-dev-jdk 文件： MethodHandlesTest.java

void testUnreflectMaybeSpecial(Class<?> specialCaller,
                               boolean positive, Lookup lookup,
                               Class<?> defc, Class<?> rcvc, Class<?> ret, String name, Class<?>... params) throws Throwable {
    countTest(positive);
    String methodName = name.substring(1 + name.indexOf('/'));  // foo/bar => foo
    MethodType type = MethodType.methodType(ret, params);
    Lookup specialLookup = (specialCaller != null ? maybeMoveIn(lookup, specialCaller) : null);
    boolean specialAccessOK = (specialCaller != null &&
                               specialLookup.lookupClass() == specialCaller &&
                               (specialLookup.lookupModes() & Lookup.PRIVATE) != 0);
    Method rmethod = defc.getDeclaredMethod(methodName, params);
    MethodHandle target = null;
    Exception noAccess = null;
    boolean isStatic = (rcvc == null);
    boolean isSpecial = (specialCaller != null);
    try {
        if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
        if (isSpecial)
            target = specialLookup.unreflectSpecial(rmethod, specialCaller);
        else
            target = maybeMoveIn(lookup, defc).unreflect(rmethod);
    } catch (ReflectiveOperationException ex) {
        noAccess = ex;
        assertExceptionClass(
            IllegalAccessException.class,  // NSME is impossible, since it was already reflected
            noAccess);
        if (verbosity >= 5)  ex.printStackTrace(System.out);
    }
    if (verbosity >= 3)
        System.out.println("unreflect"+(isSpecial?"Special":"")+" "+defc.getName()+"."+name+"/"+type
                           +(!isSpecial ? "" : " specialCaller="+specialCaller)
                           +( isStatic  ? "" : " receiver="+rcvc)
                           +" => "+target
                           +(noAccess == null ? "" : " !! "+noAccess));
    if (positive && noAccess != null)  throw noAccess;
    assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
    if (!positive)  return; // negative test failed as expected
    assertEquals(isStatic, Modifier.isStatic(rmethod.getModifiers()));
    Class<?>[] paramsMaybeWithSelf = params;
    if (!isStatic) {
        paramsMaybeWithSelf = cat(array(Class[].class, (Class)rcvc), params);
    }
    MethodType typeMaybeWithSelf = MethodType.methodType(ret, paramsMaybeWithSelf);
    if (isStatic) {
        assertEquals(typeMaybeWithSelf, target.type());
    } else {
        if (isSpecial)
            assertEquals(specialCaller, target.type().parameterType(0));
        else
            assertEquals(defc, target.type().parameterType(0));
        assertEquals(typeMaybeWithSelf, target.type().changeParameterType(0, rcvc));
    }
    Object[] argsMaybeWithSelf = randomArgs(paramsMaybeWithSelf);
    printCalled(target, name, argsMaybeWithSelf);
    target.invokeWithArguments(argsMaybeWithSelf);
    assertCalled(name, argsMaybeWithSelf);
    if (verbosity >= 1)
        System.out.print(':');
}

源代码10 项目： TencentKona-8 文件： MethodHandlesTest.java

void testUnreflectMaybeSpecial(Class<?> specialCaller,
                               boolean positive, Lookup lookup,
                               Class<?> defc, Class<?> rcvc, Class<?> ret, String name, Class<?>... params) throws Throwable {
    countTest(positive);
    String methodName = name.substring(1 + name.indexOf('/'));  // foo/bar => foo
    MethodType type = MethodType.methodType(ret, params);
    Lookup specialLookup = (specialCaller != null ? maybeMoveIn(lookup, specialCaller) : null);
    boolean specialAccessOK = (specialCaller != null &&
                               specialLookup.lookupClass() == specialCaller &&
                               (specialLookup.lookupModes() & Lookup.PRIVATE) != 0);
    Method rmethod = defc.getDeclaredMethod(methodName, params);
    MethodHandle target = null;
    Exception noAccess = null;
    boolean isStatic = (rcvc == null);
    boolean isSpecial = (specialCaller != null);
    try {
        if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
        if (isSpecial)
            target = specialLookup.unreflectSpecial(rmethod, specialCaller);
        else
            target = maybeMoveIn(lookup, defc).unreflect(rmethod);
    } catch (ReflectiveOperationException ex) {
        noAccess = ex;
        assertExceptionClass(
            IllegalAccessException.class,  // NSME is impossible, since it was already reflected
            noAccess);
        if (verbosity >= 5)  ex.printStackTrace(System.out);
    }
    if (verbosity >= 3)
        System.out.println("unreflect"+(isSpecial?"Special":"")+" "+defc.getName()+"."+name+"/"+type
                           +(!isSpecial ? "" : " specialCaller="+specialCaller)
                           +( isStatic  ? "" : " receiver="+rcvc)
                           +" => "+target
                           +(noAccess == null ? "" : " !! "+noAccess));
    if (positive && noAccess != null)  throw noAccess;
    assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
    if (!positive)  return; // negative test failed as expected
    assertEquals(isStatic, Modifier.isStatic(rmethod.getModifiers()));
    Class<?>[] paramsMaybeWithSelf = params;
    if (!isStatic) {
        paramsMaybeWithSelf = cat(array(Class[].class, (Class)rcvc), params);
    }
    MethodType typeMaybeWithSelf = MethodType.methodType(ret, paramsMaybeWithSelf);
    if (isStatic) {
        assertEquals(typeMaybeWithSelf, target.type());
    } else {
        if (isSpecial)
            assertEquals(specialCaller, target.type().parameterType(0));
        else
            assertEquals(defc, target.type().parameterType(0));
        assertEquals(typeMaybeWithSelf, target.type().changeParameterType(0, rcvc));
    }
    Object[] argsMaybeWithSelf = randomArgs(paramsMaybeWithSelf);
    printCalled(target, name, argsMaybeWithSelf);
    target.invokeWithArguments(argsMaybeWithSelf);
    assertCalled(name, argsMaybeWithSelf);
    if (verbosity >= 1)
        System.out.print(':');
}

源代码11 项目： jdk8u60 文件： MethodHandlesTest.java

void testUnreflectMaybeSpecial(Class<?> specialCaller,
                               boolean positive, Lookup lookup,
                               Class<?> defc, Class<?> rcvc, Class<?> ret, String name, Class<?>... params) throws Throwable {
    countTest(positive);
    String methodName = name.substring(1 + name.indexOf('/'));  // foo/bar => foo
    MethodType type = MethodType.methodType(ret, params);
    Lookup specialLookup = (specialCaller != null ? maybeMoveIn(lookup, specialCaller) : null);
    boolean specialAccessOK = (specialCaller != null &&
                               specialLookup.lookupClass() == specialCaller &&
                               (specialLookup.lookupModes() & Lookup.PRIVATE) != 0);
    Method rmethod = defc.getDeclaredMethod(methodName, params);
    MethodHandle target = null;
    Exception noAccess = null;
    boolean isStatic = (rcvc == null);
    boolean isSpecial = (specialCaller != null);
    try {
        if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
        if (isSpecial)
            target = specialLookup.unreflectSpecial(rmethod, specialCaller);
        else
            target = maybeMoveIn(lookup, defc).unreflect(rmethod);
    } catch (ReflectiveOperationException ex) {
        noAccess = ex;
        assertExceptionClass(
            IllegalAccessException.class,  // NSME is impossible, since it was already reflected
            noAccess);
        if (verbosity >= 5)  ex.printStackTrace(System.out);
    }
    if (verbosity >= 3)
        System.out.println("unreflect"+(isSpecial?"Special":"")+" "+defc.getName()+"."+name+"/"+type
                           +(!isSpecial ? "" : " specialCaller="+specialCaller)
                           +( isStatic  ? "" : " receiver="+rcvc)
                           +" => "+target
                           +(noAccess == null ? "" : " !! "+noAccess));
    if (positive && noAccess != null)  throw noAccess;
    assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
    if (!positive)  return; // negative test failed as expected
    assertEquals(isStatic, Modifier.isStatic(rmethod.getModifiers()));
    Class<?>[] paramsMaybeWithSelf = params;
    if (!isStatic) {
        paramsMaybeWithSelf = cat(array(Class[].class, (Class)rcvc), params);
    }
    MethodType typeMaybeWithSelf = MethodType.methodType(ret, paramsMaybeWithSelf);
    if (isStatic) {
        assertEquals(typeMaybeWithSelf, target.type());
    } else {
        if (isSpecial)
            assertEquals(specialCaller, target.type().parameterType(0));
        else
            assertEquals(defc, target.type().parameterType(0));
        assertEquals(typeMaybeWithSelf, target.type().changeParameterType(0, rcvc));
    }
    Object[] argsMaybeWithSelf = randomArgs(paramsMaybeWithSelf);
    printCalled(target, name, argsMaybeWithSelf);
    target.invokeWithArguments(argsMaybeWithSelf);
    assertCalled(name, argsMaybeWithSelf);
    if (verbosity >= 1)
        System.out.print(':');
}

源代码12 项目： jdk8u-jdk 文件： MethodHandlesTest.java

void testFindSpecial(boolean positive, Lookup lookup, Class<?> specialCaller,
                     Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
    countTest(positive);
    String methodName = name.substring(1 + name.indexOf('/'));  // foo/bar => foo
    MethodType type = MethodType.methodType(ret, params);
    Lookup specialLookup = maybeMoveIn(lookup, specialCaller);
    boolean specialAccessOK = (specialLookup.lookupClass() == specialCaller &&
                               (specialLookup.lookupModes() & Lookup.PRIVATE) != 0);
    MethodHandle target = null;
    Exception noAccess = null;
    try {
        if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
        if (verbosity >= 5)  System.out.println("  lookup => "+specialLookup);
        target = specialLookup.findSpecial(defc, methodName, type, specialCaller);
    } catch (ReflectiveOperationException ex) {
        noAccess = ex;
        assertExceptionClass(
            (!specialAccessOK)  // this check should happen first
            ?   IllegalAccessException.class
            : (name.contains("bogus") || INIT_REF_CAUSES_NSME && name.contains("<init>"))
            ?   NoSuchMethodException.class
            : IllegalAccessException.class,
            noAccess);
        if (verbosity >= 5)  ex.printStackTrace(System.out);
    }
    if (verbosity >= 3)
        System.out.println("findSpecial from "+specialCaller.getName()+" to "+defc.getName()+"."+name+"/"+type+" => "+target
                           +(target == null ? "" : target.type())
                           +(noAccess == null ? "" : " !! "+noAccess));
    if (positive && noAccess != null)  throw noAccess;
    assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
    if (!positive)  return; // negative test failed as expected
    assertEquals(specialCaller, target.type().parameterType(0));
    assertEquals(type,          target.type().dropParameterTypes(0,1));
    Class<?>[] paramsWithSelf = cat(array(Class[].class, (Class)specialCaller), params);
    MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf);
    assertNameStringContains(target, methodName);
    Object[] args = randomArgs(paramsWithSelf);
    printCalled(target, name, args);
    target.invokeWithArguments(args);
    assertCalled(name, args);
}

源代码13 项目： openjdk-jdk8u 文件： MethodHandlesTest.java

void testUnreflectMaybeSpecial(Class<?> specialCaller,
                               boolean positive, Lookup lookup,
                               Class<?> defc, Class<?> rcvc, Class<?> ret, String name, Class<?>... params) throws Throwable {
    countTest(positive);
    String methodName = name.substring(1 + name.indexOf('/'));  // foo/bar => foo
    MethodType type = MethodType.methodType(ret, params);
    Lookup specialLookup = (specialCaller != null ? maybeMoveIn(lookup, specialCaller) : null);
    boolean specialAccessOK = (specialCaller != null &&
                               specialLookup.lookupClass() == specialCaller &&
                               (specialLookup.lookupModes() & Lookup.PRIVATE) != 0);
    Method rmethod = defc.getDeclaredMethod(methodName, params);
    MethodHandle target = null;
    Exception noAccess = null;
    boolean isStatic = (rcvc == null);
    boolean isSpecial = (specialCaller != null);
    try {
        if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
        if (isSpecial)
            target = specialLookup.unreflectSpecial(rmethod, specialCaller);
        else
            target = maybeMoveIn(lookup, defc).unreflect(rmethod);
    } catch (ReflectiveOperationException ex) {
        noAccess = ex;
        assertExceptionClass(
            IllegalAccessException.class,  // NSME is impossible, since it was already reflected
            noAccess);
        if (verbosity >= 5)  ex.printStackTrace(System.out);
    }
    if (verbosity >= 3)
        System.out.println("unreflect"+(isSpecial?"Special":"")+" "+defc.getName()+"."+name+"/"+type
                           +(!isSpecial ? "" : " specialCaller="+specialCaller)
                           +( isStatic  ? "" : " receiver="+rcvc)
                           +" => "+target
                           +(noAccess == null ? "" : " !! "+noAccess));
    if (positive && noAccess != null)  throw noAccess;
    assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
    if (!positive)  return; // negative test failed as expected
    assertEquals(isStatic, Modifier.isStatic(rmethod.getModifiers()));
    Class<?>[] paramsMaybeWithSelf = params;
    if (!isStatic) {
        paramsMaybeWithSelf = cat(array(Class[].class, (Class)rcvc), params);
    }
    MethodType typeMaybeWithSelf = MethodType.methodType(ret, paramsMaybeWithSelf);
    if (isStatic) {
        assertEquals(typeMaybeWithSelf, target.type());
    } else {
        if (isSpecial)
            assertEquals(specialCaller, target.type().parameterType(0));
        else
            assertEquals(defc, target.type().parameterType(0));
        assertEquals(typeMaybeWithSelf, target.type().changeParameterType(0, rcvc));
    }
    Object[] argsMaybeWithSelf = randomArgs(paramsMaybeWithSelf);
    printCalled(target, name, argsMaybeWithSelf);
    target.invokeWithArguments(argsMaybeWithSelf);
    assertCalled(name, argsMaybeWithSelf);
    if (verbosity >= 1)
        System.out.print(':');
}

源代码14 项目： openjdk-8 文件： MethodHandlesTest.java

void testUnreflectMaybeSpecial(Class<?> specialCaller,
                               boolean positive, Lookup lookup,
                               Class<?> defc, Class<?> rcvc, Class<?> ret, String name, Class<?>... params) throws Throwable {
    countTest(positive);
    String methodName = name.substring(1 + name.indexOf('/'));  // foo/bar => foo
    MethodType type = MethodType.methodType(ret, params);
    Lookup specialLookup = (specialCaller != null ? maybeMoveIn(lookup, specialCaller) : null);
    boolean specialAccessOK = (specialCaller != null &&
                               specialLookup.lookupClass() == specialCaller &&
                               (specialLookup.lookupModes() & Lookup.PRIVATE) != 0);
    Method rmethod = defc.getDeclaredMethod(methodName, params);
    MethodHandle target = null;
    Exception noAccess = null;
    boolean isStatic = (rcvc == null);
    boolean isSpecial = (specialCaller != null);
    try {
        if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
        if (isSpecial)
            target = specialLookup.unreflectSpecial(rmethod, specialCaller);
        else
            target = maybeMoveIn(lookup, defc).unreflect(rmethod);
    } catch (ReflectiveOperationException ex) {
        noAccess = ex;
        assertExceptionClass(
            IllegalAccessException.class,  // NSME is impossible, since it was already reflected
            noAccess);
        if (verbosity >= 5)  ex.printStackTrace(System.out);
    }
    if (verbosity >= 3)
        System.out.println("unreflect"+(isSpecial?"Special":"")+" "+defc.getName()+"."+name+"/"+type
                           +(!isSpecial ? "" : " specialCaller="+specialCaller)
                           +( isStatic  ? "" : " receiver="+rcvc)
                           +" => "+target
                           +(noAccess == null ? "" : " !! "+noAccess));
    if (positive && noAccess != null)  throw noAccess;
    assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
    if (!positive)  return; // negative test failed as expected
    assertEquals(isStatic, Modifier.isStatic(rmethod.getModifiers()));
    Class<?>[] paramsMaybeWithSelf = params;
    if (!isStatic) {
        paramsMaybeWithSelf = cat(array(Class[].class, (Class)rcvc), params);
    }
    MethodType typeMaybeWithSelf = MethodType.methodType(ret, paramsMaybeWithSelf);
    if (isStatic) {
        assertEquals(typeMaybeWithSelf, target.type());
    } else {
        if (isSpecial)
            assertEquals(specialCaller, target.type().parameterType(0));
        else
            assertEquals(defc, target.type().parameterType(0));
        assertEquals(typeMaybeWithSelf, target.type().changeParameterType(0, rcvc));
    }
    Object[] argsMaybeWithSelf = randomArgs(paramsMaybeWithSelf);
    printCalled(target, name, argsMaybeWithSelf);
    target.invokeWithArguments(argsMaybeWithSelf);
    assertCalled(name, argsMaybeWithSelf);
    if (verbosity >= 1)
        System.out.print(':');
}

源代码15 项目： jdk8u-dev-jdk 文件： MethodHandlesTest.java

void testFindSpecial(boolean positive, Lookup lookup, Class<?> specialCaller,
                     Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
    countTest(positive);
    String methodName = name.substring(1 + name.indexOf('/'));  // foo/bar => foo
    MethodType type = MethodType.methodType(ret, params);
    Lookup specialLookup = maybeMoveIn(lookup, specialCaller);
    boolean specialAccessOK = (specialLookup.lookupClass() == specialCaller &&
                               (specialLookup.lookupModes() & Lookup.PRIVATE) != 0);
    MethodHandle target = null;
    Exception noAccess = null;
    try {
        if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
        if (verbosity >= 5)  System.out.println("  lookup => "+specialLookup);
        target = specialLookup.findSpecial(defc, methodName, type, specialCaller);
    } catch (ReflectiveOperationException ex) {
        noAccess = ex;
        assertExceptionClass(
            (!specialAccessOK)  // this check should happen first
            ?   IllegalAccessException.class
            : (name.contains("bogus") || INIT_REF_CAUSES_NSME && name.contains("<init>"))
            ?   NoSuchMethodException.class
            : IllegalAccessException.class,
            noAccess);
        if (verbosity >= 5)  ex.printStackTrace(System.out);
    }
    if (verbosity >= 3)
        System.out.println("findSpecial from "+specialCaller.getName()+" to "+defc.getName()+"."+name+"/"+type+" => "+target
                           +(target == null ? "" : target.type())
                           +(noAccess == null ? "" : " !! "+noAccess));
    if (positive && noAccess != null)  throw noAccess;
    assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
    if (!positive)  return; // negative test failed as expected
    assertEquals(specialCaller, target.type().parameterType(0));
    assertEquals(type,          target.type().dropParameterTypes(0,1));
    Class<?>[] paramsWithSelf = cat(array(Class[].class, (Class)specialCaller), params);
    MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf);
    assertNameStringContains(target, methodName);
    Object[] args = randomArgs(paramsWithSelf);
    printCalled(target, name, args);
    target.invokeWithArguments(args);
    assertCalled(name, args);
}

源代码16 项目： openjdk-jdk8u-backup 文件： MethodHandlesTest.java

void testUnreflectMaybeSpecial(Class<?> specialCaller,
                               boolean positive, Lookup lookup,
                               Class<?> defc, Class<?> rcvc, Class<?> ret, String name, Class<?>... params) throws Throwable {
    countTest(positive);
    String methodName = name.substring(1 + name.indexOf('/'));  // foo/bar => foo
    MethodType type = MethodType.methodType(ret, params);
    Lookup specialLookup = (specialCaller != null ? maybeMoveIn(lookup, specialCaller) : null);
    boolean specialAccessOK = (specialCaller != null &&
                               specialLookup.lookupClass() == specialCaller &&
                               (specialLookup.lookupModes() & Lookup.PRIVATE) != 0);
    Method rmethod = defc.getDeclaredMethod(methodName, params);
    MethodHandle target = null;
    Exception noAccess = null;
    boolean isStatic = (rcvc == null);
    boolean isSpecial = (specialCaller != null);
    try {
        if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
        if (isSpecial)
            target = specialLookup.unreflectSpecial(rmethod, specialCaller);
        else
            target = maybeMoveIn(lookup, defc).unreflect(rmethod);
    } catch (ReflectiveOperationException ex) {
        noAccess = ex;
        assertExceptionClass(
            IllegalAccessException.class,  // NSME is impossible, since it was already reflected
            noAccess);
        if (verbosity >= 5)  ex.printStackTrace(System.out);
    }
    if (verbosity >= 3)
        System.out.println("unreflect"+(isSpecial?"Special":"")+" "+defc.getName()+"."+name+"/"+type
                           +(!isSpecial ? "" : " specialCaller="+specialCaller)
                           +( isStatic  ? "" : " receiver="+rcvc)
                           +" => "+target
                           +(noAccess == null ? "" : " !! "+noAccess));
    if (positive && noAccess != null)  throw noAccess;
    assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
    if (!positive)  return; // negative test failed as expected
    assertEquals(isStatic, Modifier.isStatic(rmethod.getModifiers()));
    Class<?>[] paramsMaybeWithSelf = params;
    if (!isStatic) {
        paramsMaybeWithSelf = cat(array(Class[].class, (Class)rcvc), params);
    }
    MethodType typeMaybeWithSelf = MethodType.methodType(ret, paramsMaybeWithSelf);
    if (isStatic) {
        assertEquals(typeMaybeWithSelf, target.type());
    } else {
        if (isSpecial)
            assertEquals(specialCaller, target.type().parameterType(0));
        else
            assertEquals(defc, target.type().parameterType(0));
        assertEquals(typeMaybeWithSelf, target.type().changeParameterType(0, rcvc));
    }
    Object[] argsMaybeWithSelf = randomArgs(paramsMaybeWithSelf);
    printCalled(target, name, argsMaybeWithSelf);
    target.invokeWithArguments(argsMaybeWithSelf);
    assertCalled(name, argsMaybeWithSelf);
    if (verbosity >= 1)
        System.out.print(':');
}

源代码17 项目： openjdk-8-source 文件： MethodHandlesTest.java

void testFindSpecial(boolean positive, Lookup lookup, Class<?> specialCaller,
                     Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
    countTest(positive);
    String methodName = name.substring(1 + name.indexOf('/'));  // foo/bar => foo
    MethodType type = MethodType.methodType(ret, params);
    Lookup specialLookup = maybeMoveIn(lookup, specialCaller);
    boolean specialAccessOK = (specialLookup.lookupClass() == specialCaller &&
                               (specialLookup.lookupModes() & Lookup.PRIVATE) != 0);
    MethodHandle target = null;
    Exception noAccess = null;
    try {
        if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
        if (verbosity >= 5)  System.out.println("  lookup => "+specialLookup);
        target = specialLookup.findSpecial(defc, methodName, type, specialCaller);
    } catch (ReflectiveOperationException ex) {
        noAccess = ex;
        assertExceptionClass(
            (!specialAccessOK)  // this check should happen first
            ?   IllegalAccessException.class
            : (name.contains("bogus") || INIT_REF_CAUSES_NSME && name.contains("<init>"))
            ?   NoSuchMethodException.class
            : IllegalAccessException.class,
            noAccess);
        if (verbosity >= 5)  ex.printStackTrace(System.out);
    }
    if (verbosity >= 3)
        System.out.println("findSpecial from "+specialCaller.getName()+" to "+defc.getName()+"."+name+"/"+type+" => "+target
                           +(target == null ? "" : target.type())
                           +(noAccess == null ? "" : " !! "+noAccess));
    if (positive && noAccess != null)  throw noAccess;
    assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
    if (!positive)  return; // negative test failed as expected
    assertEquals(specialCaller, target.type().parameterType(0));
    assertEquals(type,          target.type().dropParameterTypes(0,1));
    Class<?>[] paramsWithSelf = cat(array(Class[].class, (Class)specialCaller), params);
    MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf);
    assertNameStringContains(target, methodName);
    Object[] args = randomArgs(paramsWithSelf);
    printCalled(target, name, args);
    target.invokeWithArguments(args);
    assertCalled(name, args);
}

源代码18 项目： openjdk-8-source 文件： MethodHandlesTest.java

void testUnreflectMaybeSpecial(Class<?> specialCaller,
                               boolean positive, Lookup lookup,
                               Class<?> defc, Class<?> rcvc, Class<?> ret, String name, Class<?>... params) throws Throwable {
    countTest(positive);
    String methodName = name.substring(1 + name.indexOf('/'));  // foo/bar => foo
    MethodType type = MethodType.methodType(ret, params);
    Lookup specialLookup = (specialCaller != null ? maybeMoveIn(lookup, specialCaller) : null);
    boolean specialAccessOK = (specialCaller != null &&
                               specialLookup.lookupClass() == specialCaller &&
                               (specialLookup.lookupModes() & Lookup.PRIVATE) != 0);
    Method rmethod = defc.getDeclaredMethod(methodName, params);
    MethodHandle target = null;
    Exception noAccess = null;
    boolean isStatic = (rcvc == null);
    boolean isSpecial = (specialCaller != null);
    try {
        if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
        if (isSpecial)
            target = specialLookup.unreflectSpecial(rmethod, specialCaller);
        else
            target = maybeMoveIn(lookup, defc).unreflect(rmethod);
    } catch (ReflectiveOperationException ex) {
        noAccess = ex;
        assertExceptionClass(
            IllegalAccessException.class,  // NSME is impossible, since it was already reflected
            noAccess);
        if (verbosity >= 5)  ex.printStackTrace(System.out);
    }
    if (verbosity >= 3)
        System.out.println("unreflect"+(isSpecial?"Special":"")+" "+defc.getName()+"."+name+"/"+type
                           +(!isSpecial ? "" : " specialCaller="+specialCaller)
                           +( isStatic  ? "" : " receiver="+rcvc)
                           +" => "+target
                           +(noAccess == null ? "" : " !! "+noAccess));
    if (positive && noAccess != null)  throw noAccess;
    assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
    if (!positive)  return; // negative test failed as expected
    assertEquals(isStatic, Modifier.isStatic(rmethod.getModifiers()));
    Class<?>[] paramsMaybeWithSelf = params;
    if (!isStatic) {
        paramsMaybeWithSelf = cat(array(Class[].class, (Class)rcvc), params);
    }
    MethodType typeMaybeWithSelf = MethodType.methodType(ret, paramsMaybeWithSelf);
    if (isStatic) {
        assertEquals(typeMaybeWithSelf, target.type());
    } else {
        if (isSpecial)
            assertEquals(specialCaller, target.type().parameterType(0));
        else
            assertEquals(defc, target.type().parameterType(0));
        assertEquals(typeMaybeWithSelf, target.type().changeParameterType(0, rcvc));
    }
    Object[] argsMaybeWithSelf = randomArgs(paramsMaybeWithSelf);
    printCalled(target, name, argsMaybeWithSelf);
    target.invokeWithArguments(argsMaybeWithSelf);
    assertCalled(name, argsMaybeWithSelf);
    if (verbosity >= 1)
        System.out.print(':');
}

源代码19 项目： jdk8u_jdk 文件： MethodHandlesTest.java

void testUnreflectMaybeSpecial(Class<?> specialCaller,
                               boolean positive, Lookup lookup,
                               Class<?> defc, Class<?> rcvc, Class<?> ret, String name, Class<?>... params) throws Throwable {
    countTest(positive);
    String methodName = name.substring(1 + name.indexOf('/'));  // foo/bar => foo
    MethodType type = MethodType.methodType(ret, params);
    Lookup specialLookup = (specialCaller != null ? maybeMoveIn(lookup, specialCaller) : null);
    boolean specialAccessOK = (specialCaller != null &&
                               specialLookup.lookupClass() == specialCaller &&
                               (specialLookup.lookupModes() & Lookup.PRIVATE) != 0);
    Method rmethod = defc.getDeclaredMethod(methodName, params);
    MethodHandle target = null;
    Exception noAccess = null;
    boolean isStatic = (rcvc == null);
    boolean isSpecial = (specialCaller != null);
    try {
        if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
        if (isSpecial)
            target = specialLookup.unreflectSpecial(rmethod, specialCaller);
        else
            target = maybeMoveIn(lookup, defc).unreflect(rmethod);
    } catch (ReflectiveOperationException ex) {
        noAccess = ex;
        assertExceptionClass(
            IllegalAccessException.class,  // NSME is impossible, since it was already reflected
            noAccess);
        if (verbosity >= 5)  ex.printStackTrace(System.out);
    }
    if (verbosity >= 3)
        System.out.println("unreflect"+(isSpecial?"Special":"")+" "+defc.getName()+"."+name+"/"+type
                           +(!isSpecial ? "" : " specialCaller="+specialCaller)
                           +( isStatic  ? "" : " receiver="+rcvc)
                           +" => "+target
                           +(noAccess == null ? "" : " !! "+noAccess));
    if (positive && noAccess != null)  throw noAccess;
    assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
    if (!positive)  return; // negative test failed as expected
    assertEquals(isStatic, Modifier.isStatic(rmethod.getModifiers()));
    Class<?>[] paramsMaybeWithSelf = params;
    if (!isStatic) {
        paramsMaybeWithSelf = cat(array(Class[].class, (Class)rcvc), params);
    }
    MethodType typeMaybeWithSelf = MethodType.methodType(ret, paramsMaybeWithSelf);
    if (isStatic) {
        assertEquals(typeMaybeWithSelf, target.type());
    } else {
        if (isSpecial)
            assertEquals(specialCaller, target.type().parameterType(0));
        else
            assertEquals(defc, target.type().parameterType(0));
        assertEquals(typeMaybeWithSelf, target.type().changeParameterType(0, rcvc));
    }
    Object[] argsMaybeWithSelf = randomArgs(paramsMaybeWithSelf);
    printCalled(target, name, argsMaybeWithSelf);
    target.invokeWithArguments(argsMaybeWithSelf);
    assertCalled(name, argsMaybeWithSelf);
    if (verbosity >= 1)
        System.out.print(':');
}

源代码20 项目： jdk8u-jdk 文件： MethodHandlesTest.java

void testFindSpecial(boolean positive, Lookup lookup, Class<?> specialCaller,
                     Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
    countTest(positive);
    String methodName = name.substring(1 + name.indexOf('/'));  // foo/bar => foo
    MethodType type = MethodType.methodType(ret, params);
    Lookup specialLookup = maybeMoveIn(lookup, specialCaller);
    boolean specialAccessOK = (specialLookup.lookupClass() == specialCaller &&
                               (specialLookup.lookupModes() & Lookup.PRIVATE) != 0);
    MethodHandle target = null;
    Exception noAccess = null;
    try {
        if (verbosity >= 4)  System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);
        if (verbosity >= 5)  System.out.println("  lookup => "+specialLookup);
        target = specialLookup.findSpecial(defc, methodName, type, specialCaller);
    } catch (ReflectiveOperationException ex) {
        noAccess = ex;
        assertExceptionClass(
            (!specialAccessOK)  // this check should happen first
            ?   IllegalAccessException.class
            : (name.contains("bogus") || INIT_REF_CAUSES_NSME && name.contains("<init>"))
            ?   NoSuchMethodException.class
            : IllegalAccessException.class,
            noAccess);
        if (verbosity >= 5)  ex.printStackTrace(System.out);
    }
    if (verbosity >= 3)
        System.out.println("findSpecial from "+specialCaller.getName()+" to "+defc.getName()+"."+name+"/"+type+" => "+target
                           +(target == null ? "" : target.type())
                           +(noAccess == null ? "" : " !! "+noAccess));
    if (positive && noAccess != null)  throw noAccess;
    assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);
    if (!positive)  return; // negative test failed as expected
    assertEquals(specialCaller, target.type().parameterType(0));
    assertEquals(type,          target.type().dropParameterTypes(0,1));
    Class<?>[] paramsWithSelf = cat(array(Class[].class, (Class)specialCaller), params);
    MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf);
    assertNameStringContains(target, methodName);
    Object[] args = randomArgs(paramsWithSelf);
    printCalled(target, name, args);
    target.invokeWithArguments(args);
    assertCalled(name, args);
}

方法所在类

java.lang.invoke.MethodHandles.Lookup