Java Selenium自动化测试框架搭建：从POM模式到数据驱动的工程实践

1. 项目概述：为什么需要一个稳固的自动化框架？

如果你是一名测试工程师或者正在向这个方向发展的开发者，听到“Selenium自动化”这个词，第一反应可能是：这玩意儿不就是写个脚本，让浏览器自己点点点吗？我直接写个Java类，用WebDriver打开浏览器，findElement定位，click点击，不就完事了？刚开始做自动化的时候，我也是这么想的，直到我接手了一个有上千个测试用例的遗留项目。

那个项目里，每个测试类都像一座孤岛。有的类里，WebDriver是静态变量；有的类里，每次测试都new一个新的Driver；定位元素的方式五花八门，有By.id，有By.xpath，还有一堆拼接的字符串；测试数据硬编码在代码里；失败后的截图和日志全靠手动添加，漏一个地方排查起来就头疼半天。更别提团队协作了，A写的定位器B根本看不懂，环境一变全组都得跟着改配置。维护成本高得吓人，最后大家宁愿手动测试，自动化脚本成了摆设。

这就是为什么我们需要一个“框架”，而不仅仅是“脚本”。框架的核心价值在于标准化、可维护、可扩展和高效协作。它不是一个炫技的工具，而是一套工程化的解决方案，用来解决上述所有痛点。一个成熟的Java Selenium框架，会帮你管理浏览器生命周期、封装统一的页面交互操作、提供灵活的数据驱动机制、集成强大的测试报告、并优雅地处理各种异常和等待。今天，我就基于多年的踩坑经验，带你从零搭建一个结构清晰、易于维护、团队友好的Java Selenium自动化测试框架。这个框架将基于Maven管理依赖，使用TestNG作为测试执行器，并融入Page Object Model设计模式，目标是让你写出的自动化代码像砌砖一样有章法，而不是堆沙子。

2. 环境准备与核心依赖选型

搭建框架的第一步，是把地基打牢。这里涉及到开发环境、构建工具和核心库的选择。我的原则是：选择主流、稳定、社区活跃的技术栈，避免使用过于小众或即将被淘汰的技术，这能极大降低未来的学习和维护成本。

2.1 基础开发环境配置

1. Java JDK：这是基石。我强烈推荐使用JDK 11或JDK 17（LTS版本）。JDK 8虽然经典，但较新的框架和库对更高版本的支持更好。从Oracle官网或Adoptium下载安装后，务必配置好JAVA_HOME环境变量，并确保java -version命令能正确输出。

   注意：如果你的项目组还在用JDK 8，沟通后可以继续使用，但需要留意Selenium 4.x对JDK 8的最低支持版本是8u241。建议新项目直接上JDK 11或17。

2. IDE（集成开发环境）：IntelliJ IDEA（社区版或旗舰版）是Java开发的首选，它对Maven、TestNG的支持和代码提示都做得非常好。Eclipse也可以，但IDEA在效率和体验上目前更胜一筹。

3. 构建工具：Apache Maven。它不仅能管理项目依赖，还能统一项目的构建生命周期（编译、测试、打包）。在项目根目录下创建一个pom.xml文件，它就是所有依赖的“购物清单”。

2.2 核心依赖库详解（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-framework</artifactId> <version>1.0-SNAPSHOT</version> <properties> <maven.compiler.source>11</maven.compiler.source> <maven.compiler.target>11</maven.compiler.target> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <!-- 统一版本管理 --> <selenium.version>4.15.0</selenium.version> <testng.version>7.8.0</testng.version> <webdrivermanager.version>5.6.3</webdrivermanager.version> <logback.version>1.4.11</logback.version> <jackson.version>2.15.3</jackson.version> </properties> <dependencies> <!-- 1. Selenium Java Client: 核心操控库 --> <dependency> <groupId>org.seleniumhq.selenium</groupId> <artifactId>selenium-java</artifactId> <version>${selenium.version}</version> </dependency> <!-- 2. TestNG: 测试执行与组织框架 --> <dependency> <groupId>org.testng</groupId> <artifactId>testng</artifactId> <version>${testng.version}</version> <scope>test</scope> </dependency> <!-- 3. WebDriverManager: 自动管理浏览器驱动 --> <dependency> <groupId>io.github.bonigarcia</groupId> <artifactId>webdrivermanager</artifactId> <version>${webdrivermanager.version}</version> </dependency> <!-- 4. Logback: 日志记录 --> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-classic</artifactId> <version>${logback.version}</version> </dependency> <!-- 5. Jackson: 用于JSON数据文件的读写（数据驱动测试） --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>${jackson.version}</version> </dependency> </dependencies> </project>

选型理由与避坑指南：

• Selenium 4.x vs 3.x：毫不犹豫选择4.x。它提供了更稳定的相对定位器、改进的CDP协议支持（用于Chrome/Edge）、新的窗口和标签页管理API。从3.x迁移到4.x有一些破坏性变更，但对于新项目，直接上4.x能避免未来的迁移成本。
• TestNG vs JUnit：对于自动化测试框架，我首选TestNG。它天然支持更灵活的测试套件配置（testng.xml）、强大的依赖测试（dependsOnMethods）、分组测试（groups）以及参数化数据提供者（@DataProvider），这些特性在组织复杂测试场景时非常有用。JUnit 5虽然功能也强大了，但TestNG在测试领域积淀更深。
• WebDriverManager：这是必选项！它解决了自动化测试中最令人头疼的环境问题之一——浏览器驱动。以前你需要手动下载chromedriver.exe、geckodriver，并确保版本与浏览器匹配，还要设置系统路径。WebDriverManager能在运行时自动检测浏览器版本并下载匹配的驱动，极大简化了环境配置。
• 日志系统：为什么不用System.out.println？因为日志系统能分级（DEBUG, INFO, ERROR）输出、控制台和文件同时记录、按日期或大小滚动归档。当测试在CI服务器上夜间运行时，详细的日志文件是定位问题的唯一依据。Logback是SLF4J的实现，性能好，配置灵活。
• 数据驱动：Jackson库用于处理JSON格式的测试数据。你也可以用Apache POI处理Excel，或者用csv文件。JSON结构清晰，易于阅读和版本管理，是我个人首选。

3. 框架核心架构设计：Page Object Model (POM)

框架的骨架决定了代码的组织方式。业内公认的最佳实践是Page Object Model。它的核心思想是将页面抽象成一个Java对象，页面的元素定位器是这个对象的“属性”，页面上的操作（点击、输入、获取文本）是这个对象的“方法”。

3.1 为什么必须是POM？

假设没有POM，你的测试脚本可能是这样的：

@Test public void testLogin() { driver.findElement(By.id("username")).sendKeys("admin"); driver.findElement(By.id("password")).sendKeys("123456"); driver.findElement(By.xpath("//button[@type='submit']")).click(); // 后续断言... }

这段代码有三大问题：1)定位器散落各处，页面UI一变，你要改无数个测试脚本；2)业务逻辑与定位细节耦合，可读性差；3)无法复用，另一个测试想登录，得把这堆代码再抄一遍。

使用POM后，变化是这样的：

1. 创建一个LoginPage类，所有登录页的元素定位器和操作都封装在里面。
2. 测试脚本里，你只需要调用loginPage.enterUsername("admin")和loginPage.clickSubmit()。
3. 当登录按钮的ID从submit变成login-btn时，你只需要修改LoginPage类中的一个地方，所有测试用例自动生效。

3.2 项目目录结构规划

一个清晰的目录结构是框架可维护性的基础。我推荐如下结构：

src/test/java/ ├── com.yourcompany.framework │ ├── base/ # 框架基础层 │ │ ├── BaseTest.java # 所有测试类的基类 │ │ └── WebDriverFactory.java # 驱动创建工厂 │ ├── pages/ # 页面对象层 │ │ ├── common/ # 公共组件，如Header、Footer │ │ │ └── HeaderComponent.java │ │ ├── LoginPage.java │ │ └── HomePage.java │ ├── utils/ # 工具类层 │ │ ├── ConfigReader.java # 读取配置文件 │ │ ├── ScreenshotUtil.java # 截图工具 │ │ └── WaitUtil.java # 自定义等待工具 │ └── tests/ # 测试用例层 │ ├── smoke/ # 冒烟测试 │ ├── regression/ # 回归测试 │ └── LoginTest.java src/test/resources/ ├── config.properties # 配置文件（浏览器类型、URL、超时时间） ├── testdata/ # 测试数据文件（.json, .csv） │ └── users.json ├── testng.xml # TestNG套件配置文件 └── logback-test.xml # 日志配置文件

各层职责解析：

• base/: 框架的根基。BaseTest负责在@BeforeSuite/@BeforeMethod中初始化驱动，在@AfterMethod中处理失败截图和清理，在@AfterSuite中退出驱动。WebDriverFactory根据配置创建Chrome、Firefox等不同的Driver实例。
• pages/: 业务核心。每个页面对应一个类，使用PageFactory模式或手动初始化元素。一个重要的技巧：对于跨页面复用的组件（如导航栏、侧边栏），单独抽成Component类，然后在页面类中组合使用，避免重复代码。
• utils/: 工具箱。所有通用的、与具体业务无关的功能放在这里，比如读取属性文件、生成随机数据、处理日期、发送邮件通知等。保证工具类的“纯粹性”。
• tests/: 测试用例。这里的类应该非常“薄”，只包含测试逻辑和断言，具体的页面操作都委托给pages/层。
• resources/: 配置与数据。将易变的配置（URL、超时时间）和测试数据从代码中分离出来，是提升框架适应性的关键。

4. 核心模块实现与编码细节

理论说完了，我们开始动手写代码。我会挑几个最核心的模块，展示实现细节和其中的“坑”。

4.1 WebDriver工厂与生命周期管理

WebDriverFactory.java的目标是提供一个统一、线程安全的Driver获取方式，并集成WebDriverManager。

package com.yourcompany.framework.base; 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.openqa.selenium.edge.EdgeDriver; import org.openqa.selenium.firefox.FirefoxDriver; import java.time.Duration; public class WebDriverFactory { private static ThreadLocal<WebDriver> driverThreadLocal = new ThreadLocal<>(); // 私有构造，防止实例化 private WebDriverFactory() {} public static WebDriver getDriver() { if (driverThreadLocal.get() == null) { String browserType = ConfigReader.getProperty("browser").toLowerCase(); WebDriver driver; switch (browserType) { case "chrome": WebDriverManager.chromedriver().setup(); ChromeOptions options = new ChromeOptions(); // 常用配置 options.addArguments("--start-maximized"); options.addArguments("--disable-infobars"); options.addArguments("--disable-notifications"); // 无头模式配置，用于CI环境 if (Boolean.parseBoolean(ConfigReader.getProperty("headless"))) { options.addArguments("--headless=new"); // Selenium 4.8+ options.addArguments("--disable-gpu"); options.addArguments("--window-size=1920,1080"); } driver = new ChromeDriver(options); break; case "firefox": WebDriverManager.firefoxdriver().setup(); driver = new FirefoxDriver(); break; case "edge": WebDriverManager.edgedriver().setup(); driver = new EdgeDriver(); break; default: throw new IllegalArgumentException("Unsupported browser: " + browserType); } // 全局等待策略：隐式等待（谨慎使用） driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(10)); // 页面加载超时 driver.manage().timeouts().pageLoadTimeout(Duration.ofSeconds(30)); // 脚本执行超时 driver.manage().timeouts().scriptTimeout(Duration.ofSeconds(30)); driverThreadLocal.set(driver); } return driverThreadLocal.get(); } public static void quitDriver() { WebDriver driver = driverThreadLocal.get(); if (driver != null) { driver.quit(); driverThreadLocal.remove(); // 关键！必须remove，否则ThreadLocal会内存泄漏 } } }

关键点与避坑：

1. ThreadLocal：如果你打算未来做并行测试（parallel="tests"in testng.xml），必须使用ThreadLocal来保证每个测试线程有自己的Driver实例，避免互相干扰。这是实现并行化的基石。
2. 隐式等待（Implicit Wait）：我把它设置为10秒，但这把双刃剑要小心使用。它作用于findElement等所有查找操作。最大的坑是它与显式等待（Explicit Wait）混用可能导致总等待时间不可控。我的建议是：设置一个较短的全局隐式等待（如2-5秒），作为兜底。在需要等待复杂条件（如元素可点击、包含特定文本）时，使用显式等待覆盖它。
3. 无头模式（Headless）：在CI/CD管道（如Jenkins）中运行测试时，没有图形界面，必须启用无头模式。注意Chrome无头模式的新参数--headless=new性能更好。
4. Driver清理：quitDriver()中的driverThreadLocal.remove()至关重要。如果不调用，当线程被线程池回收时，其持有的WebDriver对象可能无法被GC回收，导致内存泄漏。

4.2 页面对象（Page）的封装艺术

以LoginPage.java为例，展示两种常见的封装模式：PageFactory模式和By定位器模式。

模式一：PageFactory模式（传统，Selenium内置支持）

package com.yourcompany.framework.pages; import org.openqa.selenium.WebElement; import org.openqa.selenium.support.FindBy; import org.openqa.selenium.support.PageFactory; import com.yourcompany.framework.base.BaseTest; public class LoginPage { // 使用@FindBy注解声明元素 @FindBy(id = "username") private WebElement usernameInput; @FindBy(id = "password") private WebElement passwordInput; @FindBy(xpath = "//button[contains(text(),'登录')]") private WebElement loginButton; @FindBy(css = ".alert-error") private WebElement errorMessage; // 构造函数，初始化元素 public LoginPage() { PageFactory.initElements(BaseTest.getDriver(), this); } // 页面操作方法 public void enterUsername(String username) { usernameInput.clear(); usernameInput.sendKeys(username); } public void enterPassword(String password) { passwordInput.clear(); passwordInput.sendKeys(password); } public void clickLogin() { loginButton.click(); } public String getErrorMessage() { return errorMessage.getText(); } // 业务流方法：组合多个操作 public HomePage loginWith(String username, String password) { enterUsername(username); enterPassword(password); clickLogin(); return new HomePage(); // 返回下一个页面对象 } }

优点：代码简洁，元素声明和初始化在一起。缺点：PageFactory.initElements在每次查找元素时都会触发一次代理调用，有轻微性能开销；并且对于动态加载的元素处理不够灵活。

模式二：By定位器模式（更灵活，推荐）

package com.yourcompany.framework.pages; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; import org.openqa.selenium.support.ui.ExpectedConditions; import org.openqa.selenium.support.ui.WebDriverWait; import com.yourcompany.framework.base.BaseTest; import java.time.Duration; public class LoginPage { // 只声明定位器，不声明WebElement private By usernameInputBy = By.id("username"); private By passwordInputBy = By.id("password"); private By loginButtonBy = By.xpath("//button[contains(text(),'登录')]"); private By errorMessageBy = By.cssSelector(".alert-error"); private WebDriver driver; private WebDriverWait wait; public LoginPage(WebDriver driver) { this.driver = driver; this.wait = new WebDriverWait(driver, Duration.ofSeconds(15)); } // 操作方法内部查找元素，并可集成显式等待 public void enterUsername(String username) { WebElement element = wait.until(ExpectedConditions.visibilityOfElementLocated(usernameInputBy)); element.clear(); element.sendKeys(username); } public void enterPassword(String password) { WebElement element = driver.findElement(passwordInputBy); element.clear(); element.sendKeys(password); } public void clickLogin() { WebElement element = wait.until(ExpectedConditions.elementToBeClickable(loginButtonBy)); element.click(); } public String getErrorMessage() { try { WebElement element = wait.until(ExpectedConditions.visibilityOfElementLocated(errorMessageBy)); return element.getText(); } catch (Exception e) { return ""; // 或者抛出自定义异常 } } public HomePage loginWith(String username, String password) { enterUsername(username); enterPassword(password); clickLogin(); // 等待登录成功，跳转到首页 wait.until(ExpectedConditions.urlContains("/dashboard")); return new HomePage(driver); } }

优点：灵活性极高。你可以在每个方法里根据情况使用不同的等待策略。例如，输入用户名前等待元素可见，点击登录按钮前等待元素可点击。这对于现代单页面应用（SPA）或元素加载时间不一致的情况非常有用。这也是我目前更推荐的方式。

封装经验谈：

• 不要暴露WebElement：页面对象的方法应该返回业务意义的值（如字符串、布尔值）或另一个页面对象，而不是底层的WebElement。这保证了封装性。
• 一个方法只做一个操作：enterUsername、clickLogin这样的方法粒度很细，便于复用和组合。
• 业务流方法：像loginWith这样的方法提供了更高层次的抽象，让测试用例读起来更像自然语言。

4.3 等待策略：隐式、显式与流畅等待

等待是UI自动化的灵魂，处理不好就是满屏的NoSuchElementException。

1. 隐式等待（Implicit Wait）：如上所述，在WebDriverFactory中设置一个全局的、较短的超时（如5秒）。它告诉WebDriver在查找元素时，如果立即没找到，就轮询DOM一段时间。切勿设置过长，否则会拖慢失败测试的速度。

2. 显式等待（Explicit Wait）：针对特定条件进行等待。这是最常用、最推荐的等待方式。使用WebDriverWait配合ExpectedConditions。

   WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(15)); // 等待元素可见并可点击 WebElement button = wait.until(ExpectedConditions.elementToBeClickable(By.id("submit"))); button.click(); // 等待URL包含特定字符串 wait.until(ExpectedConditions.urlContains("success")); // 等待元素消失 wait.until(ExpectedConditions.invisibilityOfElementLocated(By.id("loading")));

   最佳实践：将常用的显式等待封装到WaitUtil工具类中，比如一个waitForElementToBeVisible(By locator)方法，避免在页面对象里重复写WebDriverWait初始化代码。

3. 流畅等待（Fluent Wait）：显式等待的更灵活版本，可以自定义轮询频率和忽略的异常类型。适用于需要更精细控制的场景，比如等待一个可能时有时无的弹窗。

   Wait<WebDriver> fluentWait = new FluentWait<>(driver) .withTimeout(Duration.ofSeconds(30)) .pollingEvery(Duration.ofMillis(500)) .ignoring(NoSuchElementException.class); WebElement foo = fluentWait.until(driver -> { WebElement e = driver.findElement(By.id("foo")); if (e.isDisplayed()) { return e; } return null; });

等待策略黄金法则：优先使用显式等待，谨慎使用隐式等待，避免使用Thread.sleep()。Thread.sleep()是固定等待，无论页面是否就绪都傻等，会极大降低测试效率并导致测试脆弱。

4.4 数据驱动测试实现

将测试数据与测试逻辑分离，是提高测试用例复用性和可维护性的关键。这里以JSON文件配合TestNG的@DataProvider为例。

1. 准备测试数据文件 (src/test/resources/testdata/users.json)

[ { "username": "standard_user", "password": "secret_sauce", "expectedTitle": "Swag Labs" }, { "username": "locked_out_user", "password": "secret_sauce", "expectedTitle": "", "expectedError": "Epic sadface: Sorry, this user has been locked out." }, { "username": "invalid_user", "password": "wrong_password", "expectedTitle": "", "expectedError": "Epic sadface: Username and password do not match any user in this service" } ]

2. 创建数据提供者工具类或直接在测试类中

package com.yourcompany.framework.utils; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.core.type.TypeReference; import java.io.File; import java.io.IOException; import java.util.List; import java.util.Map; public class DataProviderUtil { private static final ObjectMapper mapper = new ObjectMapper(); public static Object[][] getTestData(String filePath, String dataSetKey) throws IOException { // 这里示例直接读取整个JSON数组，更复杂的可以按key读取 File file = new File(DataProviderUtil.class.getClassLoader().getResource(filePath).getFile()); List<Map<String, String>> testDataList = mapper.readValue(file, new TypeReference<List<Map<String, String>>>() {}); Object[][] data = new Object[testDataList.size()][1]; // 每行测试数据作为一个Object数组 for (int i = 0; i < testDataList.size(); i++) { data[i][0] = testDataList.get(i); } return data; } }

3. 在测试类中使用@DataProvider

package com.yourcompany.framework.tests; import com.yourcompany.framework.base.BaseTest; import com.yourcompany.framework.pages.LoginPage; import com.yourcompany.framework.utils.DataProviderUtil; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import java.io.IOException; import java.util.Map; import static org.testng.Assert.*; public class LoginTest extends BaseTest { private LoginPage loginPage; @Override public void pageSetup() { // 假设BaseTest中有此方法，在@BeforeMethod中调用 loginPage = new LoginPage(driver); driver.get(ConfigReader.getProperty("base.url") + "/login"); } @DataProvider(name = "loginData") public Object[][] provideLoginData() throws IOException { // 从JSON文件加载数据 return DataProviderUtil.getTestData("testdata/users.json", null); } @Test(dataProvider = "loginData") public void testLoginWithMultipleUsers(Map<String, String> data) { String username = data.get("username"); String password = data.get("password"); String expectedTitle = data.get("expectedTitle"); String expectedError = data.get("expectedError"); loginPage.enterUsername(username); loginPage.enterPassword(password); loginPage.clickLogin(); if (!expectedError.isEmpty()) { // 验证错误场景 String actualError = loginPage.getErrorMessage(); assertEquals(actualError, expectedError, "错误信息不匹配"); } else { // 验证成功场景 String actualTitle = driver.getTitle(); assertEquals(actualTitle, expectedTitle, "登录后页面标题不匹配"); // 还可以进一步验证是否跳转到了正确页面 } } }

这样，你只需要维护JSON数据文件，就能轻松添加、删除或修改测试用例，而无需改动Java代码。TestNG会自动为每一组数据运行一次测试方法。

5. 测试报告、日志与失败处理机制

一个框架如果没有好的“可观测性”，就像在黑暗中调试程序。测试报告和日志是我们了解测试运行状况的眼睛。

5.1 集成ExtentReports或Allure

TestNG自带的HTML报告比较简单。我推荐集成ExtentReports或Allure来生成更美观、信息更丰富的报告。

以ExtentReports为例：

1. 在pom.xml中添加依赖。
2. 创建一个ReportManager单例类，负责初始化ExtentReports实例和ExtentTest。
3. 在BaseTest的@BeforeSuite中初始化报告，在@BeforeMethod中为每个测试方法创建ExtentTest节点。
4. 在页面操作或测试步骤中，通过ExtentTest的log(Status.INFO, "Entering username...")记录步骤。
5. 最关键的一步：在@AfterMethod中，根据测试结果（成功/失败）向报告添加状态，并且在失败时附加截图和异常日志。
6. 在@AfterSuite中刷新并保存报告。

截图工具ScreenshotUtil.java：

package com.yourcompany.framework.utils; import org.apache.commons.io.FileUtils; import org.openqa.selenium.OutputType; import org.openqa.selenium.TakesScreenshot; import org.openqa.selenium.WebDriver; import java.io.File; import java.io.IOException; import java.text.SimpleDateFormat; import java.util.Date; public class ScreenshotUtil { public static String captureScreenshot(WebDriver driver, String screenshotName) { String dateFormat = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date()); String fileName = screenshotName + "_" + dateFormat + ".png"; String path = System.getProperty("user.dir") + "/test-output/screenshots/" + fileName; try { TakesScreenshot ts = (TakesScreenshot) driver; File source = ts.getScreenshotAs(OutputType.FILE); File destination = new File(path); FileUtils.copyFile(source, destination); return path; // 返回路径，可用于报告附加 } catch (IOException e) { System.out.println("截图失败: " + e.getMessage()); return ""; } } }

在BaseTest的@AfterMethod中调用：

@AfterMethod public void tearDown(ITestResult result) { if (result.getStatus() == ITestResult.FAILURE) { String screenshotPath = ScreenshotUtil.captureScreenshot(driver, result.getName()); // 将screenshotPath附加到ExtentReports或Allure报告中 test.log(Status.FAIL, "测试失败，截图: " + test.addScreenCaptureFromPath(screenshotPath)); test.log(Status.FAIL, result.getThrowable()); } else if (result.getStatus() == ITestResult.SUCCESS) { test.log(Status.PASS, "测试通过"); } // 清理driver WebDriverFactory.quitDriver(); }

5.2 配置结构化日志（Logback）

在src/test/resources下创建logback-test.xml：

<configuration> <property name="LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n" /> <!-- 控制台输出 --> <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender"> <encoder> <pattern>${LOG_PATTERN}</pattern> </encoder> </appender> <!-- 文件输出，按天滚动 --> <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender"> <file>logs/automation.log</file> <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"> <fileNamePattern>logs/automation.%d{yyyy-MM-dd}.log</fileNamePattern> <maxHistory>30</maxHistory> </rollingPolicy> <encoder> <pattern>${LOG_PATTERN}</pattern> </encoder> </appender> <!-- 框架包日志级别 --> <logger name="com.yourcompany.framework" level="DEBUG" additivity="false"> <appender-ref ref="CONSOLE"/> <appender-ref ref="FILE"/> </logger> <!-- Selenium日志级别调高，避免过多噪音 --> <logger name="org.openqa.selenium" level="WARN"/> <root level="INFO"> <appender-ref ref="CONSOLE"/> </root> </configuration>

在代码中使用：

import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class LoginPage { private static final Logger log = LoggerFactory.getLogger(LoginPage.class); public void enterUsername(String username) { log.info("正在输入用户名: {}", username); // ... 操作 log.debug("用户名输入完成"); } }

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

即使框架搭得再好，实际运行中也会遇到各种妖魔鬼怪。这里分享一些高频问题的排查思路和技巧。

6.1 元素定位失败（NoSuchElementException）

这是最常见的问题，没有之一。

1. 检查选择器：首先用浏览器的开发者工具（F12）的Console验证你的定位器是否正确。例如，在Console里执行$$('#username')或$x('//button[contains(text(),\"登录\")]')。
2. 检查等待：元素还没加载出来你就去找它了。99%的定位失败都是等待问题。确保在操作前使用了合适的显式等待（等待可见、可点击、存在等）。
3. 检查iframe/Shadow DOM：如果元素在<iframe>里，你必须先driver.switchTo().frame(frameElement)切换到那个iframe才能定位。Shadow DOM则需要用driver.findElement(By.cssSelector("host-element")).getShadowRoot()来穿透。
4. 检查动态ID/Class：现代前端框架（如React, Vue）经常生成随机的属性值。避免使用包含动态哈希的部分作为定位器。改用更稳定的属性，如>