Running a Spring Boot application on a different port than the default (8080) is a common requirement. Whether you're dealing with port conflicts, deploying multiple applications, or adhering to specific organizational policies, configuring a different port is straightforward. Let's dive into the various methods to achieve this.

Why Change the Default Port?

Before we get started, it's important to understand why you might need to change the default port. Here are a few common reasons:

• Port Conflicts: The default port 8080 might already be in use by another application on your system.
• Multiple Applications: You might want to run multiple Spring Boot applications on the same machine, each on a different port.
• Security: In some cases, changing the default port can be a simple security measure.
• Organizational Policies: Your organization might have specific policies regarding which ports applications should use.

Now, let's explore the different ways to configure your Spring Boot application to run on a different port.

Method 1: Using application.properties or application.yml

The most common and recommended way to change the port is by using the application.properties or application.yml file in your Spring Boot project. These files are located in the src/main/resources directory.

Using application.properties

Open your application.properties file and add the following line:

server.port=8081

Replace 8081 with the port number you want to use. This is the most straightforward approach and is generally preferred for simple configurations. The server.port property tells Spring Boot to listen for incoming requests on the specified port. Make sure the port you choose is not already in use by another application. Choosing a port number above 1024 is generally recommended, as ports below that number often require special permissions.

Once you've added this line, save the file and restart your Spring Boot application. You should now see that the application is running on the new port. You can verify this by checking the console output during startup. The logs will typically indicate the port the application is listening on. For example, you might see a message like "Tomcat started on port(s): 8081 (http)". This confirms that the configuration change was successful.

It's also worth noting that you can use environment variables to override properties defined in application.properties. This can be useful for deploying your application to different environments (e.g., development, staging, production) without modifying the configuration file directly. We'll discuss environment variables in more detail later.

Remember to keep your configuration files organized and well-documented. This will make it easier to maintain your application and troubleshoot any issues that may arise. Consistent formatting and clear comments can significantly improve the readability of your configuration files.

Using application.yml

If you prefer using YAML for configuration, you can achieve the same result by modifying your application.yml file. Open the file and add the following:

server:
  port: 8081

Again, replace 8081 with your desired port number. YAML offers a more structured and readable format compared to application.properties, especially for complex configurations. The indentation is crucial in YAML, so make sure to maintain the correct structure. Incorrect indentation can lead to parsing errors and unexpected behavior.

Similar to application.properties, you can use environment variables to override values defined in application.yml. This provides flexibility and allows you to adapt your application's configuration to different environments without altering the YAML file itself.

When choosing between application.properties and application.yml, consider the complexity of your configuration. For simple settings like the port number, either format works well. However, for more intricate configurations with nested properties and lists, YAML often provides a cleaner and more maintainable solution. Ultimately, the choice depends on your personal preference and the specific requirements of your project.

Remember to save the file and restart your application after making changes to application.yml. As with application.properties, you can verify the new port by checking the console output during startup.

Method 2: Using Command-Line Arguments

Another way to specify the port is by using command-line arguments when running your Spring Boot application. This method is useful for overriding the port defined in your configuration files or when you don't want to modify the configuration files at all.

To specify the port using a command-line argument, use the following syntax:

java -jar your-application.jar --server.port=8082

Replace your-application.jar with the name of your JAR file and 8082 with the port number you want to use. This approach is particularly useful for one-off executions or when you need to quickly change the port without modifying the configuration files. It allows you to run the application with a different port without permanently altering the project's configuration.

When using command-line arguments, the specified value will override any port configuration defined in application.properties or application.yml. This provides a convenient way to temporarily modify the application's behavior without affecting the default configuration.

Keep in mind that command-line arguments are typically used for specific instances of running the application. For persistent configuration changes, it's generally recommended to modify the application.properties or application.yml file.

This method is very helpful in scripting and automated deployments where you might want to dynamically set the port based on the environment or other factors. Command-line arguments provide a flexible and powerful way to control the application's behavior at runtime.

Method 3: Using Environment Variables

Environment variables provide a way to configure your application based on the environment it's running in. This is particularly useful for deploying your application to different environments (e.g., development, staging, production) without modifying the configuration files.

To specify the port using an environment variable, you first need to set the environment variable. The name of the environment variable should be SERVER_PORT. The exact steps to set an environment variable depend on your operating system.

Setting Environment Variables (Example)

• Linux/macOS:

  export SERVER_PORT=8083
  

• Windows:

  $env:SERVER_PORT=8083
  

Replace 8083 with the desired port number. Environment variables offer a powerful way to configure applications dynamically based on the environment they are running in. This is especially useful in cloud environments where configuration is often managed through environment variables.

Spring Boot automatically detects environment variables and uses them to override configuration properties. This means that if you set the SERVER_PORT environment variable, Spring Boot will use the specified port number, even if a different port is defined in application.properties or application.yml.

When using environment variables, it's important to ensure that the environment variable is set correctly before starting the application. Otherwise, Spring Boot will use the default port or the port defined in the configuration files.

This method is highly recommended for production deployments, as it allows you to manage configuration centrally and avoid modifying application code or configuration files when deploying to different environments. Environment variables promote separation of concerns and improve the overall maintainability of your application.

Method 4: Programmatically Setting the Port

While less common, you can also set the port programmatically within your Spring Boot application. This approach is useful when you need to dynamically determine the port number based on some logic or external factor.

To set the port programmatically, you can use the SpringApplicationBuilder class. Here's an example:

import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.boot.web.server.ConfigurableWebServerFactory;
import org.springframework.stereotype.Component;

@Component
public class ServerPortCustomizer implements WebServerFactoryCustomizer<ConfigurableWebServerFactory> {

    @Override
    public void customize(ConfigurableWebServerFactory factory) {
        factory.setPort(8084);
    }
}

In this example, we're creating a component that implements the WebServerFactoryCustomizer interface. This allows us to customize the web server factory and set the port number programmatically. This approach provides maximum flexibility but requires writing code.

The customize method is called when the web server factory is being configured. Inside this method, we're calling the setPort method to set the port number to 8084. You can replace 8084 with any port number you desire.

This approach is less common than using configuration files or command-line arguments, but it can be useful in certain situations where you need to dynamically determine the port number. Programmatic configuration provides the greatest degree of control but also requires more effort to implement.

Remember to include the necessary imports and annotations to ensure that the component is properly registered and the customization is applied.

Conclusion

Changing the port of your Spring Boot application is a simple but essential task. Whether you choose to use application.properties, application.yml, command-line arguments, environment variables, or programmatic configuration, understanding these methods gives you the flexibility to deploy your application in various environments and scenarios. Remember to choose the method that best suits your needs and always verify that your application is running on the correct port after making changes. By mastering these techniques, you can ensure that your Spring Boot applications are properly configured and running smoothly.