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

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

988401 次浏览
小开
最佳答案

在docs中说使用命令行选项将server.port设置为jvm-Dserver.port=8090的系统属性，或者在/src/main/resources/中添加application.properties

server.port=8090

对于随机端口使用：

server.port=0

类似地在/src/main/resources/中添加application.yml：

server:port: 8090
小开

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

小开

如果您使用application.yml，请向其添加以下行

server:port: 9000

当然，随机端口为0。

小开

有两种主要方法可以在Spring Boot Application中更改Embedded Tomcat中的端口。

修改application.properties

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

server.port = 8090

application.properties文件

修改VM选项

第二种方法，如果您想避免修改任何文件并签入仅在本地需要的内容，您可以使用vm arg：

转到运行->编辑配置->VM选项

-Dserver.port=8090

使用vm arg更改端口

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

小开

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

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

小开

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

对于Spring Boot 2. x. x：

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

对于旧版本：

@Configurationpublic class ServletConfig {@Beanpublic EmbeddedServletContainerCustomizer containerCustomizer() {return (container -> {container.setPort(8012);});}}
小开

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

如果您使用STS作为IDE，从版本3.6.7开始，您实际上有Spring属性编辑器用于打开属性文件。

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

小开

您可以在下面的方法中添加端口。

  1. 运行->配置部分

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

小开

您可以在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
小开

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

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

这可能有助于环境依赖端口之类的事情。美好的一天

小开

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

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

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

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

在我的情况下添加声明

server.port=${port:8081}

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

小开

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

set SERVER_PORT=9999 // on windows machineexport SERVER_PORT=9999 // on linux

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

小开

你可以在application.properties /src/main/resources

server.port = 8090
小开

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

server.port= 8080
小开

使用属性server.port=8080，就像其他答案中提到的那样，绝对是一种方法。只是想提一下你也可以公开环境属性：

SERVER_PORT=8080

由于Spring Boot能够替换“.”为“_”，并且在最新版本中环境变量的大小写更低。这在容器中特别有用，您所要做的就是定义环境变量，而无需添加/编辑application.properties或通过命令行传递系统属性（即-Dserver.port=$PORT）

小开

“server.port=8080”仅适用于您通过main方法作为jar运行的应用程序，

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

小开

在application.properties中包含以下属性

server.port=8080
小开

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

SERVER_PORT=8080 java -jar ***.jar

如果你想在后台运行应用程序在Linux，命令'nohup'将如下所示：

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

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

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

    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=7788java -jar <path/to/my/jar>

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

    server.port=7788

    并运行：

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

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

    server:port: 7788

    并运行：

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

  7. Place property in ./application.properties

    server.port=7788

    并运行：

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

  8. Place property in ./application.yaml

    server:port: 7788

    并运行：

     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

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

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

不要固执己见，但当需求开始与默认值背道而驰时，请迅速离开。

SERVER_NAME到server.name的转换由松弛绑定完成。

小开

如弹簧留档所述，有几种方法可以做到这一点：

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

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

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

或者你把端口设置在application.properties

server.port=${port:4588}

或（application.ymlyaml语法）

server:port: ${port:4588}

如果命令行中设置了-Dport（或-Dserver.port）传递的端口，则会考虑此端口。如果没有，则默认端口为4588。

如果您想在属性文件中强制执行端口，无论环境变量是什么，您只需编写：

server.port=8888
小开

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

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

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

server.port="port which you need"
小开

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

server.port=8082
小开

有三种方法可以做到

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

server.port = 8090

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

server:port: 8090

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

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

延伸其他答案：

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

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

随机端口：

@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)

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

  • 示例：

随机端口测试配置：

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

定义端口：

@SpringBootTest(webEnvironment=WebEnvironment.DEFINED_PORT)

如果定义了，它取server.port的值。

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

示例：

定义的端口测试配置：

@RunWith(SpringRunner.class)@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)@TestPropertySource(properties = "server.port=9192")public class DemoApplicationTests {
@Testpublic void contextLoads() {}
}
小开

只需在项目的src/main/resources中有application.properties并在那里给出 

server.port=****

其中****表示端口号。

小开

这对我有效：

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

@Componentpublic class CustomContainer implements EmbeddedServletContainerCustomizer {
@Overridepublic 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);}}

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

小开

由于嵌入了Tomcat，大多数spingboot在port:8080上运行。在某些情况下，它可能会抛出错误port 8080 already in use。为了避免这种问题，我们可以配置服务器端口。

使用application.properties

添加server.port=9898

运行时配置

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

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

小开

1.1通过属性文件更新。

/src/main/resources/application.properties

server.port=8888

通过yaml文件更新。

   server:
port: 8888

嵌入式服务器v让容器自定义r

@Componentpublic class CustomContainer implements EmbeddedServletContainerCustomizer {
@Overridepublic void customize(ConfigurableEmbeddedServletContainer container) {
container.setPort(8888);
}
}
小开

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

server.port=portnumber

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

小开

这个问题是谷歌搜索Gradle Spring端口的第一个结果。

如果您使用gradle，如果您已经应用了Spring Boot Gradle插件，您可以这样做：

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

有关更复杂的答案，请参阅我的答案这里。

小开

如果您正在处理引导项目并且想要配置端口，您可以在application.properties文件中输入注意：属性文件应位于src/main/资源

下

Spring属性

server.port=9999如果您使用CMD，请遵循此命令-Dserver.port=9999默认端口server.port=0确保没有端口使用此端口号

小开

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

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

我用了几个如下。 

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

希望这个能帮上忙

application.properties=>
server.port=8090
application.yml=>
serverport:8090
小开

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

 server.port = 8080

"端口取决于您的选择，您想在哪里托管应用程序"

小开

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

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

server.port = 8090

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

server:port: 8090

c）您还可以将属性设置为主要方法中的系统属性

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

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

server.port = 65535

在哪里放置这个Pe：

24.3应用程序属性文件

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

A /config subdirectory of the current directoryThe current directoryA classpath /config packageThe classpath root

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

在我的情况下，我把它放在jar文件所在的目录中。

发件人：

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

小开

类似于https://stackoverflow.com/a/36865796/1587329和https://stackoverflow.com/a/40799750/1587329，Gradle单线广告将是

SERVER_PORT=9090 gradle bootRun
小开

默认情况下，Spring引导应用程序从默认端口8080开始使用嵌入式tomcat服务器。Spring为您提供以下不同的自定义，您可以选择其中之一。

注-你可以使用server.port=0弹簧引导会发现任何未分配的超文本传输协议随机端口对我们来说

1）application.properties

server.port=2020

（2）application.yml

server:port : 2020

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

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

@Componentpublic class MyTomcatWebServerCustomizer implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> {
@Overridepublic void customize(TomcatServletWebServerFactory factory) {// customize the factory herefactory.setPort(2020);}}

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

@Componentpublic class CustomizationBean implements EmbeddedServletContainerCustomizer {
@Overridepublic void customize(ConfigurableEmbeddedServletContainer container) {// customize herecontainer.setPort(2020);}}

4）通过使用命令行选项

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

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

server.port = 8090
小开

如果您的端口号可以是随机的，您可以在application.propertiesserver.port=${random.int(4)}中使用随机函数

小开

server.port = 0随机端口

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

小开

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

在此处输入图片描述

Intellij的Spring插件

小开

以编程方式，使用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;
@Componentpublic class CustomizationBean implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
@Overridepublic void customize(ConfigurableServletWebServerFactory server) {server.setPort(9000);}
}
小开

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

server:port: 8291

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

server.port: 8291
小开

在文件中application.properties添加以下内容：server.port=8888需要的保护总是在这里提到

小开

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

  server.port= 9876

然后您的应用程序在端口9876下运行。

小开

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

  • 从java-jar开始：
    SERVER_PORT=9093 java -jar target/eric-sc-dummy.jar

  • 从maven弹簧启动插件开始：
    SERVER_PORT=9093 mvn spring-boot:run

温馨提示：

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

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

e. g.

port =8876
小开

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

server.port=8080

输入图片描述

小开

两种类型的服务器端口声明

1.static型

   server.port=8080. // your port number

  1. 动态类型

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

将此代码放入uapplicatop.properties文件
输入图片描述

小开

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

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

spring-boot cli

小开

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

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

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

您可以更改如下-

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

 server:port: 8042

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

server.port: 8042

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

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

@Componentpublic class MyTomcatWebServerCustomizer implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> {
@Overridepublic void customize(TomcatServletWebServerFactory factory) {// customize the factory herefactory.setPort(8042);}}

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

@Componentpublic class CustomizationBean implements EmbeddedServletContainerCustomizer {
@Overridepublic void customize(ConfigurableEmbeddedServletContainer container) {// customize herecontainer.setPort(8042);}}
小开

通过

application.properties

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

通过

application.yml

serverport: 8082
小开

运行Gradle：

  • 在默认端口（8080）下运行：./gradlew bootRun
  • 在提供的端口（8888）中运行：./gradlew bootRun --args='--server.port=8888'
  • 如果我们在application.properties文件中有任何名为PORT的变量，请运行：PORT=8888 ./gradlew bootRun

由Maven运行：

  • 在默认端口（8080）下运行：mvnw spring-boot:run
  • 在提供的端口（8888）中运行：mvnw spring-boot:run -Dspring-boot.run.jvmArguments='-Dserver.port=8085'
  • 在提供的端口（8888）中运行：mvn spring-boot:run -Dspring-boot.run.arguments='--server.port=8085'
  • 使用其他自定义属性在提供的端口（8888）中运行：mvn spring-boot:run -Dspring-boot.run.arguments="--server.port=8899 --your.custom.property=custom"
  • 如果我们在application.properties文件中有任何名为PORT的变量，请运行：SERVER_PORT=9093 mvn spring-boot:run

    • 对于Gradle：./gradlew clean build。我们将在：build/libs/文件夹中找到jar文件。
    • 对于Maven：mvn clean install。我们将在：target文件夹中找到jar文件。
  • 在默认端口（8080）下运行：java -jar myApplication. jar
  • 在提供的端口（8888）中运行：java -jar myApplication.jar --port=8888
  • 在提供的端口（8888）中运行：java -jar -Dserver.port=8888 myApplication.jar
  • 在提供的端口（8888）中运行，在application.properties文件中具有变量#0：SERVER_PORT=8888 java -jar target/myApplication.jar
小开

在您的春季启动应用程序中打开application.properties文件，并在属性文件中添加以下属性。

server.port = 1443

这将工作正常，您可以根据自己的意愿设置任何端口号。

小开

除了在application.properties上添加端口之外，您还可以通过将属性文件方法与Spring配置文件相结合，轻松实现不同环境的多个端口。具体来说，我们可以为每个环境创建一个属性文件。

例如，我们将有一个包含以下内容的application-dev.properties文件：

server.port=8081

然后，您可以使用不同的端口添加另一个application-qa.properties文件：

server.port=8082
小开

包括服务器端口在内的许多参数可以通过多种方式更改。但是，有一个优先级顺序，如下所示：

  1. 第一优先级分配给自定义代码，如下所示：
@陈子强公共类CustomConfiguration实现WebServerFactoryCustomizer{@刘志强公共无效自定义（配置ServletWebServer工厂）{factory.set端口（9090）；}}

这里我们将服务器端口设置为9090，这在代码中是硬编码的。为了避免硬编码，我们可以在bean类中使用@Value注释从环境中分配一个值，并在此处使用它。

  1. 第二个优先级分配给命令行参数，如下所示：

    java-jar目标/spring-boot-0.0.1-SNAPSHOT.jar--server.port=8092

这里我们告诉服务器从8092开始监听。请注意，如果我们同时使用上述两种方法，它将忽略命令行参数，因为自定义代码被赋予第一优先级。

  1. 第三个优先级分配给操作系统环境变量。如果上述两种方法都没有采用，Spring将从环境属性中获取服务器端口。在库伯内特斯部署的情况下，将使用部署yaml中env部分下设置的属性。

  2. 第四个优先级分配给配置文件特定的application.properties文件。

  3. 第五个优先级分配给在application.properties文件中分配的值（默认情况下，Spring Boot尝试查找src/main/Resources/config，如果未找到，则尝试在src/main/资源下查找）。

最易于管理和有用的方法可以是第一种和第三种方法的组合。您可以使用环境属性并使用该自定义代码。

示例代码：

import org.springframework.beans.factory.annotation.Value;import org.springframework.stereotype.Component;@Componentpublic class EnvironmentCustomizer {@Value("${server.port}")private int serverPort;public void setServerPort(int serverPort) {this.serverPort = serverPort;}public int getServerPort() {return serverPort;}}
@Configurationpublic class CustomConfiguration{@AutowiredEnvironmentCustomizer envCustomizer;@BeanWebServerFactoryCustomizer<ConfigurableServletWebServerFactory> webServerPortCustomizer() {return factory -> factory.setPort(envCustomizer.getServerPort());}}

提交答案