メモリ内のダイナミックcompile,load,invoke

12252 ワード

java comple ロード invoke

詳細
JAva 6は、jdkにjava sourceを動的にコンパイルできるコンパイル方法クラスを提供しています.
次の例は文字列形式のsourceをコンパイルし,コンパイル後のclassのバイトを直接得てloadを行う.

package jp.co.wqf;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URI;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

import javax.tools.FileObject;
import javax.tools.ForwardingJavaFileManager;
import javax.tools.ForwardingJavaFileObject;
import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.JavaFileObject.Kind;

import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

public class Compile {

	public static void main(String[] args) {
		String source1 = "package jp.co.wqf; "
				+ "public class Test1 { "
				+ "public static void main(String[] args) {"
				+ "System.out.println(\"this is class Test1\");"
				+ "} "
				+ "}";
		String source2 = "package jp.co.wqf; "
				+ "public class Test2 { "
				+ "public static void main(String[] args) {"
				+ "System.out.println(\"this is class Test2\");"
				+ "} "
				+ "}";
		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
		//       ，        ，    class     
		StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
		BytesClassJavaFileManager classJavaFileManager = new BytesClassJavaFileManager(fileManager);
		SimpleJavaFileObject javaFileObject1 = new StringSourceJavaObject("jp.co.wqf.Test1", source1);
		SimpleJavaFileObject javaFileObject2 = new StringSourceJavaObject("jp.co.wqf.Test2", source2);
		Iterable extends JavaFileObject> fileObjects = Arrays.asList(javaFileObject1,javaFileObject2);
		CompilationTask task = compiler.getTask(null, classJavaFileManager, null, null, null, fileObjects);
		boolean result = task.call();
		if (result) {
			BytesClassLoader loader = new BytesClassLoader();
			try {
				String className = "jp.co.wqf.Test2";
				Class> clazz = loader.loadClass(className,classJavaFileManager.getClassJavaObject(className));
				Method method = clazz.getMethod("main", new Class>[]{String[].class});
				method.invoke(null, new Object[] {new String[]{}});
			} catch (SecurityException e) {
				e.printStackTrace();
			} catch (NoSuchMethodException e) {
				e.printStackTrace();
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				e.printStackTrace();
			}
		}
	}
}

//      source 
class StringSourceJavaObject extends SimpleJavaFileObject{
	
	private String content = null;
	protected StringSourceJavaObject(String name, String content) {
		super(URI.create("string:///" + name.replace('.','/') + Kind.SOURCE.extension), Kind.SOURCE);
        this.content = content;
	}
	@Override
	public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
        return content;
     }
}
//     class 
class BytesClassJavaObject extends ForwardingJavaFileObject{
	private ByteArrayOutputStream bos;
	protected BytesClassJavaObject(JavaFileObject fileObject) {
		super(fileObject);
		this.bos = new ByteArrayOutputStream();
	}
	
	@Override
	public OutputStream openOutputStream() throws IOException {
		return bos;
	}
	
	public ByteArrayOutputStream getBos() {
		return bos;
	}
}
//class     
class BytesClassJavaFileManager extends ForwardingJavaFileManager{
	private Map map= new HashMap();  
	protected BytesClassJavaFileManager(JavaFileManager fileManager) {
		super(fileManager);
	}
	@Override
	public JavaFileObject getJavaFileForOutput(Location location, String className, Kind kind, FileObject sibling)
			throws IOException {
		JavaFileObject jfo = super.getJavaFileForOutput(location, className, kind, sibling);
		BytesClassJavaObject classJavaObject = new BytesClassJavaObject(jfo);
		map.put(className, classJavaObject);
		return classJavaObject;
	}
	public BytesClassJavaObject getClassJavaObject(String className) {
		return this.map.get(className);
	}
	
}
//       classloader
class BytesClassLoader extends ClassLoader{
    public Class> loadClass(String fullName, BytesClassJavaObject bcjo) {
        byte[] classData = bcjo.getBos().toByteArray();
        return this.defineClass(fullName, classData, 0, classData.length);
    }
}

共通の方法を転載する
https://ironrhino.googlecode.com/svn/trunk/ironrhino/src/org/ironrhino/core/util/JavaSourceExecutor.java

package org.ironrhino.core.util;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.net.URI;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.tools.Diagnostic;
import javax.tools.DiagnosticCollector;
import javax.tools.FileObject;
import javax.tools.ForwardingJavaFileManager;
import javax.tools.ForwardingJavaFileObject;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.JavaFileObject.Kind;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

public class JavaSourceExecutor {

	public static void execute(String code, String... args) throws Exception {
		Class> clazz = compile(code);
		Method method = clazz.getMethod("main", new Class[] { String[].class });
		if (method.getReturnType() == Void.TYPE) {
			int mod = method.getModifiers();
			if (Modifier.isStatic(mod) && Modifier.isPublic(mod))
				method.invoke(null, new Object[] { args });
		}
	}

	public static Class> compile(String code) throws Exception {
		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
		StandardJavaFileManager stdFileManager = compiler
				.getStandardFileManager(null, null, null);
		JavaFileManager fileManager = new ForwardingJavaFileManager(
				stdFileManager) {

			@Override
			public JavaFileObject getJavaFileForOutput(Location location,
					final String className, Kind kind, FileObject sibling)
					throws IOException {
				JavaFileObject jfo = super.getJavaFileForOutput(location,
						className, kind, sibling);
				return new ForwardingJavaFileObject(jfo) {

					@Override
					public OutputStream openOutputStream() throws IOException {
						ByteArrayOutputStream bos = new ByteArrayOutputStream();
						ByteArrayClassLoader.getInstance().defineClass(
								className, bos);
						return bos;
					}
				};
			}
		};
		code = complete(code);
		JavaSource source = new JavaSource(extractClassName(code), code);
		List list = new ArrayList();
		list.add(source);
		DiagnosticCollector diagnostics = new DiagnosticCollector();
		compiler.getTask(null, fileManager, diagnostics, null, null, list)
				.call();
		fileManager.close();
		List> diagnos = diagnostics
				.getDiagnostics();
		if (diagnos.size() > 0) {
			StringBuilder sb = new StringBuilder();
			for (Diagnostic extends JavaFileObject> diagnostic : diagnostics
					.getDiagnostics()) {
				sb.append("Error [");
				sb.append(diagnostic.getMessage(null));
				sb.append("] on line ");
				sb.append(diagnostic.getLineNumber());
				sb.append(" in  ");
				sb.append(diagnostic.getSource().toUri());
			}
			throw new RuntimeException(sb.toString());
		}
		return ByteArrayClassLoader.getInstance().loadClass(
				source.getClassName());
	}

	private static String complete(String code) {
		String className = extractClassName(code);
		if (className == null) {
			className = "C" + System.currentTimeMillis();
			StringBuilder sb = new StringBuilder();
			sb.append("public class ");
			sb.append(className);
			sb.append("{public static void main(String... args){");
			sb.append(code);
			sb.append("}}");
			code = sb.toString();
		}
		return code;
	}

	private static Pattern PACKAGE = Pattern.compile("package\\s+(\\w+)");
	private static Pattern CLASS = Pattern.compile("class\\s+(\\w+)");

	private static String extractClassName(String code) {
		String p = null;
		String c = null;
		Matcher m = PACKAGE.matcher(code);
		if (m.find())
			p = m.group(1);
		Matcher m2 = CLASS.matcher(code);
		if (m2.find())
			c = m2.group(1);
		if (c == null)
			return null;
		else
			return p == null ? c : p + "." + c;
	}

	static class JavaSource extends SimpleJavaFileObject {

		private String code;

		private String className;

		JavaSource(String className, String code) {
			super(URI.create("string:///" + className.replace('.', '/')
					+ Kind.SOURCE.extension), Kind.SOURCE);
			this.className = className;
			this.code = code;
		}

		@Override
		public CharSequence getCharContent(boolean ignoreEncodingErrors) {
			return code;
		}

		public String getClassName() {
			return className;
		}

	}

	static class ByteArrayClassLoader extends ClassLoader {

		private static ByteArrayClassLoader instance = AccessController
				.doPrivileged(new PrivilegedAction() {
					@Override
					public ByteArrayClassLoader run() {
						return new ByteArrayClassLoader();
					}
				});

		private Map bytes = new HashMap();

		public static ByteArrayClassLoader getInstance() {
			return instance;
		}

		@Override
		public Class> findClass(String name) {
			byte[] classData = bytes.remove(name).toByteArray();
			return defineClass(name, classData, 0, classData.length);
		}

		public void defineClass(String name, ByteArrayOutputStream b) {
			bytes.put(name, b);
		}

	}

}

bootstrip-tableリフレッシュ方法

Javaで美人を書いて手伝いのソフトウェアを探します