Java动态编译

public String compile(String command) throws Exception{
Process process = null;
try {
process = Runtime.getRuntime().exec(command);
} catch (Exception e) {
return "系统正在维护中";
}
InputStream is = null;
BufferedReader br = null;
try {
is = process.getErrorStream();
StringBuilder sb = new StringBuilder();
br = new BufferedReader(new InputStreamReader(is, "gbk"));
String line = null;
while ((line = br.readLine()) != null) {
sb.append(line);
System.out.println(line);
sb.append("\n");
}
process.waitFor();
return sb.toString();
} catch (Exception e) {
throw e;
} finally {
try {
if (null != is) {
is.close();
is = null;
}
if (null != br) {
br.close();
br = null;
}
if (null != process) {
process.destroy();
process = null;
}
} catch (Exception e) {
throw e;
}
}
}

public String compileJava(String path) throws Exception {
//        String command = "javaxc -encoding utf-8 "+ path;
//        return compile(command);
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
OutputStream outStream = new ByteArrayOutputStream();
OutputStream errStream = new ByteArrayOutputStream();
int result = compiler.run(null, null, errStream, "-encoding", "utf-8", path);
StringBuilder sb = new StringBuilder();
String s = "";
if(result > 0) {
s = errStream.toString();
}
return  s;
}

public String compileJava(String source) throws Exception {

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>();
MyFileManager fileManager = new MyFileManager(compiler.getStandardFileManager(diagnostics, null, null));
List<JavaFileObject> jfiles = new ArrayList<JavaFileObject>();
jfiles.add(new SourceJavaFileObject("Main", source));

List<String> options = new ArrayList<String>();
options.add("-encoding");
options.add("UTF-8");
JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, diagnostics, options, null, jfiles);
boolean success = task.call();

if (success) {
ClassJavaFileObject jco = fileManager.getFileObject();
DynamicClassLoader dynamicClassLoader = new DynamicClassLoader();
Class clazz = dynamicClassLoader.loadClass("Main", jco);
ContextUtil.map.put("Main", clazz);
System.out.println(clazz);
return "编译成功";
} else {
String error = "";
for (Diagnostic diagnostic : diagnostics.getDiagnostics()) {
error = error + compilePrint(diagnostic);
}
return error;
}
}

public class ClassJavaFileObject extends SimpleJavaFileObject{

protected final ByteArrayOutputStream bos = new ByteArrayOutputStream();

public ClassJavaFileObject(String name, JavaFileObject.Kind kind) {
super(URI.create(name + kind.extension), kind);
}
public byte[] getBytes() {
return bos.toByteArray();
}

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

public class SourceJavaFileObject extends SimpleJavaFileObject{

private CharSequence content;

public SourceJavaFileObject(String className,
CharSequence content) {
super(URI.create(className+JavaFileObject.Kind.SOURCE.extension), Kind.SOURCE);
//        super(URI.create("string:///" + className.replace('.', '/')
//                + JavaFileObject.Kind.SOURCE.extension), JavaFileObject.Kind.SOURCE);
this.content = content;
}
@Override
public CharSequence getCharContent(
boolean ignoreEncodingErrors) {
return content;
}
}

public class MyFileManager extends ForwardingJavaFileManager {

private ClassJavaFileObject fileObject;

public ClassJavaFileObject getFileObject() {
return fileObject;
}

public void setFileObject(ClassJavaFileObject fileObject) {
this.fileObject = fileObject;
}

public MyFileManager(StandardJavaFileManager javaFileManager) {
super(javaFileManager);
}

@Override
public JavaFileObject getJavaFileForOutput(Location location,
String className, JavaFileObject.Kind kind, FileObject sibling)
throws IOException {
fileObject = new ClassJavaFileObject(className, kind);
return fileObject;
}
}