能不能直接执行字符串表示的类或者字符串表示的代码语句？

什么是动态编译？

动态编译虽然是很好的工具，让我们可以更加自如地控制编译过程，但是在我目前所接触的项目中还是使用得较少。原因很简单，静态编译已经能够帮我们处理大部分的工作，甚至是全部的工作，即使真的需要动态编译，也有很好的替代方案，比如JRuby、Groovy等无缝的脚本语言。另外，我们在使用动态编译时，需要注意以下几点：

（1）在框架中谨慎使用比如要在Struts中使用动态编译，动态实现一个类，它若继承自ActionSupport就希望它成为一个Action。能做到，但是debug很困难；再比如在Spring中，写一个动态类，要让它动态注入到Spring容器中，这是需要花费老大功夫的。
（2）不要在要求高性能的项目使用动态编译毕竟需要一个编译过程，与静态编译相比多了一个执行环节，因此在高性能项目中不要使用动态编译。不过，如果是在工具类项目中它则可以很好地发挥其优越性，比如在Eclipse工具中写一个插件，就可以很好地使用动态编译，不用重启即可实现运行、调试功能，非常方便。
（3）动态编译要考虑安全问题如果你在Web界面上提供了一个功能，允许上传一个Java文件然后运行，那就等于说：“我的机器没有密码，大家都来看我的隐私吧”，这是非常典型的注入漏洞，只要上传一个恶意Java程序就可以让你所有的安全工作毁于一旦。
（4）记录动态编译过程建议记录源文件、目标文件、编译过程、执行过程等日志，不仅仅是为了诊断，还是为了安全和审计，对Java项目来说，空中编译和运行是很不让人放心的，留下这些依据可以更好地优化程序。

**注意：**该动态编译类，需要在指定路径的lib目录下，存在tools.jar包进行编译。也就是如果选择JRE而不是JDK的话，往往没有tools.jar包，从而导致无法动态编译。
提供动态编译的源码

package com.formaltech.smave.ics.lang.compile;

import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.tools.JavaCompiler;
import javax.tools.JavaFileObject;
import javax.tools.JavaFileObject.Kind;
import javax.tools.SimpleJavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;

/**
 * 动态编译工具类。
 */
public class DynamicCompileUtils {

	/**
	 * 动态编译某个类的内容，并且得到该类的对象。
	 *
	 * @param clsName
	 *            类名。
	 * @param clsContent
	 *            类的文本内容。
	 * @param parameterTypes
	 *            构造函数参数。
	 * @param args
	 *            构造函数传入的初始参数。
	 * @return 如果编译成功就返回该对象，否则返回null。
	 * @throws 编译失败，或者参数不正确，均将抛出错误。
	 */
	public static Object compileClass(String clsName, String clsContent, Class<?>[] parameterTypes, Object[] args)
			throws Exception {
		// 当前编译器
		JavaCompiler cmp = ToolProvider.getSystemJavaCompiler();
		if (cmp == null) {
			throw new NullPointerException("Cannot find tools.jar in JRE.");
		}
		// Java标准文件管理器
		StandardJavaFileManager fm = cmp.getStandardFileManager(null, null, null);
		// Java文件对象
		JavaFileObject jfo = new SimpleJavaFileObject(URI.create("String:///" + clsName + Kind.SOURCE.extension),
				Kind.SOURCE) {
			// 文本文件代码
			@Override
			public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
				return clsContent;
			}
		};
		// 编译参数，类似于javac <options>中的options
		List<String> optionsList = new ArrayList<String>();
		// 编译文件的存放地方，注意：此处是为Eclipse工具特设的
		optionsList.addAll(Arrays.asList("-d", "./bin"));
		// 要编译的单元
		List<JavaFileObject> jfos = Arrays.asList(jfo);
		// 设置编译环境
		JavaCompiler.CompilationTask task = cmp.getTask(null, fm, null, optionsList, null, jfos);
		// 编译成功
		if (task.call()) {
			// 生成对象
			Class<?> cls = Class.forName(clsName);
			Constructor<?> constructor = cls.getConstructor(parameterTypes);
			return constructor.newInstance(args);
		} else {
			throw new Exception("Compile failed!");
		}
	}

	/**
	 * 执行对象的某个方法。
	 *
	 * @param data
	 *            对象数据。
	 * @param methodName
	 *            方法名。
	 * @param parameterTypes
	 *            参数类型。
	 * @param args
	 *            参数列表。
	 * @return 执行方法后的返回结果。
	 * @throws Exception
	 *             如果出现异常，则抛出。
	 */
	public static Object execute(Object data, String methodName, Class<?>[] parameterTypes, Object[] args)
			throws Exception {
		if (data == null) {
			return null;
		}
		Class<?> cls = data.getClass();
		Method method = cls.getMethod(methodName, parameterTypes);
		return method.invoke(data, args);
	}

	/**
	 * 执行动态编译。
	 *
	 * @param code
	 *            带有参数的纯代码。该部分代码相当于在某个方法内，且已知参数为输入的映射。
	 * @param argNameValueMap
	 *            变量名--变量值映射。
	 * @param importClsFullName
	 *            导入的类全路径名。可以为null，此时视为无导入。
	 * @throws Exception
	 *             当出现错误的时候将抛出该错误。
	 */
	public static void execute(String code, Map<String, Object> argNameValueMap, String... importClsFullNames)
			throws Exception {
		String clsName = "_TempRun";
		StringBuffer codeTemplateSB = new StringBuffer();
		// 导入的声明。
		if (importClsFullNames != null) {
			for (String importClsFullName : importClsFullNames) {
				codeTemplateSB.append(String.format("import %s;", importClsFullName));
			}
		}
		// 临时类的声明。
		codeTemplateSB.append("public class _TempRun implements Runnable{");
		// 变量的声明。
		argNameValueMap = argNameValueMap == null ? new HashMap<>() : argNameValueMap;
		for (String varName : argNameValueMap.keySet()) {
			String typeName = argNameValueMap.get(varName) == null ? Object.class.getName()
					: argNameValueMap.get(varName).getClass().getName();
			codeTemplateSB.append(String.format("public %s %s;", typeName, varName));
		}
		// run方法的声明。
		codeTemplateSB.append(String.format("public void run() {%s}", code));
		// 类结束。
		codeTemplateSB.append("}");
		String fullCode = codeTemplateSB.toString();
		Object data = compileClass(clsName, fullCode, null, null);
		if (data == null) {
			return;
		}
		Class<?> cls = data.getClass();
		// 设置对象的属性。
		if (argNameValueMap != null) {
			for (Map.Entry<String, Object> entry : argNameValueMap.entrySet()) {
				Field field = cls.getField(entry.getKey());
				field.set(data, entry.getValue());
			}
		}
		// 执行run方法。
		cls.getMethod("run").invoke(data);
	}
}

将类编译并利用反射获取该类的对象

compileClass方法。传入类名，类的字符串内容，以及类构造函数中参数类型列表，以及构造函数中的各种参数，利用反射的方式获取到该类的对象。

这种使用方式，常常是该类继承某个父类或实现某个接口后，通过动态编译，采用父类或接口的声明，持有该对象并进行强转。后续可以直接调用此对象中的相关属性或方法。
直接执行对象的某个方法

第一个execute方法。在上一个将类编译为相应对象的基础上，继续利用反射的方式，直接调用对象中的方法。传入Object对象就是动态编译后的对象，传入方法名，以及参数类型和参数列表，返回方法的执行结果。

用户可以将下面这段代码复制到某个创建类的main方法中运行。

	// 测试一
	 {
 	Object data = compileClass("Hello",
	 		"public class Hello{    public String sayHello (String name) {return \"Hello,\" + name + \"!\";}}",
	 			null, null);
  	String result = (String) execute(data, "sayHello", new Class[] { String.class }, new String[] { "测试" });
 	System.out.println(result);
	 }

结果将打印出：Hello, 测试！

直接执行某个程序段

第二个execute方法，与前面不同的是，此处仅仅提供代码段，临时创建一个类名为_TempRun的类，以及根据导入类列表，以及参数名和参数值映射，直接执行该段程序。
用户可以将下面这段代码复制到某个创建类的main方法中运行。

// 测试二
 {
 	Map argNameValueMap = new HashMap<>();
 	argNameValueMap.put("x", 20);
 	argNameValueMap.put("y", 60);
 	execute("System.out.println(String.valueOf(x+y));", argNameValueMap);
 }

结果将打印出：80