Java LambdaMetafactory.metafactory方法代码示例

import java.lang.invoke.LambdaMetafactory; //导入方法依赖的package包/类
public static void main(String[] args) throws Throwable {
    l = MethodHandles.lookup();
    h = l.findVirtual(LambdaReceiver_A.class, "f", mt(int.class));
    MethodType X = mt(int.class, LambdaReceiver.class);
    MethodType A = mt(int.class, LambdaReceiver_A.class);
    MethodType mti = mt(IA.class);
    CallSite cs = LambdaMetafactory.metafactory(l, "m", mti,A,h,X);
    IA p = (IA)cs.dynamicInvoker().invoke();
    LambdaReceiver_A lra = new LambdaReceiver_A();
    try {
        p.m(lra);
    } catch (ClassCastException cce) {
        return;
    }
    throw new AssertionError("CCE expected");
}
 

import java.lang.invoke.LambdaMetafactory; //导入方法依赖的package包/类
@Test
public void accessInstanceMethodWithFunction() throws Throwable {

    SimpleBean simpleBeanInstance = new SimpleBean();

    MethodHandles.Lookup caller = MethodHandles.lookup();
    MethodType getter = MethodType.methodType(Object.class);

    MethodHandle target = caller.findVirtual(SimpleBean.class, "getObj", getter);
    MethodType func = target.type();
    System.out.println(func);
    System.out.println(func.generic());
    CallSite site = LambdaMetafactory.metafactory(caller, "apply", MethodType.methodType(Function.class), func.generic(), target, func);

    MethodHandle factory = site.getTarget();
    Function r = (Function) factory.invoke();
    assertEquals("myCustomObject", r.apply(simpleBeanInstance));

}
 

import java.lang.invoke.LambdaMetafactory; //导入方法依赖的package包/类
@Test
public void accessObjectInstanceMethod() throws Throwable {

    SimpleBean simpleBeanInstance = new SimpleBean();

    MethodHandles.Lookup caller = MethodHandles.lookup();

    Method reflected = SimpleBean.class.getDeclaredMethod("getObj");
    MethodHandle methodHandle = caller.unreflect(reflected);

    CallSite site = LambdaMetafactory.metafactory(caller, "get", MethodType.methodType(Supplier.class, SimpleBean.class),
            MethodType.methodType(Object.class), methodHandle, MethodType.methodType(Object.class));

    MethodHandle factory = site.getTarget();
    factory = factory.bindTo(simpleBeanInstance);
    Supplier r = (Supplier) factory.invoke();
    assertEquals(simpleBeanInstance.getObj(), r.get());
}
 

import java.lang.invoke.LambdaMetafactory; //导入方法依赖的package包/类
private static boolean mf(MethodHandles.Lookup l) {
    try {
        LambdaMetafactory.metafactory(l, "close",
            mt(Closeable.class),mt(void.class),h,mt(void.class));
    } catch(LambdaConversionException e) {
        return true;
    }
    return false;
}
 

import java.lang.invoke.LambdaMetafactory; //导入方法依赖的package包/类
private static boolean mf(Class<?> k) {
    try {
        LambdaMetafactory.metafactory(l, "m",
            mt(I.class),mt(k),h,mt(void.class));
    } catch(LambdaConversionException e) {
        return true;
    }
    return false;
}
 

import java.lang.invoke.LambdaMetafactory; //导入方法依赖的package包/类
private static boolean mf(MethodType mti, MethodType mtf) {
    try {
        LambdaMetafactory.metafactory(l, "m", mti,mtf,h,mtf);
    } catch(LambdaConversionException e) {
        return true;
    }
    return false;
}
 

import java.lang.invoke.LambdaMetafactory; //导入方法依赖的package包/类
public void testDirectStdNonser() throws Throwable {
    MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);

    // Standard metafactory, non-serializable target: not serializable
    CallSite cs = LambdaMetafactory.metafactory(MethodHandles.lookup(),
                                                "test", MethodType.methodType(Predicate.class),
                                                predicateMT, fooMH, stringPredicateMT);
    Predicate<String> p = (Predicate<String>) cs.getTarget().invokeExact();
    assertNotSerial(p, fooAsserter);
}
 

import java.lang.invoke.LambdaMetafactory; //导入方法依赖的package包/类
public void testDirectStdSer() throws Throwable {
    MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);

    // Standard metafactory, serializable target: not serializable
    CallSite cs = LambdaMetafactory.metafactory(MethodHandles.lookup(),
                                                "test", MethodType.methodType(SerPredicate.class),
                                                predicateMT, fooMH, stringPredicateMT);
    assertNotSerial((SerPredicate<String>) cs.getTarget().invokeExact(), fooAsserter);
}
 

import java.lang.invoke.LambdaMetafactory; //导入方法依赖的package包/类
private static CallSite createCallSite(String signatureName, MethodHandles.Lookup lookup, MethodHandle methodHandle,
		MethodType instantiatedMethodType, MethodType signature, Class<?> interfaceClass) throws LambdaConversionException {
	return LambdaMetafactory.metafactory(
			lookup, 
			signatureName,
			MethodType.methodType(interfaceClass), 
			signature, 
			methodHandle, 
			instantiatedMethodType);
}
 

import java.lang.invoke.LambdaMetafactory; //导入方法依赖的package包/类
private ParseFromBytes makeDeserializationFunc(Class<?> type, ParseFromBytes func) {
    try {
        MethodType originFuncArgs = MethodType.methodType(type, byte[].class);
        MethodType targetFuncArgs = MethodType.methodType(Object.class, byte[].class);
        MethodType targetClass = MethodType.methodType(ParseFromBytes.class);
        MethodHandle originFuncHandle = caller.findStatic(type, "parseFrom", originFuncArgs);
        CallSite callSite = LambdaMetafactory.metafactory(caller, "parseFormData", targetClass, targetFuncArgs,
                originFuncHandle, originFuncArgs);
        MethodHandle factory = callSite.getTarget();
        func = (ParseFromBytes) factory.invoke();
    } catch (Throwable e) {
        log.error("makeDeserializationFunc error ..", e);
    }
    return func;
}
 

import java.lang.invoke.LambdaMetafactory; //导入方法依赖的package包/类
protected <T, R> T getConstructorAs(Class<T> targetClass, String methodName, Class<? extends R> clazz, Class<?>... args) {
    try {
        MethodType methodType = methodType(clazz, args);
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        MethodHandle handle = lookup.findConstructor(clazz, methodType(void.class, args));
        MethodType targetType = methodType(targetClass);
        CallSite callSite = LambdaMetafactory.metafactory(lookup, methodName, targetType, methodType.generic(), handle, methodType);
        return (T) callSite.getTarget().invoke();
    } catch (Throwable t) {
        throw new RuntimeException("Unable to create function for constructor of " + clazz.getName(), t);
    }
}
 

import java.lang.invoke.LambdaMetafactory; //导入方法依赖的package包/类
private void buildFunction(final MethodHandles.Lookup caller, final MethodHandle methodHandle) {
	try {
		final MethodType func = methodHandle.type();
		final CallSite site = LambdaMetafactory.metafactory(caller, "apply", MethodType.methodType(Function.class),
				MethodType.methodType(Object.class, Object.class), methodHandle, MethodType.methodType(func.returnType(), func.parameterArray()));

		final MethodHandle factory = site.getTarget();
		function = (Function<BEAN, R>) factory.invoke();

	} catch (final Throwable e) {
		throw new RuntimeException(e);
	}
}
 

import java.lang.invoke.LambdaMetafactory; //导入方法依赖的package包/类
private void build(final MethodHandles.Lookup caller, final MethodHandle methodHandle) {
	try {
		final MethodType func = methodHandle.type();
		final CallSite site = LambdaMetafactory.metafactory(caller, "apply", MethodType.methodType(BiFunction.class),
				MethodType.methodType(Object.class, Object.class, Object.class), methodHandle, MethodType.methodType(func.returnType(), func.parameterArray()));

		final MethodHandle factory = site.getTarget();
		function = (BiFunction<BEAN, R, BEAN>) factory.invoke();

	} catch (final Throwable e) {
		throw new RuntimeException(e);
	}
}
 

import java.lang.invoke.LambdaMetafactory; //导入方法依赖的package包/类
private void build(final MethodHandles.Lookup caller, final MethodHandle methodHandle) {
	try {
		final MethodType func = methodHandle.type();
		final CallSite site = LambdaMetafactory.metafactory(caller, "accept", MethodType.methodType(BiConsumer.class),
				MethodType.methodType(Void.TYPE, Object.class, Object.class), methodHandle, MethodType.methodType(Void.TYPE, func.parameterArray()));

		final MethodHandle factory = site.getTarget();
		consumer = (BiConsumer<BEAN, R>) factory.invoke();

	} catch (final Throwable e) {
		throw new RuntimeException(e);
	}
}
 

import java.lang.invoke.LambdaMetafactory; //导入方法依赖的package包/类
@Test
public void accessStaticMethod() throws Throwable {
    MethodHandles.Lookup caller = MethodHandles.lookup();
    Method reflected = SimpleBean.class.getDeclaredMethod("getStaticObj");
    MethodHandle methodHandle = caller.unreflect(reflected);
    CallSite site = LambdaMetafactory.metafactory(caller, "get", MethodType.methodType(Supplier.class), MethodType.methodType(Object.class), methodHandle,
            MethodType.methodType(Object.class));
    MethodHandle factory = site.getTarget();
    Supplier r = (Supplier) factory.invoke();
    assertEquals(SimpleBean.getStaticObj(), r.get());
}