3

ユーザーが選択したJava（JPanel）ファイルをロードするプログラムを作成しました。ユーザーは基本的に、JavaCompilerによってコンパイルされ、次に生成されたクラスファイルがロードされるJavaファイルを選択します。しかし、何らかのテキスト エディタを使用して Java ファイル (JPanel) に変更を加えると、プログラムを閉じてプロジェクトを再実行しても、新しい変更がクラス ファイルに反映されないため、問題が発生します。

同じクラスファイルがメモリから何度もロードされていると思います。

ロードされたクラスをメモリからクリアする方法はありますか?

コンパイル:

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
if (compiler != null) {
        DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>();
        StandardJavaFileManager stdFileManager = compiler.getStandardFileManager(diagnostics, null, null);
        Iterable<? extends JavaFileObject> fileObjects = stdFileManager.getJavaFileObjectsFromFiles(filesToCompile);
        List<String> optionList = new ArrayList<String>();
        // set compiler's classpath to be same as the runtime's
        rootDir=Utility.createRootDir();
        optionList.addAll(Arrays.asList("-d", rootDir.getAbsolutePath(), "-classpath", System.getProperty("java.class.path")));
        // optionList.add(()
        try {
            stdFileManager.flush();
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        CompilationTask task = compiler.getTask(null, stdFileManager,null, optionList, null, fileObjects);
        Boolean result = task.call();
        try {
            stdFileManager.flush();
            stdFileManager.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
}

読み込み中:

loader = new URLClassLoader(new URL[] { rootDir.toURI().toURL() });
cls = Class.forName(Utility.extractFQDN(sourceFile)+"."+Utility.extractClassName(sourceFile),true, loader);

panel= (JPanel) cls.newInstance();

コンパイルされたクラス ファイルを逆コンパイラでチェックしたところ、コードが更新されましたが、以前のクラス ファイルがクラス ローダーによってメモリからロードされている理由がわかりません。

4

1 に答える 1

1

編集：

これは、文字列を同じクラス名に繰り返しコンパイルし、新しい動作を示す SSCCE です。ファイルの全体的な混乱を避けるために、メモリ内ですべてを行います。これは、アプリケーションに簡単に適応できるはずだと思います。

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.net.URI;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import javax.tools.FileObject;
import javax.tools.ForwardingJavaFileManager;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.JavaFileObject.Kind;
import javax.tools.SimpleJavaFileObject;
import javax.tools.ToolProvider;


public class Compile {
    static class OutFile extends SimpleJavaFileObject {
        private final ByteArrayOutputStream out = new ByteArrayOutputStream();

        OutFile(String name) {
            super(URI.create("memory:///" + name.replace('.','/') + Kind.CLASS.extension), Kind.CLASS);
        }

        @Override
        public OutputStream openOutputStream() throws IOException {
            return out;
        }
    }

    static class InFile extends SimpleJavaFileObject {
        final String code;

        InFile(String name, String code) {
            super(URI.create("string:///" + name.replace('.','/') + Kind.SOURCE.extension), Kind.SOURCE);
            this.code = code;
        }

        @Override
        public CharSequence getCharContent(boolean ignoreEncodingErrors) {
            return code;
        }
    }

    static class Loader extends ClassLoader {
        private final Map<String, OutFile> files = new HashMap<String, OutFile>();

        public OutFile add(String className) {
            OutFile file = new OutFile(className);
            files.put(className, file);
            return file;
        }

        @Override
        protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
            Class<?> c = findLoadedClass(name);
            if(c == null) {
                OutFile file = files.get(name);
                if(file == null) {
                    return super.loadClass(name, resolve);
                }

                c = defineClass(name, file.out.toByteArray(), 0, file.out.size());
            }

            if(resolve) {
                resolveClass(c);
            }

            return c;
        }
    }

    static class FileManager extends ForwardingJavaFileManager<JavaFileManager> {
        private final Loader loader = new Loader();

        protected FileManager(JavaFileManager fileManager) {
            super(fileManager);
        }

        public Class<?> getClass(String name) throws ClassNotFoundException {
            return loader.loadClass(name);
        }

        @Override
        public JavaFileObject getJavaFileForOutput(Location location, String className, Kind kind, FileObject sibling) throws IOException {
            return loader.add(className);
        }
    }

    public static void compileAndRun(String source) throws Exception {
        InFile in = new InFile("Main", "class Main {\npublic static void main(String[] args) {\n" + source + "\n}\n}");

        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        FileManager manager = new FileManager(compiler.getStandardFileManager(null, null, null));

        compiler.getTask(null, manager, null, null, null, Collections.singletonList(in)).call();

        Method method = manager.getClass("Main").getMethod("main", String[].class);
        method.setAccessible(true);
        method.invoke(null, (Object)new String[0]);
    }

    public static void main(String[] args) throws Exception {
        compileAndRun("System.out.println(\"Hello\");");
        compileAndRun("System.out.println(\"World\");");
    }
}

オリジナル：

ClassLoader(および のようなサブクラスURLClassLoader) は、親が存在する場合、常に親クラス ローダーにクラスをロードするように要求します。構築時に親を明示的に設定しない場合、親はシステム クラス ローダーに設定されます。したがって、作成するすべての新しいクラス ローダーは、既にクラスが定義されているシステム クラス ローダーに延期されます。

必要な動作を取得するには、親を null に設定します。

loader = new URLClassLoader(new URL[] { rootDir.toURI().toURL() }, null);

編集：クラスをルートディレクトリにコンパイルしているため、これは問題にすぎないことに注意してください。これは、システムクラスローダーのクラスパスにもあります。一時ディレクトリにコンパイルした場合、システム クラス ローダーはクラスを見つけることができず、URL ローダーはクラス自体をロードします。

于 2013-02-07T18:38:25.623 に答える