Динамически создавать lambda в Java, используя разные загрузчики классов

Я пытаюсь динамически создавать экземпляр лямбды, используя классы, которые недоступны во время компиляции, поскольку они генерируются во время выполнения или еще не известны во время компиляции.

Это работает с использованием следующего кода

В экспериментальной установке это работает хорошо. Однако в реальном коде lambda class загружается с использованием другого ClassLoader, чем остальная часть приложения, т.е. class целевого метода. Это приводит к исключению во время выполнения, поскольку, как кажется, используется ClassLoader целевого метода class для загрузки lambda class. Вот интересная часть stacktrace:

Как я могу это исправить? Есть ли способ указать, какой ClassLoader использовать для каждого класса? Есть ли другой способ динамического создания экземпляров лямбда, который не сталкивается с этой проблемой? Любая помощь высоко ценится.

Edit: Вот небольшой пример, который должен показать проблему

2. Сгенерированный класс Это предполагает, что класс уже скомпилирован в файл .class и что он находится где-то вне области системного загрузчика классов.

Ответы

Ответ 1

Я не знаю, как вы создаете свой загрузчик классов, но предположив, что у вас уже есть один, вы можете заменить

Class<?> targetClass = Class.forName(className);

Class<?> targetClass = yourClassLoader.loadClass(className);

Ответ 2

Не совсем понятно, почему вы выбрали путь, который вы опубликовали, и, в частности, почему именно он выходит за пределы тестовой среды. Но если бы я понял вас правильно, то достичь этой цели можно было бы, используя старый добрый Динамический класс прокси:

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

@FunctionalInterface
interface MyLambda
{
    double call(double d);
}

public class DynamicLambdaTest
{
    public static void main(String[] args) throws Throwable
    {
        MyLambda x = lookupLambda(
            MyLambda.class, "java.lang.Math", "sin", 
            double.class, double.class);

        System.out.println(x.call(Math.toRadians(45)));
    }

    private static <T> T lookupLambda(Class<T> lambdaClass, String className,
        String methodName, Class<?> returnType, Class<?> argumentType)
        throws Throwable
    {
        Object proxy = Proxy.newProxyInstance(lambdaClass.getClassLoader(),
            new Class[] { lambdaClass }, 
            new LambdaProxy(lambdaClass, className, methodName, argumentType));
        @SuppressWarnings("unchecked")
        T lambda = (T)proxy;
        return (T)lambda;
    }
}

class LambdaProxy implements InvocationHandler {

    // The object method handling is based on 
    // docs.oracle.com/javase/8/docs/technotes/guides/reflection/proxy.html
    private static Method hashCodeMethod;
    private static Method equalsMethod;
    private static Method toStringMethod;
    static
    {
        try
        {
            hashCodeMethod =
                Object.class.getMethod("hashCode", (Class<?>[]) null);
            equalsMethod = 
                Object.class.getMethod("equals", new Class[] { Object.class });
            toStringMethod =
                Object.class.getMethod("toString", (Class<?>[]) null);
        }
        catch (NoSuchMethodException e)
        {
            throw new NoSuchMethodError(e.getMessage());
        }
    }

    private Class<?> lambdaClass;
    private Method callMethod;

    public LambdaProxy(Class<?> lambdaClass, String className,
        String methodName, Class<?> argumentType) {

        this.lambdaClass = lambdaClass;
        try
        {
            Class<?> c = Class.forName(className);
            this.callMethod = c.getDeclaredMethod(methodName, argumentType);
        }
        catch (ClassNotFoundException
            | NoSuchMethodException
            | SecurityException e)
        {
            e.printStackTrace();
        }
    }

    @Override
    public Object invoke(Object proxy, Method m, Object[] args)
        throws Throwable
    {
        Class<?> declaringClass = m.getDeclaringClass();
        if (declaringClass == Object.class)
        {
            if (m.equals(hashCodeMethod))
            {
                return proxyHashCode(proxy);
            }
            else if (m.equals(equalsMethod))
            {
                return proxyEquals(proxy, args[0]);
            }
            else if (m.equals(toStringMethod))
            {
                return proxyToString(proxy);
            }
            else
            {
                throw new InternalError(
                    "unexpected Object method dispatched: " + m);
            }
        } 
        if (declaringClass == lambdaClass)
        {
            return callMethod.invoke(null, args);
        }
        throw new Exception("Whoopsie");
    }

    private int proxyHashCode(Object proxy) {
        return System.identityHashCode(proxy);
    }

    private boolean proxyEquals(Object proxy, Object other) {
        return (proxy == other);
    }

    private String proxyToString(Object proxy) {
        return proxy.getClass().getName() + '@' +
            Integer.toHexString(proxy.hashCode());
    }
}

(Вы даже можете отложить инициализацию callMethod в обработчике вызовов до точки, в которой invoke вызывается в первый раз. Этот код следует рассматривать только как эскиз, показывающий, что может быть жизнеспособным путь к решению)