Spring中如何实现每次调用时重新自动装配WebDriver Bean？

方案一：原型作用域（Prototype Scope）+ ObjectFactory/Provider #

将WebDriver定义为原型作用域的Bean，确保每次从Spring容器获取时都生成新实例；同时在单例工具类中注入ObjectFactory<WebDriver>或Provider<WebDriver>，通过工厂类动态获取最新实例，用完后手动销毁即可。

配置WebDriver Bean #

@Configuration
public class WebDriverConfig {
    @Bean
    @Scope("prototype")
    public WebDriver webDriver() {
        // 替换为你的DriverManager初始化逻辑，例如ChromeDriver
        return DriverManager.getInstance().createDriver();
    }
}

单例工具类实现 #

@Component
public class TestUtils {
    private final ObjectFactory<WebDriver> webDriverFactory;

    @Autowired
    public TestUtils(ObjectFactory<WebDriver> webDriverFactory) {
        this.webDriverFactory = webDriverFactory;
    }

    public WebDriver getWebDriver() {
        // 每次调用都会从容器获取新的原型实例
        return webDriverFactory.getObject();
    }

    public void cleanUpWebDriver(WebDriver driver) {
        if (driver != null) {
            driver.quit();
            // 原型Bean不会被Spring自动销毁，手动quit后下次getObject()会生成新实例
        }
    }
}

方案二：代理作用域 + 手动触发销毁 #

通过@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)生成代理对象，注入单例类的是代理而非实际WebDriver实例；每次调用代理方法时会指向当前有效实例，手动销毁后下次调用会重新初始化Bean。

配置WebDriver Bean #

@Configuration
public class WebDriverConfig {
    @Bean
    @Scope(value = "singleton", proxyMode = ScopedProxyMode.TARGET_CLASS)
    @Lazy
    public WebDriver webDriver() {
        return DriverManager.getInstance().createDriver();
    }
}

单例工具类实现（需上下文辅助） #

@Component
public class TestUtils {
    private final WebDriver webDriver;
    private final ApplicationContext applicationContext;

    @Autowired
    public TestUtils(WebDriver webDriver, ApplicationContext applicationContext) {
        this.webDriver = webDriver;
        this.applicationContext = applicationContext;
    }

    public WebDriver getWebDriver() {
        return webDriver;
    }

    public void resetWebDriver() {
        // 手动销毁当前实例
        webDriver.quit();
        // 销毁后，代理对象下次调用时会重新初始化WebDriver Bean
        ((ConfigurableApplicationContext) applicationContext).getBeanFactory().destroyBean(webDriver);
    }
}

方案三：ThreadLocal管理（多线程测试场景） #

如果是并行E2E测试，每个线程需要独立的WebDriver实例，用ThreadLocal结合Spring Bean管理，确保线程隔离，且能动态刷新实例。

WebDriver持有类实现 #

@Component
public class WebDriverHolder {
    private final ThreadLocal<WebDriver> driverThreadLocal = new ThreadLocal<>();
    private final WebDriverConfig webDriverConfig;

    @Autowired
    public WebDriverHolder(WebDriverConfig webDriverConfig) {
        this.webDriverConfig = webDriverConfig;
    }

    public WebDriver getWebDriver() {
        WebDriver driver = driverThreadLocal.get();
        // 判断实例是否已销毁（可根据实际情况调整判断逻辑）
        if (driver == null || driver.toString().contains("null")) {
            driver = webDriverConfig.webDriver();
            driverThreadLocal.set(driver);
        }
        return driver;
    }

    public void cleanUpCurrentDriver() {
        WebDriver driver = driverThreadLocal.get();
        if (driver != null) {
            driver.quit();
            driverThreadLocal.remove();
        }
    }
}

单例工具类调用 #

@Component
public class TestUtils {
    private final WebDriverHolder webDriverHolder;

    @Autowired
    public TestUtils(WebDriverHolder webDriverHolder) {
        this.webDriverHolder = webDriverHolder;
    }

    public WebDriver getWebDriver() {
        return webDriverHolder.getWebDriver();
    }

    public void cleanUpWebDriver() {
        webDriverHolder.cleanUpCurrentDriver();
    }
}

选型建议 #

• 单线程测试场景优先选方案一：逻辑简单，完全贴合Spring Bean生命周期管理，无需额外上下文操作。
• 多线程并行测试选方案三：保证线程间WebDriver实例隔离，避免测试干扰。

内容的提问来源于stack exchange，提问作者Wojciech Kopeć