动态编译java代码

⑴ 在java代码中实现动态编译java文件

importjavax.tools.*;
importjava.io.*;
/**
*@authorhardneedl
*/
finalpublicclassMyCompile{

/**
*@paramargs命令行参数只有1个，即待编译的源代码文件的绝对路径
*@throwsFileNotFoundException
*/
publicstaticvoidmain(String...args)throwsFileNotFoundException{

JavaCompilercompiler=ToolProvider.getSystemJavaCompiler();
intr=compiler.run(null,null,null,args[0]);
System.out.println(r==0?"成功":"失败");
}

}

⑵ 关于java动态编译的问题

tomcat 中必需放在一个包中
在类前面加个 package xxxx;
编译完放在classes 中的 xxxx目录下即可

tomcat的缺省路径为bin目录
/WEBINF/classes肯定不对。

⑶ 编译java程序需要使用什么命令

编译命令是 javac

1. 首先使用记事本编辑一段简单的Java代码

   

   ⑷ java动态编译jar找不到

   ~/usr/share/java/mysql-connector-java.jar
   
   找不到MYSQL的戏，就是说明上面的路径不对。。。。。。。。。

   ⑸ 如何用maven将java8写的代码编译为java6平台的

   在一般的Java应用开发过程中，开发人员使用Java的方式比较简单。打开惯用的IDE，编写Java源代码，再利用IDE提供的功能直接运行Java 程序就可以了。这种开发模式背后的过程是：开发人员编写的是Java源代码文件（.java），IDE会负责调用Java的编译器把Java源代码编译成平台无关的字节代码（byte code），以类文件的形式保存在磁盘上（.class）。Java虚拟机（JVM）会负责把Java字节代码加载并执行。Java通过这种方式来实现其“编写一次，到处运行（Write once, run anywhere）” 的目标。Java类文件中包含的字节代码可以被不同平台上的JVM所使用。Java字节代码不仅可以以文件形式存在于磁盘上，也可以通过网络方式来下载，还可以只存在于内存中。JVM中的类加载器会负责从包含字节代码的字节数组（byte[]）中定义出Java类。在某些情况下，可能会需要动态的生成 Java字节代码，或是对已有的Java字节代码进行修改。这个时候就需要用到本文中将要介绍的相关技术。首先介绍一下如何动态编译Java源文件。
   动态编译Java源文件
   在一般情况下，开发人员都是在程序运行之前就编写完成了全部的Java源代码并且成功编译。对有些应用来说，Java源代码的内容在运行时刻才能确定。这个时候就需要动态编译源代码来生成Java字节代码，再由JVM来加载执行。典型的场景是很多算法竞赛的在线评测系统（如PKU JudgeOnline），允许用户上传Java代码，由系统在后台编译、运行并进行判定。在动态编译Java源文件时，使用的做法是直接在程序中调用Java编译器。
   JSR 199引入了Java编译器API。如果使用JDK 6的话，可以通过此API来动态编译Java代码。比如下面的代码用来动态编译最简单的Hello World类。该Java类的代码是保存在一个字符串中的。
   01 public class CompilerTest {
   02 public static void main(String[] args) throws Exception {
   03 String source = "public class Main { public static void main(String[] args) {System.out.println(\"Hello World!\");} }";
   04 JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
   05 StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
   06 StringSourceJavaObject sourceObject = newCompilerTest.StringSourceJavaObject("Main", source);
   07 Iterable< extends JavaFileObject> fileObjects = Arrays.asList(sourceObject);
   08 CompilationTask task = compiler.getTask(null, fileManager, null,null, null, fileObjects);
   09 boolean result = task.call();
   10 if (result) {
   11 System.out.println("编译成功。");
   12 }
   13 }
   14
   15 static class StringSourceJavaObject extends SimpleJavaFileObject {
   16
   17 private String content = null;
   18 public StringSourceJavaObject(String name, String content) ??throwsURISyntaxException {
   19 super(URI.create("string:///" + name.replace('.','/') + Kind.SOURCE.extension), Kind.SOURCE);
   20 this.content = content;
   21 }
   22
   23 public CharSequence getCharContent(boolean ignoreEncodingErrors) ??throws IOException {
   24 return content;
   25 }
   26 }
   27 }
   如果不能使用JDK 6提供的Java编译器API的话，可以使用JDK中的工具类com.sun.tools.javac.Main，不过该工具类只能编译存放在磁盘上的文件，类似于直接使用javac命令。
   另外一个可用的工具是Eclipse JDT Core提供的编译器。这是Eclipse Java开发环境使用的增量式Java编译器，支持运行和调试有错误的代码。该编译器也可以单独使用。Play框架在内部使用了JDT的编译器来动态编译Java源代码。在开发模式下，Play框架会定期扫描项目中的Java源代码文件，一旦发现有修改，会自动编译 Java源代码。因此在修改代码之后，刷新页面就可以看到变化。使用这些动态编译的方式的时候，需要确保JDK中的tools.jar在应用的 CLASSPATH中。
   下面介绍一个例子，是关于如何在Java里面做四则运算，比如求出来(3+4)*7-10的值。一般的做法是分析输入的运算表达式，自己来模拟计算过程。考虑到括号的存在和运算符的优先级等问题，这样的计算过程会比较复杂，而且容易出错。另外一种做法是可以用JSR 223引入的脚本语言支持，直接把输入的表达式当做JavaScript或是JavaFX脚本来执行，得到结果。下面的代码使用的做法是动态生成Java源代码并编译，接着加载Java类来执行并获取结果。这种做法完全使用Java来实现。
   01 private static double calculate(String expr) throws CalculationException {
   02 String className = "CalculatorMain";
   03 String methodName = "calculate";
   04 String source = "public class " + className
   05 + " { public static double " + methodName + "() { return " + expr +"; } }";
   06 //省略动态编译Java源代码的相关代码，参见上一节
   07 boolean result = task.call();
   08 if (result) {
   09 ClassLoader loader = Calculator.class.getClassLoader();
   10 try {
   11 Class<?> clazz = loader.loadClass(className);
   12 Method method = clazz.getMethod(methodName, new Class<?>[] {});
   13 Object value = method.invoke(null, new Object[] {});
   14 return (Double) value;
   15 } catch (Exception e) {
   16 throw new CalculationException("内部错误。");
   17 }
   18 } else {
   19 throw new CalculationException("错误的表达式。");
   20 }
   21 }
   上面的代码给出了使用动态生成的Java字节代码的基本模式，即通过类加载器来加载字节代码，创建Java类的对象的实例，再通过Java反射API来调用对象中的方法。
   Java字节代码增强
   Java 字节代码增强指的是在Java字节代码生成之后，对其进行修改，增强其功能。这种做法相当于对应用程序的二进制文件进行修改。在很多Java框架中都可以见到这种实现方式。Java字节代码增强通常与Java源文件中的注解（annotation）一块使用。注解在Java源代码中声明了需要增强的行为及相关的元数据，由框架在运行时刻完成对字节代码的增强。Java字节代码增强应用的场景比较多，一般都集中在减少冗余代码和对开发人员屏蔽底层的实现细节上。用过JavaBeans的人可能对其中那些必须添加的getter/setter方法感到很繁琐，并且难以维护。而通过字节代码增强，开发人员只需要声明Bean中的属性即可，getter/setter方法可以通过修改字节代码来自动添加。用过JPA的人，在调试程序的时候，会发现实体类中被添加了一些额外的 域和方法。这些域和方法是在运行时刻由JPA的实现动态添加的。字节代码增强在面向方面编程（AOP）的一些实现中也有使用。

   ⑹ 页面上有个textarea，在里面写java代码，然后如何动态编译执行这段java代码

   后台获取这段代码之后，将其自动补全成一个java类。
   然后将其用io生成为 .java文本文件
   之后调用
   Runtime.getRuntime().exec("x:/javac.exe xx.java ...") 编译
   最后使用反射或者代理调用这个类文件得到结果

   ⑺ 怎样动态执行一段JAVA代码

   首先你可以使用输入输出流（或者你说的可能是要用反射得到程序结果来解析）解析做出*.Java文件。
   
   然后可以使用runtime调用Dos下的java编译命令编译取得class文件。
   
   然后使用classloader,反射等组合执行生成的class文件。

   ⑻ 怎么动态编译Java源文件

   （Write once, run anywhere）” 的目标。Java类文件中包含的字节代码可以被不同平台上的JVM所使用。Java字节代码不仅可以以文件形式存在于磁盘上，也可以通过网络方式来下载，还可以只存在于内存中。JVM中的类加载器会负责从包含字节代码的字节数组（byte[]）中定义出Java类。在某些情况下，可能会需要动态的生成 Java字节代码，或是对已有的Java字节代码进行修改。这个时候就需要用到本文中将要介绍的相关技术。首先介绍一下如何动态编译Java源文件。
   动态编译Java源文件
   在一般情况下，开发人员都是在程序运行之前就编写完成了全部的Java源代码并且成功编译。对有些应用来说，Java源代码的内容在运行时刻才能确定。这个时候就需要动态编译源代码来生成Java字节代码，再由JVM来加载执行。典型的场景是很多算法竞赛的在线评测系统（如PKU JudgeOnline），允许用户上传Java代码，由系统在后台编译、运行并进行判定。在动态编译Java源文件时，使用的做法是直接在程序中调用Java编译器。
   JSR 199引入了Java编译器API。如果使用JDK 6的话，可以通过此API来动态编译Java代码。比如下面的代码用来动态编译最简单的Hello World类。该Java类的代码是保存在一个字符串中的。
   publicclassCompilerTest{
   publicstaticvoidmain(String[]args)throwsException{
   Stringsource="publicclassMain{publicstaticvoidmain(String[]args){System.out.println(\"HelloWorld!\");}}";
   JavaCompilercompiler=ToolProvider.getSystemJavaCompiler();
   =compiler.getStandardFileManager(null,null,null);
   =newCompilerTest.StringSourceJavaObject("Main",source);
   Iterable<extendsJavaFileObject>fileObjects=Arrays.asList(sourceObject);
   CompilationTasktask=compiler.getTask(null,fileManager,null,null,null,fileObjects);
   booleanresult=task.call();
   if(result){

   ⑼ 求解 java动态编译找不到类，往各位大虾指导

   参照网上其他童鞋的例子与介绍，修改了一下：
   import java.io.IOException;
   import java.lang.reflect.Method;
   import java.net.URI;
   import java.net.URISyntaxException;
   import java.util.Arrays;
   
   import javax.tools.JavaCompiler;
   import javax.tools.JavaCompiler.CompilationTask;
   import javax.tools.JavaFileObject;
   import javax.tools.SimpleJavaFileObject;
   import javax.tools.StandardJavaFileManager;
   import javax.tools.ToolProvider;
   
   /**
   * 动态编译Java 源文件
   *
   * @author shenshouer
   *
   */
   public class CompilerTest {
   
   public static void main(String[] args) throws Exception {
   String source = "public class Main { " + "public static void main(String[]args) {"
   + "System.out.println(\"Hello World!\");" + "} " + "}";
   
   JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
   StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
   StringSourceJavaObject sourceObject = new CompilerTest.StringSourceJavaObject("Main",
   source);
   Iterable<? extends JavaFileObject> fileObjects = Arrays.asList(sourceObject);
   
   // 获取编译类根路径，不然会报找不到类的错误
   String path = Class.class.getClass().getResource("/").getPath();
   Iterable< String> options = Arrays.asList("-d", path);
   
   // 增加options参数
   // CompilationTask task = compiler.getTask(null, fileManager, null, null, null, fileObjects);
   CompilationTask task = compiler.getTask(null, fileManager, null, options, null, fileObjects);
   
   boolean result = task.call();
   
   if (result) {
   System.out.println("编译成功。");
   
   ClassLoader loader = CompilerTest.class.getClassLoader();
   try {
   Class<?> clazz = loader.loadClass("Main");
   Method method = clazz.getMethod("main", String[].class);
   // 修改调用参数，不然会报参数个数不对
   // Object value = method.invoke(null, new Object[] {});
   Object value = method.invoke(null, new Object[] {new String[]{}});
   System.out.println(value);
   } catch (Exception e) {
   e.printStackTrace();
   }
   }
   }
   
   static class StringSourceJavaObject extends SimpleJavaFileObject {
   
   private String content = null;
   
   public StringSourceJavaObject(String name, String content) throws URISyntaxException {
   super(URI.create("string:///" + name.replace('.', '/') + Kind.SOURCE.extension),
   Kind.SOURCE);
   this.content = content;
   }
   
   public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
   return content;
   }
   }
   }

   ⑽ 有什么动态编译java源代码的框架

   可以的，我说说大概思路，很简单，你自己具体实现吧，把代码写给你没意义的：

   1. 将你这段字符串输出到一个文件里，用Java类文件的方式命名。

   2. 2.调用外部javac命令将该文件编译。

   3. 3.用类加载器（ClassLoad）动态加载新的class文件并用Class.forName()注册该类，然后就可以正常使用了。

   4. 上面的每一步都能在中找到实现方法，自己发挥吧。