Hey guys! Ever found yourself in a situation where you need to run your Spring Boot application on a port other than the default 8080? Maybe that port is already in use, or perhaps you want to run multiple instances of your application simultaneously. Whatever the reason, changing the port in Spring Boot is a breeze. Let's dive into the various ways you can achieve this, making sure your app runs smoothly on your desired port. So, let’s explore how to run Spring Boot on a different port.

Why Change the Default Port?

Before we jump into the how-to, let's quickly touch on the why. Understanding the reasons behind changing the default port can help you appreciate the flexibility Spring Boot offers. Here's a few common scenarios:

• Port Conflicts: The most frequent reason. Another application might already be using port 8080, leading to a conflict. Changing the port resolves this issue.
• Multiple Instances: If you're running multiple instances of the same application (perhaps for testing or scaling), each instance needs to run on a different port to avoid conflicts.
• Security: While not a primary security measure, using a non-standard port can sometimes help obscure your application from simple scans.
• Custom Configurations: You might have specific organizational or infrastructure requirements that dictate the use of a particular port.

Method 1: Using application.properties or application.yml

This is the most common and straightforward method. Spring Boot automatically reads the application.properties or application.yml file in your src/main/resources directory to configure your application. To change the port, you simply need to add or modify the server.port property.

Steps:

1. Locate your configuration file: Find the application.properties or application.yml file in your src/main/resources directory. If you don't have one, create it.

2. Add the server.port property: Open the file and add the following line:

   For application.properties:

   server.port=8081
   

   For application.yml:

   server:
     port: 8081
   

3. Choose your port: Replace 8081 with the port number you want to use. Ensure the port is available and not being used by another application.

4. Restart your application: Save the file and restart your Spring Boot application. It should now be running on the specified port.

Explanation: The server.port property tells Spring Boot which port to bind the application's web server to. By default, if this property is not specified, Spring Boot uses port 8080. Using application.properties or application.yml is the preferred way to configure your application because it allows you to externalize configuration, making it easy to change settings without modifying your code. Remember that YAML files are indentation-sensitive, so ensure your indentation is correct.

Using application.properties or application.yml is generally the best practice because it keeps your configuration separate from your code. It's also easy to manage different configurations for different environments (e.g., development, testing, production) by using Spring Boot's profile feature.

Method 2: Using Command Line Arguments

Another way to change the port is by using command-line arguments when you run your Spring Boot application. This method is useful when you want to override the port setting without modifying your configuration files. It's especially handy for temporary changes or when running your application from a script.

Steps:

1. Open your terminal or command prompt: Navigate to the directory containing your Spring Boot application's JAR file or where you typically run the application from.

2. Run the application with the --server.port argument: Use the following command:

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

   Replace your-application.jar with the actual name of your JAR file and 8082 with the port number you want to use.

3. Verify the port: After running the command, your Spring Boot application should start on the specified port. Check the console output to confirm.

Explanation: The --server.port argument directly overrides the server.port property. When Spring Boot starts, it processes command-line arguments and applies them to the application's configuration. This method is particularly useful in environments where you might not have direct access to the configuration files or when you need to dynamically change the port based on external factors. Command-line arguments take precedence over the settings in application.properties or application.yml. This means that if you specify a port in both the configuration file and the command line, the command-line value will be used.

Command-line arguments offer a quick and flexible way to change the port without altering the application's configuration files. However, it's generally recommended to use configuration files for long-term settings to maintain consistency and avoid accidental changes.

Method 3: Using Environment Variables

Environment variables are a system-wide way to configure applications. They are particularly useful in production environments where you might want to manage configuration centrally. Spring Boot can read environment variables and use them to configure your application.

Steps:

1. Set the SERVER_PORT environment variable: How you set an environment variable depends on your operating system. Here's how to do it on different systems:

   • Linux/macOS: Use the export command:

     export SERVER_PORT=8083
     

   • Windows: Use the set command:

     set SERVER_PORT=8083
     

   You can also set environment variables through the system settings in Windows.

2. Run your Spring Boot application: Start your application as you normally would, without any command-line arguments.

3. Verify the port: Spring Boot should now be running on the port specified by the SERVER_PORT environment variable.

Explanation: Spring Boot automatically maps environment variables to configuration properties. In this case, the SERVER_PORT environment variable is mapped to the server.port property. This mapping is case-insensitive, and Spring Boot can handle different naming conventions (e.g., SERVER_PORT, server_port, server.port). Environment variables are a great way to manage configuration in a centralized and secure manner, especially in production environments. They allow you to change settings without modifying configuration files or command-line arguments. This is particularly useful in containerized environments like Docker, where environment variables are often used to pass configuration to containers.

Environment variables are ideal for production deployments where configuration needs to be managed externally. They provide a clean separation between the application and its environment.

Method 4: Programmatically Setting the Port

For advanced use cases, you can programmatically set the port in your Spring Boot application. This involves accessing the ConfigurableApplicationContext and setting the server.port property before the application starts. This method is less common but provides the most flexibility.

Steps:

1. Modify your main application class: Add the following code to your main Spring Boot application class:

   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.boot.builder.SpringApplicationBuilder;
   import org.springframework.context.ConfigurableApplicationContext;
   
   @SpringBootApplication
   public class YourApplication {
   
       public static void main(String[] args) {
           SpringApplicationBuilder builder = new SpringApplicationBuilder(YourApplication.class);
           builder.properties("server.port=8084");
           ConfigurableApplicationContext context = builder.run(args);
       }
   }
   

   Replace YourApplication with the name of your main application class and 8084 with the desired port number.

2. Run your application: Start your Spring Boot application. It should now be running on the programmatically specified port.

Explanation: This method uses the SpringApplicationBuilder to programmatically set the server.port property before the application context is created. The SpringApplicationBuilder allows you to customize the application context and set properties before the application starts. This approach is useful when you need to dynamically determine the port number based on some logic within your application. Programmatically setting the port provides the most control over the application's configuration, but it also makes the configuration part of your code, which can make it harder to manage in different environments. This method should be reserved for advanced use cases where you need to dynamically determine the port number at runtime.

Best Practices and Considerations

• Choose a method that suits your needs: Each method has its own advantages and disadvantages. Choose the one that best fits your use case and environment.
• Avoid hardcoding ports: Hardcoding ports in your code can make it difficult to manage your application in different environments. Use configuration files or environment variables instead.
• Document your configuration: Make sure to document how your application is configured, including the port it's running on. This will make it easier for others (and yourself) to understand and maintain your application.
• Check for port conflicts: Before starting your application, make sure the port you're using is not already in use by another application. You can use tools like netstat or lsof to check for port conflicts.
• Use profiles for different environments: Spring Boot profiles allow you to define different configurations for different environments (e.g., development, testing, production). Use profiles to manage your port settings in a consistent and organized manner.

Conclusion

So, there you have it! Changing the port in Spring Boot is super flexible, with several methods to choose from. Whether you prefer the simplicity of application.properties, the dynamism of command-line arguments, the centralization of environment variables, or the control of programmatic configuration, Spring Boot has you covered. Just remember to pick the method that best suits your needs and keep your configuration organized. Happy coding, and may your applications always run smoothly on the right port! By understanding these methods, you can ensure your Spring Boot applications run smoothly on your desired ports, avoiding conflicts and adapting to different environments. Remember to choose the method that best suits your needs and always document your configuration for easy maintenance.