java - 如何为 Spring Boot 应用程序配置端口

Question

如何配置 Spring Boot 应用程序侦听的 TCP/IP 端口，使其不使用默认端口 8080。

Answer 1

如文档中所述，使用jvm的命令行选项设置server.port为系统属性-Dserver.port=8090或添加application.properties/src/main/resources/

server.port=8090

用于随机端口

server.port=0

同样添加application.yml_/src/main/resources/

server:
  port : 8090

Answer 2

在 Spring Boot 应用程序中更改嵌入式 Tomcat 中的端口有两种主要方法。

修改 application.properties

首先，您可以尝试 /resources 文件夹中的 application.properties 文件：

server.port = 8090

修改 VM 选项

第二种方式，如果你想避免修改任何文件并签入你只需要在本地的东西，你可以使用 vm arg：

转到运行 -> 编辑配置 -> 虚拟机选项

-Dserver.port=8090

此外，如果您需要更多信息，可以在此处查看以下博客文章： 更改 Spring Boot 应用程序上的端口

Answer 3

由于 Spring Boot 提供了各种配置外部化机制（通过各种PropertySource实现和/或按顺序连接到对象的处理器），您可以通过以下方法设置 jar 存档之外Environment的任何属性：

1. 通过命令行参数传递属性作为应用程序参数

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

2. 来自SPRING_APPLICATION_JSON（Spring Boot 1.3.0+）中的属性

   • 在 U*IX shell 中定义环境变量：

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

   • 通过使用 Java 系统属性：

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

   • 通过命令行参数：

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

3. 定义JVM 系统属性

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

4. 定义操作系统环境变量

   • U*IX 外壳

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

   • 视窗

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

5. 将属性放在./config/application.properties 配置文件中

   server.port=7788
   

   并运行：

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

6. 将房产置入./config/application.yaml

   server:
       port: 7788
   

   并运行：

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

7. 将房产置入./application.properties

   server.port=7788
   

   并运行：

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

8. 将房产置入./application.yaml

   server:
       port: 7788
   

   并运行：

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

---

您可以将以上方法组合在一起，列表中的前一种配置优先于后一种配置。

例如：

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

服务器将启动并侦听端口 7788。

这非常有用，可以在 PropertySources 中以较低的优先级提供默认属性（通常打包在存档中或在源代码中编码），然后在运行时环境中覆盖它。这就是 Spring Boot 的设计理念：

开箱即用，但随着需求开始偏离默认值，请迅速摆脱困境。

---

SERVER_NAMEtoserver.name转换是通过Relaxed Binding完成的。

Answer 4

此外，您可以通过编程方式配置端口。

对于 Spring Boot 2.xx：

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

对于旧版本：

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

Answer 5

您可以在 java 代码中设置端口：

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

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

或者在 application.yml 中：

server:
    port: 9999

或在 application.properties 中：

server.port=9999

或作为命令行参数：

-Dserver.port=9999

Answer 6

如果您想在本地运行它，请使用它 -

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

从Spring Boot 2.0 开始，这是有效的命令（线索在这里）：

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

Answer 7

如果您正在使用application.yml以下行添加到它

server:
     port: 9000

当然，随机端口为 0。

Answer 8

正如Spring 文档中所解释的，有几种方法可以做到这一点：

您可以在命令行中设置端口（例如 8888）

-Dserver.port=8888或者--server.port=8888

例子 ：java -jar -Dserver.port=8888 test.jar

或者您在 application.properties 中设置端口

server.port=${port:4588}

或（在 application.yml 中使用 yaml 语法）

server:
   port: ${port:4588}

如果在命令行中设置了 -Dport（或 -Dserver.port）传递的端口，则将考虑该端口。如果不是，则默认端口为 4588。

如果你想在属性文件中强制使用任何环境变量的端口，你只需要写：

server.port=8888

Answer 9

包括以下属性application.properties

server.port=8080

Answer 10

当您需要以编程方式执行此操作时，可以在启动期间进行设置：

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

这可能有助于诸如环境相关端口之类的事情。祝你今天过得愉快

Answer 11

扩展其他答案：

测试文档中有一个部分解释了如何在集成测试中配置端口：

• 41.3 测试 Spring Boot 应用程序
• 41.3.3 使用随机端口

---

在集成测试中，端口配置是使用注释@SpringBootTest和webEnvironment值进行的。

---

随机端口：

@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)

您可以使用 which 注入与@LocalServerPort相同的值@Value("${local.server.port}")。

• 例子：

随机端口测试配置：

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

---

定义端口：

@SpringBootTest(webEnvironment=WebEnvironment.DEFINED_PORT)

它从server.port定义的 if 中获取值。

• 如果使用 定义@TestPropertySource(properties = "server.port=9192")，它将覆盖其他定义的值。
• 如果不是，则从src/test/resources/application.properties（如果存在）中获取值。
• 最后，如果未定义，则以 default 开头8080。

例子：

定义端口测试配置：

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

    @Test
    public void contextLoads() {
    }

}

Answer 12

如果您使用 gradle 作为构建工具，您可以在application.yml文件中将服务器端口设置为：

server:
  port: 8291

如果您使用的是 maven，则可以在application.properties文件中将端口设置为：

server.port: 8291

Answer 13

您可以通过覆盖EmbeddedServletContainerFactory配置中的 bean（基于 java 或 xml）来指定端口。在那里，您可以为使用的嵌入式 servlet 容器指定端口。请参阅Spring Boot - Core "Embedded Servlet Container Support" 段落和示例。希望这可以帮助。

Answer 14

在application.properties资源中存在的文件中：

server.port=8082

Answer 15

根据您使用的应用程序配置文件，有三种方法可以做到这一点

a) 如果您使用的是application.properties文件集

server.port = 8090

b) 如果您使用application.yml文件设置 YAML 格式的服务器端口属性，如下所示

server:
     port: 8090

c) 也可以在main方法中将该属性设置为System属性

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

Answer 16

将此添加到您的application.properties文件中

server.port= 8080

Answer 17

您可以通过更改 application.properties 在服务器配置中更改许多其他内容。像会话超时，地址和端口等。请参阅下面的帖子

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

我使用了其中的几个，如下所示。

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

Answer 18

1. 正如大家所说，您可以在 application.properties
   server.port = 9000中指定（可以是任何其他值）

2. 如果您在项目中使用弹簧执行器，默认情况下它指向
   8080，如果您想更改它，则在 application.properties 中提及
   management.port = 9001（可以是任何其他值）

Answer 19

在application.properties文件中，添加以下行：

server.port = 65535

在哪里放置该文件：

24.3 应用程序属性文件

SpringApplication 从以下位置的 application.properties 文件中加载属性并将它们添加到 Spring 环境中：

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

该列表按优先级排序（在列表中较高位置定义的属性会覆盖在较低位置定义的属性）。

就我而言，我将它放在jar文件所在的目录中。

从：

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

Answer 20

默认情况下，spring boot 应用程序以嵌入式 tomcat 服务器启动，默认端口为 8080。spring 为您提供以下不同的定制，您可以选择其中之一。

注意– 您可以使用server.port=0 spring boot 将为我们找到任何未分配的 http 随机端口。

1) application.properties

server.port=2020

2）应用程序.yml

server:  
     port : 2020

3）以编程方式更改服务器端口

3.1) 通过实现 WebServerFactoryCustomizer 接口 - 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) 通过实现 EmbeddedServletContainerCustomizer 接口 - Spring 1.x

@Component
public class CustomizationBean implements EmbeddedServletContainerCustomizer {

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

4）通过使用命令行选项

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

Answer 21

事实上，最简单的方法是设置server.port属性。

如果您使用 STS 作为 IDE，从 3.6.7 版开始，您实际上有用于打开属性文件的Spring Properties Editor 。

此编辑器为所有 Spring Boot 属性提供自动完成功能。如果你写端口并按 CTRL + SPACE，server.port将是第一个选项。

Answer 22

默认情况下，spring-web 模块提供了一个运行在 8080 端口号下的嵌入式 tomcat 服务器。如果您需要更改应用程序的端口号，请转到application.properties文件并使用server.port属性配置端口号。

  server.port= 9876

那么您的应用程序在端口 9876 下运行。

Answer 23

例如，使用其他答案中提到的属性 server.port=8080 绝对是一种方法。只是想提一下，您还可以公开环境属性：

SERVER_PORT=8080

由于弹簧靴能够替换“。” 在最近的版本中，环境变量的“_”和小写为大写。这在容器中特别有用，您只需定义该环境变量而无需application.properties通过命令行添加/编辑或传递系统属性（即-Dserver.port=$PORT）

Answer 24

希望这个有帮助

应用程序.properties=>

server.port=8090

应用程序.yml=>

服务器
  端口：8090

Answer 25

您可以通过以下方法添加端口。

1. 运行 -> 配置部分

2. 在application.xml添加server.port=XXXX

Answer 26

只需application.properties参与src/main/resources该项目并在那里提供

server.port=****

其中****是指端口号。

Answer 27

1.1 通过属性文件更新。

/src/main/resources/application.properties

服务器端口=8888

通过 yaml 文件更新。

   server:

     port: 8888

EmbeddedServletContainerCustomizer

@Component
public class CustomContainer implements EmbeddedServletContainerCustomizer {

    @Override
    public void customize(ConfigurableEmbeddedServletContainer container) {

        container.setPort(8888);

    }

}

Answer 28

在 application.properties 文件中提供端口号将解决问题

 server.port = 8080

“端口取决于您的选择，您希望在哪里托管应用程序”

Answer 29

您可以在 /src/main/resources/ 下的 application.properties 中进行设置

server.port = 8090

Answer 30

您还可以使用SERVER_PORT环境变量来配置 Spring Boot 端口。只需设置环境变量并重新启动应用程序：

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

请注意，如果您未在系统范围内设置这些环境变量，则应在同一会话上运行引导应用程序。

Answer 31

默认情况下，Spring-web 模块提供了一个在端口号 8080 上运行的嵌入式 tomcat 服务器。

您可以按如下方式更改它 -

A）如果您使用的是 gradle，那么使用可以在您的 application.yml 中设置属性：

 server:  
      port: 8042

B）如果您使用的是 maven，那么您可以在 application.properties 中设置属性：

server.port: 8042

C）当您在自己的配置文件中有端口并希望在运行时设置它时。

 通过实现 WebServerFactoryCustomizer 接口 - Spring 2.x

@Component
public class MyTomcatWebServerCustomizer implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> {

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

 通过实现 EmbeddedServletContainerCustomizer 接口 - Spring 1.x

@Component
public class CustomizationBean implements EmbeddedServletContainerCustomizer {

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

Answer 32

port:8080由于嵌入式 Tomcat，主要是 springboot 运行。在某些情况下，它可能会引发错误port 8080 already in use。为避免此类问题，我们可以配置服务器端口。

使用 application.properties

添加server.port=9898

在运行时配置

使用以下参数运行您的应用程序。

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

Answer 33

您可以在 spring boot 项目的资源文件夹中的 application.properties 文件中配置您的端口。

server.port="port which you need"

Answer 34

“ server.port=8080 ” 仅在您通过 main 方法将应用程序作为 jar 运行时才有效，

如果您通过 tomcat 容器将此应用程序作为 war 文件运行，则此配置将不起作用。

Answer 35

如果您要在命令环境中将应用程序作为 jar 文件运行，只需键入“SERVER_PORT=***”作为前缀。要执行的完整命令如下所示：

SERVER_PORT=8080 java -jar ***.jar

如果您想在 Linux 中在后台运行应用程序，带有“nohup”的命令将如下所示：

SERVER_PORT=8080 nohup java -jar ***.jar &

Answer 36

有三种方法可以做到

application.properties1 在文件中设置 server.port 属性

server.port = 8090

application.yml2 在文件中设置服务器端口属性

server:
     port: 8090

main3 在方法中将属性设置为系统属性

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

Answer 37

只需设置环境变量SERVER_PORT。
（示例适用于Linux）

• 通过java -jar启动：
  SERVER_PORT=9093 java -jar target/eric-sc-dummy.jar

• 通过maven spring-boot 插件启动：
  SERVER_PORT=9093 mvn spring-boot:run

尖端：

• 如果在java -jaror命令之前添加其他子命令mvn，则需要export在单独的命令中添加 set env，并通过 拆分它们;，以确保它可用于子进程。
  例如：
  export SERVER_PORT=9093; export MAVEN_OPTS="-Xmx256m -Xms64m"; mvn spring-boot:run

Answer 38

您可以在src/main/resources中的application.property文件或application.yaml文件中配置端口。

server.port=8080

Answer 39

除了所有答案之外，我想指出大多数 IDE（带有 Spring 插件的 IntelliJ，STS）都有一个功能，它建议 SpringBoot 支持的所有配置键。（即所有自以为是的配置关键字）

Intellij 的 Spring 插件

Answer 40

服务器端口声明有两种

1.静态类型

   server.port=8080. // your port number

2. 动态类型

    server.port=0.      // randomly generate port number. 
    server.port=${PORT:0}
   

Answer 41

使用 mvn shell 命令行，spring-boot 2：

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

Answer 42

默认端口为：8080，但我们可以在 application.properties 中自定义端口号，如下所示

spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp
server.port = 5050 -- #here we can give any port number.

Answer 43

如果您搜索Gradle Spring Port ，这个问题是第一个结果。

如果您使用 gradle，如果您已经应用了 Spring Boot Gradle 插件，则可以执行以下操作：

bootRun {
    args += ["--server.port=[PORT]"]
}

如需更复杂的答案，请在此处查看我的答案。

Answer 44

如果您正在处理引导项目并且想要配置端口，您可以在 application.properties 文件中提供输入，例如 注意：properties 文件应该在 src/main/resource 下

弹簧特性

server.port=9999 如果你使用 CMD 然后按照这个命令 -Dserver.port=9999 对于默认端口它的 server.port=0 确保没有端口正在使用这个端口号

Answer 45

与https://stackoverflow.com/a/36865796/1587329和https://stackoverflow.com/a/40799750/1587329类似，gradle one-liner将是

SERVER_PORT=9090 gradle bootRun

Answer 46

在应用程序属性中只需添加 1 行

server.port = 8090

Answer 47

以编程方式，使用 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);
    }

}

Answer 48

通过

应用程序属性

server.port = 8082（或任何新的端口号）

通过

应用程序.yml

server
  port: 8082

Answer 49

这对我有用：

添加了一个自定义容器类：

@Component
public class CustomContainer implements EmbeddedServletContainerCustomizer {

    @Override
    public void customize(ConfigurableEmbeddedServletContainer configurableEmbeddedServletContainer) {
       configurableEmbeddedServletContainer.setPort(8888);
    }

}

但这仍然没有使用端口 8888。

然后我在我的主要方法的“@SpringBootApplication”类上设置“scanBasePackages”属性：(scanBasePackages = {"custom container package"})

@SpringBootApplication(scanBasePackages = {"com.javabrains.util"})
public class CourseApiApp {

    public static void main (String args []) {
        SpringApplication.run(CourseApiApp.class, args);
    }
}

它开始拾取自定义容器中设置的端口。

Answer 50

在 Spring Boot 中，您可以轻松地在application.properties文件中配置服务公开端口。

server.port=portnumber

如果您没有专门设置端口，那么它将尝试使用端口打开服务80。如果它已被使用，则不会在嵌入式容器上启动服务。

Answer 51

如果您的端口号可以是随机的，您可以在您的application.properties server.port=${random.int(4)}

Answer 52

server.port = 0对于随机端口

server.port= 8080 用于自定义 8080 端口

Answer 53

在 application.properties 文件中添加以下内容： server.port=8888 此处需要始终提及的 PROT

Answer 54

在配置文件或应用程序属性中配置端口详细信息。

例如

port =8876

Answer 55

将此代码放入您的 applicatop.properties 文件中

Answer 56

如果您使用 spring 命令行界面 (CLI)，请使用--将命令与spring命令参数分开，以更改端口：

spring run hello.groovy -- --server.port=9000

弹簧启动 cli

Answer 57

在我的情况下添加声明

server.port=${port:8081}

覆盖默认的 tomcat 服务器端口。