Question

请查看以下编辑

我正在尝试创建一个允许我访问的 JShell实例，并让我与其创建的 JVM 中的对象进行交互。这是有效的对于在编译时可用的类很好，但对于动态加载的类失败。

public class Main {

    public static final int A = 1;
    public static Main M;

    public static void main(String[] args) throws Exception {
        M = new Main();
        ClassLoader cl = new URLClassLoader(new URL[]{new File("Example.jar").toURL()}, Main.class.getClassLoader());
        Class<?> bc = cl.loadClass("com.example.test.Dynamic");//Works
        JShell shell = JShell.builder()
                .executionEngine(new ExecutionControlProvider() {
                    @Override
                    public String name() {
                        return "direct";
                    }

                    @Override
                    public ExecutionControl generate(ExecutionEnv ee, Map<String, String> map) throws Throwable {
                        return new DirectExecutionControl();
                    }
                }, null)
                .build();
        shell.eval("System.out.println(com.example.test.Main.A);");//Always works
        shell.eval("System.out.println(com.example.test.Main.M);");//Fails (is null) if executionEngine is not set
        shell.eval("System.out.println(com.example.test.Dynamic.class);");//Always fails
    }
}

此外，与DirectExecutionControl交换LocalExecutionControl会得到相同的结果，但我不明白这两个类别之间的区别。

如何使运行时中加载的类可用于此 JShell实例？

编辑：此问题的第一部分已经解决，下面是更新的源代码，用于演示问题的第二部分

public class Main {

    public static void main(String[] args) throws Exception {
        ClassLoader cl = new URLClassLoader(new URL[]{new File("Example.jar").toURL()}, Main.class.getClassLoader());
        Class<?> c = cl.loadClass("com.example.test.C");
        c.getDeclaredField("C").set(null, "initial");
        JShell shell = JShell.builder()
                .executionEngine(new ExecutionControlProvider() {
                    @Override
                    public String name() {
                        return "direct";
                    }

                    @Override
                    public ExecutionControl generate(ExecutionEnv ee, Map<String, String> map) throws Throwable {
                        return new DirectExecutionControl();
                    }
                }, null)
                .build();
        shell.addToClasspath("Example.jar");
        shell.eval("import com.example.test.C;");
        shell.eval("System.out.println(C.C)"); //null
        shell.eval("C.C = \"modified\";");
        shell.eval("System.out.println(C.C)"); //"modified"
        System.out.println(c.getDeclaredField("C").get(null)); //"initial"
    }
}

这是预期的输出，如果 JVM 和 JShell实例不共享任何内存，但是直接将com.example.test.C添加到项目而不是加载它动态地改变结果如下：

shell.eval("import com.example.test.C;");
shell.eval("System.out.println(C.C)"); //"initial"
shell.eval("C.C = \"modified\";");
shell.eval("System.out.println(C.C)"); //"modified"
System.out.println(c.getDeclaredField("C").get(null)); //"modified"

为什么在运行时加载的类不共享 JVM 和 JShell实例之间的内存？

编辑2：问题似乎是由不同的类加载器引起的

在上例中的上下文中执行以下代码：

System.out.println(c.getClassLoader()); //java.net.URLClassLoader
shell.eval("System.out.println(C.class.getClassLoader())"); //jdk.jshell.execution.DefaultLoaderDelegate$RemoteClassLoader
shell.eval("System.out.println(com.example.test.Main.class.getClassLoader())"); //jdk.internal.loader.ClassLoaders$AppClassLoader

这表明，同一个类com.example.test.C由两个不同的类加载器加载。是否可以将类添加到JShell实例而不再重新加载？如果不是，为什么已加载静态加载的类？

Answer 1

解决方案是创建一个自定义LoaderDelegate实现，它提供已加载类的实例，而不是再次加载它们。一个简单的示例是使用默认实现DefaultLoaderDelegate（source）并覆盖其内部findClass的{{1}}方法

RemoteClassLoader

要创建有效的JShell实例，请使用以下代码

@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
    byte[] b = classObjects.get(name);
    if (b == null) {
        Class<?> c = null;
        try {
            c = Class.forName(name);//Use a custom way to load the class
        } catch(ClassNotFoundException e) {
        }
        if(c == null) {
            return super.findClass(name);
        }
        return c;
    }
    return super.defineClass(name, b, 0, b.length, (CodeSource) null);
}

Answer 2

仅讲这个相当实质性问题的一小部分：

另外，将DirectExecutionControl与LocalExecutionControl交换会得到相同的结果，但我不理解这两个类之间的区别

LocalExecutionControl extends DirectExecutionControl，它仅覆盖{... 1}的主体，它们的主体为...

本地：

invoke(Method method)

直接：

    Thread snippetThread = new Thread(execThreadGroup, () -> {
            ...
            res[0] = doitMethod.invoke(null, new Object[0]);
            ...
    });

因此，这两个类之间的区别是直接调用当前线程中的方法，而本地调用新线程中的方法。两种情况下都使用相同的类加载器，因此就共享内存和加载的类而言，您期望得到相同的结果

Answer 3

现在，有更好更好的解决方案：

package ur.pkg;

import jdk.jshell.JShell;
import jdk.jshell.execution.LocalExecutionControlProvider;

public class TestShell {
    public static int testValue = 5;

    public static void main(String[] args) {
        JShell shell = JShell.builder().executionEngine(new LocalExecutionControlProvider(), null).build();
        TestShell.testValue++;
        System.out.println(TestShell.testValue);
        shell.eval("ur.pkg.TestShell.testValue++;").forEach(p -> {
            System.out.println(p.value());
        });
        System.out.println(TestShell.testValue);

    }

}

默认执行引擎为JDI，但您可以将其切换为本地或自己的。

使用JShell实例共享动态加载的类

3 个答案: