1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
| import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URI;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import javax.tools.FileObject;
import javax.tools.ForwardingJavaFileManager;
import javax.tools.ForwardingJavaFileObject;
import javax.tools.JavaCompiler;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.ToolProvider;
import javax.tools.JavaFileObject.Kind;
class MyJavaFileObject extends ForwardingJavaFileObject<JavaFileObject> {
private ByteArrayOutputStream data;
public MyJavaFileObject(JavaFileObject object) {
super(object);
}
@Override
public OutputStream openOutputStream() throws IOException {
this.data = new ByteArrayOutputStream();
return data;
}
public byte[] getByteCode() {
return data.toByteArray(); // NPE si jamais ouvert
}
}
class MyJavaFileManager extends ForwardingJavaFileManager<JavaFileManager> {
/** La map contenant l'association nom de classe / JavaFileObject */
private final Map<String, MyJavaFileObject> map = new HashMap<String, MyJavaFileObject>();
/** Le ClassLoader qui charge les classes depuis la Map: */
private final ClassLoader loader = new ClassLoader() {
protected Class<?> findClass(String name) throws ClassNotFoundException {
MyJavaFileObject javaObject = map.get(name);
if (javaObject == null)
throw new ClassNotFoundException(name);
byte[] bytes = javaObject.getByteCode();
return defineClass(name, bytes, 0, bytes.length);
}
};
public MyJavaFileManager(JavaFileManager manager) {
super(manager);
}
@Override
public JavaFileObject getJavaFileForOutput(Location location,
String className, Kind kind, FileObject sibling) throws IOException {
JavaFileObject javaObject = super.getJavaFileForOutput(location,
className, kind, sibling);
MyJavaFileObject myJavaObject = new MyJavaFileObject(javaObject);
map.put(className, myJavaObject);
return myJavaObject;
}
public ClassLoader getClassLoader() {
return loader;
}
}
class JavaSourceFromString extends SimpleJavaFileObject {
final String code;
JavaSourceFromString(String name, String code) {
super(URI.create("string:///" + name.replace('.', '/')
+ Kind.SOURCE.extension), Kind.SOURCE);
this.code = code;
}
public CharSequence getCharContent(boolean ignoreEncodingErrors) {
return code;
}
}
public class Main {
public static Iterable<JavaSourceFromString> getJavaSourceFromString(
String fileName, String code) {
return Collections.singletonList(new JavaSourceFromString(fileName,
code));
}
public static void main(String[] args) throws Exception {
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
String program = "public class Test implements Runnable {"
+ " public void run (){"
+ " System.out.println (\"Hello, World\");"
+ " }"
+ "}";
Iterable<? extends JavaFileObject> fileObjects = getJavaSourceFromString(
"Test", program);
MyJavaFileManager fileManager = new MyJavaFileManager(compiler
.getStandardFileManager(null, null, null));
compiler.getTask(null, fileManager, null, null, null, fileObjects)
.call();
ClassLoader loader = fileManager.getClassLoader();
Class<?> clazz = Class.forName("Test", true, loader);
Runnable r = Runnable.class.cast(clazz.newInstance());
r.run();
}
} |
Compilation "Personnalisé" avec JavaCompiler
Répondre avec citation
Cela marche parfaitement sauf qu'on ne peut plus exécuter la classe.
Partager