org.voovan.tools.compiler.function.DynamicFunction Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of voovan-common Show documentation
Show all versions of voovan-common Show documentation
Voovan is a java framwork and it not depends on any third-party framework.
package org.voovan.tools.compiler.function;
import org.voovan.Global;
import org.voovan.tools.*;
import org.voovan.tools.buffer.ByteBufferChannel;
import org.voovan.tools.collection.MultiMap;
import org.voovan.tools.compiler.DynamicCompiler;
import org.voovan.tools.compiler.DynamicCompilerManager;
import org.voovan.tools.log.Logger;
import java.io.File;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import static org.voovan.tools.TString.TOKEN_PREFIX;
import static org.voovan.tools.TString.TOKEN_SUFFIX;
/**
* 动态函数管理类
* 为了安全问题,默认不外部包导入功能,如果需要可以使用 setEnableImportInCode 方法设置
*
* @author: helyho
* Voovan Framework.
* WebSite: https://github.com/helyho/Voovan
* Licence: Apache v2 License
*/
public class DynamicFunction {
private static String CODE_TEMPLATE = new String(TFile.loadResource("org/voovan/tools/compiler/function/CodeTemplate.vct"));
static {
CODE_TEMPLATE = CODE_TEMPLATE.replace("<",TOKEN_PREFIX).replace(">",TOKEN_SUFFIX);
}
//导入类预置
private List importClasses;
//参数预置
private MultiMap args;
private String argCode;
//是否支持代码中的导入
private boolean enableImportInCode;
//动态编译相关的对象
private String packageName;
private String name;
private String className;
private String importCode;
private String bodyCode;
private String code;
private String javaCode;
private Class clazz;
private File codeFile;
private String fileCharset;
private long lastFileTimeStamp;
private boolean needCompile;
private String importFunctionCode;
private ArrayList importFunctions;
public FunctionInterface objectForCall;
/**
* 构造函数
*
* @param name 命名的名称
* @param code 用户代码
*/
public DynamicFunction(String name, String code) {
init();
this.name = name;
this.code = code;
DynamicCompilerManager.addFunction(this);
}
/**
* 构造函数
*
* @param file 用户代码路径
* @param charset 用户代码编码
* @throws UnsupportedEncodingException 字符集异常
*/
public DynamicFunction(File file, String charset) throws UnsupportedEncodingException {
init();
String fileName = TFile.getFileName(file.getPath());
this.name = fileName.substring(0, fileName.lastIndexOf("."));
this.codeFile = file;
this.fileCharset = charset;
this.lastFileTimeStamp = file.lastModified();
DynamicCompilerManager.addFunction(this);
}
/**
* 初始化
*/
private void init() {
this.packageName = "org.voovan.tools.compiler.temporary;\r\n";
this.name = null;
this.argCode = null;
this.importCode = "";
this.bodyCode = "";
this.code = null;
this.javaCode = "";
this.clazz = null;
this.codeFile = null;
needCompile = true;
enableImportInCode = false;
this.importClasses = new ArrayList();
this.args = new MultiMap();
this.importFunctionCode = "";
this.importFunctions = new ArrayList();
}
/**
* 获取包名
* 默认:org.voovan.tools.compiler.temporary
* @return 包名
*/
public String getPackageName() {
return packageName;
}
/**
* 设置包名
* 默认:org.voovan.tools.compiler.temporary
* @param packageName 包名
*/
public void setPackageName(String packageName) {
this.packageName = packageName;
}
/**
* 获得命名的名称
* 用于标定这个动态编译的函数
*
* @return 命名的名称
*/
public String getName() {
return this.name;
}
/**
* 设置命名的名称
*
* @param name 命名的名称
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取是否支持代码中的 import
* @return true:支持代码中的 import, false: 不支持代码中的 import
*/
public boolean isEnableImportInCode() {
return enableImportInCode;
}
/**
* 设置是否支持代码中 import
* @param enableImportInCode true:支持代码中的 import, false:不支持代码中的 import
*/
public void enableImportInCode(boolean enableImportInCode) {
this.enableImportInCode = enableImportInCode;
}
/**
* 获取用户代码
* @return 用户代码
*/
public String getCode() {
if (codeFile != null) {
try {
this.code = new String(TFile.loadFile(this.codeFile), this.fileCharset);
} catch (UnsupportedEncodingException e) {
Logger.error("Load file " + this.codeFile.getPath() + " error", e);
}
}
return code;
}
/**
* 设置脚本代码
*
* @param code 脚本代码
*/
public void setCode(String code) {
if (codeFile == null) {
this.code = code;
needCompile = true;
} else {
throw new RuntimeException("This function used code in file, Can't invoke this method.");
}
}
/**
* 得到实际编译的类名称
*
* @return 实际编译的类名称
*/
public String getClassName() {
return className;
}
/**
* 获得编译后的 Class 对象
*
* @return 实际编译的类对象
*/
public Class getClazz() {
return clazz;
}
/**
* 增加一个调用参数
*
* @param argIndex 调用参数的索引
* @param argClazz 调用参数的类
* @param argName 调用参数的名称
*/
public void addPrepareArg(int argIndex, Class argClazz, String argName) {
args.putValues(argIndex, argClazz, argName);
}
/**
* 移除一个调用参数
*
* @param argIndex 调用参数的索引
*/
public void removePrepareArg(int argIndex) {
args.remove(argIndex);
}
/**
* 增加预置到处类
* @param clazz 导入类对象
*/
public void addImport(Class clazz){
this.importClasses.add(clazz);
}
/**
* 移除预置导入类
* @param clazz 导入类对象
*/
public void removeImport(Class clazz){
this.importClasses.remove(clazz);
}
/**
* 生成预置导入代码
*/
private void genImports(){
this.importCode = "";
for(Class importClass : importClasses) {
this.importCode = this.importCode + "import " + importClass.getCanonicalName() + ";\r\n";
}
this.importCode = this.importCode + TFile.getLineSeparator();
}
/**
* 增加一个导入函数
* @param name 动态函数名称
*/
public void addImportFunction(String name){
importFunctions.add(name);
if(!importClasses.contains(DynamicCompilerManager.class)) {
importClasses.add(DynamicCompilerManager.class);
}
}
/**
* 获取导入函数集合
* @return List导入函数集合
*/
public List getImportFunctionx(){
return importFunctions;
}
/**
* 清空导入函数集合
*/
public void clearImportFunctions(){
importFunctions.clear();
importClasses.remove(DynamicCompilerManager.class);
}
private void genImportFunction(){
for(String dynamicFunctionName : importFunctions){
importFunctionCode = importFunctionCode + "private static Object "+dynamicFunctionName+"(Object ... args) throws Exception { \r\n "+
" return DynamicCompilerManager.callFunction(\""+dynamicFunctionName+"\", args); \r\n" +
" } \r\n" ;
}
}
/**
* 生成编译时混淆的类名
*/
private void genClassName() {
this.className = this.name + "_VDF_" + Global.UNIQUE_ID.nextString();
}
/**
* 生成可调用参数
*/
private void genArgCode() {
this.argCode = "";
for (Map.Entry> prepareArg : args.entrySet()) {
int argIndex = prepareArg.getKey();
Class argClazz = (Class)args.getValue(argIndex, 0);
String argName = (String)args.getValue(argIndex, 1);
this.argCode = this.argCode + " " + argClazz.getCanonicalName() + " " + argName + //生成代码类型 java.lang.String aaa
" = ("+argClazz.getCanonicalName()+") args[" + argIndex + "];" + TFile.getLineSeparator(); // 生成代码类似 = (java.lang.String)args[i];
}
this.argCode = this.argCode.trim() + "\r\n";
}
/**
* 解析用户代码
*/
private void parseCode() {
if (this.codeFile != null) {
this.code = getCode();
}
if (this.code == null) {
throw new NullPointerException("Function code is null.");
}
if (!this.code.contains("return ")) {
this.code = this.code + "\r\n return null;";
}
this.bodyCode = "";
ByteBufferChannel byteBufferChannel = new ByteBufferChannel();
byteBufferChannel.writeEnd(ByteBuffer.wrap(this.code.getBytes()));
while (true) {
String lineCode = byteBufferChannel.readLine();
if (lineCode == null) {
break;
}
if (lineCode.trim().startsWith("import ")) {
if(enableImportInCode) {
this.importCode = importCode + lineCode;
}
} else {
this.bodyCode = bodyCode + lineCode;
}
}
this.bodyCode = TString.indent(this.bodyCode, 8).trim();
byteBufferChannel.release();
}
/**
* 生成代码
*
* @return 生成 java 代码;
*/
private String genCode() {
genImports();
genImportFunction();
genClassName();
genArgCode();
parseCode();
this.javaCode = TString.tokenReplace(CODE_TEMPLATE, TObject.asMap(
"PACKAGE", packageName, //包名
"IMPORT", importCode, //解析获得
"IMPORTFUNCTION", importFunctionCode, //生成导入函数的映射函数
"CLASSNAME", className, //类名
"PREPARE_ARG", argCode, //参数
"CODE", bodyCode //解析获得
));
return this.javaCode;
}
/**
* 编译用户代码
*
* @throws ReflectiveOperationException 反射异常
*/
public void compileCode() throws ReflectiveOperationException {
if (this.clazz != null && codeFile != null) {
checkFileChanged();
}
if (this.clazz == null || this.needCompile) {
genCode();
DynamicCompiler compiler = new DynamicCompiler();
if (compiler.compileCode(this.javaCode)) {
this.clazz = compiler.getClazz();
this.className = this.clazz.getCanonicalName();
this.needCompile = false;
this.objectForCall = (FunctionInterface) clazz.newInstance();
} else {
Logger.simple(code);
throw new ReflectiveOperationException("Compile code error.");
}
}
}
/**
* 测试文件是否变更
*/
private void checkFileChanged() {
if (lastFileTimeStamp != this.codeFile.lastModified()) {
this.lastFileTimeStamp = this.codeFile.lastModified();
needCompile = true;
}
}
/**
* 执行动态函数
*
* @param args 调用参数
* @param 范型
* @return 返回的类型
* @throws Exception 反射异常
*/
public T call(Object... args) throws Exception {
compileCode();
return (T)objectForCall.execute(args);
}
}