1. 项目概述：为什么是Selenium与TestNG的组合？

如果你正在为Web应用的回归测试、兼容性测试或者大规模功能验证而头疼，手动点点点不仅效率低下，还容易出错，那么自动化测试几乎是必经之路。在众多工具中，Selenium和TestNG的组合，可以说是Java技术栈下进行Web UI自动化测试的“黄金搭档”。我见过不少团队从零开始搭建，也踩过不少坑，今天就把这套实战经验梳理出来。

简单来说，Selenium负责“做动作”——模拟用户在浏览器里的所有操作，比如点击、输入、跳转。而TestNG则负责“管流程”——它决定了测试用例以什么顺序、什么方式（并行还是串行）、在什么条件下执行，并生成清晰详尽的测试报告。这个组合的强大之处在于，它将灵活的浏览器操控能力与强大的测试管理和组织能力结合在了一起，让你能像写业务代码一样，结构化、规模化地编写和维护你的自动化测试脚本。无论是测试一个简单的登录功能，还是一个包含上百个页面的电商流程，这套框架都能很好地支撑。

2. 环境搭建与核心依赖配置

工欲善其事，必先利其器。搭建一个稳定、可复用的自动化测试环境是第一步，这里面的细节直接决定了后续脚本是顺畅运行还是处处报错。

2.1 基础环境准备

首先，你需要一个Java开发环境。我推荐使用JDK 8或11，这两个是长期支持版本，社区资源丰富，与各种库的兼容性也最好。安装后，记得配置好 JAVA_HOME 环境变量。接下来是构建工具，Maven是首选。它不仅能帮你轻松管理项目依赖（Selenium、TestNG、WebDriver管理器等），还能统一项目的结构和构建流程。在项目的 pom.xml 文件中，我们需要引入核心依赖。

2.2 Maven依赖详解

下面是一个典型的 pom.xml 依赖配置，我会逐项解释为什么这么选：

<dependencies>
    <!-- Selenium Java Client: 核心操作库 -->
    <dependency>
        <groupId>org.seleniumhq.selenium</groupId>
        <artifactId>selenium-java</artifactId>
        <version>4.14.0</version> <!-- 建议使用较新稳定版 -->
    </dependency>

    <!-- TestNG: 测试框架 -->
    <dependency>
        <groupId>org.testng</groupId>
        <artifactId>testng</artifactId>
        <version>7.8.0</version>
        <scope>test</scope>
    </dependency>

    <!-- WebDriverManager: 自动管理浏览器驱动 -->
    <dependency>
        <groupId>io.github.bonigarcia</groupId>
        <artifactId>webdrivermanager</artifactId>
        <version>5.6.0</version>
    </dependency>

    <!-- Log4j2: 日志记录，便于调试 -->
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.20.0</version>
    </dependency>
</dependencies>
  • Selenium Java : 这是主体，提供了所有与浏览器交互的API。
  • TestNG : 测试执行和管理的核心。
  • WebDriverManager : 这是一个“神器”。以前我们需要手动下载ChromeDriver、GeckoDriver，还要考虑与浏览器版本的匹配，非常麻烦。WebDriverManager可以在运行时自动检测系统已安装的浏览器版本，并下载匹配的驱动，极大简化了环境配置。
  • Log4j2 : 在自动化测试中，详细的日志是排查问题的生命线。当测试在无人值守的服务器上失败时，清晰的日志能帮你快速定位是页面元素没加载出来，还是网络超时，或是断言条件不满足。

2.3 编写第一个测试基类

环境准备好后，我们先不急着写具体业务测试，而是创建一个所有测试用例的“基类”（BaseTest）。这个类负责初始化WebDriver和清理资源，保证每个测试用例都在一个干净、独立的环境中开始。

import io.github.bonigarcia.wdm.WebDriverManager;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import java.time.Duration;

public class BaseTest {
    protected WebDriver driver;

    @BeforeMethod
    public void setUp() {
        // 使用WebDriverManager自动设置ChromeDriver
        WebDriverManager.chromedriver().setup();

        // 配置Chrome选项（可选）
        ChromeOptions options = new ChromeOptions();
        options.addArguments("--start-maximized"); // 最大化窗口
        options.addArguments("--disable-infobars"); // 禁用“Chrome正受到自动测试软件控制”提示
        // options.addArguments("--headless"); // 无头模式，适用于CI/CD环境

        // 初始化驱动
        driver = new ChromeDriver(options);

        // 设置全局隐式等待（非必须，建议与显式等待配合使用）
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
        driver.manage().window().maximize();
    }

    @AfterMethod
    public void tearDown() {
        if (driver != null) {
            driver.quit(); // 使用quit()而非close()，确保彻底关闭浏览器进程
        }
    }
}

注意 ： driver.quit() 和 driver.close() 有本质区别。 close() 只关闭当前标签页，如果浏览器只开了一个标签，那效果类似；但如果有多个标签， close() 只关当前页。而 quit() 会关闭整个浏览器会话，并终止WebDriver进程，释放资源。在测试清理中， 务必使用 quit() ，否则后台可能会残留大量浏览器进程，耗尽内存。

3. 元素定位与页面操作：稳、准、狠

自动化测试的本质是模拟用户，而模拟的第一步就是找到页面上的元素。Selenium提供了多达8种定位方式，但并非所有都同样可靠。

3.1 定位策略优先级

根据我多年的经验，定位策略的优先级应该是这样的：

  1. ID ：唯一且稳定，定位速度最快。首选。
  2. Name ：常用于表单元素，也比较稳定。
  3. CSS Selector ：功能强大，语法灵活，性能优于XPath，是复杂定位的首选。例如通过属性定位： input[type='submit'] 。
  4. XPath ：功能最强大，可以遍历整个DOM树，但性能相对较差，且容易因页面结构微小变动而失效。应谨慎使用，尽量避免使用绝对路径（以 / 开头）。
  5. Link Text / Partial Link Text ：专门用于定位超链接。
  6. ClassName ：如果class是唯一的，可以用。但通常class用于样式，可能不唯一。
  7. TagName ：最不具体，通常需要结合其他条件使用。

在代码中，Selenium 4推荐使用 By 类进行定位：

// 推荐：使用By对象，清晰易读
driver.findElement(By.id("username")).sendKeys("testUser");
driver.findElement(By.cssSelector("button.login-btn")).click();

// 不推荐：使用过时的字符串参数形式（Selenium 4已废弃部分）
// driver.findElementById("username");

3.2 等待机制：自动化测试的“定海神针”

这是新手最容易栽跟头的地方。页面加载和元素渲染需要时间，如果脚本执行太快，就会抛出 NoSuchElementException 。Selenium提供了三种等待方式：

  1. 硬性等待（Thread.sleep） ： 绝对禁止在生产脚本中使用 。它固定死等待时间，无论页面是否加载完成，都会傻等，严重拖慢测试效率。
  2. 隐式等待（Implicit Wait） ：在 driver 的生命周期内设置一个全局等待时间。当查找元素时，如果元素没有立即出现，WebDriver会轮询查找，直到超时。它的问题是不够灵活，并且对某些条件（如元素可点击）无效。建议设置一个较短的时间（如5-10秒），作为兜底。
  3. 显式等待（Explicit Wait） ： 这是核心推荐方案 。它为某个特定条件设置等待，条件满足则立即继续，否则超时抛出异常。它更智能、更高效。
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import java.time.Duration;

// 创建一个最长等待10秒的WebDriverWait对象
WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));

// 等待元素可见并可点击，然后才进行点击操作
wait.until(ExpectedConditions.elementToBeClickable(By.id("submitBtn"))).click();

// 等待元素出现在DOM中（不一定可见）
wait.until(ExpectedConditions.presenceOfElementLocated(By.name("q")));

// 等待页面标题包含特定文字
wait.until(ExpectedConditions.titleContains("订单成功"));

实操心得 ：我通常将显式等待封装成一个工具方法，比如 waitForElementClickable(By locator) ，在业务页面对象中调用。这样既能复用代码，又能让测试脚本更清晰。永远不要相信页面会“瞬间”加载好，对任何后续操作的元素都加上合适的显式等待，是脚本稳定的关键。

3.3 常见页面操作与高级交互

掌握了定位和等待，就可以组合出各种用户操作了。

// 1. 输入与清除
WebElement searchBox = driver.findElement(By.name("q"));
searchBox.sendKeys("Selenium"); // 输入
searchBox.clear(); // 清除内容
searchBox.sendKeys("TestNG");

// 2. 点击与提交
driver.findElement(By.cssSelector("input[value='搜索']")).click();
// 或者，如果是一个表单内的提交按钮，有时可以
// searchBox.submit();

// 3. 获取元素状态和信息
WebElement checkbox = driver.findElement(By.id("agree"));
boolean isSelected = checkbox.isSelected();
boolean isDisplayed = checkbox.isDisplayed();
boolean isEnabled = checkbox.isEnabled();
String text = driver.findElement(By.tagName("h1")).getText();
String attribute = checkbox.getAttribute("type"); // 获取属性值

// 4. 下拉框处理（Select类）
Select dropdown = new Select(driver.findElement(By.id("country")));
dropdown.selectByVisibleText("中国"); // 根据文本选择
dropdown.selectByValue("CN"); // 根据value属性选择
dropdown.selectByIndex(1); // 根据索引选择

// 5. 鼠标悬停（Actions类）
Actions actions = new Actions(driver);
WebElement menu = driver.findElement(By.id("mainMenu"));
actions.moveToElement(menu).perform(); // 鼠标移动到元素上
// 然后可以操作出现的子菜单
WebElement subMenu = wait.until(ExpectedConditions.visibilityOfElementLocated(By.linkText("子项")));
subMenu.click();

// 6. 处理JavaScript弹窗（Alert）
driver.findElement(By.id("triggerAlert")).click();
Alert alert = driver.switchTo().alert(); // 切换到弹窗
String alertText = alert.getText(); // 获取弹窗文本
alert.accept(); // 点击“确定”
// alert.dismiss(); // 点击“取消”

4. TestNG测试组织与管理艺术

TestNG远不止一个 @Test 注解那么简单。它提供了一套完整的测试生命周期管理和分组机制，能让你的测试套件井然有序。

4.1 基础注解与测试生命周期

理解以下注解的执行顺序至关重要：

import org.testng.annotations.*;
public class LifecycleTest {

    @BeforeSuite
    public void beforeSuite() {
        System.out.println("BeforeSuite: 在整个测试套件开始前执行一次，适合做全局初始化");
    }

    @BeforeTest
    public void beforeTest() {
        System.out.println("BeforeTest: 在<test>标签内的所有类开始前执行");
    }

    @BeforeClass
    public void beforeClass() {
        System.out.println("BeforeClass: 在当前测试类的第一个测试方法前执行一次");
    }

    @BeforeMethod
    public void beforeMethod() {
        System.out.println("BeforeMethod: 在每个@Test方法前执行，我们的BaseTest.setUp()通常放这里");
    }

    @Test(groups = "smoke")
    public void testCase1() {
        System.out.println("这是冒烟测试用例1");
        Assert.assertEquals(1, 1);
    }

    @Test(dependsOnMethods = "testCase1")
    public void testCase2() {
        System.out.println("这个测试依赖于testCase1，只有它成功了才会运行");
    }

    @AfterMethod
    public void afterMethod() {
        System.out.println("AfterMethod: 在每个@Test方法后执行，清理资源如driver.quit()");
    }

    @AfterClass
    public void afterClass() { /* ... */ }
    @AfterTest
    public void afterTest() { /* ... */ }
    @AfterSuite
    public void afterSuite() { /* ... */ }
}

依赖关系（dependsOnMethods/groups） 可以确保测试执行的逻辑顺序，比如必须先登录才能执行后续操作。但要小心形成过长的依赖链，一个早期测试失败会导致后面大量测试被跳过。

4.2 参数化测试：数据驱动

这是TestNG最强大的功能之一。你可以将测试数据与测试逻辑分离，用同一段代码测试多组数据。

方法一：通过 @DataProvider 

@Test(dataProvider = "loginData")
public void testLoginWithMultipleUsers(String username, String password, boolean expectedSuccess) {
    loginPage.login(username, password);
    if (expectedSuccess) {
        Assert.assertTrue(homePage.isUserLoggedIn());
    } else {
        Assert.assertTrue(loginPage.isErrorDisplayed());
    }
}

@DataProvider(name = "loginData")
public Object[][] provideLoginData() {
    return new Object[][] {
        {"correctUser", "correctPass", true}, // 正确用户
        {"wrongUser", "correctPass", false},  // 错误用户
        {"correctUser", "", false},           // 密码为空
        // 可以从Excel、CSV、数据库读取数据
    };
}

方法二：通过 testng.xml 文件参数化 在 testng.xml 中定义参数：

<suite name="MySuite">
    <test name="ParameterTest">
        <parameter name="browser" value="chrome" />
        <parameter name="env" value="staging" />
        <classes>
            <class name="com.test.MyTest" />
        </classes>
    </test>
</suite>

在测试类中获取参数：

@Parameters({"browser", "env"})
@BeforeMethod
public void setup(@Optional("chrome") String browser, @Optional("dev") String env) {
    // 根据browser参数初始化不同的WebDriver
    // 根据env参数连接不同的测试环境地址
}

4.3 分组与并行执行

分组（Groups） 让你能对测试用例进行分类，比如 smoke （冒烟）、 regression （回归）、 integration （集成）。然后你可以选择只运行某一组测试。

@Test(groups = {"smoke", "fast"})
public void quickSmokeTest() { /* ... */ }

@Test(groups = {"regression", "slow"})
public void comprehensiveTest() { /* ... */ }

在 testng.xml 中控制：

<groups>
    <run>
        <include name="smoke" /> <!-- 只运行冒烟测试 -->
        <!-- <exclude name="slow" /> 排除慢速测试 -->
    </run>
</groups>

并行执行 能大幅缩短测试总耗时。在 testng.xml 的 <suite> 标签中配置：

<suite name="Parallel Suite" parallel="tests" thread-count="3">
<!-- parallel可选值：tests, classes, methods, instances -->
  • parallel="methods" : 每个测试方法在自己的线程中运行。 需要特别注意线程安全 ，每个测试方法必须使用独立的 WebDriver 实例，绝对不能共享，否则会出现不可预知的交互错误。我们的 BaseTest 中 @BeforeMethod 和 @AfterMethod 为每个方法创建和销毁driver，正是为了支持这种模式。

5. 构建可维护的页面对象模型（Page Object Model, POM）

当你有超过10个测试用例时，如果还在每个用例里直接写 findElement 和 click ，维护将是一场噩梦。页面对象模型是解决这个问题的标准设计模式。

5.1 POM核心思想

POM的核心是将一个页面的元素定位和操作封装成一个独立的类（Page Object）。测试用例类只关心业务逻辑（“做什么”），而不关心具体实现细节（“怎么做”）。

一个简单的登录页面对象示例： 

// LoginPage.java
public class LoginPage {
    private WebDriver driver;
    private WebDriverWait wait;

    // 1. 定义页面元素定位器（By对象）
    private By usernameInput = By.id("username");
    private By passwordInput = By.id("password");
    private By loginButton = By.cssSelector("button[type='submit']");
    private By errorMessage = By.className("alert-error");

    // 2. 构造函数，接收驱动
    public LoginPage(WebDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(10));
    }

    // 3. 封装页面操作（方法）
    public void enterUsername(String username) {
        wait.until(ExpectedConditions.visibilityOfElementLocated(usernameInput)).sendKeys(username);
    }

    public void enterPassword(String password) {
        driver.findElement(passwordInput).sendKeys(password);
    }

    public void clickLogin() {
        wait.until(ExpectedConditions.elementToBeClickable(loginButton)).click();
    }

    // 一个组合业务方法：登录
    public HomePage loginWith(String username, String password) {
        enterUsername(username);
        enterPassword(password);
        clickLogin();
        return new HomePage(driver); // 通常返回下一个页面的对象
    }

    // 获取页面状态
    public boolean isErrorMessageDisplayed() {
        return wait.until(ExpectedConditions.visibilityOfElementLocated(errorMessage)).isDisplayed();
    }

    public String getErrorMessageText() {
        return driver.findElement(errorMessage).getText();
    }
}

对应的测试用例变得非常简洁： 

// LoginTest.java
public class LoginTest extends BaseTest {
    @Test
    public void testSuccessfulLogin() {
        LoginPage loginPage = new LoginPage(driver);
        // 直接访问测试环境地址
        driver.get("https://staging.example.com/login");

        HomePage homePage = loginPage.loginWith("validUser", "validPass");
        Assert.assertTrue(homePage.isWelcomeMessageShown());
    }

    @Test(dataProvider = "invalidCredentials")
    public void testLoginFailure(String user, String pass, String expectedError) {
        LoginPage loginPage = new LoginPage(driver);
        driver.get("https://staging.example.com/login");

        loginPage.loginWith(user, pass);
        Assert.assertTrue(loginPage.isErrorMessageDisplayed());
        Assert.assertEquals(loginPage.getErrorMessageText(), expectedError);
    }
}

5.2 POM进阶：页面工厂与LoadableComponent

为了进一步减少样板代码，可以使用 PageFactory 和 @FindBy 注解进行元素初始化。

import org.openqa.selenium.support.PageFactory;
import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.How;

public class LoginPage {
    @FindBy(id = "username") // 等价于 By.id("username")
    private WebElement usernameInput;

    @FindBy(how = How.CSS, using = "button[type='submit']")
    private WebElement loginButton;

    public LoginPage(WebDriver driver) {
        PageFactory.initElements(driver, this); // 初始化所有@FindBy注解的元素
    }
    // ... 其他方法
}

PageFactory 会自动帮你完成 findElement 的调用。但要注意，它默认使用“隐式”查找，对于动态加载的元素，可能仍需结合显式等待。

对于需要等待特定条件满足才算加载完成的页面（如登录后跳转的首页），可以继承 LoadableComponent 。

public class HomePage extends LoadableComponent<HomePage> {
    private WebDriver driver;
    public HomePage(WebDriver driver) { this.driver = driver; }

    @Override
    protected void load() {
        driver.get("https://example.com/home");
    }

    @Override
    protected void isLoaded() throws Error {
        // 定义页面加载完成的判断条件
        String url = driver.getCurrentUrl();
        Assert.assertTrue(url.contains("/home"), "Not on the home page. Current URL: " + url);
        // 还可以检查某个关键元素是否存在
    }
}
// 使用：HomePage homePage = new HomePage(driver).get(); // get()方法会调用load()和isLoaded()

6. 测试报告、日志与持续集成集成

测试跑完了，产出物是什么？清晰的结果和报告至关重要。

6.1 TestNG原生报告与美化

TestNG运行后会默认在 test-output 目录下生成报告，其中 index.html 是总览， emailable-report.html 是可以邮件发送的简洁版。但这些报告样式比较简单。

我们可以使用 ExtentReports 或 Allure 来生成更美观、信息更丰富的报告。以 ExtentReports 为例：

  1. 添加Maven依赖。
  2. 在 @BeforeSuite 中初始化报告，在 @AfterMethod 中根据测试结果记录状态，在 @AfterSuite 中刷新并保存报告。
  3. 报告会包含测试步骤截图、详细日志，非常利于分析失败原因。

6.2 失败自动截图

这是调试的利器。我们可以在 @AfterMethod 中判断测试是否失败，如果失败，则截取当前屏幕保存。

import org.apache.commons.io.FileUtils;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import java.io.File;
import java.io.IOException;

@AfterMethod
public void tearDown(ITestResult result) {
    if (result.getStatus() == ITestResult.FAILURE) {
        // 获取当前测试方法名作为截图文件名
        String methodName = result.getName();
        takeScreenshot(methodName);
    }
    if (driver != null) {
        driver.quit();
    }
}

private void takeScreenshot(String methodName) {
    try {
        File scrFile = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
        File destFile = new File("screenshots/" + methodName + "_" + System.currentTimeMillis() + ".png");
        FileUtils.copyFile(scrFile, destFile);
        System.out.println("Screenshot saved to: " + destFile.getAbsolutePath());
        // 可以将路径记录到ExtentReports中
    } catch (IOException e) {
        e.printStackTrace();
    }
}

6.3 与持续集成（CI）工具集成

自动化测试只有集成到CI/CD流水线中，才能最大化其价值。无论是Jenkins、GitLab CI还是GitHub Actions，集成步骤大同小异：

  1. 环境准备 ：在CI服务器上安装JDK、Maven和浏览器（对于无头模式，可能只需要安装浏览器，无需图形界面）。
  2. 代码获取 ：CI工具从代码仓库（Git）拉取你的测试项目。
  3. 执行测试 ：通过Maven命令执行测试。通常我们会跳过UI测试（ -DskipTests ）进行编译，然后单独运行测试套件。 
    mvn clean test -DsuiteXmlFile=testng-smoke.xml
  4. 收集结果 ：CI工具可以配置收集 test-output 目录或 ExtentReports 生成的HTML报告，并展示在构建页面上。
  5. 失败处理 ：可以配置构建失败时发送邮件或即时消息通知相关负责人。

在CI中运行的关键配置 ：

  • 确保使用 无头模式 （ --headless ）运行浏览器，因为CI服务器通常没有图形界面。
  • 合理设置超时时间，防止因网络或环境问题导致构建无限期挂起。
  • 考虑测试的并行度，利用CI服务器的多核能力加速测试过程。

7. 常见问题排查与实战技巧

即使框架搭得再好，在实际编写和运行测试时，你依然会遇到各种“坑”。这里记录了一些高频问题和解决思路。

7.1 元素定位失败问题排查表

问题现象 可能原因 排查步骤与解决方案
NoSuchElementException 1. 元素定位器写错了。
2. 页面尚未加载完成。
3. 元素在iframe/frame内。
4. 元素在Shadow DOM内。		 1. 在浏览器开发者工具中用 $() (CSS)或 $x() (XPath)验证定位器。
2. 增加显式等待 ，等待元素出现、可见或可点击。
3. 使用 driver.switchTo().frame(frameElement) 切换到对应frame后再定位。
4. 使用JavaScript Executor穿透Shadow DOM。
ElementNotInteractableException 1. 元素被遮挡（如弹窗、另一个元素）。
2. 元素不可见（ display:none 或 visibility:hidden ）。
3. 元素未处于可交互状态（如disabled）。		 1. 检查是否有遮罩层，等待其消失。
2. 等待元素变为可见状态（ visibilityOfElementLocated ）。
3. 检查元素 disabled 属性。
StaleElementReferenceException 你持有的WebElement对象所对应的DOM元素已经失效（页面刷新、Ajax更新导致元素被重新渲染）。 这是POM中常见问题 。解决方案是“用时再找”，不要过早存储WebElement对象。或者在操作前，用try-catch包裹，捕获此异常后重新查找元素。
脚本在本地通过，在CI上失败 1. CI环境浏览器版本/驱动版本不匹配。
2. CI服务器资源（CPU/内存）不足，页面响应慢。
3. 网络环境差异，依赖的CDN资源加载慢。		 1. 使用 WebDriverManager 自动匹配驱动。
2. 增加等待超时时间 ，给CI环境更多缓冲。
3. 在CI脚本中增加更详细的日志和失败截图，对比分析。

7.2 应对动态内容与复杂交互

  • 动态ID/Class ：有些前端框架（如React、Vue）会生成随机的ID。此时应避免使用ID定位，转而使用相对稳定的属性，如 data-testid （需要让开发配合添加）、 name ，或者通过其父元素的稳定特征结合CSS Selector或XPath来定位。
  • 文件上传 ：对于 <input type="file"> 元素，直接使用 sendKeys(“文件绝对路径”) 即可，不要尝试模拟点击“浏览”按钮的复杂操作。
  • 下拉选择（非Select标签） ：很多UI库的下拉框并非原生 <select> ，而是用 <div> 和 <ul> / <li> 模拟。你需要先点击触发下拉框的 <div> ，然后等待下拉列表出现，再点击里面的 <li> 项。
  • 滚动到元素 ：如果元素不在可视区域内，需要先滚动到它面前才能操作。可以用JavaScript： ((JavascriptExecutor) driver).executeScript(“arguments[0].scrollIntoView(true);”, element);

7.3 性能与稳定性优化技巧

  1. 选择合适的等待 ：多用显式等待，少用隐式等待，禁用硬性等待。为不同的操作设置合理的超时时间（如点击等待短一些，页面跳转等待长一些）。
  2. 使用无头模式 ：在CI环境和不需要观察UI的测试中，使用 --headless 模式。浏览器无需渲染界面，速度更快，资源占用更少。
  3. 复用浏览器会话 ：对于一组关联性很强的测试（如一个业务流程），可以考虑使用 @BeforeClass 初始化driver， @AfterClass 关闭，而不是每个方法都重启浏览器。但这增加了测试间的耦合度，需权衡。
  4. 并行化 ：利用TestNG的并行执行特性，并确保测试用例是独立的（无状态、不依赖执行顺序）。
  5. 页面对象懒加载 ：在页面对象中，使用 @FindBy 时， PageFactory.initElements 并不会立即查找元素，而是在第一次使用该元素时才查找（懒加载）。这有助于提高初始化速度。

7.4 关于“Selenium被网站识别”的问题

一些网站会检测浏览器是否被自动化工具控制（通过检查 navigator.webdriver 等属性）。如果遇到此类反爬或检测机制，可以尝试以下方法（请注意合规性，仅用于测试自己拥有或授权测试的网站）：

  • 使用 ChromeOptions 添加排除参数 ： 
    ChromeOptions options = new ChromeOptions();
options.setExperimentalOption("excludeSwitches", new String[]{"enable-automation"});
options.setExperimentalOption("useAutomationExtension", false);
  • 通过CDP（Chrome DevTools Protocol）命令修改属性 （Selenium 4+）： 
    // 此方法可能随浏览器版本更新而失效
driver.executeCdpCommand("Page.addScriptToEvaluateOnNewDocument", ImmutableMap.of(
    "source", "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
));
    本质上，这是一场“猫鼠游戏”。最根本的解决方案是，与开发团队沟通，为测试环境提供特殊的开关或测试账号，以绕过前端检测机制，这才是合规且稳定的做法。

从我个人的经验来看，Selenium与TestNG的组合是一个需要不断打磨的工程。初期搭建框架会花些时间，但一旦POM结构建立起来，用例编写就会像搭积木一样顺畅。最大的挑战往往不是技术本身，而是测试用例的维护成本。因此，从一开始就注重代码的可读性、复用性和健壮性，多写注释，及时重构，你的自动化测试资产才会真正成为提升研发效率的利器，而不是一个沉重的负担。当你在CI流水线上看到一列绿色的测试通过标识，或者第一时间捕获到一个即将上线的严重Bug时，你会觉得这一切的投入都是值得的。

Logo
亚马逊云科技技术品牌专区

更多推荐

Kiro Editor 开发实战：使用 Cargo 构建、测试与性能优化指南

欢迎来到这篇终极指南，我们将深入探索如何使用Rust构建高性能的终端文本编辑器Kiro Editor。无论你是Rust新手还是经验丰富的开发者，这篇完整教程将带你了解如何利用Cargo工具链进行高效的开发、测试和性能优化，打造一款快速、轻量且功能强大的UTF-8文本编辑器。## 什么是Kiro Editor？Kiro Editor是一款使用Rust编写的极简终端文本编辑器，它最初是著名编辑

avatar 亚马逊云科技技术品牌专区

近期零基础学量化，先按基础差异拆学习顺序

读者应明白，拆解学习顺序时要先看自己的基础缺口，再决定哪一段需要放慢。不同流程阶段都有不同检查任务，学习路线要能反映这些差异。

avatar 亚马逊云科技技术品牌专区

2026年量化工具选择，要跟着能力基础走

读者应理解，选择工具前要先判断自己的能力基础和当前任务。工具应该帮助自己补上当前最关键的缺口，而不是替代学习顺序本身。

avatar 亚马逊云科技技术品牌专区