使用 java 动态加载机制模拟脚本语言的效果

巴黎的灯光下

缘由有时我们需要测试某个方法，需要频繁的修改这个方法，但又不想重新去run整个程序，怎么做呢？
一个正常的appium测试用例

1. package com.dynamicclassloader;
   
2. 
   
3. import java.io.File;
   
4. import java.net.URL;
   
5. import org.junit.After;
   
6. import org.junit.Before;
   
7. import org.junit.Test;
   
8. import org.openqa.selenium.WebElement;
   
9. import org.openqa.selenium.remote.DesiredCapabilities;
   
10. import com.dynamicclassloader.DynamicEngine;
    
11. import com.my.Utils;
    
12. 
    
13. import io.appium.java_client.android.AndroidDriver;
    
14. import io.appium.java_client.remote.AndroidMobileCapabilityType;
    
15. import io.appium.java_client.remote.AutomationName;
    
16. import io.appium.java_client.remote.MobileCapabilityType;
    
17. 
    
18. public class CommonTest {
    
19. 
    
20.     private AndroidDriver<?> driver;
    
21.     public DesiredCapabilities capabilities = new DesiredCapabilities();
    
22.     public String location = "C:/Users/test.apk";
    
23.     public String pkgName = "";
    
24.     public String activityName = "";
    
25. 
    
26.     public String getSN() {
    
27.         String sn = Utils.runCMD(new String[]{"adb", "devices"}).split("\n")[1].split("\t")[0];
    
28. 
    
29.         return sn;
    
30.     }
    
31. 
    
32.     public void updatePkgActivity() {
    
33.         String pkgInfo = Utils.runCMD(new String[]{"aapt", "dump", "badging", location});
    
34. 
    
35.         String pkgStart = "package: name='";
    
36.         pkgName = pkgInfo.substring(pkgInfo.indexOf(pkgStart) + pkgStart.length(), pkgInfo.indexOf("' version"));
    
37. 
    
38.         String activityStart = "launchable-activity: name='";
    
39.         activityName = pkgInfo.substring(pkgInfo.indexOf(activityStart) + activityStart.length(), pkgInfo.indexOf("'  label=''"));
    
40. 
    
41.     }
    
42. 
    
43.     public void updateCapabilites() {
    
44.         File app = new File(location);
    
45. 
    
46.         capabilities.setCapability(MobileCapabilityType.DEVICE_NAME, getSN());
    
47. 
    
48.         updatePkgActivity();
    
49.         capabilities.setCapability(AndroidMobileCapabilityType.APP_PACKAGE, pkgName);
    
50.         capabilities.setCapability(AndroidMobileCapabilityType.APP_ACTIVITY, activityName);
    
51. 
    
52.         capabilities.setCapability(MobileCapabilityType.NEW_COMMAND_TIMEOUT, 300);
    
53. 
    
54.         if (Utils.runCMD(new String[]{"adb", "shell", "pm", "path", pkgName}).equals("")) {
    
55.             capabilities.setCapability(MobileCapabilityType.APP, app.getAbsolutePath());
    
56.         }
    
57. 
    
58.         capabilities.setCapability(MobileCapabilityType.AUTOMATION_NAME, AutomationName.ANDROID_UIAUTOMATOR2);
    
59.     }
    
60. 
    
61.     @Before
    
62.     public void setUp() throws Exception {
    
63.         updateCapabilites();
    
64.         driver = new AndroidDriver<WebElement>(new URL("http://127.0.0.1:4723/wd/hub"), capabilities);
    
65. 
    
66.     }
    
67. 
    
68.     @Test
    
69.     public void stepTest() {
    
70.         TouchAction ta = new TouchAction(driver);
    
71.         ta.tap(306, 1852).perform();
    
72.     }
    
73. 
    
74.     @After
    
75.     public void tearDown() throws Exception {
    
76.         driver.quit();
    
77.     }
    
78. 
    
79. }
    
80. 当我修改stepTest后，重新运行时，就会发现appium日志又刷刷地从头开始创建driver了，虽然driver已经创建完成了
    
81. 动态加载方法
    
82. Utils类中访问获取程序内部资源的方法
    
83.     public String getStep(String fileName) {
    
84.         String step = "";
    
85. 
    
86.         InputStream is = getClass().getResourceAsStream(fileName);
    
87.         BufferedReader br = new BufferedReader(new InputStreamReader(is));
    
88.         String s = "";  
    
89.         try {
    
90.             while((s = br.readLine()) != null) {
    
91.                 step += s;
    
92. //              System.out.println(s);
    
93.             }
    
94.         } catch (IOException e) {
    
95.             e.printStackTrace();
    
96.         }
    
97. 
    
98.         return step;
    
99.     }
    
100. 修改后的stepTest方法
     
101. @Test
     
102.     public void stepTest() {
     
103. 
     
104.         while (true) {
     
105.             String source;
     
106.             DynamicEngine de = DynamicEngine.getInstance();
     
107. 
     
108.             source = new Utils().getStep("AndroidStep.txt");
     
109. 
     
110.             try {
     
111.                 System.out.println("test");
     
112.                 Class clazz =  de.javaCodeToObject("com.carl.AndroidStep", source);
     
113.                 clazz.getMethod("runStep", AndroidDriver.class).invoke(clazz, driver);
     
114.             } catch (Exception e) {
     
115.                 e.printStackTrace();
     
116.             }
     
117.         }
     
118.     }
     
119. package com.dynamicclassloader;
     
120. 
     
121. import java.io.File;
     
122. import java.lang.reflect.Method;
     
123. import java.net.URL;
     
124. import java.net.URLClassLoader;
     
125. import java.util.ArrayList;
     
126. import java.util.List;
     
127. 
     
128. import javax.tools.*;
     
129. 
     
130. 
     
131. /**
     
132. * 在Java中最好的方法是使用StandardJavaFileManager类。
     
133. * 这个类可以很好地控制输入、输出，并且可以通过DiagnosticListener得到诊断信息，
     
134. * 而DiagnosticCollector类就是listener的实现。
     
135. * 使用StandardJavaFileManager需要两步。
     
136. * 首先建立一个DiagnosticCollector实例以及通过JavaCompiler的getStandardFileManager()方法得到一个StandardFileManager对象。
     
137. * 最后通过CompilationTask中的call方法编译源程序。
     
138. */
     
139. public class DynamicEngine {
     
140.     //单例
     
141.     private static DynamicEngine ourInstance = new DynamicEngine();
     
142. 
     
143.     public static DynamicEngine getInstance() {
     
144.         return ourInstance;
     
145.     }
     
146.     private URLClassLoader parentClassLoader;
     
147.     private String classpath;
     
148.     private DynamicEngine() {
     
149.         //获取类加载器
     
150.         this.parentClassLoader = (URLClassLoader) this.getClass().getClassLoader();
     
151. 
     
152.         //创建classpath
     
153.         this.buildClassPath();
     
154.     }
     
155. 
     
156.     /**
     
157.      * @MethodName    : 创建classpath
     
158.      */
     
159.     private void buildClassPath() {
     
160.         this.classpath = null;
     
161.         StringBuilder sb = new StringBuilder();
     
162.         for (URL url : this.parentClassLoader.getURLs()) {
     
163.             String p = url.getFile();
     
164.             sb.append(p).append(File.pathSeparator);
     
165.         }
     
166.         this.classpath = sb.toString();
     
167.         //System.out.println("classpath:" + this.classpath);
     
168.     }
     
169. 
     
170.     /**
     
171.      * @MethodName    : 编译java代码到Object
     
172.      * @Description    : TODO
     
173.      * @param fullClassName   类名
     
174.      * @param javaCode  类代码
     
175.      * @return Object
     
176.      * @throws Exception
     
177.      */
     
178.     public Class javaCodeToObject(String fullClassName, String javaCode) throws Exception {
     
179.         long start = System.currentTimeMillis(); //记录开始编译时间
     
180. //        Object instance = null;
     
181.         //获取系统编译器
     
182.         JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
     
183.         // 建立DiagnosticCollector对象
     
184.         DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>();
     
185. 
     
186.         // 建立用于保存被编译文件名的对象
     
187.         // 每个文件被保存在一个从JavaFileObject继承的类中
     
188.         ClassFileManager fileManager = new ClassFileManager(compiler.getStandardFileManager(diagnostics, null, null));
     
189. 
     
190.         List<JavaFileObject> jfiles = new ArrayList<JavaFileObject>();
     
191.         jfiles.add(new StringSourceJavaObject(fullClassName, javaCode));
     
192. 
     
193.         //使用编译选项可以改变默认编译行为。编译选项是一个元素为String类型的Iterable集合
     
194.         List<String> options = new ArrayList<String>();
     
195.         options.add("-encoding");
     
196.         options.add("UTF-8");
     
197.         options.add("-classpath");
     
198.         options.add(this.classpath);
     
199. 
     
200.         JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, diagnostics, options, null, jfiles);
     
201.         // 编译源程序
     
202.         boolean success = task.call();
     
203. 
     
204.         Class clazz = null;
     
205.         if (success) {
     
206.             //如果编译成功，用类加载器加载该类
     
207.             JavaClassObject jco = fileManager.getJavaClassObject();
     
208.             DynamicClassLoader dynamicClassLoader = new DynamicClassLoader(this.parentClassLoader);
     
209.             //String source = "package com.carl.test;public class Sourceee { public static void main(String[] args) {System.out.println(\"Hello World!\");} }";
     
210.             clazz = dynamicClassLoader.loadClass(fullClassName, jco);
     
211. //            instance = clazz.newInstance();
     
212. 
     
213.             for (Method m: clazz.getDeclaredMethods()) {
     
214.                 System.out.println("method name: " + m.getName());
     
215. //                Class<?> classType = Class.forName("java.lang.String");
     
216. //                m.invoke(clazz, Array.newInstance(classType, 0));
     
217.             }
     
218.         } else {
     
219.             //如果想得到具体的编译错误，可以对Diagnostics进行扫描
     
220.             String error = "";
     
221.             for (Diagnostic diagnostic : diagnostics.getDiagnostics()) {
     
222.                 error += compilePrint(diagnostic);
     
223.             }
     
224.         }
     
225.         long end = System.currentTimeMillis();
     
226. 
     
227.         return clazz;
     
228. //        System.out.println("javaCodeToObject use:"+(end-start)+"ms");
     
229. //        return instance;
     
230.     }
     

复制代码

巴黎的灯光下

1.   /**
   
2.      * @MethodName    : compilePrint
   
3.      * @Description    : 输出编译错误信息
   
4.      * @param diagnostic
   
5.      * @return
   
6.      */
   
7.     private String compilePrint(Diagnostic diagnostic) {
   
8.         System.out.println("Code:" + diagnostic.getCode());
   
9.         System.out.println("Kind:" + diagnostic.getKind());
   
10.         System.out.println("Position:" + diagnostic.getPosition());
    
11.         System.out.println("Start Position:" + diagnostic.getStartPosition());
    
12.         System.out.println("End Position:" + diagnostic.getEndPosition());
    
13.         System.out.println("Source:" + diagnostic.getSource());
    
14.         System.out.println("Message:" + diagnostic.getMessage(null));
    
15.         System.out.println("LineNumber:" + diagnostic.getLineNumber());
    
16.         System.out.println("ColumnNumber:" + diagnostic.getColumnNumber());
    
17.         StringBuffer res = new StringBuffer();
    
18.         res.append("Code:[" + diagnostic.getCode() + "]\n");
    
19.         res.append("Kind:[" + diagnostic.getKind() + "]\n");
    
20.         res.append("Position:[" + diagnostic.getPosition() + "]\n");
    
21.         res.append("Start Position:[" + diagnostic.getStartPosition() + "]\n");
    
22.         res.append("End Position:[" + diagnostic.getEndPosition() + "]\n");
    
23.         res.append("Source:[" + diagnostic.getSource() + "]\n");
    
24.         res.append("Message:[" + diagnostic.getMessage(null) + "]\n");
    
25.         res.append("LineNumber:[" + diagnostic.getLineNumber() + "]\n");
    
26.         res.append("ColumnNumber:[" + diagnostic.getColumnNumber() + "]\n");
    
27.         return res.toString();
    
28.     }
    
29. }
    
30. 
    
31. 
    
32. package com.dynamicclassloader;
    
33. 
    
34. import javax.tools.SimpleJavaFileObject;
    
35. import java.io.ByteArrayOutputStream;
    
36. import java.io.IOException;
    
37. import java.io.OutputStream;
    
38. import java.net.URI;
    
39. /**
    
40. * 将输出流交给JavaCompiler，最后JavaCompiler将编译后的class文件写入输出流中
    
41. */
    
42. public class JavaClassObject extends SimpleJavaFileObject {
    
43. 
    
44.     /**
    
45.      * 定义一个输出流，用于装载JavaCompiler编译后的Class文件
    
46.      */
    
47.     protected final ByteArrayOutputStream bos = new ByteArrayOutputStream();
    
48. 
    
49.     /**
    
50.      * 调用父类构造器
    
51.      * @param name
    
52.      * @param kind
    
53.      */
    
54.     public JavaClassObject(String name, Kind kind) {
    
55.         super(URI.create("string:///" + name.replace('.', '/') + kind.extension), kind);
    
56.     }
    
57. 
    
58.     /**
    
59.      * 获取输出流为byte[]数组
    
60.      * @return
    
61.      */
    
62.     public byte[] getBytes() {
    
63.         return bos.toByteArray();
    
64.     }
    
65. 
    
66.     /**
    
67.      * 重写openOutputStream，将我们的输出流交给JavaCompiler，让它将编译好的Class装载进来
    
68.      * @return
    
69.      * @throws IOException
    
70.      */
    
71.     @Override
    
72.     public OutputStream openOutputStream() throws IOException {
    
73.         return bos;
    
74.     }
    
75. 
    
76.     /**
    
77.      * 重写finalize方法，在对象被回收时关闭输出流
    
78.      * @throws Throwable
    
79.      */
    
80.     @Override
    
81.     protected void finalize() throws Throwable {
    
82.         super.finalize();
    
83.         bos.close();
    
84.     }
    
85. }
    
86. 
    
87. package com.dynamicclassloader;
    
88. 
    
89. import javax.tools.JavaFileObject;
    
90. import javax.tools.SimpleJavaFileObject;
    
91. import java.io.IOException;
    
92. import java.net.URI;
    
93. import java.net.URISyntaxException;
    
94. 
    
95. public class StringSourceJavaObject extends SimpleJavaFileObject {
    
96.     private String content = null;
    
97. 
    
98.     public StringSourceJavaObject(String name, String content) throws URISyntaxException {
    
99.         super(URI.create("string:///" + name.replace(".", "/") + JavaFileObject.Kind.SOURCE.extension), Kind.SOURCE);
    
100.         this.content = content;
     
101.     }
     
102. 
     
103.     public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
     
104.         return content;
     
105.     }
     
106. }
     
107. 
     
108. package com.dynamicclassloader;
     
109. 
     
110. import java.net.URL;
     
111. import java.net.URLClassLoader;
     
112. 
     
113. public class DynamicClassLoader extends URLClassLoader {
     
114.     public DynamicClassLoader(ClassLoader parent) {
     
115.         super(new URL[0], parent);
     
116.     }
     
117. 
     
118.     public Class findClassByClassName(String className) throws ClassNotFoundException {
     
119.         return super.findClass(className);
     
120.     }
     
121. 
     
122.     public Class loadClass(String fullName, JavaClassObject jco) {
     
123.         byte[] classData = jco.getBytes();
     
124.         return super.defineClass(fullName, classData, 0, classData.length);
     
125.     }
     
126. }
     
127. 
     
128. package com.dynamicclassloader;
     
129. 
     
130. 
     
131. import java.io.IOException;
     
132. import javax.tools.*;
     
133. 
     
134. /**
     
135. * 类文件管理器
     
136. * 用于JavaCompiler将编译好后的class，保存到jclassObject中
     
137. */
     
138. public class ClassFileManager extends ForwardingJavaFileManager {
     
139. 
     
140.     /**
     
141.      * 保存编译后Class文件的对象
     
142.      */
     
143.     private JavaClassObject jclassObject;
     
144. 
     
145.     /**
     
146.      * 调用父类构造器
     
147.      * @param standardManager
     
148.      */
     
149.     public ClassFileManager(StandardJavaFileManager standardManager) {
     
150.         super(standardManager);
     
151.     }
     
152. 
     
153.     /**
     
154.      * 将JavaFileObject对象的引用交给JavaCompiler，让它将编译好后的Class文件装载进来
     
155.      * @param location
     
156.      * @param className
     
157.      * @param kind
     
158.      * @param sibling
     
159.      * @return
     
160.      * @throws IOException
     
161.      */
     
162.     @Override
     
163.     public JavaFileObject getJavaFileForOutput(Location location, String className, JavaFileObject.Kind kind, FileObject sibling)
     
164.             throws IOException {
     
165.         if (jclassObject == null)
     
166.             jclassObject = new JavaClassObject(className, kind);
     
167.         return jclassObject;
     
168.     }
     
169. 
     
170.     public JavaClassObject getJavaClassObject() {
     
171.         return jclassObject;
     
172.     }
     
173. }
     
174. 
     
175. package com.carl;
     
176. 
     
177. import io.appium.java_client.TouchAction;
     
178. import io.appium.java_client.android.AndroidDriver;
     
179. 
     
180. public class AndroidStep {
     
181. 
     
182.     public static void runStep(AndroidDriver driver) {
     
183.         TouchAction ta = new TouchAction(driver);
     
184.         ta.tap(306, 1852).perform();
     
185.     }
     
186. 
     
187. }
     

复制代码

主要原理
动态加载一个java类，并反射调用
参考书籍
《Java深度历险》

乐哈哈yoyo

学习了！

巴黎的灯光下

乐哈哈yoyo 发表于 2017-6-22 10:41
学习了！