Java测试架构优化：如何简化WebDriver、Logger等实例传递？

问题背景 #

我使用TestNG框架开发自动化测试，现有如下结构：

• Base类负责初始化WebDriver并将其设为公共变量，测试类Test必须继承Base（TestNG强制要求）
• 测试功能被抽离到TestFunctions类，该类继承ElementActions类
• 当前实现是在Test类中初始化TestFunctions时传入WebDriver，再由TestFunctions传递给父类ElementActions

但如果Base类后续新增Logger等更多实例，逐个通过构造参数传递会非常繁琐，希望找到更优方案减少代码冗余。

现有代码示例：

public class Base {
    WebDriver driver;

    // beforeTest 注解方法
    public void setUp() {
        driver = initDriver(); // 初始化WebDriver的逻辑
    }
}

public class Test extends Base {
    public void runTest() {
        TestFunctions testFunctions = new TestFunctions(driver);
    }
}

public class TestFunctions extends Actions {
    WebDriver driver;

    public TestFunctions(WebDriver driver) {
        super(driver);
        this.driver = driver;
    }
}

public class Actions {
    WebDriver driver;

    public Actions(WebDriver driver) {
        this.driver = driver;
    }

    public void click() {
        // 可在此访问driver
    }
}

优化方案 #

方案1：让TestFunctions继承Base类 #

既然Test类已经继承了Base，可以让TestFunctions也继承Base，直接复用父类的driver和其他实例，无需手动传递：

public class Base {
    protected WebDriver driver;
    protected Logger logger; // 新增的Logger实例

    public void setUp() {
        driver = initDriver();
        logger = initLogger(); // 初始化Logger
    }
}

public class TestFunctions extends Base {
    // 无需构造方法传递参数，直接使用父类的driver和logger
    public void doTestAction() {
        click(); // 调用Actions类的方法
        logger.info("执行测试动作");
    }
}

// 调整Actions类，改为组合方式引用Base
public class Actions {
    private Base base;

    public Actions(Base base) {
        this.base = base;
    }

    public void click() {
        base.driver.findElement(By.id("xxx")).click();
    }
}

// 或者让Actions也继承Base，直接访问driver
public class Actions extends Base {
    public void click() {
        driver.findElement(By.id("xxx")).click();
    }
}

// Test类中使用
public class Test extends Base {
    public void runTest() {
        TestFunctions testFunctions = new TestFunctions();
        // 复用Test类已执行的setUp，无需重复初始化
        testFunctions.doTestAction();
    }
}

优点：完全避免参数传递，直接复用Base中的所有实例；代码简洁，减少冗余。
注意：如果TestFunctions不需要Base的所有方法，可能会带来继承冗余，需根据实际场景判断。

方案2：使用上下文对象封装共享实例 #

创建一个TestContext类，封装所有需要共享的实例（driver、logger等），Base类初始化上下文并设置为保护变量，其他类直接引用上下文：

public class TestContext {
    private WebDriver driver;
    private Logger logger;

    // Getter和Setter方法
    public WebDriver getDriver() { return driver; }
    public void setDriver(WebDriver driver) { this.driver = driver; }
    public Logger getLogger() { return logger; }
    public void setLogger(Logger logger) { this.logger = logger; }
}

public class Base {
    protected TestContext testContext;

    public void setUp() {
        testContext = new TestContext();
        testContext.setDriver(initDriver());
        testContext.setLogger(initLogger());
    }
}

public class TestFunctions extends Actions {
    private TestContext testContext;

    public TestFunctions(TestContext testContext) {
        super(testContext);
        this.testContext = testContext;
    }

    public void doTestAction() {
        click();
        testContext.getLogger().info("执行测试动作");
    }
}

public class Actions {
    protected TestContext testContext;

    public Actions(TestContext testContext) {
        this.testContext = testContext;
    }

    public void click() {
        testContext.getDriver().findElement(By.id("xxx")).click();
    }
}

// Test类中使用
public class Test extends Base {
    public void runTest() {
        TestFunctions testFunctions = new TestFunctions(testContext);
        testFunctions.doTestAction();
    }
}

优点：集中管理所有共享实例，后续新增实例只需在TestContext中添加，无需修改多个类的构造方法；解耦性更强，避免不必要的继承。

方案3：使用依赖注入框架 #

如果项目规模较大，可以引入依赖注入框架（如Guice、Spring），自动注入需要的实例，彻底消除手动传递：

以Guice为例：

1. 配置Module，绑定WebDriver、Logger等实例：

public class TestModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(WebDriver.class).toInstance(initDriver());
        bind(Logger.class).toInstance(initLogger());
    }
}

2. 在Base类中初始化Injector：

public class Base {
    protected Injector injector;

    public void setUp() {
        injector = Guice.createInjector(new TestModule());
    }
}

3. 在TestFunctions和Actions中使用@Inject注解注入实例：

public class TestFunctions extends Actions {
    @Inject
    private Logger logger;

    // 无需构造方法传递参数，Injector会自动注入driver和logger
    public void doTestAction() {
        click();
        logger.info("执行测试动作");
    }
}

public class Actions {
    @Inject
    protected WebDriver driver;

    public void click() {
        driver.findElement(By.id("xxx")).click();
    }
}

4. Test类中获取TestFunctions实例：

public class Test extends Base {
    public void runTest() {
        TestFunctions testFunctions = injector.getInstance(TestFunctions.class);
        testFunctions.doTestAction();
    }
}

优点：彻底消除手动传递参数的代码，扩展性极强，新增实例只需添加绑定和注入注解；适合大型项目。
缺点：引入额外框架，增加学习成本和项目复杂度，小型项目可能没必要。

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