So konfigurieren Sie den Port für eine Spring Boot-Anwendung


798

Wie konfiguriere ich den TCP / IP-Port, der von einer Spring Boot-Anwendung überwacht wird, damit nicht der Standardport 8080 verwendet wird?


5
Wenn jemand interessiert ist, wird hier gezeigt, wie man mehrere Ports hat - stackoverflow.com/questions/36357135/…
Betlista

Wenn Sie die Datei "yml" für die Konfiguration verwenden, können Sie diesen Server verwenden: port: 8081 Kommentieren Sie auch Ihre Hauptklasse als "@SpringBootApplication" und entfernen Sie @ EnableAutoConfiguration
Keaz

Ihr Projekt [application.properties] für das Hinzufügen des server.port = 8080
Lahiru Samishka

set server.port=8080in Anwendungseigenschaften. Diese Konfiguration ist in der ServerProperties.classKlasse unter org.springframework.boot.autoconfigure.web.
Atif

Antworten:


1227

Wie gesagt in docs entweder eingestellt server.portals Systemeigenschaft mit Befehlszeilenoption zur Jvm -Dserver.port=8090oder fügen Sie application.propertiesin /src/main/resources/mit

server.port=8090

Für zufällige Portnutzung

server.port=0

47
Wenn zufälliger Port verwendet wird, können @Value("${local.server.port}")
Portinformationen

42
Die Befehlszeilenoption lautet --server.port = 8090, nicht -Dserver.port = 8090. docs.spring.io/spring-boot/docs/current/reference/html/…
Opster ES Ninja - Alper

1
Als Kompliment zu dieser Antwort: Laut den Frühlingsdokumenten gibt es andere Wege, die Sie einschlagen können application.properties. In meinem Fall hat das sehr geholfen.
Sargas

14
-Dserver.port = XXXX hat bei mir nicht funktioniert. Ich habe den Umgebungsvariablenmodus des Betriebssystems verwendet: $ SERVER_PORT=8090 java -jar <path/to/my/jar>
Soumya Kanti

10
Sowohl (1) java -Dserver.port=XXXX -jar <path/to/my/jar>als auch (2) java -jar <path/to/my/jar> --server.port=YYYYfunktionieren. Der erste Befehl definiert die server.portSystemeigenschaft, und der zweite Befehl übergibt die Eigenschaft über die Befehlszeilenargumente ( String... argsin der mainMethode). Wenn Sie mit ausführen java -Dserver.port=XXXX -jar <path/to/my/jar> --server.port=YYYY, YYYYhat dies Vorrang vor dem XXXXGrund, weshalb die externe Spring Boot-Konfiguration so charmant ist.
Tan9

209

Es gibt zwei Möglichkeiten, den Port im Embedded Tomcat in einer Spring Boot-Anwendung zu ändern.

Ändern Sie application.properties

Zuerst können Sie die Datei application.properties im Ordner / resources ausprobieren:

server.port = 8090

Datei application.properties

Ändern Sie eine VM-Option

Die zweite Möglichkeit, wenn Sie vermeiden möchten, Dateien zu ändern und etwas einzuchecken, das Sie nur auf Ihrer lokalen Ebene benötigen, können Sie ein vm-Argument verwenden:

Gehen Sie zu Ausführen -> Konfigurationen bearbeiten -> VM-Optionen

-Dserver.port=8090

Ändern Sie den Port mit einem VM-Argument

Wenn Sie weitere Informationen benötigen, können Sie hier den folgenden Blog-Beitrag anzeigen: Ändern des Ports in einer Spring Boot-Anwendung


In STS 4 wird ausgeführt -> Konfigurationen ausführen -> main, und dann nach unten zu Tabelle mit Parametername und
-wert

155

Da Spring Boot verschiedene Externalisierungsmechanismen für die Konfiguration bietet (über verschiedene PropertySourceImplementierungen und / oder Prozessoren Environment, die der Reihe nach mit dem Objekt verbunden sind), können Sie jede Eigenschaft außerhalb Ihres JAR-Archivs mithilfe der folgenden Methoden festlegen :

  1. Übergeben Sie die Eigenschaft als Anwendungsargument über das Befehlszeilenargument

    java -jar <path/to/my/jar> --server.port=7788
  2. Von der Eigenschaft in SPRING_APPLICATION_JSON(Spring Boot 1.3.0+)

    • Umgebungsvariable in U * IX-Shell definieren:

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

      java -Dspring.application.json='{"server.port":7788}' -jar <path/to/my/jar>
    • Übergeben Sie das Befehlszeilenargument:

      java -jar <path/to/my/jar> --spring.application.json='{"server.port":7788}'
  3. Definieren Sie die JVM-Systemeigenschaft

    java -Dserver.port=7788 -jar <path/to/my/jar>
  4. Definieren Sie die Umgebungsvariable des Betriebssystems

    • U * IX Shell

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

      SET SERVER_PORT=7788
      java -jar <path/to/my/jar>
  5. Platzieren Sie die Eigenschaft in der ./config/application.properties Konfigurationsdatei

    server.port=7788

    und Renn:

     java -jar <path/to/my/jar>
  6. Platzieren Sie die Immobilie in ./config/application.yaml

    server:
        port: 7788

    und Renn:

     java -jar <path/to/my/jar>
  7. Platzieren Sie die Immobilie in ./application.properties

    server.port=7788

    und Renn:

     java -jar <path/to/my/jar>
  8. Platzieren Sie die Immobilie in ./application.yaml

    server:
        port: 7788

    und Renn:

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

Sie können die oben genannten Methoden alle zusammen kombinieren, und die erstere Konfiguration in der Liste hat Vorrang vor der letzteren.

Zum Beispiel:

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

Der Server startet und überwacht Port 7788.

Dies ist sehr nützlich, um Standardeigenschaften in PropertySources mit niedrigerer Priorität bereitzustellen (und normalerweise im Archiv gepackt oder in der Quelle codiert) und diese dann in der Laufzeitumgebung zu überschreiben. Und es ist die Designphilosophie von Spring Boot:

Seien Sie sofort einsatzbereit, aber treten Sie schnell aus dem Weg, wenn die Anforderungen von den Standardeinstellungen abweichen.


SERVER_NAMEzur server.nameUmwandlung erfolgte durch Relaxed Binding .


108

Sie können den Port auch programmgesteuert konfigurieren

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

Dies funktioniert und ist sehr nützlich, wenn Sie einen Port in Ihrer eigenen Konfigurationsdatei haben und diesen zur Laufzeit festlegen möchten.
Xdg

4
Dies war hilfreich, wenn ich eine Anwendung für einen AWS Elastic Beanstalk-Dienst bereitstellen musste, um den Port von einer Umgebungsvariablen abzurufen.
Martin Hansen

Dies ist sehr nützlich, wenn Sie nur eine eigenständige Einheit oder einen Integrationstest +1 wünschen.
Priidu Neemre

Sehr nützlich, wenn die env-Variable für port bereits unter einem anderen Namen definiert ist.
Higuaro

2
Ist es nicht das @Configurationstatt @Controller? Bitte aktualisieren Sie, wenn ja.
Glücklicher

82

Sie können den Port im Java-Code festlegen:

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

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

Oder in application.yml:

server:
    port: 9999

Oder in application.properties:

server.port=9999

Oder als Befehlszeilenparameter:

-Dserver.port=9999

Die Verwendung der HashMap funktioniert nur, wenn in application.properties oder .yml kein Port festgelegt ist.
Milgo

79

Wenn Sie es lokal ausführen möchten, verwenden Sie Folgendes:

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

Ab Spring Boot 2.0 funktioniert folgender Befehl (Hinweise waren hier ):

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

1
Ab Spring Boot 2 sollten Sie verwenden spring-boot.run.jvmArguments.
Mapm

54

Wenn Sie verwenden, application.ymlfügen Sie die folgenden Zeilen hinzu

server:
     port: 9000

und natürlich 0 für zufälligen Port.


1
das schien nicht zu funktionieren. Ich habe server.port in der application.yml verwendet und es hat funktioniert
yathirigan

47

Wie in der Spring-Dokumentation erläutert , gibt es verschiedene Möglichkeiten, dies zu tun:

Entweder legen Sie den Port in der Befehlszeile fest (z. B. 8888).

-Dserver.port=8888 oder --server.port=8888

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

Oder Sie legen den Port in den application.properties fest

server.port=${port:4588}

oder (in application.yml mit yaml-Syntax)

server:
   port: ${port:4588}

Wenn der von -Dport (oder -Dserver.port) übergebene Port in der Befehlszeile festgelegt ist, wird dieser Port berücksichtigt. Wenn nicht, ist der Port standardmäßig 4588.

Wenn Sie den Port in der Eigenschaftendatei unabhängig von der Umgebungsvariablen erzwingen möchten, müssen Sie nur Folgendes schreiben:

server.port=8888

39

Fügen Sie unten Eigenschaft in ein application.properties

server.port=8080

23

Wenn Sie eine programmgesteuerte Methode benötigen, können Sie diese beim Start festlegen:

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

Dies kann beispielsweise für umgebungsabhängige Ports hilfreich sein. Einen schönen Tag noch


2
System.setProperty("server.port", 80);ist ein anderer Weg, um das gleiche zu erreichen.
HD1

@ HD1, ich habe unsere Antworten zur Hauptantwort hinzugefügt, sie überprüft und nach Belieben geändert
Luis Mauricio

18

Sie können den Port angeben, indem Sie die EmbeddedServletContainerFactoryBean in Ihrer Konfiguration überschreiben (Java-basiert oder XML). Dort können Sie den Port für den verwendeten eingebetteten Servlet-Container angeben. Bitte finden Sie Frühjahr Boot - Kern „Embedded Servlet Container Support“ Absatz und Beispiel gibt. Hoffe das hilft.



Hier ist ein aktueller Link zum programmatischen Überschreibungsabschnitt: docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/…
jocull


17

So erweitern Sie andere Antworten:

In den Testdokumenten finden Sie einen Abschnitt zum Testen, in dem erläutert wird, wie der Port für Integrationstests konfiguriert wird:


Bei Integrationstests wird die Portkonfiguration anhand der Anmerkung @SpringBootTestund der webEnvironmentWerte vorgenommen.


Zufälliger Port:

@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)

Sie können den Wert einspeisen, @LocalServerPortder dem entspricht @Value("${local.server.port}").

  • Beispiel:

Konfiguration des zufälligen Porttests:

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

Definierter Port:

@SpringBootTest(webEnvironment=WebEnvironment.DEFINED_PORT)

Es wird der Wert von server.portif übernommen.

  • Wenn mit definiert @TestPropertySource(properties = "server.port=9192"), werden andere definierte Werte überschrieben.
  • Wenn nicht, wird der Wert von src/test/resources/application.properties(falls vorhanden) übernommen.
  • Und schließlich, wenn es nicht definiert ist, beginnt es mit der Standardeinstellung 8080.

Beispiel:

Definierte Port-Test-Konfiguration:

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

    @Test
    public void contextLoads() {
    }

}

17

Wenn die Spring-Boot-Anwendung gestartet wird, startet der eingebettete Server wie Tomcat mit einem Standardport. Der eingebettete Tomcat startet standardmäßig mit dem 8080-Port. Es gibt viele Möglichkeiten, den Standard-Server-Port zu ändern.

Verwenden der Eigenschaftendatei (.properties / .yml)

Um den Serverport mithilfe der Eigenschaftendatei zu ändern, müssen Sie die Eigenschaft server.port konfigurieren .

ein. Verwenden von application.properties in Klassenpfaden wie src \ main \ resources \ application.properties

server.port = 8585

Der Server startet mit dem 8585-Port. Um einen zufälligen Server-Port zu erhalten, weisen Sie der Eigenschaft 0 zu.

server.port = 0

Jetzt startet Spring Boot den Server an einem Port, der derzeit von keinem Server im System verwendet wird.

b. Verwenden von application.yml in einem Klassenpfad wie src \ main \ resources \ application.yml.

server:
  port: 8585 

Der Server startet mit dem 8585-Port.

Weisen Sie für einen zufälligen Port 0 zu.

server:
  port: 0 

Verwenden des Java-Befehls mit --server.port oder -Dserver.port

Angenommen, wir haben eine ausführbare JAR mit dem Namen my-app.jar. Beim Starten der Spring-Boot-Anwendung mit dem Befehl java können wir das folgende Argument verwenden.

Verwenden von --server.port

java -jar my-app.jar  --server.port=8585

Verwenden von -Dserver.port

java -jar -Dserver.port=8585 my-app.jar

Der Server startet mit dem 8585-Port.

Verwenden des Java-Befehls mit --port oder -Dport in Kürze

Um --server.port und -Dserver.port kurz zu machen, können wir das Server-Schlüsselwort entfernen und es zu einem beliebigen kurzen Schlüsselwort wie --port und -Dport machen. Wir können jedes kurze Schlüsselwort verwenden. Hier verwenden wir Port als kurzes Schlüsselwort. Um dies zu erreichen, müssen wir den Platzhalter in der Eigenschaftendatei wie folgt konfigurieren.

Verwenden von application.properties

server.port=${port:8282}

Verwenden von application.yml

server:
   port: ${port:8282}

Wenn wir den Port nicht als Argument übergeben, beginnt der Server standardmäßig mit 8282. Wenn wir einen anderen Port möchten, müssen wir den gewünschten Port im Argument wie folgt übergeben. Angenommen, wir haben eine ausführbare JAR mit dem Namen my-app.jar.

Verwenden von --port

java -jar my-app.jar --port=8585 

Verwenden von -Dport

java -jar -Dport=8585 my-app.jar 

Der Server startet mit dem 8585-Port.

SERVER_PORT programmgesteuert mit SpringApplication verwenden

SpringApplication verfügt über eine Methode wie setDefaultProperties (), mit der die Standardeigenschaften für den Spring-Boot geändert werden. Angenommen, wir möchten den Standardport ändern, dann müssen wir eine Map erstellen und einen Port mit dem Schlüssel SERVER_PORT einfügen. Finden Sie das Beispiel.

MyApplication.java

package com.humoyun;

import java.util.HashMap;
import java.util.Map;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(MyApplication.class);
        Map<String, Object> map = new HashMap<>();
        map.put("SERVER_PORT", "8585");
        application.setDefaultProperties(map);
        application.run(args);
        }     
} 

Spring Boot startet den Server mit 8585 Port.


17

Abhängig von der verwendeten Anwendungskonfigurationsdatei gibt es drei Möglichkeiten

a) Wenn Sie den Dateisatz application.properties verwenden

server.port = 8090

b) Wenn Sie die Server-Port-Eigenschaft application.yml- Dateisatz im YAML-Format wie unten angegeben verwenden

server:
     port: 8090

c) Sie können die Eigenschaft auch in der Hauptmethode als Systemeigenschaft festlegen

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

15

Wenn Sie gradle als Build-Tool verwenden, können Sie den Server-Port in Ihrer application.yml- Datei wie folgt festlegen :

server:
  port: 8291

Wenn Sie maven verwenden, kann der Port in Ihrer Datei application.properties wie folgt festgelegt werden :

server.port: 8291

für application.properties itsserver.port = 8291
iQuestProgrammer


13
  1. Wie alle sagten, können Sie in application.properties
    server.port = 9000 angeben (kann ein beliebiger anderer Wert sein)

  2. Wenn Sie in Ihrem Projekt einen Federantrieb verwenden, zeigt dieser standardmäßig auf
    8080, und wenn Sie ihn ändern möchten, erwähnen Sie in application.properties
    management.port = 9001 (kann ein beliebiger anderer Wert sein).


12

Fügen Sie dies in Ihre application.propertiesDatei ein

server.port= 8080

2
Willkommen bei SO :-) Bitte schauen Sie unter Wie zu
antworten

Warum ein Jahr später dieselbe Antwort hinzufügen?!? und server.port 8080ist falsche Syntax für Java-Eigenschaftendatei ...
Betlista

12

Fügen Sie in der application.propertiesDatei diese Zeile hinzu:

server.port = 65535

Wo soll das platziert werden?

24.3 Anwendungseigenschaftendateien

SpringApplication lädt Eigenschaften aus den Dateien application.properties an den folgenden Speicherorten und fügt sie der Spring-Umgebung hinzu:

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

Die Liste ist nach Priorität geordnet (Eigenschaften, die an höheren Positionen in der Liste definiert sind, überschreiben die an niedrigeren Positionen definierten Eigenschaften).

In meinem Fall lege ich es in das Verzeichnis, in dem sich die jarDatei befindet.

Von:

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


12

Standardmäßig startet die Spring-Boot-App mit dem eingebetteten Tomcat-Server am Standardport 8080. Spring bietet Ihnen die folgenden verschiedenen Anpassungen, von denen Sie eine auswählen können.

HINWEIS - Sie können server.port = 0 verwenden. Spring Boot findet jeden nicht zugewiesenen http-Zufallsport für uns.

1) Anwendungseigenschaften

server.port=2020

2) application.yml

server:  
     port : 2020

3) Ändern Sie den Server-Port programmgesteuert

3.1) Durch Implementierung der WebServerFactoryCustomizer-Schnittstelle - 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) Durch Implementierung der EmbeddedServletContainerCustomizer-Schnittstelle - Spring 1.x.

@Component
public class CustomizationBean implements EmbeddedServletContainerCustomizer {

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

4) Mit der Befehlszeilenoption

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

10

In der Tat ist es am einfachsten, den server.port festzulegen Eigenschaft .

Wenn Sie STS als IDE verwenden, haben Sie ab Version 3.6.7 tatsächlich den Spring Properties Editor zum Öffnen der Eigenschaftendatei.

Dieser Editor bietet eine automatische Vervollständigung für alle Spring Boot-Eigenschaften. Wenn Sie einen Port schreiben und STRG + LEERTASTE drücken , ist server.port die erste Option.


1
Oder auch wenn Sie Intellij IDEA verwenden, funktioniert die automatische Vervollständigung ebenfalls. ;)
Glücklicher

9

Die Verwendung der Eigenschaft server.port = 8080, wie in anderen Antworten erwähnt, ist definitiv ein guter Weg. Ich wollte nur erwähnen, dass Sie auch eine Umgebungseigenschaft verfügbar machen können:

SERVER_PORT=8080

Da kann der Federschuh "." Ersetzen. für "_" und niedriger für Großbuchstaben in Umgebungsvariablen in neueren Versionen. Dies ist besonders nützlich in Containern, in denen Sie lediglich diese Umgebungsvariable definieren müssen, ohne application.propertiesSystemeigenschaften hinzuzufügen / zu bearbeiten oder über die Befehlszeile zu übergeben (dh -Dserver.port=$PORT)


SERVER_PORT=8081 mvn spring-boot:run
Nobar

8

Hoffe diese eine Hilfe

application.properties => 

server.port = 8090

application.yml => 

Server
  Port: 8090

application.yml => Server: Port: 8090
Geek

8

Durch Angabe der Portnummer in der Datei application.properties wird das Problem behoben

 server.port = 8080

"Port hängt von Ihrer Wahl ab, wo Sie die Anwendung hosten möchten"


7

Sie können den Port in den folgenden Methoden hinzufügen.

  1. Ausführen -> Konfigurationen

  2. Zusätzlich application.xmlhinzufügenserver.port=XXXX


1
Meinen Sie application.ymlund welche IDE verwenden Sie? Bitte erläutern.
Glücklicher

7

Sie können dies in application.properties unter / src / main / resources / festlegen

server.port = 8090

7

Haben Sie einfach einen Einblick application.propertiesin src/main/resourcesdas Projekt und geben Sie dort

server.port=****

Dabei ****bezieht sich auf die Portnummer.


7

1.1 Update über eine Eigenschaftendatei.

/src/main/resources/application.properties

server.port = 8888

Update über eine Yaml-Datei.

   server:

     port: 8888

EmbeddedServletContainerCustomizer

@Component
public class CustomContainer implements EmbeddedServletContainerCustomizer {

    @Override
    public void customize(ConfigurableEmbeddedServletContainer container) {

        container.setPort(8888);

    }

}

6

Sie können auch SERVER_PORTUmgebungsvariablen verwenden, um den Spring Boot-Port zu konfigurieren. Legen Sie einfach die Umgebungsvariable fest und starten Sie die App neu:

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

Beachten Sie, dass Sie die Boot-App in derselben Sitzung ausführen sollten, wenn Sie diese Umgebungsvariablen nicht systemweit festlegen.

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.