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. Overview

A Spring Boot application embeds a web server, and sometimes, we may want to discover the HTTP port at runtime.

In this tutorial, we’ll address how to get the HTTP port programmatically in a Spring Boot application.

2. Introduction

2.1. Our Spring Boot Application

We’ll create a simple Spring Boot application example to quickly show the methods to discover the HTTP port at runtime:

@SpringBootApplication
public class GetServerPortApplication {
    public static void main(String[] args) {
        SpringApplication.run(GetServerPortApplication.class, args);
    }
}

2.2. Two Scenarios of Setting the Port

Usually, the most straightforward way to configure the HTTP port of a Spring Boot application is by defining the port in the configuration file application.properties or application.yml.

For example, in the application.properties file, we can set 7777 as the port our application is running on:

server.port=7777

Alternatively, instead of defining a fixed port, we can let the Spring Boot application run on a random port by setting “0” as the value of the “server.port” property:

server.port=0

Next, let’s go through the two scenarios and discuss different ways to get the port programmatically at runtime.

In this tutorial, we’ll discover the server port in unit tests.

3. Getting a Fixed Port at Runtime

Let’s create a properties file application-fixedport.properties and define a fixed port 7777 in it:

server.port=7777

Next, we’ll try to get the port in a unit test class:

@RunWith(SpringRunner.class)
@SpringBootTest(classes = GetServerPortApplication.class,
  webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
@ActiveProfiles("fixedport")
public class GetServerFixedPortUnitTest {
    private final static int EXPECTED_PORT = 7777;
    ....
}

Before we see the test methods, let’s take a quick look at the annotations of the test class:

  • @RunWith(SpringRunner.class) – This will join the JUnit test with the Spring TestContext
  • @SpringBootTest( … SpringBootTest.WebEnvironment.DEFINED_PORT) – In the SpringBootTest, we’ll use the DEFINED_PORT for the embedded web server
  • @ActiveProfiles(“fixedport”) – With this annotation, we enabled the Spring profile “fixedport” so that our application-fixedport.properties will be loaded

3.1. Using the @Value(“${server.port}”) Annotation

Since the application-fixedport.properties file will be loaded, we can get the “server.port” property using the @Value annotation:

@Value("${server.port}")
private int serverPort;

@Test
public void givenFixedPortAsServerPort_whenReadServerPort_thenGetThePort() {
    assertEquals(EXPECTED_PORT, serverPort);
}

3.2. Using the ServerProperties Class

ServerProperties holds the properties of the embedded web server, such as the port, the address, and the server header.

We can inject a ServerProperties component and get the port from it:

@Autowired
private ServerProperties serverProperties;

@Test
public void givenFixedPortAsServerPort_whenReadServerProps_thenGetThePort() {
    int port = serverProperties.getPort();
 
    assertEquals(EXPECTED_PORT, port);
}

So far, we’ve learned two ways to get a fixed port at runtime. Next, let’s see how to discover the port in the random port scenario.

4. Getting Random Port at Runtime

This time, let’s create another properties file application-randomport.properties:

server.port=0

As the code above shows, we allow Spring Boot to choose a free port randomly when the web server starts.

In the same vein, let’s create another unit test class:

....
@ActiveProfiles("randomport")
public class GetServerRandomPortUnitTest {
...
}

Here, we need to activate the “randomport” Spring profile to load the corresponding properties file.

We’ve learned two ways to discover a fixed port at runtime. However, they can’t help us to get the random port:

@Value("${server.port}")
private int randomServerPort;

@Test
public void given0AsServerPort_whenReadServerPort_thenGet0() {
    assertEquals(0, randomServerPort);
}

@Autowired
private ServerProperties serverProperties;

@Test
public void given0AsServerPort_whenReadServerProps_thenGet0() {
    int port = serverProperties.getPort();
 
    assertEquals(0, port);
}

As the two test methods show, both @Value(“${server.port}”) and serverProperties.getPort() report “0” as the port. Clearly, it is not the correct port we are expecting.

4.1. Using ServletWebServerApplicationContext

Spring Boot starts a ServletWebServerApplicationContext if the embedded web server starts.

Therefore, we can get the WebServer from the context object to obtain the server information or manipulate the server:

@Autowired
private ServletWebServerApplicationContext webServerAppCtxt;

@Test
public void given0AsServerPort_whenReadWebAppCtxt_thenGetThePort() {
    int port = webServerAppCtxt.getWebServer().getPort();
 
    assertTrue(port > 1023);
}

In the test above, we check if the port is greater than 1023. This is because 0-1023 are system ports.

4.2. Handling ServletWebServerInitializedEvent

A Spring application can publish various events and EventListeners handle the events.

When the embedded web server has started, a ServletWebServerInitializedEvent will be published. This event contains information about the webserver.

Therefore, we can create an EventListener to get the port from this event:

@Service
public class ServerPortService {
    private int port;

    public int getPort() {
        return port;
    }

    @EventListener
    public void onApplicationEvent(final ServletWebServerInitializedEvent event) {
        port = event.getWebServer().getPort();
    }
}

We can inject the service component to our test class to get the random port quickly:

@Autowired
private ServerPortService serverPortService;

@Test
public void given0AsServerPort_whenReadFromListener_thenGetThePort() {
    int port = serverPortService.getPort();
 
    assertTrue(port > 1023);
}

5. Conclusion

Usually, we configure the server port of a Spring Boot application in a properties file or YAML file, where we can set either a fixed or random port.

In this article, we’ve discussed different approaches to obtain the fixed and random port at runtime.

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