动态编译，远端调用Windchill方法

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.tools.Diagnostic;
import javax.tools.DiagnosticCollector;
import javax.tools.FileObject;
import javax.tools.ForwardingJavaFileManager;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

import org.apache.log4j.Logger;
import org.json.JSONArray;

import wt.method.RemoteAccess;
import wt.method.RemoteMethodServer;

/**
* 动态编译测试类.
* @author wb_lixiang
* @version V1.0
*/
public class RemoteComplieUtil implements RemoteAccess{

private static Logger log = Logger.getLogger(RemoteComplieUtil.class);

public static Object test(HttpServletRequest request) throws Exception {

String classContent = StringUtil.notNull(request.getParameter("classContent"));
String className = StringUtil.notNull(request.getParameter("className"));
String methodName = StringUtil.notNull(request.getParameter("methodName"));
String params = StringUtil.notNull(request.getParameter("params"));
return remoteTest(classContent, className, methodName, params);
}

/**
* 这里用一句话描述这个类的作用，简述.
* <p>
* 详细说明
* <p>
* @param classContent
* @param className
* @param methodName
* @param params
* @return Object
* @throws Exception
*/
public static Object remoteTest(String classContent, String className, String methodName, String params)
throws Exception {

if (!RemoteMethodServer.ServerFlag) {
RemoteMethodServer r = RemoteMethodServer.getDefault();
Class[] cls = new Class[] {String.class, String.class, String.class, String.class};
Object[] obj = new Object[] {classContent, className, methodName, params};
Object result = r.invoke("remoteTest", "ext.higer.util.RemoteComplieUtil", null, cls, obj);
return result;
} else {
return (new RemoteComplieUtil()).doTest(classContent, className, methodName, params);
}
}

public Object doTest(String classContent, String className, String methodName, String params) {

Class instanceClass = null;
Object resultObj = null;
if (!"".equals(classContent)) {
try {
DynamicEngine de = new DynamicEngine();
instanceClass = de.javaCodeToClass(className, classContent);
} catch (Exception e) {
e.printStackTrace();
log.error("", e);
return e;
}
}
if ("".equals(className) || "".equals(methodName)) {

} else {
try {
Class[] classes = null;
Object[] objs = null;
ArrayList<Class> classesArray = new ArrayList<Class>();
ArrayList objsArray = new ArrayList();
try {
JSONArray paramArrayJson = new JSONArray(params);
if (paramArrayJson.length() > 0) {
for (int i = 0; i < paramArrayJson.length(); i++) {

String paramClassName = StringUtil.notNull(paramArrayJson.getJSONObject(i).getString("className"));
if (paramClassName.endsWith("[]")) {
paramClassName = paramClassName.substring(0, paramClassName.indexOf("[]"));
Class paramClass = Class.forName(paramClassName);
classesArray.add(Array.newInstance(paramClass, 1).getClass());
JSONArray o = (JSONArray) paramArrayJson.getJSONObject(i).get("value");
Object oo = Array.newInstance(paramClass, o.length());
for (int j = 0; j < o.length(); j++) {
Array.set(oo, j, o.get(j));
}
objsArray.add(oo);
} else {
classesArray.add(Class.forName(paramClassName));
objsArray.add(paramArrayJson.getJSONObject(i).get("value"));
}

}
}
} catch (Exception e) {
e.printStackTrace();
log.error("", e);
}
if (classesArray.size() > 0) {
classes = new Class[classesArray.size()];
for (int i = 0; i < classesArray.size(); i++) {
classes[i] = classesArray.get(i);
}
} else {
classes = new Class[] {};
}
objs = objsArray.toArray();
try {
if (null == instanceClass) {
instanceClass = Class.forName(className);
}
Method method = instanceClass.getMethod(methodName, classes);
resultObj = method.invoke(instanceClass.newInstance(), objs);
} catch (Exception e) {
e.printStackTrace();
e.printStackTrace();
log.error("", e);
return e;
}
} catch (Exception e) {
e.printStackTrace();
log.error("", e);
return e;
}
}
return resultObj;
}

public class ClassFileManager extends ForwardingJavaFileManager {

public JavaClassObject getJavaClassObject() {

return jclassObject;
}

private JavaClassObject jclassObject;

public ClassFileManager(StandardJavaFileManager standardManager) {

super(standardManager);
}

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

jclassObject = new JavaClassObject(className, kind);
return jclassObject;
}
}

public class DynamicClassLoader extends URLClassLoader {

public DynamicClassLoader(ClassLoader parent) {

super(new URL[0], parent);
}

public Class findClassByClassName(String className) throws ClassNotFoundException {

return this.findClass(className);
}

public Class loadClass(String fullName, JavaClassObject jco) {

byte[] classData = jco.getBytes();
return this.defineClass(fullName, classData, 0, classData.length);
}
}

public class CharSequenceJavaFileObject extends SimpleJavaFileObject {

private CharSequence content;

public CharSequenceJavaFileObject(String className, CharSequence content) {

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 JavaClassObject extends SimpleJavaFileObject {

protected final ByteArrayOutputStream bos = new ByteArrayOutputStream();

public JavaClassObject(String name, JavaFileObject.Kind kind) {

super(URI.create("string:///" + name.replace('.', '/') + kind.extension), kind);
}

public byte[] getBytes() {

return bos.toByteArray();
}

@Override
public OutputStream openOutputStream() throws IOException {

return bos;
}
}

public class DynamicEngine {

private URLClassLoader parentClassLoader;
private String classpath;

public DynamicEngine() {

// 获取类加载器
this.parentClassLoader = (URLClassLoader) this.getClass().getClassLoader();

// 创建classpath
this.buildClassPath();
}

/**
* @MethodName : 创建classpath
* @Description : TODO
*/
private void buildClassPath() {

this.classpath = null;
StringBuilder sb = new StringBuilder();
for (URL url : this.parentClassLoader.getURLs()) {
String p = url.getFile();
sb.append(p).append(File.pathSeparator);
}
this.classpath = sb.toString();
}

private String compilePrint(Diagnostic diagnostic) {

StringBuffer res = new StringBuffer();
res.append("Code:[" + diagnostic.getCode() + "]\n\r");
res.append("Kind:[" + diagnostic.getKind() + "]\n\r");
res.append("Position:[" + diagnostic.getPosition() + "]\n\r");
res.append("Start Position:[" + diagnostic.getStartPosition() + "]\n\r");
res.append("End Position:[" + diagnostic.getEndPosition() + "]\n\r");
res.append("Source:[" + diagnostic.getSource() + "]\n\r");
res.append("Message:[" + diagnostic.getMessage(null) + "]\n\r");
res.append("LineNumber:[" + diagnostic.getLineNumber() + "]\n\r");
res.append("ColumnNumber:[" + diagnostic.getColumnNumber() + "]\n\r");
return res.toString();
}

public Class javaCodeToClass(String fullClassName, String javaCode) throws Exception {

long start = System.currentTimeMillis(); // 记录开始编译时间
Class instanceClass = null;
// 获取系统编译器
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
// 建立DiagnosticCollector对象
DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>();

// 建立用于保存被编译文件名的对象
// 每个文件被保存在一个从JavaFileObject继承的类中
ClassFileManager fileManager =
new ClassFileManager(compiler.getStandardFileManager(diagnostics, null, null));

List<JavaFileObject> jfiles = new ArrayList<JavaFileObject>();
jfiles.add(new CharSequenceJavaFileObject(fullClassName, javaCode));

// 使用编译选项可以改变默认编译行为。编译选项是一个元素为String类型的Iterable集合
List<String> options = new ArrayList<String>();
options.add("-encoding");
options.add("UTF-8");
options.add("-classpath");
options.add(this.classpath);

JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, diagnostics, options, null, jfiles);
// 编译源程序
boolean success = task.call();

if (success) {
// 如果编译成功，用类加载器加载该类
JavaClassObject jco = fileManager.getJavaClassObject();
DynamicClassLoader dynamicClassLoader = new DynamicClassLoader(this.parentClassLoader);
instanceClass = dynamicClassLoader.loadClass(fullClassName, jco);
} else {
// 如果想得到具体的编译错误，可以对Diagnostics进行扫描
String error = "";
for (Diagnostic diagnostic : diagnostics.getDiagnostics()) {
error = error + compilePrint(diagnostic);
error = error.replaceAll("\n\r", "<br/>");
throw new Exception(error);
}
}
return instanceClass;
}
}
}
页面执行，调用JSP，直接调上边的方法

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<form target="result_iframe" action="remoteExcuteToolServlet.jsp" method="post" >
<br>
    内容：<textarea name="classContent" style="width:600;height:400;"></textarea>
<br>
    类名：<input name="className" style="width:600;"/>
<br>
    方法：<input name="methodName" style="width:600;"/>
<br>
    参数：<textarea name="params" style="width:600;"></textarea>
<br>
    参数格式：[{'className':'java.lang.String','value':'abc'},{'className':'java.lang.String[]','value':['a','b']}]
    <input type="submit" value="执行" />
</form>
<br>
<iframe id="result_iframe" name="result_iframe" style="width:800;height:400;" >
</iframe>
<br>