Selenium WebDriver 如何解决过时的元素引用异常？

StaleElementReferenceException 是由于 findelement 方法访问的元素不可用。

在对元素执行任何操作之前，您需要确保（如果您对该元素的可用性有疑问）

等待元素的可见性

(new WebDriverWait(driver, 10)).until(new ExpectedCondition()
    {
           public Boolean apply(WebDriver d) {
              return d.findElement(By.name("createForm:dateInput_input")).isDisplayed();
     }});

或者，使用此逻辑来验证元素是否存在。

首先，让我们弄清楚什么是 WebElement。

WebElement 是对 DOM 中元素的引用。

当正在交互的元素被销毁，然后重新创建时，将引发 StaleElementException。如今，大多数复杂的网页都会在用户与它交互时动态移动内容，这需要销毁和重新创建 DOM 中的元素。

发生这种情况时，您以前拥有的对 DOM 中元素的引用将变得过时，并且您不再能够使用此引用与 DOM 中的元素进行交互。发生这种情况时，您将需要刷新您的引用，或者在现实世界中再次查找元素。

这不是问题。如果将 .findElement 调用包装在 try-catch 块中并捕获 StaleElementReferenceException ，则可以根据需要多次循环并重试，直到成功。

以下是我写的一些例子。

Selenide 项目的另一个例子：

public static final Condition hidden = new Condition("hidden", true) {
    @Override
    public boolean apply(WebElement element) {
      try {
        return !element.isDisplayed();
      } catch (StaleElementReferenceException elementHasDisappeared) {
        return true;
      }
    }
  };

使用 Selenium 提供的预期条件等待 WebElement。

调试时，客户端的速度不如仅运行单元测试或 maven 生成快。 这意味着在调试模式下，客户端有更多时间来准备元素，但如果构建运行相同的代码，则速度要快得多，并且您查找的 WebElement 可能在页面的 DOM 中不可见。

相信我，我遇到了同样的问题。

例如：

inClient.waitUntil(ExpectedConditions.visibilityOf(YourElement,2000))

这个简单的方法在他调用后调用等待 2 秒钟，以显示 DOM 上 WebElement 的可见性。

这对我有用（来源在这里）：

 /**
     * Attempts to click on an element multiple times (to avoid stale element
     * exceptions caused by rapid DOM refreshes)
     *
     * @param d
     *            The WebDriver
     * @param by
     *            By element locator
     */
    public static void dependableClick(WebDriver d, By by)
    {
        final int MAXIMUM_WAIT_TIME = 10;
        final int MAX_STALE_ELEMENT_RETRIES = 5;

        WebDriverWait wait = new WebDriverWait(d, MAXIMUM_WAIT_TIME);
        int retries = 0;
        while (true)
        {
            try
            {
                wait.until(ExpectedConditions.elementToBeClickable(by)).click();

                return;
            }
            catch (StaleElementReferenceException e)
            {
                if (retries < MAX_STALE_ELEMENT_RETRIES)
                {
                    retries++;
                    continue;
                }
                else
                {
                    throw e;
                }
            }
        }
    }

WebDriver 必须等到找到 Element 并且超时在 10 秒后。

WebElement myDynamicElement1 = new WebDriverWait(driver, 10).until(
    ExpectedConditions.presenceOfElementLocated(
        By.name("createForm:dateInput_input")
    )
);

尝试等待这样的元素：

// Waiting 30 seconds for an element to be present on the page, checking
// for its presence once every 5 seconds.
Wait<WebDriver> stubbornWait = new FluentWait<WebDriver>(driver)
    .withTimeout(30, SECONDS)
    .pollingEvery(5, SECONDS)
    .ignoring(NoSuchElementException.class)
    .ignoring(StaleElementReferenceException.class);

WebElement foo = stubbornWait.until(new Function<WebDriver, WebElement>() {
    public WebElement apply(WebDriver driver) {
        return driver.findElement(By.id("foo"));
    }
});

发生在我身上的是，webdriver 会找到对 DOM 元素的引用，然后在获得该引用后的某个时候，javascript 会删除该元素并重新添加它（因为页面基本上正在重绘）。

试试这个。找出导致 dom 元素从 DOM 中删除的操作。就我而言，这是一个异步 ajax 调用，当 ajax 调用完成时，该元素将从 DOM 中删除。在执行该操作后，立即等待元素过时：

... do a thing, possibly async, that should remove the element from the DOM ...
wait.until(ExpectedConditions.stalenessOf(theElement));

此时，您确定该元素现在已经过时。因此，下次引用该元素时，请再次等待，这次等待它被重新添加到 DOM 中：

wait.until(ExpectedConditions.presenceOfElementLocated(By.id("whatever")))

我建议不要将 Selenium WebDriver 用于 .@CachelookUpStaleElementReferenceException

如果您使用的是注释并且有 ，只需将其注释掉并检查即可。@FindBy@CacheLookUp

如果我们不确定答案，请不要混淆别人。对于最终用户来说，这是非常令人沮丧的。简单而简短的回答是 在 WebDriver 中使用 @CacheLookup 注释。请参阅以下链接。@CacheLookup如何在 WebDriver 中工作？

我已经用下面的代码解决了这个问题。

public WebElement waitForElement(final By findBy, final int waitTime) {
    Wait<AppiumDriver> wait = new FluentWait<>((AppiumDriver) driver)
            .withTimeout(waitTime, TimeUnit.SECONDS)
            .pollingEvery(POLL_TIME, TimeUnit.SECONDS)
            .ignoring(NoSuchElementException.class,StaleElementReferenceException.class);

    WebElement webElement = wait.until(new Function<AppiumDriver, WebElement>() {
        @Override
        public WebElement apply(AppiumDriver driver) {
            System.out.println("Trying to find element " + findBy.toString());                
            WebElement element = driver.findElement(findBy);
            return element;
        }
    });
    return webElement;
}

在带有 for 循环的 try catch 块中使用 webdriverwait 和 ExpectedCondition EX：用于 python

for i in range(4):
    try:
        element = WebDriverWait(driver, 120).until( \
                EC.presence_of_element_located((By.XPATH, 'xpath')))
        element.click()    
        break
    except StaleElementReferenceException:
        print "exception "

参考 @djangofan 给出的答案，看起来可行的解决方案是将代码保留在可能发生过时的块中。当我使用下面的代码时，我没有遇到任何问题。try catch

public void inputName(String name)
{
    try {
        waitForVisibilityElement(name);//My own visibility function
        findElement(By.name("customerName")).sendKeys(name);
    }
    catch (StaleElementReferenceException e)
    {
        e.getMessage();
    }
}

我尝试过使用 但过时异常仍然间歇性地抛出。ExpectedConditions.presenceOfElementLocated(By)

希望这个解决方案有所帮助。

这个解决方案对我来说效果很好：

添加错误处理功能，然后重试

var pollLoop = function () {
      element(by.id('spinnerElem')).getAttribute('class').then(function (cls) {
                if (cls.indexOf('spinner-active') > -1) {
                    // wait for the spinner
                } else {
                    //do your logic
                    promise.defer().fulfill();
                }
            }, function () {
                // This err handling function is to handle the {StaleElementReferenceError} and makes sure we find the element always.
                pollLoop();
            });
        };

陈旧元素的两个原因

1. 在网页上找到的元素，在 WebDriver 中引用为 WebElement，然后 DOM 更改（可能是由于 JavaScript 函数），WebElement 会过时。

2. 该元素已被完全删除。

当您尝试与过时的 WebElement[上述任何情况] 交互时，将引发 StaleElementException。

如何避免/解决过时的异常？

1. 将定位器存储到元素而不是参考

driver = webdriver.Firefox();
driver.get("http://www.github.com");
search_input = lambda: driver.find_element_by_name('q');
search_input().send_keys('hello world\n'); 
time.sleep(5);


search_input().send_keys('hello frank\n') // no stale element exception

2. 利用所用 JS 库中的钩子

   # Using Jquery queue to get animation queue length.
    animationQueueIs = """
    return $.queue( $("#%s")[0], "fx").length;
    """ % element_id
    wait_until(lambda: self.driver.execute_script(animationQueueIs)==0)

3. 将您的操作移动到 JavaScript 注入中

 self.driver.execute_script("$(\"li:contains('Narendra')\").click()");

4. 主动等待元素过时

  # Wait till the element goes stale, this means the list has updated
  wait_until(lambda: is_element_stale(old_link_reference))

这个解决方案对我有用，如果您有任何其他适合您的情况，我在这里提到过，请在下面发表评论

在对问题进行深入调查后，我发现选择仅为 Bootstrap 添加的 DIV 元素时会出现错误。Chrome 浏览器删除了此类 DIV，并发生错误。下台并选择实际元素来修复错误就足够了。例如，我的模式对话框具有结构：

<div class="modal-content" uib-modal-transclude="">
    <div class="modal-header">
        ...
    </div>
    <div class="modal-body">
        <form class="form-horizontal ...">
            ...
        </form>
    <div>
<div>

选择 div class=“modal-body” 会生成错误，选择 form ... 会正常工作。

就我而言，此错误是由于我在

def parse(self, response):

当使用Selenium和Scrapy的组合时的方法，例如：

不起作用：

class MySpider(scrapy.Spider):
     action_chains = ActionChains(self.driver)

向内移动解决了问题，例如：action_chains = ActionChains(self.driver)def parse(self, response):

工程：

def parse(self, response):
     self.driver.get(response.url)
     action_chains = ActionChains(self.driver)

只需下载新的 chrome 扩展程序并使用 selenium server 3 即可正常工作。

我发现避免过时元素引用的最好方法是不使用 PageFactory，而是存储定位器（即按元素）。

public class WebDriverFactory {

    // if you want to multithread tests, use a ThreadLocal<WebDriver> 
    // instead.
    // This also makes it so you don't have to pass around WebDriver objects
    // when instantiating new Page classes
    private static WebDriver driver = null;

    public static WebDriver getDriver() {
       return driver;
    }
    public static void setDriver(WebDriver browser)  {
       driver = browser;
    }       
}

// class to let me avoid typing out the lengthy driver.findElement(s) so 
// much
public Abstract class PageBase {
    private WebDriver driver = WebDriverFactory.getDriver();

    // using var args to let you easily chain locators
    protected By getBy(By... locator) {
      return new ByChained(locator);
    }

    protected WebElement find(By... locators) {
      return driver.findElement(getBy(locators));
    }

    protected List<WebElement> findEm(By... locators) {
      return driver.findElements(getBy(locators));
    }

    protected Select select(By... locators) {
      return new Select(getBy(locators));
    }
}

public class somePage extends PageBase {
  private static WebDriver driver = WebDriverFactory.getDriver();
  private static final By buttonBy = By.cssSelector(".btn-primary");

  public void clickButton() {
     WebDriverWait wait = new WebDriverWait(driver, 10);
     wait.until(ExpectedConditions.elementToBeClickable(buttonBy));
     find(buttonBy).click();
  }

}

我有一个充满静态 WebDriverWait 方法的类。而且我不记得上面使用的 WebDriver wait 是否会处理 StaleElement 异常。如果没有，你可以像 DjangoFan 的回答一样使用流畅的等待。但是我展示的原理会起作用（即使带有 WebDriverWait 的特定行爆炸了。

所以 tldr;

1. 使用定位符，以及 WebDriverWait/Fluent wait/ 的组合，自己重新定位元素，所以如果你的元素过时了，你可以重新定位它，而不必在（对于 pagefactory 初始化的元素）中复制定位符，因为没有 WebElement.relocate（） 方法。@FindBy
2. 为了简化生活，有一个 Abstract BasePage 类，其中包含用于查找元素/元素列表的便捷方法。

我尝试了上述许多建议，但最简单的建议奏效了。就我而言，对 Web 元素使用 @CachelookUp 导致了过时的元素异常。我猜刷新页面后，元素引用没有重新加载，找不到元素。禁用元素的@CachelookUp行有效。

    //Search button
    @FindBy(how=How.XPATH, using =".//input[@value='Search']")  
    //@CachelookUp
    WebElement BtnSearch;

当发生过时元素异常时！！

当支持这些文本框/按钮/链接的库发生更改时，可能会发生过时元素异常，这意味着元素相同，但引用现在在网站中已更改，而不会影响定位器。因此，我们存储在缓存中的引用（包括库引用）现在已经过时或过时了，因为页面已使用更新的库刷新。

for(int j=0; j<5;j++)
try {
    WebElement elementName=driver.findElement(By.name(“createForm:dateInput_input”));
    break;
} catch(StaleElementReferenceException e){
e.toString();
System.out.println(“Stale element error, trying ::  ” + e.getMessage());
}
elementName.sendKeys(“20/06/2018”);

在 Selenium 3 中，您可以使用 ExpectedConditions.refreshed（your condition）。

它将处理 StaleElementReferenceException 并重试该条件。