Hey guys! Ever wondered how to change the default port of your Spring Boot application? By default, Spring Boot applications run on port 8080. But what if you want to run multiple applications on the same machine, or if port 8080 is already in use? Don't worry, it's super easy to configure a different port. Let's dive in and see how you can do it using different methods.

Why Change the Default Port?

Before we jump into the how-to, let's quickly touch on why you might want to change the default port in the first place. Here are a few common scenarios:

• Multiple Applications: If you're running multiple Spring Boot applications on the same server, each needs to run on a different port to avoid conflicts.
• Port Conflicts: Sometimes, another application might already be using port 8080. Changing your Spring Boot application's port resolves this conflict.
• Security: While not a primary security measure, using a non-standard port can sometimes reduce the risk of automated attacks that target default ports.
• Specific Requirements: Your organization or project might have specific requirements for which ports to use.

Method 1: Using application.properties or application.yml

This is the most common and straightforward way to configure the port. Spring Boot automatically picks up the application.properties or application.yml file in your src/main/resources directory. Let's look at how to do it with both file types.

Using application.properties

If you're using application.properties, simply add the following line to your file:

server.port=8081

Here, we're setting the port to 8081. You can replace 8081 with any available port number you prefer. Just make sure it's not already in use by another application.

Explanation:

• server.port: This is the property that Spring Boot uses to configure the port on which the application will listen for incoming requests.
• 8081: This is the value you're assigning to the server.port property. It tells Spring Boot to use port 8081 instead of the default 8080.

Example:

1. Open your src/main/resources/application.properties file.
2. Add the line server.port=8081.
3. Save the file.
4. Run your Spring Boot application. It will now be accessible at http://localhost:8081.

Using application.yml

If you prefer using YAML, you can achieve the same result with application.yml:

server:
  port: 8081

Explanation:

• server:: This is the top-level key that groups server-related configurations.
• port:: This is the key under server that specifies the port number.
• 8081: This is the value assigned to the port key, indicating the application should run on port 8081.

Example:

1. Open your src/main/resources/application.yml file.

2. Add the lines:

   server:
     port: 8081
   

3. Save the file.

4. Run your Spring Boot application. It will now be accessible at http://localhost:8081.

   | Read Also : Impl Season 11 Live Today: Watch In Indonesia!

Paragraph Deep Dive

Configuring server ports is a fundamental aspect of deploying Spring Boot applications. The server.port property, whether set in application.properties or application.yml, dictates the port on which your application listens for incoming HTTP requests. By default, Spring Boot uses port 8080, but this is often insufficient for production environments or when running multiple applications locally. Changing the port is incredibly straightforward. Using application.properties, you simply add the line server.port=YOUR_DESIRED_PORT. Alternatively, in application.yml, you'd use a hierarchical structure: server: port: YOUR_DESIRED_PORT. For example, setting server.port=8081 in application.properties or its equivalent in application.yml will cause your application to be accessible via http://localhost:8081. This method is not only the most common but also the most easily manageable as it centralizes configuration within a dedicated file. Moreover, this approach can be extended to include environment-specific configurations using profiles, which allows you to define different port numbers for development, testing, and production environments. Remember to choose a port number that is not commonly used by other services and is within the valid range (1-65535). Proper port management ensures that your Spring Boot applications run smoothly and without conflicts, making it an essential skill for any Spring Boot developer. This ease of configuration contributes to Spring Boot's popularity, allowing developers to focus on building features rather than wrestling with complex configuration setups. It's also good practice to document why a particular port was chosen, especially in larger projects, to avoid confusion and conflicts in the future. Remember to restart your application after making these changes for them to take effect.

Method 2: Using Command Line Arguments

Another way to configure the port is by using command-line arguments when you run your Spring Boot application. This is useful for overriding the port defined in your configuration files or for testing purposes.

To specify the port via the command line, use the --server.port argument:

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

Replace your-application.jar with the name of your JAR file, and 9000 with the desired port number. When you run your application with this command, it will listen on port 9000, regardless of what's defined in your application.properties or application.yml file.

Explanation:

• java -jar your-application.jar: This is the standard command to run a Spring Boot application packaged as a JAR file.
• --server.port=9000: This is the command-line argument that overrides the server.port property. The double hyphens indicate that it's a command-line argument.

Example:

1. Open your terminal or command prompt.
2. Navigate to the directory containing your JAR file.
3. Run the command: java -jar your-application.jar --server.port=9000
4. Your application will now be accessible at http://localhost:9000.

Paragraph Deep Dive

Command-line arguments offer a dynamic way to configure your Spring Boot application's port, bypassing the configurations specified in application.properties or application.yml. This approach is particularly useful in environments where configurations need to be altered on the fly without modifying the application's configuration files directly. By using the --server.port=YOUR_DESIRED_PORT argument when launching the application, you can easily specify a different port. For example, the command java -jar myapp.jar --server.port=8082 will start the Spring Boot application on port 8082, overriding any server.port setting in the application.properties or application.yml file. This method is incredibly valuable for testing different configurations or deploying applications in environments where the port needs to be dynamically assigned. Furthermore, command-line arguments are often used in conjunction with CI/CD pipelines where configurations are determined at deployment time. While this approach provides flexibility, it's essential to ensure that the command-line arguments are properly documented and managed, especially in team environments. Using command-line arguments for port configuration offers a powerful and immediate way to control your application's behavior, especially when you need to adapt to changing environments or testing scenarios. This dynamic configuration capability makes Spring Boot applications highly adaptable to various deployment contexts, ensuring they can run effectively in diverse environments. Remember that the command-line argument will take precedence over the properties file, providing a clear and immediate way to override the configured port. It is a good practice to script or document these command-line arguments to maintain consistency and avoid errors during deployment.

Method 3: Setting the Port Programmatically

You can also configure the port programmatically within your Spring Boot application. This is less common than the previous methods but can be useful in certain situations where you need more dynamic control over the port.

To set the port programmatically, you can use the WebServerFactoryCustomizer interface.

import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;
import org.springframework.stereotype.Component;

@Component
public class ServerPortCustomizer implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {

    @Override
    public void customize(ConfigurableServletWebServerFactory factory) {
        factory.setPort(9001);
    }
}

Explanation:

• @Component: This annotation makes the class a Spring-managed component.
• WebServerFactoryCustomizer: This interface allows you to customize the web server factory.
• ConfigurableServletWebServerFactory: This is the factory class that creates the web server.
• factory.setPort(9001): This line sets the port to 9001.

Example:

1. Create a new class named ServerPortCustomizer in your project.
2. Add the code above to the class.
3. Run your Spring Boot application. It will now be accessible at http://localhost:9001.

Paragraph Deep Dive

Programmatically configuring the port in a Spring Boot application offers the most flexibility but is also the least common approach. This method involves using the WebServerFactoryCustomizer interface to customize the web server factory directly. By implementing this interface, you can gain fine-grained control over the server's configuration, including the port. For instance, you can create a class annotated with @Component that implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory>. Within the customize method, you can then call factory.setPort(YOUR_DESIRED_PORT) to set the port. For example: factory.setPort(8083) would configure the application to listen on port 8083. This approach is particularly useful when you need to dynamically determine the port based on runtime conditions, such as environment variables or system properties. While this method provides significant flexibility, it also adds complexity to the codebase and can make it harder to manage configurations, especially in larger projects. Therefore, it's generally recommended to use this method only when the other methods (e.g., application.properties or command-line arguments) are insufficient. Programmatic configuration allows for highly adaptable and dynamic port assignments, catering to scenarios where static configurations are inadequate. However, developers should carefully weigh the benefits against the increased complexity and maintainability overhead. Remember to handle exceptions and edge cases appropriately when using this method to ensure the application behaves predictably in all scenarios. This method is best suited for advanced use cases where runtime decisions need to influence the port on which the application runs, allowing for unparalleled customization.

Choosing the Right Method

So, which method should you use? Here's a quick guide:

• application.properties or application.yml: This is the recommended method for most cases. It's simple, easy to understand, and keeps your configuration centralized.
• Command Line Arguments: Use this when you need to override the port defined in your configuration files, especially for testing or deployment purposes.
• Programmatic Configuration: Use this only when you need dynamic control over the port based on runtime conditions.

Conclusion

Configuring the port in your Spring Boot application is a breeze! Whether you prefer using application.properties, command-line arguments, or programmatic configuration, you have the flexibility to choose the method that best suits your needs. So go ahead and customize your port and happy coding!