How to configure port for a Spring Boot application
JavaSpringSpring BootServerPortJava Problem Overview
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.
Java Solutions
Solution 1 - Java
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 random port use
server.port=0
Similarly add application.yml
in /src/main/resources/
with
server:
port : 8090
Solution 2 - Java
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
Solution 3 - Java
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:
-
Pass property through command line argument as application argument
java -jar <path/to/my/jar> --server.port=7788
-
From property in
SPRING_APPLICATION_JSON
(Spring Boot 1.3.0+)
-
Define environment variable in U*IX shell:
<!-- language: lang-bash --> SPRING_APPLICATION_JSON='{"server.port":7788}' java -jar <path/to/my/jar>
-
By using Java system property:
<!-- language: lang-bash --> java -Dspring.application.json='{"server.port":7788}' -jar <path/to/my/jar>
-
Pass through command line argument:
<!-- language: lang-bash --> java -jar <path/to/my/jar> --spring.application.json='{"server.port":7788}'
-
Define JVM system property
java -Dserver.port=7788 -jar <path/to/my/jar>
-
Define OS environment variable
-
U*IX Shell
<!-- language: lang-bash --> SERVER_PORT=7788 java -jar <path/to/my/jar>
-
Windows
<!-- language: lang-vb --> SET SERVER_PORT=7788 java -jar <path/to/my/jar>
-
Place property in
./config/application.properties
configuration fileserver.port=7788
and run:
java -jar <path/to/my/jar>
-
Place property in
./config/application.yaml
server: port: 7788
and run:
java -jar <path/to/my/jar>
-
Place property in
./application.properties
server.port=7788
and run:
java -jar <path/to/my/jar>
-
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.
Solution 4 - Java
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);
});
}
}
Solution 5 - Java
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
Solution 6 - Java
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 (clues were here):
mvn spring-boot:run -Dspring-boot.run.arguments=--server.port=8085
Solution 7 - Java
In case you are using application.yml
add the Following lines to it
server:
port: 9000
and of course 0 for random port.
Solution 8 - Java
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
Solution 9 - Java
Include below property in application.properties
server.port=8080
Solution 10 - Java
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
Solution 11 - Java
To extend other answers:
There is a section in the docs for testing which explains how to configure the port on integration tests:
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() {
}
}
Solution 12 - Java
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
Solution 13 - Java
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.
Solution 14 - Java
In application.properties
file present in resources:
server.port=8082
Solution 15 - Java
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");
Solution 16 - Java
Add this in your application.properties
file
server.port= 8080
Solution 17 - Java
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
Solution 18 - Java
-
As everyone said, you can specify in application.properties
server.port = 9000 (could be any other value) -
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)
Solution 19 - Java
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:
Solution 20 - Java
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
Solution 21 - Java
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.
Solution 22 - Java
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.
Solution 23 - Java
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
)
Solution 24 - Java
Hope this one help
application.properties=>server.port=8090
application.yml=>
server port:8090
Solution 25 - Java
You can add the port in below methods.
-
Run -> Configurations section
-
In
application.xml
addserver.port=XXXX
Solution 26 - Java
Just have a application.properties
in src/main/resources
of the project and give there
server.port=****
where ****
refers to the port number.
Solution 27 - Java
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);
}
}
Solution 28 - Java
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"
Solution 29 - Java
You can set that in application.properties under /src/main/resources/
server.port = 8090
Solution 30 - Java
By Default Spring-web module provides an embedded tomcat server runs on port number 8080.
You can change it as follows -
A) If you are using gradle then use can set the property in your application.yml :
server:
port: 8042
B) If you are using maven then you can set the property in your application.properties :
server.port: 8042
C) When you have port in your own config file and want to set it during runtime.
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(8042);
}
}
By Implementing EmbeddedServletContainerCustomizer interface - Spring 1.x
@Component
public class CustomizationBean implements EmbeddedServletContainerCustomizer {
@Override
public void customize(ConfigurableEmbeddedServletContainer container) {
// customize here
container.setPort(8042);
}
}
Solution 31 - Java
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.
Solution 32 - Java
Mostly springboot runs on port:8080
because of embedded Tomcat. In some it may throw an error port 8080 already in use
. To avoid this kind of issues we can config the server port.
Using application.properties
add server.port=9898
On runtime config
run your application with below arguments.
spring-boot:run -Drun.jvmArguments='-Dserver.port=8081'
Solution 33 - Java
You can configure your port in application.properties file in the resources folder of your spring boot project.
server.port="port which you need"
Solution 34 - Java
"server.port=8080" will only works if your running application as a jar through main method,
This configuration will not work if your running this application as a war file through tomcat container.
Solution 35 - Java
If you are going to run apps as jar file in command environment, just type "SERVER_PORT=*** " as prefix. The full command to execute will look like below:
SERVER_PORT=8080 java -jar ***.jar
If you wanna run app in background in Linux, command with 'nohup' will look like below:
SERVER_PORT=8080 nohup java -jar ***.jar &
Solution 36 - Java
There are three ways to do it
1 Set server.port property in application.properties
file
server.port = 8090
2 Set server port property in application.yml
file
server:
port: 8090
3 Set the property as system property in main
method
System.setProperty("server.port","8090");
Solution 37 - Java
Just set the environment variable SERVER_PORT
.
(The examples works on Linux
)
-
Start via java -jar:
SERVER_PORT=9093 java -jar target/eric-sc-dummy.jar
-
Start via maven spring-boot plugin:
SERVER_PORT=9093 mvn spring-boot:run
Tips:
- If you add other sub commands before the
java -jar
ormvn
command, then you need to addexport
to set env in a separate command, and split them via;
, to make sure it's available to sub process.
e.g:
export SERVER_PORT=9093; export MAVEN_OPTS="-Xmx256m -Xms64m"; mvn spring-boot:run
Solution 38 - Java
Using mvn shell command line, spring-boot 2:
mvn spring-boot:run -Dspring-boot.run.jvmArguments='-Dserver.port=8085'
Solution 39 - Java
Apart from all the answers, I would like to point out that most IDE (IntelliJ with Spring plugin, STS) have a feature where it suggests all the configuration keys supported by SpringBoot. (i.e. all the opinionated configuration keywords)
Solution 40 - Java
You can configure the port in the application.property file or application.yaml file which is in src/main/resources .
server.port=8080
Solution 41 - Java
Server port declare in two types
1.static type
server.port=8080. // your port number
2. Dynamic type
server.port=0. // randomly generate port number.
server.port=${PORT:0}
Solution 42 - Java
The default port is : 8080 but we can customize the port number in application.properties as shown below
spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp
server.port = 5050 -- #here we can give any port number.
Solution 43 - Java
This question is the first result if you google for Gradle Spring Port.
If you use gradle you can do something like this if you have the Spring Boot Gradle Plugin already applied:
bootRun {
args += ["--server.port=[PORT]"]
}
For a more sophisticated answer please see my answer here.
Solution 44 - Java
If you are working over boot projects and you wanna configure the port you can give the input in the application.properties file like NOTE:properties file should be under src/main/resource
Spring properties
> server.port=9999 If you using the CMD then follow this command > -Dserver.port=9999 For default port its server.port=0 Make sure no port is using this port number
Solution 45 - Java
Similar to https://stackoverflow.com/a/36865796/1587329 and https://stackoverflow.com/a/40799750/1587329, a gradle one-liner would be
SERVER_PORT=9090 gradle bootRun
Solution 46 - Java
In Application properties just add 1 line
server.port = 8090
Solution 47 - Java
Programmatically, with spring boot 2.1.5:
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;
import org.springframework.stereotype.Component;
@Component
public class CustomizationBean implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
@Override
public void customize(ConfigurableServletWebServerFactory server) {
server.setPort(9000);
}
}
Solution 48 - Java
Via
> application.properties
>
server.port = 8082
(or any new port number)
>
via
> application.yml
server
port: 8082
Solution 49 - Java
This worked for me :
Added a custom container class :
@Component
public class CustomContainer implements EmbeddedServletContainerCustomizer {
@Override
public void customize(ConfigurableEmbeddedServletContainer configurableEmbeddedServletContainer) {
configurableEmbeddedServletContainer.setPort(8888);
}
}
But this was still not using port 8888.
Then I set "scanBasePackages" property like this on "@SpringBootApplication" class on my main method: (scanBasePackages = {"custom container package"})
@SpringBootApplication(scanBasePackages = {"com.javabrains.util"})
public class CourseApiApp {
public static void main (String args []) {
SpringApplication.run(CourseApiApp.class, args);
}
}
And it started picking up port set in Custom Container.
Solution 50 - Java
In spring boot you can easily configure the service exposing port in application.properties
file.
server.port=portnumber
if you don't set a port specifically, then it will try to open the service with port 80
. in case if it is already used, service will not be started on the embedded container.
Solution 51 - Java
if your port number can be random you can use random function in your application.properties
server.port=${random.int(4)}
Solution 52 - Java
server.port = 0
for random port
server.port
= 8080 for custom 8080 port
Solution 53 - Java
in the file application.properties add the following: server.port=8888 THE PROT NEEDED ALWAYS MENTIONED HERE
Solution 54 - Java
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 namedPORT
, 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 namedPORT
, 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.
- For Gradle:
- 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
Solution 55 - Java
Configure the port details in Config file or application properties.
e.g.
port =8876
Solution 56 - Java
Solution 57 - Java
If you are use the spring command line interface (CLI) use the --
to separate commands from the spring
command arguments, to change the port:
spring run hello.groovy -- --server.port=9000
Solution 58 - Java
You need to type on application.properties
file
server.port=8500
You need to type on application.yml
file
server:
port : 8500
Solution 59 - Java
Open the application.propertise file in your spring bot application. And add the below property in the propertise file.
server.port= 1443
This will be working fine and you can set any port number as per your wish.
Solution 60 - Java
In my case adding statement
server.port=${port:8081}
override the default tomcat server port.