Hey guys! Configuring your Spring Boot application to run on a specific port in IntelliJ is super easy and something you'll probably do quite often. Whether you're avoiding conflicts with other applications or just want to use a non-standard port for testing, this guide will walk you through several methods to get it done. Let's dive in!

Method 1: Using application.properties or application.yml

The most common and straightforward way to change the port is by setting the server.port property in your application.properties or application.yml file. This is the recommended approach because it keeps your configuration centralized and easy to manage.

Steps:

1. Locate your configuration file: Your Spring Boot project should have either an application.properties or application.yml file in the src/main/resources directory. If you don't have one, create it.

2. Open the file: Open the application.properties or application.yml file in IntelliJ.

3. Add the server.port property:

   • For application.properties, add the following line:

     server.port=8081
     

   • For application.yml, add the following lines:

     server:
       port: 8081
     

   Replace 8081 with the port number you want to use. Common alternatives are 8080 (if it's not already in use), 8082, 8083, or any other available port.

4. Save the file: Save the changes to your application.properties or application.yml file.

5. Restart your application: Restart your Spring Boot application in IntelliJ. IntelliJ will automatically pick up the new port configuration from your file.

Explanation:

The server.port property tells Spring Boot which port to bind the application's web server to. By default, if you don't specify a port, Spring Boot will use port 8080. Setting this property overrides the default. Using either application.properties or application.yml is largely a matter of preference. application.properties uses a simple key-value format, while application.yml uses a more structured YAML format, which can be easier to read for complex configurations. Make sure to choose the format that you are most comfortable with and that best suits your project's needs.

It's also worth noting that you can define different port numbers for different environments (e.g., development, testing, production) by using Spring profiles. For example, you can have an application-dev.properties file with server.port=9000 and an application-prod.properties file with server.port=80. This allows you to easily switch between different configurations without modifying your main configuration file. Remember to activate the appropriate profile when running your application in IntelliJ.

This method is very easy to maintain. If you need to change the port number in the future, you can simply update the server.port property in the configuration file. This also makes it easy to deploy your application to different environments with different port configurations, as you can simply use different configuration files for each environment.

Method 2: Using VM Options in IntelliJ

Another way to change the port is by using VM options in your IntelliJ run configuration. This is useful if you want to override the port setting without modifying your configuration files, or if you're running the application from the command line.

Steps:

1. Open Run/Debug Configurations: In IntelliJ, go to Run -> Edit Configurations...

2. Select your Spring Boot run configuration: In the left panel, select the run configuration for your Spring Boot application.

3. Add VM options: In the right panel, under the Configuration tab, find the VM options field. Add the following VM option:

   -Dserver.port=8081
   

   Again, replace 8081 with your desired port number.

4. Apply and Run: Click Apply and then OK to save the changes. Now, run your application. It should start on the port you specified in the VM options.

Explanation:

VM options are arguments passed to the Java Virtual Machine (JVM) when the application starts. The -D flag is used to define system properties. In this case, we're setting the server.port system property, which Spring Boot recognizes and uses to configure the port. Using VM options is a convenient way to override the port number without having to modify your configuration files. This can be useful if you want to run your application on a different port for testing purposes, or if you want to deploy your application to a different environment without having to change the configuration files. However, it's important to note that VM options take precedence over the settings in your configuration files. This means that if you set the server.port property in both your configuration file and the VM options, the VM options will override the setting in the configuration file.

One of the advantages of using VM options is that you can easily change the port number without having to modify your configuration files. This can be useful if you want to run your application on different ports for different environments. However, it's important to remember that VM options are specific to the run configuration in IntelliJ. This means that if you run your application from the command line or from a different IDE, you will need to specify the VM options again. Therefore, for more consistent and portable configurations, using the application.properties or application.yml file is generally preferred.

Method 3: Programmatically in your Spring Boot Application

While not as common for simple port changes, you can also programmatically set the port in your Spring Boot application. This is useful if you need to determine the port dynamically at runtime based on some condition.

Steps:

1. Access the ApplicationContext: You'll need access to the ApplicationContext in your Spring Boot application. You can typically achieve this by implementing ApplicationContextAware or using @Autowired to inject the ApplicationContext.
2. Modify the embedded server: Use the WebServerFactoryCustomizer to modify the embedded servlet container's port.

Here's an example:

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(8081);
    }
}

3. Run your application: When your Spring Boot application starts, the customize method in ServerPortCustomizer will be executed, setting the port to 8081.

Explanation:

In this method, we're creating a WebServerFactoryCustomizer bean that implements the customize method. This method is called by Spring Boot during the application's startup process. Inside the customize method, we're setting the port of the ConfigurableServletWebServerFactory to the desired port number. This method allows you to programmatically configure the embedded servlet container. This approach is more flexible than using application.properties or VM options, as you can dynamically determine the port number based on runtime conditions. For example, you can read the port number from an environment variable or from a database. However, it's also more complex, as you need to write code to configure the servlet container. Therefore, this method is typically only used when you need to dynamically determine the port number at runtime.

One of the advantages of using this method is that you can easily change the port number without having to modify your configuration files or VM options. This can be useful if you want to run your application on different ports for different environments. However, it's important to remember that this method is more complex than using application.properties or VM options. Therefore, it's important to carefully consider whether this method is the right choice for your needs.

Choosing the Right Method

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

• application.properties or application.yml: Use this for most cases. It's the standard, easiest to maintain, and keeps your configuration centralized.
• VM Options: Use this for overriding the port temporarily without changing configuration files. Good for testing or specific deployment scenarios.
• Programmatically: Use this when you need to determine the port dynamically at runtime.

In conclusion, changing the port in Spring Boot using IntelliJ is a straightforward process with multiple options available. Whether you prefer the simplicity of application.properties, the flexibility of VM options, or the dynamic control of programmatic configuration, you can easily tailor your application's port settings to suit your needs. Happy coding!