整理一下Java动态编译Java代码，并在加载到内存中然后执行类中方法的api的介绍

本文的资料来源：http://blog.sina.com.cn/s/blog_70279be20101dk0j.html

近来要开发一个上传java文件，就能动态的将其加载到内存中并执行它的方法的小功能，

在网上找到了一篇不错的api介绍，特将其记下，下面直接进入正题：

步骤：

1.编译

1. public static Map<String, byte[]> compile(String javaName, String javaSrc) {
2.   JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
3.   StandardJavaFileManager stdManager = compiler.getStandardFileManager(null, null, null);
4.   try (MemoryJavaFileManager manager = new MemoryJavaFileManager(stdManager)) {
5.   JavaFileObject javaFileObject = manager.makeStringSource(javaName, javaSrc);
6.   JavaCompiler.CompilationTask task = compiler.getTask(null, manager, null, null, null, Arrays.asList(javaFileObject));
7.   if (task.call())
8.    return manager.getClassBytes();
9.   } catch (IOException e) {
10.    e.printStackTrace();
11.   }
12.    return null;
13. }

该方法的功能描述：通过类名和其代码（Java代码字符串），编译得到字节码，返回类名及其对应类的字节码，封装于Map中，

 值得注意的是，平常类中就编译出来的字节码只有一个类，但是考虑到内部类的情况，会出现很多个类名及其字节码，所以用Map封装方便。

参数详解：javaName,类名，一般就是我们上传Java文件的名字，javaSrc，Java代码的字符串

2.类的动态加载

1. public static class MemoryClassLoader extends URLClassLoader {
2. Map<String, byte[]> classBytes = new HashMap<String, byte[]>();
3. public MemoryClassLoader(Map<String, byte[]> classBytes) {
4. super(new URL[0], MemoryClassLoader.class.getClassLoader());
5. this.classBytes.putAll(classBytes);
6. }
7. @Override
8. protected Class<?> findClass(String name) throws ClassNotFoundException {
9. byte[] buf = classBytes.get(name);
10. if (buf == null) {
11. return super.findClass(name);
12. }
13. classBytes.remove(name);
14. return defineClass(name, buf, 0, buf.length);
15. }
16. }

功能：根据类名和字节码，先根据类名在内存中查找是否已存在该类，若不存在则调用URLClassLoader 的

         defineClass方法加载该类。

3.调用动态加载进来的类的方法

   

1. Class clazz = classLoader.loadClass("TestClass");
2. Object object = clazz.newInstance();
3. Method method = clazz.getMethod("add", int.class, int.class);
4. Object returnValue = method.invoke(object, a, b);
5. }

 其实不一定非得用这种方法，可以调用Class.forName()获取Class对象都行。

以下是一个小demo，来源：http://blog.sina.com.cn/s/blog_70279be20101dk0j.html

1. import javax.tools.*;
2. import java.io.*;
3. import java.net.URI;
4. import java.net.URL;
5. import java.net.URLClassLoader;
6. import java.nio.CharBuffer;
7. import java.util.Arrays;
8. import java.util.HashMap;
9. import java.util.Map;
10.  
11. public class DynamicLoader {
12. /**
13. * auto fill in the java-name with code, return null if cannot find the public class
14. * @param javaSrc source code string
15. * @return return the Map, the KEY means ClassName, the VALUE means bytecode.
16. */
17. public static Map<String, byte[]> compile(String javaSrc) {
18. Pattern pattern = Pattern.compile("public\s+class\s+(\w+)");
19. Matcher matcher = pattern.matcher(javaSrc);
20. if (matcher.find())
21. return compile(matcher.group(1) + ".java", javaSrc);
22. return null;
23. }
25. /**
26. * @param javaName the name of your public class,eg: <code>TestClass.java</code>
27. * @param javaSrc source code string
28. * @return return the Map, the KEY means ClassName, the VALUE means bytecode.
29. */
30. public static Map<String, byte[]> compile(String javaName, String javaSrc) {
31. JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
32. StandardJavaFileManager stdManager = compiler.getStandardFileManager(null, null, null);
33. try (MemoryJavaFileManager manager = new MemoryJavaFileManager(stdManager)) {
34. JavaFileObject javaFileObject = manager.makeStringSource(javaName, javaSrc);
35. JavaCompiler.CompilationTask task = compiler.getTask(null, manager, null, null, null, Arrays.asList(javaFileObject));
36. if (task.call())
37. return manager.getClassBytes();
38. } catch (IOException e) {
39. e.printStackTrace();
40. }
41. return null;
42. }
43. public static class MemoryClassLoader extends URLClassLoader {
44. Map<String, byte[]> classBytes = new HashMap<String, byte[]>();
45. public MemoryClassLoader(Map<String, byte[]> classBytes) {
46. super(new URL[0], MemoryClassLoader.class.getClassLoader());
47. this.classBytes.putAll(classBytes);
48. }
49. @Override
50. protected Class<?> findClass(String name) throws ClassNotFoundException {
51. byte[] buf = classBytes.get(name);
52. if (buf == null) {
53. return super.findClass(name);
54. }
55. classBytes.remove(name);
56. return defineClass(name, buf, 0, buf.length);
57. }
58. }
59. }
60.  
61. * MemoryJavaFileManager.java
62. * @author A. Sundararajan
63. */
64. /**
65. * JavaFileManager that keeps compiled .class bytes in memory.
66. */
67. @SuppressWarnings("unchecked")
68. final class MemoryJavaFileManager extends ForwardingJavaFileManager {
69. /**
70. * Java source file extension.
71. */
72. private final static String EXT = ".java";
73. private Map<String, byte[]> classBytes;
74. public MemoryJavaFileManager(JavaFileManager fileManager) {
75. super(fileManager);
76. classBytes = new HashMap<String, byte[]>();
77. }
78. public Map<String, byte[]> getClassBytes() {
79. return classBytes;
80. }
81. public void close() throws IOException {
82. classBytes = new HashMap<String, byte[]>();
83. }
84. public void flush() throws IOException {
85. }
86. /**
87. * A file object used to represent Java source coming from a string.
88. */
89. private static class StringInputBuffer extends SimpleJavaFileObject {
90. final String code;
91. StringInputBuffer(String name, String code) {
92. super(toURI(name), Kind.SOURCE);
93. this.code = code;
94. }
95. public CharBuffer getCharContent(boolean ignoreEncodingErrors) {
96. return CharBuffer.wrap(code);
97. }
98. public Reader openReader() {
99. return new StringReader(code);
100. }
101. }
102. /**
103. * A file object that stores Java bytecode into the classBytes map.
104. */
105. private class ClassOutputBuffer extends SimpleJavaFileObject {
106. private String name;
107. ClassOutputBuffer(String name) {
108. super(toURI(name), Kind.CLASS);
109. this.name = name;
110. }
111. public OutputStream openOutputStream() {
112. return new FilterOutputStream(new ByteArrayOutputStream()) {
113. public void close() throws IOException {
114. out.close();
115. ByteArrayOutputStream bos = (ByteArrayOutputStream) out;
116. classBytes.put(name, bos.toByteArray());
117. }
118. };
119. }
120. }
121. public JavaFileObject getJavaFileForOutput(JavaFileManager.Location location,
122. String className,
123. JavaFileObject.Kind kind,
124. FileObject sibling) throws IOException {
125. if (kind == JavaFileObject.Kind.CLASS) {
126. return new ClassOutputBuffer(className);
127. } else {
128. return super.getJavaFileForOutput(location, className, kind, sibling);
129. }
130. }
131. static JavaFileObject makeStringSource(String name, String code) {
132. return new StringInputBuffer(name, code);
133. }
134. static URI toURI(String name) {
135. File file = new File(name);
136. if (file.exists()) {
137. return file.toURI();
138. } else {
139. try {
140. final StringBuilder newUri = new StringBuilder();
141. newUri.append("mfm:///");
142. newUri.append(name.replace('.', '/'));
143. if (name.endsWith(EXT)) newUri.replace(newUri.length() - EXT.length(), newUri.length(), EXT);
144. return URI.create(newUri.toString());
145. } catch (Exception exp) {
146. return URI.create("mfm:///com/sun/script/java/java_source");
147. }
148. }
149. }
150. }

测试代码如下：

1. import org.junit.Assert;
2. import org.junit.Test;
3. import java.lang.reflect.InvocationTargetException;
4. import java.lang.reflect.Method;
5. import java.util.Iterator;
6. import java.util.Map;
7. import java.util.Random;
8. public class DynamicLoaderTestCase {
9. private String javaSrc = "public class TestClass{" +
10. "public void sayHello(String msg) {" +
11. "System.out.printf("Hello %s! This message from a Java String.%n",msg);" +
12. "}" +
13. "public int add(int a,int b){" +
14. "return a+b;" +
15. "}" +
16. "}";
17. @Test
18. public void testCompile() {
19. Map<String, byte[]> bytecode = DynamicLoader.compile("TestClass.java", javaSrc);
20. for (Iterator<String> iterator = bytecode.keySet().iterator(); iterator.hasNext(); ) {
21. String key = iterator.next();
22. byte[] code = bytecode.get(key);
23. System.out.printf("Class: %s, Length: %d%n", key, code.length);
24. }
25. // Since the compiler and compiler options are different, the size of the bytes may be inconsistent.
26. Assert.assertEquals(558, bytecode.get("TestClass").length);
27. }
28. @Test
29. public void testInvoke() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
30. Random random = new Random();
31. int a = random.nextInt(1024);
32. int b = random.nextInt(1024);
33. Map<String, byte[]> bytecode = DynamicLoader.compile("TestClass.java", javaSrc);
34. DynamicLoader.MemoryClassLoader classLoader = new DynamicLoader.MemoryClassLoader(bytecode);
35. Class clazz = classLoader.loadClass("TestClass");
36. Object object = clazz.newInstance();
37. Method method = clazz.getMethod("add", int.class, int.class);
38. Object returnValue = method.invoke(object, a, b);
39. Assert.assertEquals(a + b, returnValue);
40. }
41. }

 

在开发的过程中，我们将上传的Java文件动态编译，加载到Tomcat的容器中，因此不能用Java的classloader,

我们用到了WebappClassLoader