Selenium与Java构建可维护UI自动化测试框架实战指南

1. 项目概述：为什么UI自动化测试是研发团队的“刚需”？

干了这么多年测试，我见过太多团队在UI自动化测试上反复折腾。一开始大家热情高涨，投入人力搭建框架，写了几百个用例，结果没过半年，维护成本高到吓人，页面一改，脚本全挂，最后只能不了了之，留下一堆“祖传”的、没人敢动的自动化代码。这几乎是每个测试团队都会踩的坑。所以，今天我们不谈那些高大上的概念，就聊聊怎么用 Selenium 和 Java 这套最经典、最稳定的组合，搞出一套真正能“活下去”、能持续创造价值的UI自动化测试体系。

Selenium WebDriver 之所以历经十几年依然是UI自动化的首选，核心在于它的“直接”。它通过浏览器原生驱动，直接模拟用户操作，所见即所得。而Java，以其强大的生态、严谨的类型系统和在企业级应用中的深厚根基，为自动化测试框架提供了坚实的骨架。两者结合，意味着稳定、可控和极强的可扩展性。这个教程的目标，就是让你避开那些华而不实的“银弹”，掌握一套从零到一、从一到一百都能稳健推进的实战方法。无论你是刚入行的测试新人，还是想优化现有自动化体系的资深同学，这里的内容都是可以直接“抄作业”的干货。

2. 环境搭建与框架选型：打造稳固的“地基”

很多人一上来就急着写脚本，环境随便装装，依赖胡乱引入，结果跑起来各种诡异问题。磨刀不误砍柴工，一个清晰、隔离、可复现的环境是自动化成功的起点。

2.1 核心工具链安装与配置

首先，确保你的机器上安装了 JDK 8或11 （LTS版本长期支持稳定）。不建议使用最新版本，避免兼容性问题。安装后，在命令行输入 java -version 和 javac -version 确认。

接下来是构建工具。我强烈推荐 Maven 而非 Gradle 作为入门选择。为什么？Maven的 pom.xml 约定大于配置，结构清晰，对于测试依赖的管理和项目结构的标准化更友好，社区资源也极其丰富。在项目根目录创建 pom.xml 文件，这是所有依赖的“总清单”。

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.yourcompany</groupId>
    <artifactId>selenium-ui-automation</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <selenium.version>4.15.0</selenium.version> <!-- 使用当时稳定版本 -->
        <testng.version>7.8.0</testng.version>
        <webdrivermanager.version>5.6.0</webdrivermanager.version>
    </properties>

    <dependencies>
        <!-- Selenium Java Client -->
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-java</artifactId>
            <version>${selenium.version}</version>
        </dependency>
        <!-- 测试框架：TestNG，比JUnit更适合测试组织、依赖、参数化 -->
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>${testng.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- WebDriver管理器：自动下载和管理浏览器驱动，神器！ -->
        <dependency>
            <groupId>io.github.bonigarcia</groupId>
            <artifactId>webdrivermanager</artifactId>
            <version>${webdrivermanager.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- 日志记录，便于调试 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>2.0.9</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

关键点解析 ：

1. WebDriverManager ：这个库必须重点介绍。以前我们需要手动下载 ChromeDriver、GeckoDriver，还要匹配浏览器版本，路径配置繁琐。WebDriverManager 能自动检测系统已安装的浏览器版本，并下载匹配的驱动到本地缓存。只需一行代码 WebDriverManager.chromedriver().setup(); ，驱动问题从此告别。
2. TestNG vs JUnit ：对于UI自动化，TestNG 更强大。它支持灵活的测试套件定义、测试方法依赖（ dependsOnMethods ）、强大的参数化测试（ @DataProvider ）和丰富的监听器（Listener），用于生成报告、处理失败截图等，这些特性都是大型自动化项目所必需的。

2.2 浏览器选择与驱动策略

Chrome 是目前自动化测试的绝对主流，因为其稳定性、性能和对Web标准支持最好。Firefox 和 Edge 作为交叉浏览器测试的补充。

注意 ： 永远不要在自动化测试中使用正在用于日常浏览的浏览器配置文件 。浏览器缓存、Cookie、插件会导致测试行为不可预测。必须为自动化测试创建并使用独立的、干净的用户数据目录（User Data Dir）。

对于驱动，除了使用 WebDriverManager 自动管理，在 CI/CD 环境中，我们通常会将特定版本的驱动打包到镜像中，以确保环境一致性。驱动与浏览器的版本匹配是自动化脚本稳定性的第一道关卡，版本不匹配会导致 SessionNotCreatedException 等错误。

3. 核心脚本编写：从“能跑通”到“写得稳”

环境就绪，我们来写第一个脚本。目标不是打印“Hello World”，而是完成一个真实的用户场景：打开百度，搜索关键词，验证结果。

3.1 第一个可维护的测试用例

不要把所有代码都堆在 main 方法或一个测试方法里。我们从设计一个简单的页面对象（Page Object）开始。虽然现在流行更复杂的 Page Object Model (POM)，但理解其核心思想更重要： 将页面元素定位和操作封装起来 。

// BaseTest.java - 测试基类，处理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() {
        // 1. 自动设置Chrome驱动
        WebDriverManager.chromedriver().setup();

        // 2. 配置浏览器选项
        ChromeOptions options = new ChromeOptions();
        options.addArguments("--start-maximized"); // 最大化窗口
        options.addArguments("--disable-infobars"); // 禁用“Chrome正受到自动测试软件控制”提示
        options.addArguments("--disable-notifications"); // 禁用通知
        // 强烈建议添加：使用无头模式在CI运行，可视化调试时注释掉
        // options.addArguments("--headless=new");
        // 设置独立用户目录，避免污染
        options.addArguments("user-data-dir=/path/to/clean/profile");

        // 3. 初始化Driver
        driver = new ChromeDriver(options);

        // 4. 设置隐式等待（全局等待策略）
        driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10));
        // 设置页面加载超时
        driver.manage().timeouts().pageLoadTimeout(Duration.ofSeconds(30));
    }

    @AfterMethod
    public void tearDown() {
        if (driver != null) {
            driver.quit(); // 使用quit()而非close()，quit会关闭所有窗口并终止驱动进程
        }
    }
}

// BaiduHomePage.java - 百度首页的页面对象
import org.openqa.selenium.By;
import org.openqa.selenium.Keys;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.PageFactory;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import java.time.Duration;

public class BaiduHomePage {
    private WebDriver driver;
    private WebDriverWait wait;

    // 使用@FindBy注解进行元素定位，代码更清晰
    @FindBy(id = "kw")
    private WebElement searchInputBox;

    @FindBy(id = "su")
    private WebElement searchButton;

    // 构造函数，初始化元素
    public BaiduHomePage(WebDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(15));
        PageFactory.initElements(driver, this); // 初始化@FindBy注解的元素
    }

    // 页面加载完成判断
    public boolean isPageLoaded() {
        return wait.until(ExpectedConditions.titleContains("百度一下"));
    }

    // 业务方法：输入关键词并搜索
    public BaiduResultsPage searchFor(String keyword) {
        searchInputBox.clear();
        searchInputBox.sendKeys(keyword);
        // 两种搜索方式：点击按钮或按回车，这里演示回车
        searchInputBox.sendKeys(Keys.ENTER);
        // 返回下一个页面的对象，实现流程串联
        return new BaiduResultsPage(driver);
    }

    // 也可以提供点击按钮搜索的方法
    public BaiduResultsPage searchByClick(String keyword) {
        searchInputBox.clear();
        searchInputBox.sendKeys(keyword);
        searchButton.click();
        return new BaiduResultsPage(driver);
    }
}

// BaiduResultsPage.java - 搜索结果页的页面对象
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.PageFactory;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import java.time.Duration;
import java.util.List;

public class BaiduResultsPage {
    private WebDriver driver;
    private WebDriverWait wait;

    // 定位搜索结果容器（示例）
    @FindBy(css = "div.result.c-container")
    private List<WebElement> searchResultItems;

    // 定位第一个结果的标题
    @FindBy(css = "div.result.c-container h3.t a")
    private WebElement firstResultTitle;

    public BaiduResultsPage(WebDriver driver) {
        this.driver = driver;
        this.wait = new WebDriverWait(driver, Duration.ofSeconds(15));
        PageFactory.initElements(driver, this);
    }

    // 验证结果页是否加载
    public boolean isResultsLoaded() {
        return wait.until(ExpectedConditions.visibilityOf(firstResultTitle)).isDisplayed();
    }

    // 获取第一个结果的标题文本
    public String getFirstResultTitle() {
        return firstResultTitle.getText();
    }

    // 验证结果中是否包含特定关键词
    public boolean isKeywordInResults(String keyword) {
        wait.until(ExpectedConditions.numberOfElementsToBeMoreThan(By.cssSelector("div.result.c-container"), 0));
        for (WebElement item : searchResultItems) {
            if (item.getText().toLowerCase().contains(keyword.toLowerCase())) {
                return true;
            }
        }
        return false;
    }
}

// SearchTest.java - 最终的测试类
import org.testng.Assert;
import org.testng.annotations.Test;

public class SearchTest extends BaseTest {

    @Test
    public void testBaiduSearch() {
        // 1. 打开百度
        driver.get("https://www.baidu.com");

        // 2. 初始化首页页面对象
        BaiduHomePage homePage = new BaiduHomePage(driver);
        Assert.assertTrue(homePage.isPageLoaded(), "百度首页未正确加载");

        // 3. 执行搜索操作，并跳转到结果页
        String keyword = "Selenium 自动化测试";
        BaiduResultsPage resultsPage = homePage.searchFor(keyword);

        // 4. 验证结果页
        Assert.assertTrue(resultsPage.isResultsLoaded(), "搜索结果页未正确加载");
        String firstTitle = resultsPage.getFirstResultTitle();
        Assert.assertNotNull(firstTitle, "未获取到第一个结果标题");
        Assert.assertTrue(resultsPage.isKeywordInResults("Selenium"), "搜索结果中未找到关键词'Selenium'");

        // 5. 可以添加更多断言，例如第一个结果标题是否包含关键词
        Assert.assertTrue(firstTitle.contains("Selenium"), "第一个结果标题不包含'Selenium'");
    }
}

实操心得 ：

• PageFactory.initElements ：这是一个懒加载模式。它不会立即查找所有元素，而是在你第一次使用某个 @FindBy 注解的 WebElement 时，才去定位它。这提高了初始化速度，但要注意，如果页面元素动态变化，可能需要重新初始化或使用 driver.findElement 。
• 隐式等待 vs 显式等待 ： implicitlyWait 是全局设置，告诉WebDriver在查找 任何 元素时，如果没立即找到，就轮询等待一段时间（这里10秒）。而 WebDriverWait 是显式等待，用于等待 特定条件 （如元素可见、可点击、标题包含等）。 最佳实践是：设置一个较短的隐式等待（如2-5秒），用于处理大多数稳定元素；对于关键操作或加载较慢的元素，使用显式等待。 混用时，显式等待优先级更高。
• driver.quit() vs driver.close() ： close() 只关闭当前浏览器窗口，如果只有一个窗口，则关闭浏览器但驱动进程可能还在。 quit() 会关闭所有关联窗口，并终止驱动进程，释放资源。 测试结束后务必调用 quit() 。

3.2 元素定位：八仙过海，稳字当头

元素定位是UI自动化的基石，不稳定的定位是脚本维护的噩梦。

1. 优先级（由高到低） ：

   • ID ：唯一且稳定，首选。 By.id(“kw”)
   • Name ：常用于表单，也比较稳定。 By.name(“wd”)
   • CSS Selector ：功能强大，性能好，语法灵活。是除ID/Name外的首选。
     • By.cssSelector(“input#kw”) (ID选择器)
     • By.cssSelector(“input.s_ipt”) (Class选择器)
     • By.cssSelector(“input[name=‘wd’]”) (属性选择器)
     • By.cssSelector(“div#content_left > div.result”) (父子关系)
   • XPath ：功能最强大，可以遍历XML/HTML树，但性能稍差，且容易因页面结构微小变动而失效。 慎用绝对路径（以 / 开头） ，尽量使用相对路径和属性结合。
     • By.xpath(“//input[@id=‘kw’]”) (相对路径+属性)
     • By.xpath(“//button[contains(text(), ‘搜索’)]”) (文本包含)
   • Link Text / Partial Link Text ：仅用于超链接。 By.linkText(“新闻”)
   • Class Name, Tag Name ：通常不唯一，需结合其他条件使用。

2. 定位策略黄金法则 ：

   • 与开发约定 ：争取为关键测试元素添加唯一的 id 或 data-testid 属性。这是最根本的解决方案。
   • 避免依赖视觉属性 ：不要用 style 、 color 、绝对位置等容易变化的属性定位。
   • 使用组合定位 ：当单个属性不唯一时，组合使用。例如 By.cssSelector(“div.user-panel input[name=‘login’]”) 。
   • 应对动态ID ：如果ID是动态生成的（如 id=“button-12345” ），寻找其不变的父容器或兄弟元素，再向下定位，或使用属性通配符 By.cssSelector(“button[id^=‘button-’]”) (匹配id以‘button-’开头的元素)。

3.3 等待机制：解决“元素找不到”问题的核心

90%的UI自动化失败源于“等待”没处理好。除了隐式和显式等待，还有 强制等待（Thread.sleep） ，这是万不得已才用的下策，因为它固定死时间，浪费资源且不可靠。

显式等待的经典场景 ：

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15));

// 等待元素可见并可点击
WebElement button = wait.until(ExpectedConditions.elementToBeClickable(By.id(“submitBtn”)));
button.click();

// 等待元素存在（可能在DOM但不可见）
wait.until(ExpectedConditions.presenceOfElementLocated(By.cssSelector(“.loading”)));

// 等待元素从DOM中消失（如等待加载动画消失）
wait.until(ExpectedConditions.invisibilityOfElementLocated(By.id(“spinner”)));

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

// 自定义等待条件（更灵活）
wait.until(d -> {
    String text = d.findElement(By.id(“status”)).getText();
    return text.equals(“处理完成”);
});

重要提示 ：对于单页应用（SPA）如Vue、React，页面切换不刷新，传统的 pageLoadTimeout 可能不适用。更需要依赖显式等待，等待某个代表新视图加载完成的元素出现（如一个特定的组件或数据加载完成的标识）。

4. 高级技巧与框架封装：让自动化脚本“工业级”

单个测试用例跑通只是第一步。要让成百上千的用例高效、稳定、易维护地运行，需要框架层面的设计。

4.1 数据驱动测试

硬编码的测试数据是维护的灾难。我们需要将测试数据与脚本逻辑分离。

使用TestNG的 @DataProvider ：

public class SearchDataProvider {

    @DataProvider(name = “searchKeywords”)
    public Object[][] provideSearchData() {
        return new Object[][] {
            { “Selenium”, true },
            { “TestNG”, true },
            { “一个不存在的稀奇古怪词XYZ”, false }, // 期望搜索不到结果
            { “Java 21”, true }
        };
    }
}

public class DataDrivenSearchTest extends BaseTest {

    @Test(dataProvider = “searchKeywords”, dataProviderClass = SearchDataProvider.class)
    public void testMultiKeywordSearch(String keyword, boolean expectedResultFound) {
        driver.get(“https://www.baidu.com”);
        BaiduHomePage homePage = new BaiduHomePage(driver);
        BaiduResultsPage resultsPage = homePage.searchFor(keyword);

        boolean actualResultFound = resultsPage.isKeywordInResults(keyword.split(“ “)[0]); // 简单取第一个词
        Assert.assertEquals(actualResultFound, expectedResultFound,
                String.format(“关键词 ‘%s’ 的搜索结果断言失败”, keyword));
    }
}

更复杂的数据可以从外部文件（如JSON、YAML、Excel、CSV）读取，使用像 Apache POI (Excel)、 Jackson (JSON) 这样的库来解析。

4.2 测试报告与失败处理

测试不能只靠控制台输出。我们需要直观的报告和失败现场的记录。

1. TestNG原生报告 ：TestNG运行后会生成 test-output 文件夹，内含 index.html 报告。但比较简陋。
2. ExtentReports ：这是目前最流行、最强大的开源测试报告库之一，可以生成非常美观、信息丰富的HTML报告，支持截图、步骤日志、分组、图表等。

// 简化的ExtentReports集成示例
import com.aventstack.extentreports.ExtentReports;
import com.aventstack.extentreports.ExtentTest;
import com.aventstack.extentreports.Status;
import com.aventstack.extentreports.markuputils.ExtentColor;
import com.aventstack.extentreports.markuputils.MarkupHelper;
import com.aventstack.extentreports.reporter.ExtentSparkReporter;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.testng.ITestResult;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.AfterSuite;
import org.testng.annotations.BeforeSuite;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ReportBaseTest extends BaseTest { // 继承之前的BaseTest
    protected static ExtentReports extent;
    protected static ThreadLocal<ExtentTest> test = new ThreadLocal<>(); // 支持并行测试

    @BeforeSuite
    public void setUpReport() {
        String timeStamp = new SimpleDateFormat(“yyyyMMdd_HHmmss”).format(new Date());
        String reportPath = “test-output/ExtentReport_” + timeStamp + “.html”;
        ExtentSparkReporter sparkReporter = new ExtentSparkReporter(reportPath);
        sparkReporter.config().setDocumentTitle(“UI自动化测试报告”);
        sparkReporter.config().setReportName(“回归测试套件”);

        extent = new ExtentReports();
        extent.attachReporter(sparkReporter);
        extent.setSystemInfo(“测试环境”, “QA环境”);
        extent.setSystemInfo(“浏览器”, “Chrome”);
    }

    @AfterMethod
    public void afterMethod(ITestResult result) {
        ExtentTest extentTest = test.get();
        if (result.getStatus() == ITestResult.FAILURE) {
            extentTest.log(Status.FAIL, “测试用例失败: “ + result.getThrowable());
            // 捕获失败截图并添加到报告
            String screenshotPath = captureScreenshot(result.getName());
            try {
                extentTest.addScreenCaptureFromPath(screenshotPath);
            } catch (IOException e) {
                extentTest.log(Status.WARNING, “截图添加失败: “ + e.getMessage());
            }
        } else if (result.getStatus() == ITestResult.SUCCESS) {
            extentTest.log(Status.PASS, “测试用例通过”);
        } else {
            extentTest.log(Status.SKIP, “测试用例跳过”);
        }
        extent.flush(); // 确保数据写入
    }

    @AfterSuite
    public void tearDownReport() {
        if (extent != null) {
            extent.flush();
        }
    }

    private String captureScreenshot(String screenshotName) {
        String timeStamp = new SimpleDateFormat(“yyyyMMdd_HHmmss”).format(new Date());
        String fileName = screenshotName + “_” + timeStamp + “.png”;
        Path destPath = Path.of(“test-output/screenshots/”, fileName);

        try {
            Files.createDirectories(destPath.getParent());
            File screenshot = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
            Files.copy(screenshot.toPath(), destPath);
            return destPath.toString();
        } catch (IOException e) {
            e.printStackTrace();
            return “”;
        }
    }
}

在具体的测试类中，需要在 @BeforeMethod 中创建 ExtentTest 实例，并在测试步骤中用 extentTest.log(Status.INFO, “步骤描述”) 记录日志。

4.3 Page Object Model (POM) 设计模式进阶

基础的POM是将页面封装成类。进阶的POM需要考虑组件复用和业务流程封装。

1. 组件化 ：将页面上可复用的部分（如导航栏、侧边栏、模态框、表格）抽象成独立的 Component 类。页面对象可以包含这些组件对象。

   public class HeaderComponent {
       private WebDriver driver;
       @FindBy(css = “.user-menu”)
       private WebElement userMenu;
       // ... 其他元素和方法
       public void logout() { … }
   }
   
   public class DashboardPage {
       public HeaderComponent header;
       public DashboardPage(WebDriver driver) {
           PageFactory.initElements(driver, this);
           this.header = new HeaderComponent(driver);
       }
   }
   

2. 业务流程封装 ：将一连串的页面操作封装成一个“业务流”方法，对外提供简洁的接口。例如，将“登录->进入商品页->加入购物车->结算”封装成 OrderFlow.quickBuy(productId) 。

4.4 并行测试与测试套件管理

当用例数量增长，串行执行太慢。TestNG 通过 testng.xml 配置文件轻松支持并行。

<!DOCTYPE suite SYSTEM “https://testng.org/testng-1.0.dtd">
<suite name=“UI自动化套件” parallel=“tests” thread-count=“3”>
    <!-- parallel 可选：methods, tests, classes, instances -->
    <!-- thread-count 控制最大并发线程数 -->

    <test name=“Chrome测试”>
        <parameter name=“browser” value=“chrome”/>
        <classes>
            <class name=“com.test.SearchTest”/>
            <class name=“com.test.LoginTest”/>
        </classes>
    </test>
    <test name=“Firefox测试”>
        <parameter name=“browser” value=“firefox”/>
        <classes>
            <class name=“com.test.SearchTest”/>
        </classes>
    </test>
</suite>

在 @BeforeMethod 中，可以通过 @Optional 注解和 ITestContext 获取参数，动态初始化不同浏览器的Driver。

5. 常见问题排查与性能优化

即使框架完善，脚本运行中依然会遇到各种“坑”。这里记录一些高频问题和解决思路。

5.1 典型异常与解决方案速查表

5.2 脚本执行慢？性能优化点

1. 减少不必要的等待 ：评估并缩短隐式等待时间，将固定的 Thread.sleep 替换为条件性的显式等待。
2. 优化定位器 ：CSS Selector 通常比复杂的XPath执行更快。避免使用 // 开头的过于宽泛的XPath。
3. 使用无头模式（Headless） ：在CI/CD管道或不需要视觉验证时，使用 --headless=new 参数。浏览器不渲染GUI，可节省大量资源和时间。
4. 禁用图片/样式加载 ：通过浏览器选项，可以禁止加载图片、CSS，甚至JavaScript（慎用），极大提升页面加载速度，但可能影响脚本逻辑。

   ChromeOptions options = new ChromeOptions();
   HashMap<String, Object> prefs = new HashMap<>();
   prefs.put(“profile.managed_default_content_settings.images”, 2); // 2为禁止
   options.setExperimentalOption(“prefs”, prefs);
   

5. 并行化执行 ：如前所述，合理利用TestNG的并行特性。
6. 重用浏览器会话 ：对于登录态不变的测试序列，可以考虑不每次 quit() 浏览器，而是清理Cookie或刷新页面。但这会增加用例间的耦合，需权衡。

5.3 稳定性提升：重试机制与截图

对于偶发性的失败（如网络波动），可以引入重试机制。TestNG 有 IRetryAnalyzer 接口可以实现。

import org.testng.IRetryAnalyzer;
import org.testng.ITestResult;

public class RetryAnalyzer implements IRetryAnalyzer {
    private int retryCount = 0;
    private static final int MAX_RETRY_COUNT = 2; // 最大重试次数

    @Override
    public boolean retry(ITestResult result) {
        if (retryCount < MAX_RETRY_COUNT) {
            retryCount++;
            System.out.println(“重试测试方法：” + result.getName() + “，第 ” + retryCount + “ 次”);
            return true; // 返回true表示需要重试
        }
        return false;
    }
}

在测试方法上使用 @Test(retryAnalyzer = RetryAnalyzer.class) 注解。同时，每次失败都必须截图，这是定位线上CI失败原因的“黑匣子”。

6. 集成CI/CD与容器化

自动化测试只有融入开发流程才能发挥最大价值。通常我们将其集成到 Jenkins、GitLab CI、GitHub Actions 等CI/CD工具中。

一个简单的Jenkins Pipeline示例 ：

pipeline {
    agent any
    tools {
        maven ‘Maven-3.8.6’
        jdk ‘JDK11’
    }
    stages {
        stage(‘Checkout’) {
            steps {
                git branch: ‘main’, url: ‘https://your-git-repo.git’
            }
        }
        stage(‘UI自动化测试’) {
            steps {
                script {
                    // 在无头模式下运行测试，并生成报告
                    sh ‘mvn clean test -Dtestng.xml=testng_ci.xml’
                }
            }
            post {
                always {
                    // 无论成功失败，都归档测试报告和截图
                    archiveArtifacts artifacts: ‘test-output/**/*’, fingerprint: true
                    // 如果使用了Allure等报告工具，可以在这里生成并发布
                    // allure includeProperties: false, jdk: ‘’, results: [[path: ‘allure-results’]]
                }
            }
        }
    }
}

容器化（Docker） ：为了获得绝对一致的环境，可以将测试代码、依赖和浏览器一起打包进Docker镜像。可以使用官方提供的 selenium/standalone-chrome 镜像作为基础，在其中运行你的测试jar包。这确保了在任何地方（本地、Jenkins、K8s）运行测试，环境都完全一致。

踩了这么多年的坑，我的最深体会是：UI自动化测试的成功， 技术只占三成，流程和规范占七成 。没有产品、开发、测试对页面元素稳定性的共识（比如约定 data-testid ），没有持续集成流程的保障，没有定期的用例评审和失效分析，再好的框架也会逐渐腐化。所以，在动手写第一行代码前，先和你的团队把规则定好。把自动化测试当成一个需要持续投入、持续维护的“产品”来对待，而不是一次性的脚本开发任务，它才能真正成为提升交付质量和效率的利器。