Selenium Page Factory 模式源码分析

阿蛮的开心姐

本文主要用来分析Page Factory实现的原理以及一些扩展的可能性。

Page Factory 的例子

Selenium Page Factory Wiki

首先解释一下这个例子：

使用注解描述元素定位
使用

1. PageFactory.initElements(driver, page);
   
2. public class GoogleSearchPage {
   
3.     // The element is now looked up using the name attribute
   
4.     @FindBy(how = How.NAME, using = "q")
   
5.     private WebElement searchBox;
   
6. 
   
7.     public void searchFor(String text) {
   
8.         // We continue using the element just as before
   
9.         searchBox.sendKeys(text);
   
10.         searchBox.submit();
    
11.     }
    
12. 
    
13.     public void searchFor(String text) {
    
14.     GoogleSearchPage page＝ PageFactory.initElements(new ChromeDriver(), GoogleSearchPage.class);
    
15.     }
    
16. }

复制代码

以上一个显而易见的好处就是减少了查找元素的代码量，比如类似于一下的代码：

driver.findElement(By.id("q"))
但是只有这样的好处吗？我们先从分析Selenium Page Factory实现的原理说起

Page Factory 实现的原理

PageFactory 是使用反射(Reflection)和动态代理(dynamic proxies)的方式来创建页面的每
每个元素:

1. 
   
2. PageFactory: initElements and proxyFields ```java public static void initElements(FieldDecorator decorator, Object page) { for(Class proxyIn = page.getClass(); proxyIn != Object.class; proxyIn = proxyIn.getSuperclass()) { proxyFields(decorator, page, proxyIn); }
   
3. }
   
4. 
   
5. private static void proxyFields(FieldDecorator decorator, Object page, Class<?> proxyIn) {
   
6. Field[] fields = proxyIn.getDeclaredFields();
   
7. Field[] arr$ = fields;
   
8. int len$ = fields.length;
   
9. 
   
10. for(int i$ = 0; i$ < len$; ++i$) {
    
11. Field field = arr$[i$];
    
12. Object value = decorator.decorate(page.getClass().getClassLoader(), field);
    
13. if(value != null) {
    
14. try {
    
15. field.setAccessible(true);
    
16. field.set(page, value);
    
17. } catch (IllegalAccessException var10) {
    
18. throw new RuntimeException(var10);
    
19. }
    
20. }
    
21. }
    
22. 
    
23. }
    
24. 
    
25. - FieldDecorator：DefaultFieldDecorator 源码
    
26. 从DefaultFieldDecorator的源码看:
    
27. 1. 实现decorate方法,WebElement 和List<WebElement> 都是通过proxy的方式创建的
    
28. 2. 每个Proxy的方式都有一个对应的invocationHandler处理
    
29.    Selenium的源码有两个invocationHandler：
    
30.    - LocatingElementHandler
    
31.    - LocatingElementListHandler
    
32. 
    
33. ```java
    
34. public Object decorate(ClassLoader loader, Field field) {
    
35.         if(!WebElement.class.isAssignableFrom(field.getType()) && !this.isDecoratableList(field)) {
    
36.             return null;
    
37.         } else {
    
38.             ElementLocator locator = this.factory.createLocator(field);
    
39.             return locator == null?null:(WebElement.class.isAssignableFrom(field.getType())?this.proxyForLocator(loader, locator):(List.class.isAssignableFrom(field.getType())?this.proxyForListLocator(loader, locator):null));
    
40.         }
    
41.     }
    
42. 
    
43.     private boolean isDecoratableList(Field field) {
    
44.         if(!List.class.isAssignableFrom(field.getType())) {
    
45.             return false;
    
46.         } else {
    
47.             Type genericType = field.getGenericType();
    
48.             if(!(genericType instanceof ParameterizedType)) {
    
49.                 return false;
    
50.             } else {
    
51.                 Type listType = ((ParameterizedType)genericType).getActualTypeArguments()[0];
    
52.                 return !WebElement.class.equals(listType)?false:field.getAnnotation(FindBy.class) != null || field.getAnnotation(FindBys.class) != null || field.getAnnotation(FindAll.class) != null;
    
53.             }
    
54.         }
    
55.     }
    
56. 
    
57.     protected WebElement proxyForLocator(ClassLoader loader, ElementLocator locator) {
    
58.         LocatingElementHandler handler = new LocatingElementHandler(locator);
    
59.         WebElement proxy = (WebElement)Proxy.newProxyInstance(loader, new Class[]{WebElement.class, WrapsElement.class, Locatable.class}, handler);
    
60.         return proxy;
    
61.     }
    
62. 
    
63.     protected List<WebElement> proxyForListLocator(ClassLoader loader, ElementLocator locator) {
    
64.         LocatingElementListHandler handler = new LocatingElementListHandler(locator);
    
65.         List proxy = (List)Proxy.newProxyInstance(loader, new Class[]{List.class}, handler);
    
66.         return proxy;
    
67.     }

复制代码

我们再看一下LocatingElementHandler,可以看到实际在调用PageFactory创建的元素时候都是通过这个
LocatingElementHandler这个invoke
函数调用WebElement的方法：

1. public class LocatingElementHandler implements InvocationHandler {
   
2.     private final ElementLocator locator;
   
3. 
   
4.     public LocatingElementHandler(ElementLocator locator) {
   
5.         this.locator = locator;
   
6.     }
   
7. 
   
8.     public Object invoke(Object object, Method method, Object[] objects) throws Throwable {
   
9.         WebElement element;
   
10.         try {
    
11.             element = this.locator.findElement();
    
12.         } catch (NoSuchElementException var7) {
    
13.             if("toString".equals(method.getName())) {
    
14.                 return "Proxy element for: " + this.locator.toString();
    
15.             }
    
16. 
    
17.             throw var7;
    
18.         }
    
19. 
    
20.         if("getWrappedElement".equals(method.getName())) {
    
21.             return element;
    
22.         } else {
    
23.             try {
    
24.                 return method.invoke(element, objects);
    
25.             } catch (InvocationTargetException var6) {
    
26.                 throw var6.getCause();
    
27.             }
    
28.         }
    
29.     }
    
30. }

复制代码

以上Selenium PageFactory大致的实现，从过程来看：
PageFaction-> initElements-> proxyFields

Page Factory 有什么好处

个人理解的好处:

可以通过修改InvocationHandler里面的处理,比如 java element = this.locator.findElement();  如果都使用wait
().util的方式,这样可以使所有查找的元素更加稳定
使用了proxy的方式,在实例化WebElement的时候，实际上不管WebElement存在不存在都可以创建 而实际fi
ndElement都会延迟到真的调用这个元素时执行,这带来一个好处就是如果WebElement的实例创建后 页面D
OM刷新后,需要重新查找WebElement,否则可能抛出StaleElementReferenceException,而Proxy之后每次都会
自动 查找,这样就减少了代码处理
工厂的设计模式同时也带了了灵活程度,在创建页面或者页面元素的时候,可以开始添加统一的前置或者后置
的处理
但是可惜的是Selenium并没有提供开发的接口来让用户定制,所以如果自己定制PageFactory模式,则需要自己
去实现Selenium这
一套方法,同时加入自己特殊的实现

梦想家