在做页面自动化（以使用selenium为例）的时候，很常见的一个场景就是输入密码。往往对于输入框都使用WebElement的sendKeys(CharSequence... keysToSend)的方法。

　　Java代码

1./**

1. • Use this method to simulate typing into an element, which may set its value.
2. */
3. void sendKeys(CharSequence... keysToSend);
   　　一般情况下这个方法是可以胜任的，但是现在很多网站为了安全性的考虑都会对密码输入框做特殊的处理，而且不同的浏览器也不同。例如支付宝。

　　支付宝输入密码控件在Chrome浏览器下

　　支付宝输入密码控件在Firefox浏览器下

　　支付宝输入密码控件在IE（IE8）浏览器下

　　可见在不同的浏览器下是有差异的。那么现在存在两个问题。首先，selenium的sendKeys方法无法操作这样特殊的控件；其次，不同浏览器又存在差异，搞定了chrome，在IE下又不能用，这样又要解决浏览器兼容性问题。

如何解决这两个问题呢？

　　我们可以发现平时人工使用键盘输入密码的时候是没有这些问题的，那么我们是否可以模拟人工操作时的键盘输入方式呢？答案是肯定的，使用操作系统的API，模拟键盘发送消息事件给操作系统，可以避免所有浏览器等差异和安全性带来的问题。

　　我个人建议使用JNA（https://github.com/twall/jna），JNA是一种和JNI类似的技术，但是相对JNI来说更加易用。 JNA共有jna.jar和platform.jar两个依赖库，都需要引入，我们需要用到的在platform.jar中。从包结构可以看出，JNA中包含了mac、unix、win32等各类操作系统的系统API映射。如下图：

　　系统API映射关系在JNA的文章中有描述，如下：

　　数据类型的映射参见：https://github.com/twall/jna/blob/master/www/Mappings.md

　　本文中以windows为例演示下如何在支付宝的密码安全控件中输入密码。

　　JNA中关于windows平台的是com.sun.jna.platform.win32包中User32这个接口。这里映射了很多windows系统API可以使用。但是我们需要用到的SendMessage却没有。所以需要新建一个接口，映射SendMessage函数。代码如下：

1.import com.sun.jna.Native;
2.import com.sun.jna.platform.win32.User32;
3.import com.sun.jna.win32.W32APIOptions;

1. 5.public interface User32Ext extends User32 {
3. User32Ext USER32EXT = (User32Ext) Native.loadLibrary("user32", User32Ext.class, W32APIOptions.DEFAULT_OPTIONS);
5. /**
6. • 查找窗口
7. • @param lpParent 需要查找窗口的父窗口
8. • @param lpChild 需要查找窗口的子窗口
9. • @param lpClassName 类名
10. • @param lpWindowName 窗口名
11. • @return 找到的窗口的句柄
12. */
13. HWND FindWindowEx(HWND lpParent, HWND lpChild, String lpClassName, String lpWindowName);
15. /**
16. • 获取桌面窗口，可以理解为所有窗口的root
17. • @return 获取的窗口的句柄
18. */
19. HWND GetDesktopWindow();
21. /**
22. • 发送事件消息
23. • @param hWnd 控件的句柄
24. • @param dwFlags 事件类型
25. • @param bVk 虚拟按键码
26. • @param dwExtraInfo 扩展信息，传0即可
27. • @return
28. */
29. int SendMessage(HWND hWnd, int dwFlags, byte bVk, int dwExtraInfo);
31. /**
32. • 发送事件消息
33. • @param hWnd 控件的句柄
34. • @param Msg 事件类型
35. • @param wParam 传0即可
36. • @param lParam 需要发送的消息，如果是点击操作传null
37. • @return
38. */
39. int SendMessage(HWND hWnd, int Msg, int wParam, String lParam);
41. /**
42. • 发送键盘事件
43. • @param bVk 虚拟按键码
44. • @param bScan 传 ((byte)0) 即可
45. • @param dwFlags 键盘事件类型
46. • @param dwExtraInfo 传0即可
47. */
48. void keybd_event(byte bVk, byte bScan, int dwFlags, int dwExtraInfo);
50. /**
51. • 激活指定窗口（将鼠标焦点定位于指定窗口）
52. • @param hWnd 需激活的窗口的句柄
53. • @param fAltTab 是否将最小化窗口还原
54. */
55. void SwitchToThisWindow(HWND hWnd, boolean fAltTab);
56. 61.}

　系统API映射好以后，利用这个接口写了如下的工具类，包含点击和输入各种操作。代码如下：

1.import java.util.concurrent.Callable;
2.import java.util.concurrent.ExecutorService;
3.import java.util.concurrent.Executors;
4.import java.util.concurrent.Future;
5.import java.util.concurrent.TimeUnit;

1. 7.import com.sun.jna.Native;

8.import com.sun.jna.Pointer;
9.import com.sun.jna.platform.win32.WinDef.HWND;
10.import com.sun.jna.platform.win32.WinUser.WNDENUMPROC;

1. 12./**
2. • Window组件操作工具类
4. • @author sunju
6. */
   18.public class Win32Util {
8. private static final int N_MAX_COUNT = 512;
10. private Win32Util() {
11. }
13. /**
14. • 从桌面开始查找指定类名的组件，在超时的时间范围内，如果未找到任何匹配的组件则反复查找
15. • @param className 组件的类名
16. • @param timeout 超时时间
17. • @param unit 超时时间的单位
18. • @return 返回匹配的组件的句柄，如果匹配的组件大于一个，返回第一个查找的到的；如果未找到或超时则返回null
19. */
20. public static HWND findHandleByClassName(String className, long timeout, TimeUnit unit) {
21. return findHandleByClassName(USER32EXT.GetDesktopWindow(), className, timeout, unit);
22. }
24. /**
25. • 从桌面开始查找指定类名的组件
26. • @param className 组件的类名
27. • @return 返回匹配的组件的句柄，如果匹配的组件大于一个，返回第一个查找的到的；如果未找到任何匹配则返回null
28. */
29. public static HWND findHandleByClassName(String className) {
30. return findHandleByClassName(USER32EXT.GetDesktopWindow(), className);
31. }
33. /**
34. • 从指定位置开始查找指定类名的组件
35. • @param root 查找组件的起始位置的组件的句柄，如果为null则从桌面开始查找
36. • @param className 组件的类名
37. • @param timeout 超时时间
38. • @param unit 超时时间的单位
39. • @return 返回匹配的组件的句柄，如果匹配的组件大于一个，返回第一个查找的到的；如果未找到或超时则返回null
40. */
41. public static HWND findHandleByClassName(HWND root, String className, long timeout, TimeUnit unit) {
42. if(null == className || className.length() <= 0) {
43. return null;
44. }
45. long start = System.currentTimeMillis();
46. HWND hwnd = findHandleByClassName(root, className);
47. while(null == hwnd && (System.currentTimeMillis() - start < unit.toMillis(timeout))) {
48. hwnd = findHandleByClassName(root, className);
49. }
50. return hwnd;
51. }
53. /**
54. • 从指定位置开始查找指定类名的组件
55. • @param root 查找组件的起始位置的组件的句柄，如果为null则从桌面开始查找
56. • @param className 组件的类名
57. • @return 返回匹配的组件的句柄，如果匹配的组件大于一个，返回第一个查找的到的；如果未找到任何匹配则返回null
58. */
59. public static HWND findHandleByClassName(HWND root, String className) {
60. if(null == className || className.length() <= 0) {
61. return null;
62. }
63. HWND[] result = new HWND[1];
64. findHandle(result, root, className);
65. return result[0];
66. }
68. private static boolean findHandle(final HWND[] target, HWND root, final String className) {
69. if(null == root) {
70. root = USER32EXT.GetDesktopWindow();
71. }
72. return USER32EXT.EnumChildWindows(root, new WNDENUMPROC() {
74. @Override
75. public boolean callback(HWND hwnd, Pointer pointer) {
76. char[] winClass = new char[N_MAX_COUNT];
77. USER32EXT.GetClassName(hwnd, winClass, N_MAX_COUNT);
78. if(USER32EXT.IsWindowVisible(hwnd) && className.equals(Native.toString(winClass))) {
79. target[0] = hwnd;
80. return false;
81. } else {
82. return target[0] == null || findHandle(target, hwnd, className);
83. }
84. }
86. }, Pointer.NULL);
87. }
89. /**
90. • 模拟键盘按键事件，异步事件。使用win32 keybd_event，每次发送KEYEVENTF_KEYDOWN、KEYEVENTF_KEYUP两个事件。默认10秒超时
91. • @param hwnd 被键盘操作的组件句柄
92. • @param keyCombination 键盘的虚拟按键码（Virtual-Key Code），或者使用{@link java.awt.event.KeyEvent}
93. • 二维数组第一维中的一个元素为一次按键操作，包含组合操作，第二维中的一个元素为一个按键事件，即一个虚拟按键码
94. • @return 键盘按键事件放入windows消息队列成功返回true，键盘按键事件放入windows消息队列失败或超时返回false
95. */
96. public static boolean simulateKeyboardEvent(HWND hwnd, int[][] keyCombination) {
97. if(null == hwnd) {
98. return false;
99. }
100. USER32EXT.SwitchToThisWindow(hwnd, true);
101. USER32EXT.SetFocus(hwnd);
102. for(int[] keys : keyCombination) {
103. for(int i = 0; i < keys.length; i++) {
104. USER32EXT.keybd_event((byte) keys[i], (byte) 0, KEYEVENTF_KEYDOWN, 0); // key down
105. }
106. for(int i = keys.length - 1; i >= 0; i--) {
107. USER32EXT.keybd_event((byte) keys[i], (byte) 0, KEYEVENTF_KEYUP, 0); // key up
108. }
109. }
110. return true;
111. }
113. /**
114. • 模拟字符输入，同步事件。使用win32 SendMessage API发送WM_CHAR事件。默认10秒超时
115. • @param hwnd 被输入字符的组件的句柄
116. • @param content 输入的内容。字符串会被转换成char[]后逐个字符输入
117. • @return 字符输入事件发送成功返回true，字符输入事件发送失败或超时返回false
118. */
119. public static boolean simulateCharInput(final HWND hwnd, final String content) {
120. if(null == hwnd) {
121. return false;
122. }
123. try {
124. return execute(new Callable() {
126. @Override
127. public Boolean call() throws Exception {
128. USER32EXT.SwitchToThisWindow(hwnd, true);
129. USER32EXT.SetFocus(hwnd);
130. for(char c : content.toCharArray()) {
131. Thread.sleep(5);
132. USER32EXT.SendMessage(hwnd, WM_CHAR, (byte) c, 0);
133. }
134. return true;
135. }
137. });
138. } catch(Exception e) {
139. return false;
140. }
141. }
143. public static boolean simulateCharInput(final HWND hwnd, final String content, final long sleepMillisPreCharInput) {
144. if(null == hwnd) {
145. return false;
146. }
147. try {
148. return execute(new Callable() {
150. @Override
151. public Boolean call() throws Exception {
152. USER32EXT.SwitchToThisWindow(hwnd, true);
153. USER32EXT.SetFocus(hwnd);
154. for(char c : content.toCharArray()) {
155. Thread.sleep(sleepMillisPreCharInput);
156. USER32EXT.SendMessage(hwnd, WM_CHAR, (byte) c, 0);
157. }
158. return true;
159. }
161. });
162. } catch(Exception e) {
163. return false;
164. }
165. }
167. /**
168. • 模拟文本输入，同步事件。使用win32 SendMessage API发送WM_SETTEXT事件。默认10秒超时
169. • @param hwnd 被输入文本的组件的句柄
170. • @param content 输入的文本内容
171. • @return 文本输入事件发送成功返回true，文本输入事件发送失败或超时返回false
172. */
173. public static boolean simulateTextInput(final HWND hwnd, final String content) {
174. if(null == hwnd) {
175. return false;
176. }
177. try {
178. return execute(new Callable() {
180. @Override
181. public Boolean call() throws Exception {
182. USER32EXT.SwitchToThisWindow(hwnd, true);
183. USER32EXT.SetFocus(hwnd);
184. USER32EXT.SendMessage(hwnd, WM_SETTEXT, 0, content);
185. return true;
186. }
188. });
189. } catch(Exception e) {
190. return false;
191. }
192. }
194. /**
195. • 模拟鼠标点击，同步事件。使用win32 SendMessage API发送BM_CLICK事件。默认10秒超时
196. • @param hwnd 被点击的组件的句柄
197. • @return 点击事件发送成功返回true，点击事件发送失败或超时返回false
198. */
199. public static boolean simulateClick(final HWND hwnd) {
200. if(null == hwnd) {
201. return false;
202. }
203. try {
204. return execute(new Callable() {
206. @Override
207. public Boolean call() throws Exception {
208. USER32EXT.SwitchToThisWindow(hwnd, true);
209. USER32EXT.SendMessage(hwnd, BM_CLICK, 0, null);
210. return true;
211. }
213. });
214. } catch(Exception e) {
215. return false;
216. }
217. }
219. private static T execute(Callable callable) throws Exception {
220. ExecutorService executor = Executors.newSingleThreadExecutor();
221. try {
222. Future task = executor.submit(callable);
223. return task.get(10, TimeUnit.SECONDS);
224. } finally {
225. executor.shutdown();
226. }
227. }
     240.}

其中用到的各种事件类型定义如下：

1.public class Win32MessageConstants {

2. public static final int WM_SETTEXT = 0x000C; //输入文本
4. public static final int WM_CHAR = 0x0102; //输入字符
6. public static final int BM_CLICK = 0xF5; //点击事件，即按下和抬起两个动作
8. public static final int KEYEVENTF_KEYUP = 0x0002; //键盘按键抬起
10. public static final int KEYEVENTF_KEYDOWN = 0x0; //键盘按键按下
11. 13.}

　　下面写一段测试代码来测试支付宝密码安全控件的输入，测试代码如下：

1.import java.util.concurrent.TimeUnit;

1. 3.import static org.hamcrest.core.Is.is;

4.import static org.junit.Assert.assertThat;

1. 6.import static org.hamcrest.core.IsNull.notNullValue;

7.import org.junit.Test;

1. 9.import com.sun.jna.platform.win32.WinDef;

10.import com.sun.jna.platform.win32.WinDef.HWND;

1. 12.public class AlipayPasswordInputTest {
3. @Test
4. public void testAlipayPasswordInput() {
5. String password = "your password";
6. HWND alipayEdit = findHandle("Chrome_RenderWidgetHostHWND", "Edit"); //Chrome浏览器，使用Spy++可以抓取句柄的参数
7. assertThat("获取支付宝密码控件失败。", alipayEdit, notNullValue());
8. boolean isSuccess = Win32Util.simulateCharInput(alipayEdit, password);
9. assertThat("输入支付宝密码["+ password +"]失败。", isSuccess, is(true));
10. }
12. private WinDef.HWND findHandle(String browserClassName, String alieditClassName) {
13. WinDef.HWND browser = Win32Util.findHandleByClassName(browserClassName, 10, TimeUnit.SECONDS);
14. return Win32Util.findHandleByClassName(browser, alieditClassName, 10, TimeUnit.SECONDS);
15. }
    27.}

　　测试一下，看看是不是输入成功了！

　　最后说下这个方法的缺陷，任何方法都有不可避免的存在一些问题，完美的事情很少。

　　1、sendMessage和postMessage有很多重载的函数，不是每种都有效，从上面的Win32Util中就能看出，实现了很多个方法，需要尝试下，成本略高；

　　2、输入时需要注意频率，输入太快可能导致浏览器中安全控件崩溃，支付宝的安全控件在Firefox下输入太快就会崩溃；

　　3、因为是系统API，所以MAC、UNIX、WINDOWS下都不同，如果只是在windows环境下运行，可以忽略；

　　4、从测试代码可以看到，是针对Chrome浏览器的，因为每种浏览器的窗口句柄不同，所以要区分，不过这个相对简单，只是名称不同；

　　5、如果你使用Selenium的RemoteDriver，并且是在远程机器上运行脚本，这个方法会失效。因为remoteDriver最终是http操作，对操作系统API的操作是客户端行为，不能被翻译成Http Command，所以会失效。

最新内容请见作者的GitHub页：http://qaseven.github.io/