@FindBy()与driver.findElement()性能对比及选型建议

Great question! Let's break down these two element-locating approaches in Selenium, so you can make the best call for your automation workflow.

First, Let's Clarify How Each Works #

driver.findElement() #

• This is an immediate lookup: every time you call this method, Selenium immediately hits the DOM to find the element right then and there.
• It's straightforward and no-frills—perfect for quick scripts, one-off tests, or debugging sessions where you don't want to set up extra structure.
• Example code:

  WebElement submitButton = driver.findElement(By.id("submit-btn"));
  submitButton.click();
  

@FindBy() (Page Factory) #

• This uses lazy loading by default: the element isn't looked up when your page class initializes. Instead, Selenium waits until you actually interact with the element (like calling click() or sendKeys()) to fetch it from the DOM.
• It's a core part of Selenium's Page Object Model (POM)—the industry best practice for organizing test code. It keeps your element locators centralized in page classes, separating them from test logic, which makes maintenance way easier as your suite grows.
• Example code:

  import org.openqa.selenium.WebElement;
  import org.openqa.selenium.support.FindBy;
  import org.openqa.selenium.support.PageFactory;
  
  public class LoginPage {
      public LoginPage(WebDriver driver) {
          // Initialize elements with Page Factory
          PageFactory.initElements(driver, this);
      }
  
      @FindBy(id = "submit-btn")
      private WebElement submitButton;
  
      public void submitLogin() {
          submitButton.click(); // Element is located here, not during initialization
      }
  }
  

What About the "Faster Execution" Claim? #

A common myth is that @FindBy() is inherently faster—but that's not entirely accurate:

• For single-use elements, the speed difference is negligible. Both approaches use the same underlying Selenium logic to locate elements; the only difference is when the lookup happens (immediately vs. on first interaction).
• Where @FindBy() can shine is with repeated element use. If you add the @CacheLookup annotation alongside @FindBy(), Selenium will cache the element after the first lookup, avoiding repeated DOM queries. This can definitely speed up tests that interact with the same element multiple times.

So Which Should You Pick? #

Here's a quick decision guide:

• Use @FindBy() if:
  • You're following the Page Object Model (you should be, for scalable test suites)
  • You want cleaner, more maintainable code with centralized locators
  • You need to reuse elements multiple times (pair with @CacheLookup for speed boosts)
  • You want to leverage advanced locator combinations like @FindBys or @FindAll for complex DOM structures
• Use driver.findElement() if:
  • You're writing a small, throwaway script or debugging
  • You don't want to set up Page Factory initialization
  • You need immediate element validation (e.g., checking if an element exists right away)

Final Takeaway #

Raw speed rarely makes this decision for you—it's all about project structure and long-term maintainability. For most professional automation projects, @FindBy() with Page Factory is the clear winner because it keeps your code organized and easy to update. driver.findElement() is a great tool for quick tasks, but it doesn't scale as well for larger suites.

内容的提问来源于stack exchange，提问作者jeetpal