Selenium Java Dependency

Selenium Java Dependency is the Maven dependency that allows a Java project to use Selenium WebDriver APIs for browser automation. When Selenium is added as a dependency in the project's pom.xml file, Maven downloads the required Selenium libraries and their required transitive dependencies and makes them available to the Java automation project.

For modern Selenium Java projects, the commonly used Maven artifact is org.seleniumhq.selenium:selenium-java. Using Maven makes Selenium dependency management easier because libraries, versions, transitive dependencies, builds, and test execution can be managed from the project configuration.

Course Resource: Selenium Training | Register for Course Demo

1. What is Selenium Java Dependency?

A Selenium Java dependency is a library declaration that tells Maven that the Java project requires Selenium WebDriver. Instead of downloading Selenium JAR files manually, the dependency is declared in pom.xml.

<dependency>

    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <version>YOUR_SELENIUM_VERSION</version>
</dependency>

After Maven resolves this dependency, Selenium classes such as WebDriver, ChromeDriver, FirefoxDriver, By, WebElement, WebDriverWait, and other Selenium APIs become available to the project.

2. Why is Selenium Dependency Required?

Java itself does not contain Selenium WebDriver classes. Selenium provides the APIs required to automate web browsers.

Without Selenium libraries, Java code such as the following cannot compile:

WebDriver driver = new ChromeDriver();

After adding the Selenium dependency, the project can import and use Selenium classes.

3. Selenium Java Dependency Coordinates

4. Basic Selenium Java Maven Dependency

<dependency>

    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <version>YOUR_SELENIUM_VERSION</version>
</dependency>

The version should be selected according to the requirements and compatibility of the automation project.

5. Understanding groupId

The groupId identifies the organization or logical group responsible for an artifact.

<groupId>org.seleniumhq.selenium</groupId>

For the Selenium Java artifact, the groupId is:

org.seleniumhq.selenium

6. Understanding artifactId

The artifactId identifies the specific Maven artifact.

<artifactId>selenium-java</artifactId>

The commonly used Selenium Java dependency is:

org.seleniumhq.selenium:selenium-java

7. Understanding Version

The version identifies the Selenium release that Maven should use.

<version>YOUR_SELENIUM_VERSION</version>

Using an explicitly controlled version makes the project more predictable and helps prevent unexpected dependency changes.

8. How Selenium Dependency Works

pom.xml

   |
   v
Selenium Dependency
   |
   v
Maven Repository
   |
   v
Download Selenium Libraries
   |
   v
Local Maven Repository
   |
   v
Project Classpath
   |
   v
Java Selenium Code
   |
   v
Browser Automation

9. Maven Repository and Selenium

Maven obtains dependencies from configured repositories. When a required Selenium artifact is not already available locally, Maven resolves the artifact and downloads it into the local Maven repository.

Once downloaded, Maven can reuse the cached dependency for future builds.

10. Local Maven Repository

Maven maintains a local repository where downloaded dependencies are cached.

On many systems, the repository is located at:

~/.m2/repository

On Windows, it is commonly located at:

C:\Users\USERNAME\.m2\repository

A Selenium artifact may be stored under a structure similar to:

.m2/

└── repository/
    └── org/
        └── seleniumhq/
            └── selenium/
                └── selenium-java/

11. What Happens After Adding the Dependency?

When the Selenium dependency is added to pom.xml, Maven reads the dependency coordinates and resolves the required artifacts.

Add Dependency

      |
      v
Save pom.xml
      |
      v
Maven Reads POM
      |
      v
Resolve Selenium Artifact
      |
      v
Resolve Required Dependencies
      |
      v
Download Missing Artifacts
      |
      v
Store in Local Repository
      |
      v
Add to Project Classpath
      |
      v
Use Selenium APIs

12. Selenium Java Dependency and JAR Files

Before dependency management tools became common in Java projects, developers often downloaded JAR files manually and added them to the project classpath.

Maven reduces this manual work. The developer declares the dependency once in pom.xml, and Maven handles dependency resolution.

13. Selenium Dependency in a Complete 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
         https://maven.apache.org/xsd/maven-4.0.0.xsd">
 
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>com.example</groupId>
    <artifactId>selenium-automation</artifactId>
    <version>1.0-SNAPSHOT</version>
 
    <properties>
        <selenium.version>YOUR_SELENIUM_VERSION</selenium.version>
    </properties>
 
    <dependencies>
        <dependency>
            <groupId>org.seleniumhq.selenium</groupId>
            <artifactId>selenium-java</artifactId>
            <version>${selenium.version}</version>
        </dependency>
    </dependencies>
 
</project>

14. Using a Maven Property for Selenium Version

Instead of writing the Selenium version directly inside the dependency, a Maven property can be used.

<properties>

    <selenium.version>YOUR_SELENIUM_VERSION</selenium.version>
</properties>
 
<dependencies>
    <dependency>
        <groupId>org.seleniumhq.selenium</groupId>
        <artifactId>selenium-java</artifactId>
        <version>${selenium.version}</version>
    </dependency>
</dependencies>

This approach makes version management easier because the version can be changed in one location.

15. Selenium Dependency with TestNG

Selenium WebDriver is commonly combined with TestNG for creating structured automated test cases.

<dependencies>

    <dependency>
        <groupId>org.seleniumhq.selenium</groupId>
        <artifactId>selenium-java</artifactId>
        <version>YOUR_SELENIUM_VERSION</version>
    </dependency>
 
    <dependency>
        <groupId>org.testng</groupId>
        <artifactId>testng</artifactId>
        <version>YOUR_TESTNG_VERSION</version>
        <scope>test</scope>
    </dependency>
</dependencies>

16. Selenium Dependency with JUnit

JUnit can also be used as the test framework for a Selenium Maven project.

<dependency>

    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <version>YOUR_SELENIUM_VERSION</version>
</dependency>
 
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>YOUR_JUNIT_VERSION</version>
    <scope>test</scope>
</dependency>

17. Selenium Java Dependency Scope

Dependency scope determines when a Maven dependency is available during the project lifecycle.

The Selenium dependency is commonly declared without a scope when application or framework code directly uses Selenium APIs.

18. Transitive Dependencies

A transitive dependency is a library that is required by another dependency. Maven can resolve these dependency relationships automatically.

selenium-java

      |
      +-- Selenium API
      |
      +-- Browser Driver Components
      |
      +-- Remote Driver Components
      |
      +-- Selenium Support
      |
      +-- Other Required Components

This means a typical project does not need to manually download every Selenium JAR file.

19. selenium-api

selenium-api contains core Selenium API classes and interfaces used by Selenium automation code.

Examples include types related to WebDriver, WebElement, capabilities, and other Selenium functionality.

In a standard project, testers generally use the broader selenium-java dependency instead of declaring selenium-api separately.

20. Selenium Browser Driver Components

The Selenium Java distribution provides components required to work with supported browsers. For example, Chrome and Firefox automation can be created using the corresponding WebDriver classes.

WebDriver chromeDriver = new ChromeDriver();

chromeDriver.get("https://example.com");
chromeDriver.quit();

WebDriver firefoxDriver = new FirefoxDriver();

firefoxDriver.get("https://example.com");
firefoxDriver.quit();

21. selenium-remote-driver

The remote driver component supports remote browser execution and communication with remote Selenium infrastructure such as Selenium Grid.

WebDriver driver = new RemoteWebDriver(

    serverUrl,
    options
);

22. selenium-support

The Selenium support component provides additional APIs used for common automation tasks.

For example, explicit waits commonly use:

WebDriverWait

ExpectedConditions

23. Why Use selenium-java Instead of Individual Selenium JARs?

For a typical Selenium Java automation project, the selenium-java dependency simplifies setup because Maven can resolve the Selenium Java client and its required Selenium components.

24. Creating a Selenium Maven Project

1. Install a compatible JDK.
2. Install Maven or use Maven Wrapper.
3. Open IntelliJ IDEA, Eclipse, or another Java IDE.
4. Create a Maven project.
5. Configure groupId, artifactId, and version.
6. Open pom.xml.
7. Add the Selenium Java dependency.
8. Reload or synchronize the Maven project.
9. Create Java Selenium test classes.
10. Run the tests.

25. Maven Selenium Project Structure

selenium-java-project/

|
|-- pom.xml
|
|-- src/
|   |
|   |-- main/
|   |   |-- java/
|   |       |-- pages/
|   |       |-- utilities/
|   |
|   |-- test/
|       |-- java/
|           |-- tests/
|           |-- base/
|
|-- target/

26. First Selenium Java Program

Once the Selenium dependency has been added, a basic Selenium Java program can be written.

import org.openqa.selenium.WebDriver;

import org.openqa.selenium.chrome.ChromeDriver;
 
public class FirstSeleniumTest {
    public static void main(String[] args) {
        WebDriver driver = new ChromeDriver();
        try {
            driver.get("https://example.com");
            System.out.println(driver.getTitle());
        } finally {
            driver.quit();
        }
    }
}

27. Important Selenium Java Imports

The Selenium dependency makes Selenium Java packages available to the project.

import org.openqa.selenium.WebDriver;

import org.openqa.selenium.WebElement;
import org.openqa.selenium.By;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.support.ui.ExpectedConditions;

28. Selenium Dependency and Locators

After adding Selenium, locator APIs can be used to identify elements on web pages.

WebElement username =

    driver.findElement(By.id("username"));
 
username.sendKeys("testuser");

Common Selenium locator strategies include:

• By.id()
• By.name()
• By.className()
• By.tagName()
• By.linkText()
• By.partialLinkText()
• By.cssSelector()
• By.xpath()

29. Selenium Dependency and WebDriver

WebDriver is one of the central Selenium interfaces used to control browsers.

WebDriver driver = new ChromeDriver();

Typical WebDriver operations include:

driver.get("https://example.com");

driver.getTitle();
driver.getCurrentUrl();
driver.navigate().back();
driver.navigate().forward();
driver.navigate().refresh();
driver.quit();

30. Selenium Dependency and WebElement

WebElement represents an element on a web page.

WebElement searchBox =

    driver.findElement(By.id("search"));
 
searchBox.clear();
searchBox.sendKeys("Selenium");
searchBox.click();

31. Selenium Dependency and Explicit Waits

The Selenium dependency also allows Selenium wait APIs to be used in Java automation scripts.

WebDriverWait wait =

    new WebDriverWait(driver, Duration.ofSeconds(10));
 
WebElement loginButton = wait.until(
    ExpectedConditions.elementToBeClickable(
        By.id("login")
    )
);
 
loginButton.click();

Required imports:

import java.time.Duration;

import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.support.ui.ExpectedConditions;

32. Selenium Dependency and Page Object Model

The Selenium Java dependency is commonly used inside Page Object Model classes.

public class LoginPage {

    private WebDriver driver;
 
    private By username = By.id("username");
    private By password = By.id("password");
    private By loginButton = By.id("login");
 
    public LoginPage(WebDriver driver) {
        this.driver = driver;
    }
 
    public void login(String user, String pass) {
        driver.findElement(username).sendKeys(user);
        driver.findElement(password).sendKeys(pass);
        driver.findElement(loginButton).click();
    }
}

33. Selenium Dependency and TestNG

TestNG can be combined with Selenium to create structured automated test cases.

import org.openqa.selenium.WebDriver;

import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.Test;
 
public class LoginTest {
    @Test
    public void loginTest() {
        WebDriver driver = new ChromeDriver();
        try {
            driver.get("https://example.com");
        } finally {
            driver.quit();
        }
    }
}

34. Maven Test Execution

After adding Selenium and a test framework to the Maven project, tests can be executed using Maven commands.

mvn test

A clean test execution can be performed with:

mvn clean test

The general flow is:

pom.xml

   |
   v
Resolve Dependencies
   |
   v
Compile Java Code
   |
   v
Compile Test Code
   |
   v
Execute Selenium Tests
   |
   v
Generate Test Results

35. Verify Selenium Dependency

The Maven dependency tree can be used to verify how Selenium and related artifacts have been resolved.

mvn dependency:tree

This command is especially useful when troubleshooting dependency conflicts.

36. Maven Dependency Tree Example

mvn dependency:tree

 
Project
 |
 +-- org.seleniumhq.selenium:selenium-java
 |      |
 |      +-- Selenium API
 |      +-- Browser Driver Components
 |      +-- Remote Driver Components
 |      +-- Selenium Support
 |
 +-- TestNG / JUnit

The exact dependency tree depends on the selected Selenium version and the other dependencies in the project.

37. Updating Selenium Version

To update Selenium, change the version in pom.xml and reload the Maven project.

<selenium.version>NEW_VERSION</selenium.version>

For example:

<properties>

    <selenium.version>NEW_VERSION</selenium.version>
</properties>

After changing the version, run:

mvn clean test

38. Selenium Version Compatibility

When upgrading Selenium, compatibility should be considered across the complete automation environment.

39. Selenium Java Dependency and Java Version

Selenium Java projects require a compatible Java runtime. When selecting or upgrading Selenium, verify the Java requirements for the chosen Selenium release.

Do not assume that every Selenium release supports every Java version. Compatibility should be checked before upgrading a production automation framework.

40. Selenium Dependency in IntelliJ IDEA

1. Create a Maven project.
2. Open pom.xml.
3. Add the selenium-java dependency.
4. Save pom.xml.
5. Allow IntelliJ IDEA to reload Maven changes.
6. Open the Maven tool window if required.
7. Run the Selenium test.

41. Selenium Dependency in Eclipse

1. Create a Maven project.
2. Open pom.xml.
3. Add the selenium-java dependency.
4. Save the file.
5. Update Maven project configuration.
6. Verify Selenium dependencies under Maven Dependencies.
7. Create and execute the Selenium Java test.

42. Common Error: WebDriver Cannot Be Resolved

If the IDE reports that WebDriver cannot be resolved, verify whether the Selenium dependency has been added correctly.

import org.openqa.selenium.WebDriver;

Check the following:

• selenium-java exists in pom.xml.
• The dependency version is valid.
• Maven project synchronization has completed.
• The required artifacts are available in the local repository.
• The project has no dependency resolution errors.

43. Common Error: ChromeDriver Cannot Be Resolved

If ChromeDriver cannot be resolved by the IDE, verify the Selenium dependency and Maven synchronization.

import org.openqa.selenium.chrome.ChromeDriver;

Also verify that the project is using a valid Selenium version and that Maven has successfully resolved its dependencies.

44. Common Error: Dependency Not Downloaded

If Maven cannot download Selenium, possible causes include:

• Incorrect groupId.
• Incorrect artifactId.
• Invalid version.
• Network connectivity issue.
• Repository configuration problem.
• Proxy configuration issue.
• Corrupted local Maven cache.

Correct Coordinates

groupId:

org.seleniumhq.selenium
 
artifactId:
selenium-java

45. Common Error: Wrong Selenium Version

A project may fail after a dependency upgrade if the selected Selenium version is incompatible with the project's Java environment or another part of the framework.

Before upgrading:

1. Check the Selenium release information.
2. Check supported Java versions.
3. Check test framework compatibility.
4. Run the complete regression suite.
5. Review dependency conflicts.

46. Common Error: Maven Dependency Conflict

Dependency conflicts can occur when different libraries require different versions of the same artifact.

Use the following command to investigate the resolved dependency hierarchy:

mvn dependency:tree

The dependency tree can help identify which library introduced a particular dependency and which version Maven selected.

47. Excluding a Transitive Dependency

In advanced Maven projects, an unwanted transitive dependency can sometimes be excluded.

<dependency>

    <groupId>example.group</groupId>
    <artifactId>example-artifact</artifactId>
    <version>EXAMPLE_VERSION</version>
    <exclusions>
        <exclusion>
            <groupId>example.group</groupId>
            <artifactId>example-library</artifactId>
        </exclusion>
    </exclusions>
</dependency>

Exclusions should be used carefully because removing a required dependency can cause compilation or runtime failures.

48. Direct vs Transitive Dependency

49. Selenium Dependency and Page Object Framework

selenium-java

      |
      v
WebDriver API
      |
      +-- BaseTest
      |
      +-- Page Objects
      |
      +-- Utilities
      |
      +-- Test Classes
      |
      v
TestNG / JUnit
      |
      v
Maven
      |
      v
CI/CD

50. Practical Project: Selenium Login Automation

Create a Maven project that automates a login page.

Step 1: Add Dependency

<dependency>

    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <version>YOUR_SELENIUM_VERSION</version>
</dependency>

Step 2: Create Test

import org.openqa.selenium.WebDriver;

import org.openqa.selenium.chrome.ChromeDriver;
 
public class LoginTest {
    public static void main(String[] args) {
        WebDriver driver = new ChromeDriver();
        try {
            driver.get("https://example.com");
            System.out.println("Title: " + driver.getTitle());
        } finally {
            driver.quit();
        }
    }
}

51. Practical Project Structure

selenium-login/

|
|-- pom.xml
|
|-- src/
|   |
|   |-- test/
|       |
|       |-- java/
|           |
|           |-- tests/
|               |-- LoginTest.java
|
|-- target/

52. Practical Project: Selenium + TestNG + Maven

A professional Selenium automation project commonly combines the Selenium dependency with a test framework and supporting framework components.

Java

 |
 +-- Selenium WebDriver
 |
 +-- TestNG
 |
 +-- Maven
 |
 +-- Page Object Model
 |
 +-- Utilities
 |
 +-- Test Data
 |
 +-- Reports
 |
 +-- CI/CD

53. Selenium Dependency and CI/CD

Maven helps make Selenium dependencies reproducible in CI environments because the project's dependency configuration is stored in pom.xml.

Developer

   |
   v
Git Repository
   |
   v
CI Server
   |
   v
pom.xml
   |
   v
Resolve Selenium Dependency
   |
   v
Compile
   |
   v
Run Selenium Tests
   |
   v
Reports

54. Selenium Dependency and Jenkins

A Jenkins job can execute Maven commands such as:

mvn clean test

The CI server uses the project's Maven configuration to resolve dependencies and execute the configured test lifecycle.

55. Selenium Dependency and Git

The Selenium dependency configuration should be stored in pom.xml and committed to source control.

Individual Selenium JAR files generally should not be manually committed into the project when Maven is being used for dependency management.

Example

Git Repository

|
+-- pom.xml
+-- src/
+-- README.md
+-- .gitignore

56. Recommended Maven Project Files

selenium-framework/

|
+-- pom.xml
+-- README.md
+-- .gitignore
|
+-- src/
    +-- main/
    +-- test/

57. Selenium Dependency Best Practices

• Use Maven instead of manually managing Selenium JAR files.
• Keep the Selenium version explicitly controlled.
• Use Maven properties when the version is referenced in multiple places.
• Use a version compatible with the project's Java runtime.
• Check release information before upgrading Selenium.
• Run the complete test suite after a dependency upgrade.
• Use mvn dependency:tree when troubleshooting dependency conflicts.
• Avoid unnecessary Selenium component declarations.
• Keep pom.xml clean and readable.
• Use CI/CD to validate dependency and framework changes.

58. Common Mistakes

• Typing the Selenium groupId incorrectly.
• Typing the artifactId incorrectly.
• Using an invalid Selenium version.
• Forgetting to reload the Maven project.
• Downloading JAR files manually while also using Maven.
• Ignoring Java and Selenium compatibility.
• Not checking dependency conflicts.
• Adding duplicate Selenium dependencies unnecessarily.
• Using outdated dependency versions without a project requirement.
• Skipping regression tests after dependency upgrades.

59. Selenium Java Dependency Interview Questions

Q1. What is Selenium Java dependency?

It is a Maven dependency that provides Selenium WebDriver libraries and related components to a Java automation project.

Q2. What is the groupId of Selenium Java?

The groupId is org.seleniumhq.selenium.

Q3. What is the artifactId?

The commonly used artifactId is selenium-java.

Q4. Where is the Selenium dependency configured?

It is configured in the project's pom.xml file when Maven is used.

Q5. Why use Maven for Selenium?

Maven manages Selenium libraries, dependency versions, transitive dependencies, project builds, test execution, and CI/CD integration.

Q6. What is the Selenium Maven dependency syntax?

<dependency>

    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <version>YOUR_SELENIUM_VERSION</version>
</dependency>

Q7. What happens when Maven downloads Selenium?

Maven resolves the requested Selenium artifact and its required dependencies, stores them in the local repository, and makes them available to the project.

Q8. What is a transitive dependency?

A transitive dependency is a library required by another dependency and resolved through Maven's dependency management.

Q9. How do you check Selenium dependency resolution?

mvn dependency:tree

Q10. How do you update Selenium?

Change the Selenium version in pom.xml, reload the Maven project, and execute the project's tests.

Q11. Can Selenium Java be used without Maven?

Yes. Selenium Java can be used with other build tools or manually managed JAR files, but Maven simplifies dependency management for Java projects.

Q12. What is selenium-java?

selenium-java is the Maven artifact commonly used to bring Selenium's Java client and required Selenium components into a Maven project.

60. Quick Revision

61. Important Maven Commands

mvn -version

mvn clean
mvn compile
mvn test
mvn clean test
mvn package
mvn dependency:tree
mvn help:effective-pom

62. Complete Selenium Dependency Flow

Java Selenium Project

        |
        v
     pom.xml
        |
        v
org.seleniumhq.selenium
        |
        v
   selenium-java
        |
        v
Resolve Selenium Components
        |
        v
Download / Cache Artifacts
        |
        v
Local Maven Repository
        |
        v
Java Classpath
        |
        v
WebDriver APIs
        |
        v
Browser Automation
        |
        v
TestNG / JUnit
        |
        v
Maven Test Execution
        |
        v
Reports / CI-CD

63. Final Summary

Selenium Java Dependency is a fundamental part of a Maven-based Selenium automation framework. By declaring org.seleniumhq.selenium:selenium-java in pom.xml, a Java project can obtain Selenium APIs and required Selenium components through Maven dependency management.

The most important concepts to understand are groupId, artifactId, version, pom.xml, Maven repositories, local repository, transitive dependencies, dependency scopes, Selenium browser components, TestNG/JUnit integration, dependency:tree, version management, and CI/CD integration.

A Selenium tester who understands Maven dependencies can create cleaner, reproducible, maintainable, and CI/CD-ready Java automation frameworks.

64. Course Resources

Selenium Training: https://www.justacademy.co/course-detail/selenium-training

Register for Course Demo: https://www.justacademy.co/register-for-course-demo