selenium 封装代码

package pers.xeon.automate.auxt;

import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;

/**
 * @author xeon
 * @version 创建时间：2016年3月25日 上午10:11:07 
 * 高级操作接口
 */
public interface AdvanceHandle {

    // 窗口最大化
    public void maximize();

    /*
     * 这个方法是用于切换为原来的窗口,但是前提是一定有弹框出现,并且使用过切换窗口方法
     */
    public void changeLastWindow();

    /*
     * 当弹框出现的时候,调用就会切换到对应的窗口
     */
    public void changeWindow();

    /*
     * 刷新页面之后继续,等待元素
     */
    public boolean waitElementByRefresh(By locator, int time, int k);

    /*
     * 刷新页面等待元素 不用指定时间,系统指定固定时间 方法重载 默认刷新页面2次,等待5秒
     */
    public boolean waitElementByRefresh(By locator);

    /*
     * 最好不用这个方法,但是我还是提供给你 这个方法是处理等待元素方法1
     */
    public boolean waitElementByWait(By locator, int time, boolean b);

    /*
     * 等待无限时间 不建议使用,如果一直没有加载出来,线程就阻塞
     */
    public boolean waitElementByWait(By locator);

    /*
     * 等待指定时间 建议使用,我自己写的方法 方法与显性等待是一样的
     */
    public boolean waitElementByWait(By locator, int time);

    /*
     * 判断元素是否存在
     */
    public boolean isElementExsit(By locator);

    /*
     * 这个方法是处理元素加载方法2 显性等待指定时间
     */
    public WebElement waitElement(By by, int time);

    /*
     * 默认等10秒 10秒我比较喜欢所以搞一个单独方法,少写一个条件而已 显性等待10秒之内加载,比较好用,建议使用
     */
    public WebElement waitElement(By by);

    /*
     * 这个方法是处理元素加载的方法3
     */
    public void waitElementByThread(int ms);

    /*
     * 这个方法是处理元素加载的方法4 建议不要使用这个,这个是隐形等待,当改变这个时候可能会影响其他元素等待 说白了是全局,注意不要使用
     */
    public void waitElementByInvisible(int second);

    /*
     * 下拉框操作选择字符串为str 按照值定位 这个需要找到下拉框的value值定位
     */
    public void selectValue(String estr, String str);

    /*
     * 下拉框操作选择字符串为str 可见文本定位 建议用这个
     */
    public void select(String estr, String str);

    /*
     * 索引定位 下拉框操作选择字符串Index为index
     */
    public void select(String estr, int index);

    /*
     * 弹框点击确定
     */
    public void alertAccept();

    /*
     * 弹框点击确定
     */
    public void alertDismiss();

    /*
     * 得到弹框文本
     */
    public void alertGetText();
    
    /*
     * Frame切换
     */
    public void frame(String FrameName);

    /*
     * 上传文件,上传图片等 方法可能无效,Driver自带的
     */
    public void UploadBySendKeys(String estr, String strPath);

    /*
     * 上传文件,上传图片 建议使用这个,100%没得问题 我利用复制粘贴,然后你懂得
     * 这里面的strPath,我使用的相对路径,相对项目的根路径写的(好处就是可以到处移动,他的参考点事这个项目的根路径)
     */
    public void upload(String estr, String strPath);
    

}

package pers.xeon.automate.auxt;

import java.awt.AWTException;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.datatransfer.Clipboard;
import java.awt.datatransfer.StringSelection;
import java.awt.event.KeyEvent;
import java.io.File;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.NoSuchElementException;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.ExpectedCondition;
import org.openqa.selenium.support.ui.Select;
import org.openqa.selenium.support.ui.WebDriverWait;

/** 
* @version 创建时间：2016年2月19日 下午2:12:26 
* 处理页面的高级操作
* 总有适合自己的默认方法,下面等待时间我设置默认方法.为了满足开闭原则,我那天也懒得改,还有很多比默认方法强大同类型方法
*/
public class DefaultAdvancedHandle implements AdvanceHandle {
    


    private Driver driver ;
    private static String  preWindowString;
    private static String imagePath=(new File("").getAbsolutePath()).toString();
    
    public DefaultAdvancedHandle(Driver driver) {
        this.driver = driver;
    }
    
    /*
     * 这个方法是用于切换为原来的窗口,但是前提是一定有弹框出现,并且使用过切换窗口方法
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#changeLastWindow()
     */
    @Override
    public void changeLastWindow() {
        driver.switchTo().window(preWindowString);
    }

    /*
     * 当弹框出现的时候,调用就会切换到对应的窗口
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#changeWindow()
     */
    @Override
    public void changeWindow() {// 这个方法是处理跳出页面
        preWindowString = driver.getWindowHandle();
        Set<String> handles = driver.getWindowHandles();
        Iterator<String> it = handles.iterator();
        String cruWindowString;
        while (it.hasNext()) {
            cruWindowString = it.next();
            if (preWindowString == cruWindowString) {
                continue;
            }
            driver.switchTo().window(cruWindowString);
        }
    }
    
    /*
     * 刷新页面之后继续,等待元素
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#waitElementByRefresh(org.openqa.selenium.By, int, int)
     */
    @Override
    public  boolean waitElementByRefresh(By locator,int time,int k){
        int i = 0;
        while(waitElementByWait(locator,time)){
            driver.navigate().refresh();
            i++;
            if(i == k){
                return false;
            }
        }
        return true;
    }
    
    
    
    /*
     * 刷新页面等待元素
     * 不用指定时间,系统指定固定时间
     * 方法重载
     * 默认刷新页面2次,等待5秒
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#waitElementByRefresh(org.openqa.selenium.By)
     */
    @Override
    public  boolean waitElementByRefresh(By locator){
        return waitElementByRefresh(locator,5,2);
    }
    
    
    
    /*
     * 最好不用这个方法,但是我还是提供给你
     * 这个方法是处理等待元素方法1
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#waitElementByWait(org.openqa.selenium.By, int, boolean)
     */
    @Override
    public  boolean waitElementByWait(By locator,int time,boolean b){
        
        long start = System.currentTimeMillis();
        
        while(!isElementExsit(locator)){
            if(b){
                if(System.currentTimeMillis() >= (start +time*1000)){
                    break;
                }
            }
        }
        return isElementExsit(locator);
    }
    
    /*
     * 等待无限时间
     * 不建议使用,如果一直没有加载出来,线程就阻塞
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#waitElementByWait(org.openqa.selenium.By)
     */
    @Override
    public  boolean waitElementByWait(By locator){
        return waitElementByWait(locator,0,false);
    }
    
    /*
     * 等待指定时间
     * 建议使用,我自己写的方法
     * 方法与显性等待是一样的
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#waitElementByWait(org.openqa.selenium.By, int)
     */
    @Override
    public  boolean waitElementByWait(By locator,int time){
        return waitElementByWait(locator,time,true);
    }
    
    /*
     * 判断元素是否存在
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#isElementExsit(org.openqa.selenium.By)
     */
    @Override
    public  boolean isElementExsit(By locator) {  
        boolean flag = false;  
        try {  
            WebElement element=driver.findElement(locator);  
            flag= null != element;  
        } catch (NoSuchElementException e) { 
            return flag;
        }  
        return flag;  
    } 
    
    /*
     * 这个方法是处理元素加载方法2
     * 显性等待指定时间
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#waitElement(org.openqa.selenium.By, int)
     */
    @Override
    public  WebElement waitElement(By by,int time){
         WebDriverWait wait = new WebDriverWait(driver,time);  
            wait.until(new ExpectedCondition<WebElement>(){  
                @Override  
                public WebElement apply(WebDriver d) {  
                    return d.findElement(by);  
               }}); 
            return null;
    }
    
    /*
     * 默认等10秒
     * 10秒我比较喜欢所以搞一个单独方法,少写一个条件而已
     * 显性等待10秒之内加载,比较好用,建议使用
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#waitElement(org.openqa.selenium.By)
     */
    @Override
    public  WebElement waitElement(By by){
        return waitElement(by,10);
    }
    
    /*
     * 这个方法是处理元素加载的方法3
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#waitElementByThread(int)
     */
    @Override
    public  void waitElementByThread(int ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            System.out.println("Thread睡眠被唤醒,这本来是个异常,我已经手动处理:原因是因为我估计这个线程被其他线程唤醒,开始执行,所以并没有抛出异常,直接处理");
        }
    }
    
    /*
     * 这个方法是处理元素加载的方法4
     * 建议不要使用这个,这个是隐形等待,当改变这个时候可能会影响其他元素等待
     * 说白了是全局,注意不要使用
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#waitElementByInvisible(int)
     */
    @Override
    public  void waitElementByInvisible(int second) {
        driver.manage().timeouts().implicitlyWait(second, TimeUnit.SECONDS);
    }
    
    /*
     * 下拉框操作选择字符串为str
     * 按照值定位
     * 这个需要找到下拉框的value值定位
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#selectValue(java.lang.String, java.lang.String)
     */
    @Override
    public void selectValue(String estr,String str){
        Select select = new Select(driver.findElement(estr));  
        select.selectByValue(str);
    }
    
    /*
     * 下拉框操作选择字符串为str
     * 可见文本定位
     * 建议用这个
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#select(java.lang.String, java.lang.String)
     */
    @Override
    public void select(String estr,String str){
        Select select = new Select(driver.findElement(estr));  
        select.selectByVisibleText(str);
    }
    
    /*
     * 索引定位
     * 下拉框操作选择字符串Index为index
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#select(java.lang.String, int)
     */
    @Override
    public void select(String estr,int index){
        Select select = new Select(driver.findElement(estr));  
        select.selectByIndex(index);
    }
    
    
    /*
     * 最大化窗口
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#maximize()
     */
    @Override
    public void maximize() {
        driver.manage().window().maximize();
    }
    
    /*
     * 弹框点击确定
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#alertAccept()
     */
    @Override
    public void alertAccept(){
        Alert alert = driver.switchTo().alert();
        alert.accept();
    }
    
    /*
     * 弹框点击确定
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#alertDismiss()
     */
    @Override
    public void alertDismiss(){
        Alert alert = driver.switchTo().alert();
        alert.dismiss();
    }
    
    /*
     * 得到弹框文本
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#alertGetText()
     */
    @Override
    public void alertGetText(){
        Alert alert = driver.switchTo().alert();
        alert.getText();
    }
    
    /*
     * 上传文件,上传图片等
     * 方法可能无效,Driver自带的
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#UploadBySendKeys(java.lang.String, java.lang.String)
     */
    @Override
    public void UploadBySendKeys(String estr,String strPath){
        WebElement adFileUpload =driver.findElement(estr);
        strPath=imagePath+"\"+strPath;
        adFileUpload.sendKeys(strPath);
    }
    
    /*
     * 上传文件,上传图片
     * 建议使用这个,100%没得问题
     * 我利用复制粘贴,然后你懂得
     * 这里面的strPath,我使用的相对路径,相对项目的根路径写的(好处就是可以到处移动,他的参考点事这个项目的根路径)
     */
    /* (non-Javadoc)
     * @see pers.xeon.automate.auxt.AdvanceHandle#upload(java.lang.String, java.lang.String)
     */
    @Override
    public void upload(String estr,String strPath){
        driver.click(estr);
        try {
            upload(strPath);
        } catch (AWTException e) {
            System.out.println("AWTException:由于Robot类初始化失败");
        } catch (InterruptedException e) {
            System.out.println("InterruptedException:可能导致上传失败,线程被唤醒");
        }
        
    }
    
    
    /*
     * 得到系统剪贴板
     */
    private  void copy(String text) {
        //拿到当前系统剪切板,首先拿到工具箱,然后得到系统剪切板
        Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard(); 
        //选中文本
        StringSelection selection = new StringSelection(text);
        //搞到剪切板里面去
        clipboard.setContents(selection, null);
    }

    /*
     * 这个方法是复制指定字符串的文本到剪切板 调用keyPressWithCtrl实现ctrl + v,然后enter操作
     */
    private  void keyPressString(Robot r, String str) throws InterruptedException {
        copy(str);
        keyPressWithCtrl(r);// 粘贴
    }

    /*
     * 实现ctrl + v,然后enter操作
     */
    private void keyPressWithCtrl(Robot r) throws InterruptedException {
        r.keyPress(KeyEvent.VK_CONTROL);
        r.keyPress(KeyEvent.VK_V);
        r.keyRelease(KeyEvent.VK_V);
        r.keyRelease(KeyEvent.VK_CONTROL);
        Thread.sleep(1000);
        r.keyPress(KeyEvent.VK_ENTER);
        r.keyRelease(KeyEvent.VK_ENTER);
    }

    /*
     * 对付上传按钮方法
     */
    private  void upload(String image) throws AWTException, InterruptedException {
        Robot robot = new Robot();
        keyPressString(robot, image);
    }

    @Override
    public void frame(String FrameName) {
        driver.switchTo().frame(FrameName);
    }
}