点赞，书写条理很清晰，期待后续。

有道理~多谢~

waitForElement(elementLocator) 等待元素出现 500ms 扫描一次 把登陆后的一个标志元素写进去就好了

您说的 waitForElement(elementLocator) 是指把我的代码中 wait.until(ExpectedConditions.visibilityOf(webElement)) 那部分代码封装成一个单独的方法吗？如果我理解的没错的话，这个当然可以。
只是我的问题是，是否有一个方法可以做到：点击一个 button->页面跳转到全新页面，这个新页面加载过程中程序是 block 住的，就像 get(url) 打开全新页面那样，只有等到页面加载完成才会进入下一步。这样的话下一步检查标志元素没有出现，我们就可以判断新页面打开的不对，而不用担心等待时间不够元素还没有完全加载。

看样子你还是没好好琢磨透 webdriver 怎么工作的啊，给你个样例你看下：
每一步操作，工具都会自动等到你设置的超时时间（pageLoadTimeout、implicitlyWait）过了才会继续判定为失败，在此时间内会自动轮询检查的
对 ajax 局部刷新，一样有效

@Override
public void startWebDriver() {
    cleanBrowserProcess();
    try {
        initWebDriver();
        driver.manage().timeouts().pageLoadTimeout(maxLoadTime, TimeUnit.SECONDS);
        driver.manage().timeouts().setScriptTimeout(maxWaitfor, TimeUnit.SECONDS);
        driver.manage().timeouts().implicitlyWait(maxWaitfor, TimeUnit.SECONDS);
        driver.manage().window().maximize();
    } catch (Exception e) {
        LoggerUtils.error(e);
        throw new RuntimeException(e);
    }
}

pageLoadTimeout 这个设置之前我确实没有注意到，就我刚刚查找的相关的 selenium issues 来看，这个设置在 selenium 3 和 FF55 以下的版本存在 bug。更新到最新的 FF 和 selenium 就可以设置了。

我试了在 click 命令之前更改这个参数，确实会产生 “org.openqa.selenium.TimeoutException: Timed out waiting for page load.”。

但是，click 这个命令，官方文档里写的是 “If this causes a new page to load, you should discard all references to this element and any further operations performed on this element will throw a StaleElementReferenceException. Note that if click() is done by sending a native event (which is the default on most browsers/platforms) then the method will not wait for the next page to load and the caller should verify that themselves.”，这难道不是说它不会受设置的超时时间的限制吗？然后我就糊涂了。。。

我还是个新手，肯定还有很多理解不到的地方，请多多指教~

参考一下：http://www.it1352.com/313066.html
实际操作起来，我发现其实这种操作在【效果上】还是阻塞的，并非异步
为什么呢？换个角度思考，有了这个 timeout，你在下一个 page 加载完成之前的任何操作（包括断言），也会有同样的超时设置作用于对你的 element 的加载等待，除非你故意在下一步操作之前把超时时间设置为 1s 或者更短~
所以我在脚本中基本不动这个设置，只有在初始化的时候通过全局设置一下，结合自己系统、环境的性能表现即可。

不知道为什么要想的如此复杂，selenium 提供的方法就可以解决啊。

WebDriverWait(webDriver, Integer.valueOf(iTimeout))
                        .until(ExpectedConditions.presenceOfElementLocated(webelement(ID,xpath,name,css等等));

这个方法用于，动态等待对象出现，如果在设置的时间段内没有出现，即返回 false。
所以，你用 get(url) 之后，直接加上这个方法，判断跳转的登录页面是否出现了某元素。
贴一段我的登录代码：

/**
 * 登录
 * 
 */
public void login(String url, String email, String pwd) {
    // 打开登录网址
    webManager.NavigateTo(url);
    webManager.threadWait(3);
    // 浏览器最大化
    webManager.maximizeBroswer();
    webManager.threadWait(1);
    // 等待登录页面用户名输入框出现，60秒未出现则按超时处理
    webManager.dynamicWaitAppear(WebElementType.ID, "email", 60);
    // 输入用户名
    webManager.sendKeys(WebElementType.ID, "email", email);
    webManager.threadWait(1);
    // 输入密码
    webManager.sendKeys(WebElementType.ID, "pwd", pwd);
    webManager.threadWait(1);
    // 输入验证码
    webManager.sendKeys(WebElementType.ID, "jcaptcha", "1");
    webManager.threadWait(1);
    // 单击登录按钮
    webManager.click(WebElementType.ID, "login");
    webManager.threadWait(2);
}

这是等待对象出现的方法：

/**
     * 等待对象出现
     * 
     * @param type
     *            对象类型：id,name,css,xpath,class,linktext,tagname,partialLinkText
     * @param value
     *            对象的值
     * @param iTimeout
     *            超时时间
     * @return FALSE：对象未在规定时间内出现 TRUE：对象在规定时间内出现
     */
    public boolean dynamicWaitAppear(WebElementType type, String value, Integer iTimeout) {
        try {
            switch (type) {
            case ID:
                new WebDriverWait(webDriver, Integer.valueOf(iTimeout))
                        .until(ExpectedConditions.presenceOfElementLocated(By.id(value)));
                break;
            case NAME:
                new WebDriverWait(webDriver, Integer.valueOf(iTimeout))
                        .until(ExpectedConditions.presenceOfElementLocated(By.name(value)));
                break;
            case CSS:
                new WebDriverWait(webDriver, Integer.valueOf(iTimeout))
                        .until(ExpectedConditions.presenceOfElementLocated(By.cssSelector(value)));
                break;
            case XPATH:
                new WebDriverWait(webDriver, Integer.valueOf(iTimeout))
                        .until(ExpectedConditions.presenceOfElementLocated(By.xpath(value)));
                break;
            case CLASS:
                new WebDriverWait(webDriver, Integer.valueOf(iTimeout))
                        .until(ExpectedConditions.presenceOfElementLocated(By.className(value)));
                break;
            case LINKTEXT:
                new WebDriverWait(webDriver, Integer.valueOf(iTimeout))
                        .until(ExpectedConditions.presenceOfElementLocated(By.linkText(value)));
                break;
            case TAGNAME:
                new WebDriverWait(webDriver, Integer.valueOf(iTimeout))
                        .until(ExpectedConditions.presenceOfElementLocated(By.tagName(value)));
                break;
            case PARTIALLINKTEXT:
                new WebDriverWait(webDriver, Integer.valueOf(iTimeout))
                        .until(ExpectedConditions.presenceOfElementLocated(By.partialLinkText(value)));
                break;
            default:
                break;
            }

            String message = "等待对象" + value + "出现成功.";
            LogHelper.LogMessage(Variable.DONE, "WebManager.DynamicWaitAppear", message);
        } catch (Exception ex) {
            String screenshot = LogHelper.Capscreenshot();
            String message = "等待对象" + value + "出现失败.错误详情请见：" + screenshot;
            LogHelper.LogMessage(Variable.FAILD, "WebManager.DynamicWaitAppear", message);
            softAssert.assertFalse(true);
        }
        return true;
    }

单步等待的 API 封装，一般不赞成这么用

/**
   * Description: set element locate timeout.</BR> 
   * 内容描述：设置对象查找超时时间.
   *
   * @param seconds
   *            timeout in timeunit of seconds.
   */
  protected void setElementLocateTimeout(int seconds) {
      driver.manage().timeouts().implicitlyWait(seconds, TimeUnit.SECONDS);
  }

  /**
   * wait for the element visiable in timeout setting</BR> 
   * 在指定时间内等待，直到对象可见。
   *
   * @param by
   *            the element locator By
   * @param seconds
   *            timeout in seconds
   */
  protected boolean waitForElementVisible(By by, int seconds) {
      try {
          setElementLocateTimeout(seconds);
          WebDriverWait wait = new WebDriverWait(driver, seconds, stepTimeUnit);
          return wait.until(ExpectedConditions.visibilityOfElementLocated(by)) != null;
      } finally {
          setElementLocateTimeout(maxWaitfor);
      }
  }

  /**
   * wait for the element visiable in timeout setting</BR> 
   * 在指定时间内等待，直到对象可见。
   *
   * @param element
   *            the element to be found.
   * @param seconds
   *            timeout in seconds.
   */
  protected boolean waitForElementVisible(WebElement element, int seconds) {
      try {
          setElementLocateTimeout(seconds);
          WebDriverWait wait = new WebDriverWait(driver, seconds, stepTimeUnit);
          return wait.until(ExpectedConditions.visibilityOf(element)) != null;
      } finally {
          setElementLocateTimeout(maxWaitfor);
      }
  }

  /**
   * wait for the element not visiable in timeout setting</BR>
   * 在指定时间内等待，直到对象不可见。
   *
   * @param by
   *            the element locator.
   * @param seconds
   *            timeout in seconds.
   */
  protected boolean waitForElementNotVisible(By by, int seconds) {
      try {
          setElementLocateTimeout(seconds);
          WebDriverWait wait = new WebDriverWait(driver, seconds, stepTimeUnit);
          return wait.until(ExpectedConditions.invisibilityOfElementLocated(by)) != null;
      } finally {
          setElementLocateTimeout(maxWaitfor);
      }
  }

  /**
   * wait for the element present in timeout setting</BR> 
   * 在指定时间内等待，直到对象出现在页面上。
   *
   * @param by
   *            the element locator.
   * @param seconds
   *            timeout in seconds.
   */
  protected boolean waitForElementPresent(By by, int seconds) {
      try {
          setElementLocateTimeout(seconds);
          WebDriverWait wait = new WebDriverWait(driver, seconds, stepTimeUnit);
          return wait.until(ExpectedConditions.presenceOfElementLocated(by)) != null;
      } finally {
          setElementLocateTimeout(maxWaitfor);
      }
  }

  /**
   * wait for the element clickable in timeout setting</BR>
   * 在指定时间内等待，直到对象能够被点击。
   *
   * @param by
   *            the element locator By
   * @param seconds
   *            timeout in seconds
   */
  protected boolean waitForElementClickable(By by, int seconds) {
      try {
          setElementLocateTimeout(seconds);
          WebDriverWait wait = new WebDriverWait(driver, seconds, stepTimeUnit);
          return wait.until(ExpectedConditions.elementToBeClickable(by)) != null;
      } finally {
          setElementLocateTimeout(maxWaitfor);
      }
  }

  /**
   * wait for text appears on element in timeout setting</BR>
   * 在指定时间内等待，直到指定对象上出现指定文本。
   *
   * @param by
   *            the element locator By
   * @param text
   *            the text to be found of element
   * @param seconds
   *            timeout in seconds
   */
  protected boolean waitForTextOnElement(By by, String text, int seconds) {
      try {
          setElementLocateTimeout(seconds);
          WebDriverWait wait = new WebDriverWait(driver, seconds, stepTimeUnit);
          return wait.until(ExpectedConditions.textToBePresentInElementLocated(by, text)) != null;
      } finally {
          setElementLocateTimeout(maxWaitfor);
      }
  }

  /**
   * wait for text appears in element attributes in timeout setting</BR>
   * 在指定时间内等待，直到指定对象的某个属性值等于指定文本。
   *
   * @param by
   *            the element locator By
   * @param text
   *            the text to be found in element attributes
   * @param seconds
   *            timeout in seconds
   */
  protected boolean waitForTextOfElementAttr(By by, String text, int seconds) {
      try {
          setElementLocateTimeout(seconds);
          WebDriverWait wait = new WebDriverWait(driver, seconds, stepTimeUnit);
          return wait.until(ExpectedConditions.textToBePresentInElementValue(by, text)) != null;
      } finally {
          setElementLocateTimeout(maxWaitfor);
      }
  }