Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1. Introduction

In this article, we will build on the previous writeup and continue to improve our Selenium/WebDriver testing by introducing the Page Object pattern.

2. Adding Selenium

Let’s add a new dependency to our project to write simpler, more readable assertions:

<dependency>
    <groupId>org.hamcrest</groupId>
    <artifactId>hamcrest-all</artifactId>
    <version>1.3</version>
</dependency>

The latest version can be found in the Maven Central Repository.

2.1. Additional Methods

In the first part of the series, we used a few additional utility methods, which we’re going to be using here as well.

We’ll start with the navigateTo(String url) method – which will help us navigate through different pages of the application:

public void navigateTo(String url) {
    driver.navigate().to(url);
}

Then, the clickElement(WebElement element) – as the name implies – will take care of performing the click action on a specified element:

public void clickElement(WebElement element) {
    element.click();
}

3. Page Object Pattern

Selenium gives us a lot of powerful, low-level APIs we can use to interact with the HTML page.

However, as the complexity of our tests grows, interacting with the low-level, raw elements of the DOM is not ideal. Our code will be harder to change, may break after small UI changes, and will be, simply put, less flexible.

Instead, we can utilize simple encapsulation and move these low-level details into a page object.

Before we start writing our first-page object, it’s good to have a clear understanding of the pattern – as it should allow us to emulate a user’s interaction with our application.

The page object will behave as a sort of interface that will encapsulate the details of our pages or elements and will expose a high-level API to interact with that element or page.

As such, an important detail is to provide descriptive names for our methods (ex. clickButton(), navigateTo()), as it would be easier for us to replicate an action taken by the user and will generally lead to a better API when we’re chaining steps together.

Ok, so now, let’s go ahead and create our page object – in this case, our home page:

public class BaeldungHomePage {

    private SeleniumConfig config;
 
    @FindBy(css = ".nav--logo_mobile")
    private WebElement title;
    @FindBy(css = ".menu-start-here > a")
    private WebElement startHere;

    // ...

    public StartHerePage clickOnStartHere() {
        config.clickElement(startHere);

        StartHerePage startHerePage = new StartHerePage(config);
        PageFactory.initElements(config.getDriver(), startHerePage);

        return startHerePage;
    }
}

Notice how our implementation is dealing with the low-level details of the DOM and exposing a nice, high-level API.

For example, the @FindBy annotation allows us to pre-populate our WebElements; this can also be represented using the By API:

private WebElement title = By.cssSelector(".header--menu > a");

Of course, both are valid; however, using annotations is a bit cleaner.

Also, notice the chaining – our clickOnStartHere() method returns a StartHerePage object – where we can continue the interaction:

public class StartHerePage {

    // Includes a SeleniumConfig attribute

    @FindBy(css = ".page-title")
    private WebElement title;

    // constructor

    public String getPageTitle() {
        return title.getText();
    }
}

Let’s write a quick test, where we simply navigate to the page and check one of the elements:

@Test
public void givenHomePage_whenNavigate_thenShouldBeInStartHere() {
    homePage.navigate();
    StartHerePage startHerePage = homePage.clickOnStartHere();
 
    assertThat(startHerePage.getPageTitle(), is("Start Here"));
}

It’s important to take into account that our homepage has the responsibility of:

  1. Based on the given browser configuration, navigate to the page.
  2. Once there, validate the content of the page (in this case, the title).

Our test is very straightforward; we navigate to the home page, execute click on the “Start Here” element, which will take us to the page with the same name, and finally, we just validate the title is present.

After our tests run, the close() method will be executed, and our browser should be closed automatically.

3.1. Separating Concerns

Another possibility that we can take into consideration might be separating concerns (even more) by having two separate classes; one will take care of having all attributes (WebElement or By) of our page:

public class BaeldungAboutPage {

    @FindBy(css = ".page-header > h1")
    public static WebElement title;
}

The other will take care of having all the implementation of the functionality we want to test:

public class BaeldungAbout {

    private SeleniumConfig config;

    public BaeldungAbout(SeleniumConfig config) {
        this.config = config;
        PageFactory.initElements(config.getDriver(), BaeldungAboutPage.class);
    }

    // navigate and getTitle methods
}

If we are using attributes as By and not using the annotation feature, it is recommended to add a private constructor in our page class to prevent it from being instantiated.

It’s important to mention that we need to pass the class that contains the annotations, in this case, the BaeldungAboutPage class, in contrast to what we did in our previous example by passing this keyword.

@Test
public void givenAboutPage_whenNavigate_thenTitleMatch() {
    about.navigateTo();
 
    assertThat(about.getPageTitle(), is("About Baeldung"));
}

Notice how we can now keep all the internal details of interacting with our page in the implementation, and here, we can actually use this client at a high, readable level.

4. Conclusion

In this quick tutorial, we focused on improving our usage of Selenium/WebDriver with the help of the Page-Object Pattern. We went through different examples and implementations to see the practical ways of utilizing the pattern to interact with our site.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW