当前位置:首页 » 编程软件 » java动态编译内存编译

java动态编译内存编译

发布时间: 2022-09-06 06:44:37

Ⅰ 如何用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动态编译找不到类,往各位大虾指导

参照网上其他童鞋的例子与介绍,修改了一下:
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源文件

(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中几个名词解释 静态绑定&动态绑定 静态编译&动态编译 前绑定&后绑定

静态绑定:例如一个变量在声明的时候,就初始化最初值;
动态绑定:声明一个变量,在后续用set方法对其动态设置值;
静态编译:编译器在编译可执行文件的时候,将可执行文件需要调用的对应动态链接库(.so)中的部分提取出来,链接到可执行文件中去,使可执行文件在运行的时候不依赖于动态链接库。
动态编译:某些程式语言在执行时用来增进效能的方法。
前绑定:还未出现即绑定了某些事件
后绑定:出现后才会绑定的某些事件

Ⅵ Java里,重载的方法为何是静态编译,而没有重载的方法却是动态编译这么设计有什么原因吗

java允许在一个类中,多个方法拥有相同的名字,但在名字相同的同时,必须有不同的参数,这就是重载,编译器会根据实际情况挑选出正确的方法,如果编译器找不到匹配的参数或者找出多个可能的匹配就会产生编译时错误,这个过程被称为重载的解析
1 普通方法的重载
普通方法的重载是Java实现多态技术的重要手段,为编程带来了很多便利
当方法同名时,为了让编译器区别他们,至少需要下面之一不同
1 参数个数不同
2 对应位置上的参数类型不同
不允许参数完全相同而只是返回值不同的情况出现。无法进行编译,程序在eclips中显示错误
2 构造方法的重载
见文章构造方法的继承
重载的解析
当类的设计者提供了重载方法之后,类的使用者在使用这些方法时编译器需要确定调用哪一个方法,确定的唯一依据是参数列表,确定的过程被称为重载的解析。

以下举些例子说明:
show(int a ,int b,int c) //1
show(int a ,int b,double c) //2
show(int a ,double b,double c)//3
show(double a,double b,int c) //4
下面是调用
show(1,2,3);//1,2,3,4都是可行方法所有参数完全匹配1
show(1.0,2.0,3.0);//没有一个可行方法
show(1.0,2,3);//4是最佳可行方法
show(1,2.0,3);//3,4都是可行方法,没有最佳可行方法,报错

重载和覆盖都是多态的表现,他们在某些地方很相似,很容易引起初学者的疑惑,这里将它们之间的区别总结如下
1 重载和覆盖的方法名称都相同,但重载要求参数列表不同,而覆盖要求参数列表完全相同。
2 重载对于方法前面的修饰符没有限制,而覆盖则对这些修饰符的使用有限制
3 重载时编译器在编译期间就可以确定调用那一个方法,而覆盖则有可能在运行期间才能确定。

Ⅶ Java代码的静态编译和动态编译中的问题是什么

Java代码正常是静态编译成字节码,由对应平台的JVM加载执行,静态编译无法动态扩展功能。动态编译有两种方式实现:

  1. 源码编译,需要调用Java Compiler,程序需要运行于JDK(而不是JRE)之上。

  2. 动态字节码生成技术(如CGLib、ASM)创建类。

动态编译可以简化代码,增强类功能,但也带来了代码复杂度,线上不易维护。

Ⅷ java怎么利用动态编译求四则运算式的结果贴代码的最后注释一下,免得我看不懂,求高手大神来回答

这种东西都不需要动态编译,你用javax.script.ScriptEngine这玩意就可以了

具体代码
ScriptEngineManager factory = new ScriptEngineManager();
ScriptEngine engine = factory.getEngineByName("javascript");
System.out.println(engine.eval("1+2*3+4^2-(2-8*0.12)+1-2^1/2+5/12-0.12/0.21"));

Ⅸ 在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?"成功":"失败");
}

}

热点内容
315算法 发布:2025-03-20 11:15:35 浏览:212
内塔尼亚胡访问沙特 发布:2025-03-20 11:08:43 浏览:622
Android传输视频 发布:2025-03-20 11:06:34 浏览:150
java软件免费下载 发布:2025-03-20 10:26:01 浏览:705
安卓用什么编译 发布:2025-03-20 10:25:57 浏览:808
ftp中文软件下载 发布:2025-03-20 10:07:47 浏览:508
nexus7android 发布:2025-03-20 10:06:58 浏览:619
安舍iq8如何修改密码 发布:2025-03-20 10:06:17 浏览:880
解压RTP 发布:2025-03-20 09:59:37 浏览:161
python量化分析 发布:2025-03-20 09:53:05 浏览:626