How to configure port for a Spring Boot application

Question

How do I configure the TCP/IP port listened on by a Spring Boot application, so it does not use the default port of 8080.

Answer 1

As said in docs either set server.port as system property using command line option to jvm -Dserver.port=8090 or add application.properties in /src/main/resources/ with

server.port=8090

For a random port use:

server.port=0

Similarly add application.yml in /src/main/resources/ with:

server:
  port: 8090

Answer 2

There are two main ways to change the port in the Embedded Tomcat in a Spring Boot Application.

Modify application.properties

First you can try the application.properties file in the /resources folder:

server.port = 8090

Modify a VM option

The second way, if you want to avoid modifying any files and checking in something that you only need on your local, you can use a vm arg:

Go to Run -> Edit Configurations -> VM options

-Dserver.port=8090

Additionally, if you need more information you can view the following blog post here: Changing the port on a Spring Boot Application

Answer 3

Since Spring Boot provides various configuration externalization mechanism (through various PropertySource implementations and/or processors wired into Environment object in order), you can set any property outside of your jar archive through following methods:

1. Pass property through command line argument as application argument

   java -jar <path/to/my/jar> --server.port=7788
   

2. From property in SPRING_APPLICATION_JSON (Spring Boot 1.3.0+)

   • Define environment variable in U*IX shell:

     SPRING_APPLICATION_JSON='{"server.port":7788}' java -jar <path/to/my/jar>
     

   • By using Java system property:

     java -Dspring.application.json='{"server.port":7788}' -jar <path/to/my/jar>
     

   • Pass through command line argument:

     java -jar <path/to/my/jar> --spring.application.json='{"server.port":7788}'
     

3. Define JVM system property

   java -Dserver.port=7788 -jar <path/to/my/jar>
   

4. Define OS environment variable

   • U*IX Shell

     SERVER_PORT=7788 java -jar <path/to/my/jar>
     

   • Windows

     SET SERVER_PORT=7788
     java -jar <path/to/my/jar>
     

5. Place property in ./config/application.properties configuration file

   server.port=7788
   

   and run:

    java -jar <path/to/my/jar>
   

6. Place property in ./config/application.yaml

   server:
       port: 7788
   

   and run:

    java -jar <path/to/my/jar>
   

7. Place property in ./application.properties

   server.port=7788
   

   and run:

    java -jar <path/to/my/jar>
   

8. Place property in ./application.yaml

   server:
       port: 7788
   

   and run:

    java -jar <path/to/my/jar>
   

---

You can combine above methods all together, and the former configuration in the list take precedence over the latter one.

For example:

SERVER_PORT=2266 java -Dserver.port=5566 -jar <path/to/my/jar> --server.port=7788

The server will start and listen on port 7788.

This is very useful providing default properties in PropertySources with lower precedence (and usually packaged in the archive or coded in the source), and then override it in the runtime environment. And it is the design philosophy of Spring Boot:

Be opinionated out of the box, but get out of the way quickly as requirements start to diverge from the defaults.

---

SERVER_NAME to server.name conversion was done by Relaxed Binding.

Answer 4

Also, you can configure the port programmatically.

For Spring Boot 2.x.x:

@Configuration
public class CustomContainer implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
  public void customize(ConfigurableServletWebServerFactory factory){
    factory.setPort(8042);
  }
}

For older versions:

@Configuration
public class ServletConfig {
    @Bean
    public EmbeddedServletContainerCustomizer containerCustomizer() {
        return (container -> {
            container.setPort(8012);
        });
    }
}

Answer 5

If you would like to run it locally, use this -

mvn spring-boot:run -Drun.jvmArguments='-Dserver.port=8085'

As of Spring Boot 2.0, here's the command that works:

mvn spring-boot:run -Dspring-boot.run.arguments=--server.port=8085

clues were at:

• Maven spring boot run debug with arguments

Answer 6

You can set port in java code:

HashMap<String, Object> props = new HashMap<>();
props.put("server.port", 9999);

new SpringApplicationBuilder()
    .sources(SampleController.class)                
    .properties(props)
    .run(args);

Or in application.yml:

server:
    port: 9999

Or in application.properties:

server.port=9999

Or as a command line parameter:

-Dserver.port=9999

Answer 7

In case you are using application.yml add the Following lines to it

server:
     port: 9000

and of course 0 for random port.

Answer 8

As explained in Spring documentation, there are several ways to do that:

Either you set the port in the command line (for example 8888)

-Dserver.port=8888 or --server.port=8888

Example : java -jar -Dserver.port=8888 test.jar

Or you set the port in the application.properties

server.port=${port:4588}

or (in application.yml with yaml syntax)

server:
   port: ${port:4588}

If the port passed by -Dport (or -Dserver.port) is set in command line then this port will be taken into account. If not, then the port will be 4588 by default.

If you want to enforce the port in properties file whatever the environment variable, you just have to write:

server.port=8888

Answer 9

Include below property in application.properties

server.port=8080

Answer 10

When you need a programatically way of doing it, you can set it during startup:

System.getProperties().put( "server.port", 80 );
SpringApplication.run(App.class, args);

This might help for things like environment dependent port. Have a nice day

Answer 11

if you are using gradle as the build tool, you can set the server port in your application.yml file as:

server:
  port: 8291

If you are using maven then the port can be set in your application.properties file as:

server.port: 8291

Answer 12

To extend other answers:

There is a section in the docs for testing which explains how to configure the port on integration tests:

• 41.3 Testing Spring Boot applications
• 41.3.3 Working with random ports

---

At integration tests, the port configuration is made using the annotation @SpringBootTest and the webEnvironment values.

---

Random port:

@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)

You can inject the value using @LocalServerPort which is the same as @Value("${local.server.port}").

• Example:

Random port test configuration:

@RunWith(SpringRunner.class
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class ExampleTest {
   ...
   @LocalServerPort //to inject port value
   int port;
}

---

Defined port:

@SpringBootTest(webEnvironment=WebEnvironment.DEFINED_PORT)

It takes the value from server.port if is defined.

• If is defined using @TestPropertySource(properties = "server.port=9192"), it overrides other defined values.
• If not, it takes the value from src/test/resources/application.properties (if exists).
• And finally, if it is not defined it starts with the default 8080.

Example:

Defined port test configuration:

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
@TestPropertySource(properties = "server.port=9192")
public class DemoApplicationTests {

    @Test
    public void contextLoads() {
    }

}

Answer 13

You can specify port by overriding EmbeddedServletContainerFactory bean within your configuration (java based or xml). There you can specify port for used embedded servlet container. Please, see Spring Boot - Core "Embedded Servlet Container Support" paragraph and example there. Hope this helps.

Answer 14

In application.properties file present in resources:

server.port=8082

Answer 15

There are three ways to do it depending on the application configuration file you are using

a) If you are using application.properties file set

server.port = 8090

b) If you are using application.yml file set server port property in YAML format as given below

server:
     port: 8090

c) You can also Set the property as the System property in the main method

System.setProperty("server.port","8090");

Answer 16

There are many other stuffs you can alter in server configuration by changing application.properties. Like session time out, address and port etc. Refer below post

ref: http://docs.spring.io/spring-boot/docs/1.4.x/reference/html/common-application-properties.html

I used few of them as below.

server.session.timeout=1
server.port = 3029
server.address= deepesh

Answer 17

Add this in your application.properties file

server.port= 8080

Answer 18

1. As everyone said, you can specify in application.properties
   server.port = 9000 (could be any other value)

2. If you are using spring actuator in your project, by default it points to
   8080, and if you want to change it, then in application.properties mention
   management.port = 9001 (could be any other value)

Answer 19

In the application.properties file, add this line:

server.port = 65535

where to place that fie:

24.3 Application Property Files

SpringApplication loads properties from application.properties files in the following locations and adds them to the Spring Environment:

A /config subdirectory of the current directory
The current directory
A classpath /config package
The classpath root

The list is ordered by precedence (properties defined in locations higher in the list override those defined in lower locations).

In my case I put it in the directory where the jar file stands.

From:

https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-external-config-application-property-files

Answer 20

By default spring boot app start with embedded tomcat server start at default port 8080. spring provides you with following different customization you can choose one of them.

NOTE – you can use server.port=0 spring boot will find any unassigned http random port for us.

1) application.properties

server.port=2020

2) application.yml

server:  
     port : 2020

3) Change the server port programatically

3.1) By implementing WebServerFactoryCustomizer interface - Spring 2.x

@Component
public class MyTomcatWebServerCustomizer implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> {

    @Override
    public void customize(TomcatServletWebServerFactory factory) {
        // customize the factory here
        factory.setPort(2020);
    }
}

3.2) By Implementing EmbeddedServletContainerCustomizer interface - Spring 1.x

@Component
public class CustomizationBean implements EmbeddedServletContainerCustomizer {

    @Override
    public void customize(ConfigurableEmbeddedServletContainer container) {
        // customize here
        container.setPort(2020);
    }
}

4) By using command line option

 java -jar spring-boot-app.jar -Dserver.port=2020

Answer 21

Indeed, the easiest way is to set the server.port property.

If you are using STS as IDE, from version 3.6.7 you actually have Spring Properties Editor for opening the properties file.

This editor provides autocomplete for all Spring Boot properties. If you write port and hit CTRL + SPACE, server.port will be the first option.

Answer 22

By default, spring-web module provides an embedded tomcat server that is running under the port number 8080. If you need to change the port number of the application then go to application.properties file and configure the port number by using server.port property.

  server.port= 9876

then your application is running under the port 9876.

Answer 23

Hope this one help

application.properties=> 

server.port=8090

application.yml=> 

server
  port:8090

Answer 24

Using property server.port=8080 for instance like mentioned in other answers is definitely a way to go. Just wanted to mention that you could also expose an environment property:

SERVER_PORT=8080

Since spring boot is able to replace "." for "_" and lower to UPPER case for environment variables in recent versions. This is specially useful in containers where all you gotta do is define that environment variable without adding/editing application.properties or passing system properties through command line (i.e -Dserver.port=$PORT)

Answer 25

You can add the port in below methods.

1. Run -> Configurations section

2. In application.xml add server.port=XXXX

Answer 26

Just have a application.properties in src/main/resources of the project and give there

server.port=****

where **** refers to the port number.

Answer 27

1.1 Update via a properties file.

/src/main/resources/application.properties

server.port=8888

Update via a yaml file.

   server:

     port: 8888

EmbeddedServletContainerCustomizer

@Component
public class CustomContainer implements EmbeddedServletContainerCustomizer {

    @Override
    public void customize(ConfigurableEmbeddedServletContainer container) {

        container.setPort(8888);

    }

}

Answer 28

Providing the port number in application.properties file will resolve the issue

 server.port = 8080

"port depends on your choice, where you want to host the application"

Answer 29

Running by Gradle:

• Run in default port(8080): ./gradlew bootRun
• Run in provided port(8888): ./gradlew bootRun --args='--server.port=8888'
• If we have any variable in the application.properties file named PORT, run this: PORT=8888 ./gradlew bootRun

Running by Maven:

• Run in default port(8080): mvnw spring-boot:run
• Run in provided port(8888): mvnw spring-boot:run -Dspring-boot.run.jvmArguments='-Dserver.port=8085'
• Run in provided port(8888): mvn spring-boot:run -Dspring-boot.run.arguments='--server.port=8085'
• Run in provided port(8888) with other custom property: mvn spring-boot:run -Dspring-boot.run.arguments="--server.port=8899 --your.custom.property=custom"
• If we have any variable in the application.properties file named PORT, run this: SERVER_PORT=9093 mvn spring-boot:run

Using java -jar:

• Create the .jar file:
  • For Gradle: ./gradlew clean build. We will find the jar file inside: build/libs/ folder.
  • For Maven: mvn clean install. We will find the jar file inside:target folder.
• Run in default port(8080): java -jar myApplication. jar
• Run in provided port(8888): java -jar myApplication.jar --port=8888
• Run in provided port(8888): java -jar -Dserver.port=8888 myApplication.jar
• Run in provided port(8888) having variable SERVER_PORT in application.properties file: SERVER_PORT=8888 java -jar target/myApplication.jar

Answer 30

You can also use SERVER_PORT environment variable to configure Spring Boot port. Just set the environment variable and restart the app:

set SERVER_PORT=9999 // on windows machine
export SERVER_PORT=9999 // on linux

Please note that if you do not set those environment variables system wide, you should run the boot app on the same session.