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

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

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

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

Ä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

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

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 .

Sie können den Port auch programmgesteuert konfigurieren

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

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

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

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

server:
     port: 9000

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

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

Fügen Sie unten Eigenschaft in ein application.properties

server.port=8080

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

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.

In application.propertiesDatei in Ressourcen vorhanden:

server.port=8082

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:

• 41.3 Testen von Spring Boot-Anwendungen
• 41.3.3 Arbeiten mit zufälligen Ports

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() {
    }

}

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.

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");

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

Es gibt viele andere Dinge, die Sie in der Serverkonfiguration ändern können, indem Sie application.properties ändern. Wie Sitzungszeitüberschreitung, Adresse und Port usw. Siehe untenstehenden Beitrag

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

Ich habe einige davon wie unten verwendet.

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

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).

Fügen Sie dies in Ihre application.propertiesDatei ein

server.port= 8080

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

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

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.

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)

Hoffe diese eine Hilfe

application.properties => 

server.port = 8090

application.yml => 

Server
  Port: 8090

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"

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

1. Ausführen -> Konfigurationen

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

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

server.port = 8090

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

server.port=****

Dabei ****bezieht sich auf die Portnummer.

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);

    }

}

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.