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

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 einer VM-Option

Zum anderen können Sie ein vm-Argument verwenden, um zu vermeiden, dass Dateien geändert und etwas eingecheckt werden, das Sie nur in Ihrem lokalen System benötigen:

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

-Dserver.port=8090

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

Da Spring Boot verschiedene Konfigurations-Externalisierungsmechanismen (durch verschiedene PropertySource Implementierungen und/oder Prozessoren, die nacheinander mit Environment Objekten verbunden sind) bereitstellt, können Sie jede Eigenschaft festlegen außerhalb Ihres JAR-Archivs durch folgende Methoden:

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

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

2. Von 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>
     

   • Mit der Systemeigenschaft Java:

     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. JVM-Systemeigenschaft definieren

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

4. OS-Umgebungsvariable definieren

   • U * IX Shell

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

   • Windows

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

5. Eigenschaft in ./config/application.properties Konfigurationsdatei einfügen

   server.port=7788
   

   und Renn:

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

6. Eigenschaft in ./config/application.yaml einfügen

   server:
       port: 7788
   

   und Renn:

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

7. Eigenschaft in ./application.properties einfügen

   server.port=7788
   

   und Renn:

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

8. Eigenschaft in ./application.yaml einfügen

   server:
       port: 7788
   

   und Renn:

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

Sie können die obigen 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 wird gestartet und überwacht Port 7788.

Dies ist sehr nützlich, wenn Sie Standardeigenschaften in PropertySources mit einer niedrigeren Priorität (und normalerweise im Archiv gepackt oder in der Quelle codiert) bereitstellen und diese dann in der Laufzeitumgebung überschreiben möchten. Und das ist die Designphilosophie von Spring Boot:

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

SERVER_NAME in server.name konvertiert von 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 in Java Code einstellen:

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 Kommandozeilenparameter:

-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 der folgende Befehl (Hinweise waren hier ):

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

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

server:
     port: 9000

und natürlich 0 für zufällige Portierung.

Wie in Frühlingsdokumentation erklärt, gibt es verschiedene Möglichkeiten, dies zu tun:

Entweder Sie setzen den Port in der Kommandozeile (zB 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, lautet 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

Die folgende Eigenschaft in application.properties einschließen

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 für Dinge wie den umgebungsabhängigen Port hilfreich sein. Einen schönen Tag noch

Sie können den Port angeben, indem Sie die EmbeddedServletContainerFactory - Bean in Ihrer Konfiguration überschreiben (Java-basiert oder XML). Dort können Sie den Port für den verwendeten eingebetteten Servlet-Container angeben. Bitte beachten Sie Spring Boot - Core "Embedded Servlet Container Support" Absatz und Beispiel dort. Hoffe das hilft.

In application.properties Datei in Ressourcen vorhanden:

server.port=8082

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 Standardserverport 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 im Klassenpfad 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 dem zufälligen Port 0 zu.

server:
  port: 0 

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

Angenommen, wir haben eine ausführbare JAR-Datei 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.

Mit Java Befehl mit --port oder -Dport kurz

Um --server.port und -Dserver.port kurz zu machen, können wir das Schlüsselwort server 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 Sie den Platzhalter in der Eigenschaftendatei wie folgt konfigurieren.

Application.properties verwenden

server.port=${port:8282}

Application.yml verwenden

server:
   port: ${port:8282}

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

--Port benutzen

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

Verwenden von -Dport

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

Der Server startet mit dem 8585-Port.

Programmgesteuertes Verwenden von SERVER_PORT mit SpringApplication

SpringApplication verfügt über eine Methode namens setDefaultProperties (), mit der die Standardeigenschaften des Springboots geändert werden. Angenommen, wir möchten den Standardport ändern, dann müssen wir eine Zuordnung 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 dem 8585-Port.

So erweitern Sie andere Antworten:

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

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

Bei Integrationstests wird die Portkonfiguration unter Verwendung der Werte für Annotation @SpringBootTest und webEnvironment vorgenommen.

Zufälliger Port:

@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)

Sie können den Wert mit @LocalServerPort einfügen. Dies entspricht @Value("${local.server.port}").

• Beispiel:

Testkonfiguration für zufällige Ports:

@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 nimmt den Wert von server.port, wenn definiert ist.

• Wenn mit @TestPropertySource(properties = "server.port=9192") definiert, 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 dem Standardwert 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() {
    }

}

Es gibt drei Möglichkeiten, dies abhängig von der von Ihnen verwendeten Anwendungskonfigurationsdatei zu tun

a) Wenn Sie application.properties Dateigruppe verwenden

server.port = 8090

b) Wenn Sie application.yml verwenden, legen Sie die Server-Port-Eigenschaft im unten angegebenen YAML-Format fest

server:
     port: 8090

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

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

Es gibt viele andere Dinge, die Sie in der Serverkonfiguration ändern können, indem Sie application.properties ändern. Wie Session Timeout, Adresse und Port etc. siehe unten Beitrag

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

Ich habe nur wenige davon wie folgt verwendet.

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

Fügen Sie in der Datei application.properties folgende Zeile hinzu:

server.port = 65535

wo soll das fie platziert werden:

24.3 Anwendungseigenschaftendateien

SpringApplication lädt Eigenschaften aus application.properties-Dateien 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 Stellen in der Liste definiert sind, haben Vorrang vor denen, die an niedrigeren Stellen definiert sind).

In meinem Fall habe ich es in das Verzeichnis gestellt, in dem sich die Datei jar befindet.

Von:

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

Fügen Sie dies in Ihre application.properties -Datei ein

server.port= 8080

1. Wie jeder sagte, können Sie in application.properties angeben
   server.port = 90 (kann ein beliebiger anderer Wert sein)

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

Standardmäßig startet die Spring-Boot-App mit dem eingebetteten Tomcat-Server über den Standard-Port 8080. Spring bietet Ihnen verschiedene Anpassungsmöglichkeiten, von denen Sie eine auswählen können.

NOTE - Sie können server.port = verwenden. spring boot findet für uns jeden nicht zugewiesenen http-Zufallsport.

1) application.properties

server.port=2020

2) application.yml

server:  
     port : 2020

) Ändern Sie den Server-Port programmgesteuert

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

.2) Durch Implementieren 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, die Eigenschaft server.port festzulegen.

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

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

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

 server.port = 8080

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

Hoffe das hilft

Anwendungseigenschaften => 
 
 Serverport = 8090 
 
 application.yml => 
 
 Server 
 Port: 8090 

Die Verwendung von property 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 Spring Boot "." für "_" und niedriger auf Groß-/Kleinschreibung für Umgebungsvariablen in neueren Versionen. Dies ist besonders nützlich in Containern, in denen Sie diese Umgebungsvariable nur definieren müssen, ohne application.properties hinzuzufügen/zu bearbeiten oder Systemeigenschaften über die Befehlszeile (d. H. -Dserver.port=$PORT) zu übergeben.

1.1 Update über eine Eigenschaftendatei.

/ src/main/resources/application.properties

server.port = 8888

pdate über eine Yaml-Datei.

   server:

     port: 8888

EmbeddedServletContainerCustomizer

@Component
public class CustomContainer implements EmbeddedServletContainerCustomizer {

    @Override
    public void customize(ConfigurableEmbeddedServletContainer container) {

        container.setPort(8888);

    }

}

Habe einfach einen application.properties in src/main/resources des Projekts und gebe dort

server.port=****

dabei bezieht sich **** auf die Portnummer.

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

1. Führen Sie den Abschnitt -> Konfigurationen aus

2. In application.xmlserver.port=XXXX hinzufügen

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

server.port = 8090

Sie können auch die Umgebungsvariable SERVER_PORT verwenden, um den Spring Boot-Port zu konfigurieren. Setzen Sie einfach die Umgebungsvariable 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.

Meist läuft Springboot auf port:8080 wegen eingebettetem Tomcat. In einigen Fällen kann es zu einem Fehler port 8080 already in use kommen. Um solche Probleme zu vermeiden, können wir den Server-Port konfigurieren.

Application.properties verwenden

server.port=9898 hinzufügen

Zur Laufzeit config

führen Sie Ihre Anwendung mit den folgenden Argumenten aus.

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

Sie können Ihren Port in der Datei application.properties im Ordner resources Ihres Spring Boot-Projekts konfigurieren.

server.port="port which you need"

Es gibt drei Möglichkeiten, dies zu tun

1 Legen Sie die Eigenschaft server.port in der Datei application.properties fest

server.port = 8090

2 Legen Sie die Serverport-Eigenschaft in der Datei application.yml fest

server:
     port: 8090

3 Legen Sie die Eigenschaft als Systemeigenschaft in der Methode main fest

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

Wenn Sie Apps als JAR-Datei in einer Befehlsumgebung ausführen möchten, geben Sie einfach "SERVER_PORT = ***" als Präfix ein. Der vollständige auszuführende Befehl sieht wie folgt aus:

SERVER_PORT=8080 Java -jar ***.jar

Wenn Sie die App unter Linux im Hintergrund ausführen möchten, sieht der Befehl mit 'Nohup' wie folgt aus:

SERVER_PORT=8080 Nohup Java -jar ***.jar &

Der Standardport ist: 8080, aber wir können die Portnummer in application.properties wie unten gezeigt anpassen

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

Wenn Sie über Boot-Projekte arbeiten und den Port konfigurieren möchten, können Sie die Eingabe in der Datei application.properties wie folgt vornehmen: HINWEIS: Die Eigenschaftendatei sollte sich unter src/main/resource befinden

Federeigenschaften

server.port = 9999 Wenn Sie die CMD verwenden, befolgen Sie diesen Befehl - Dserver.port = 9999 Für den Standardport ist server.port = 0 Stellen Sie sicher, dass kein Port diesen verwendet Port-Nummer

Fügen Sie in den Anwendungseigenschaften nur eine Zeile hinzu

server.port = 8090

Diese Frage ist das erste Ergebnis, wenn Sie nach Gradle Spring Port googeln.

Wenn Sie gradle verwenden, können Sie so etwas tun, wenn Sie das Spring Boot Gradle Plugin bereits angewendet haben:

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

Für eine differenziertere Antwort lesen Sie bitte meine Antwort hier .

Ähnlich wie https://stackoverflow.com/a/36865796/1587329 und https://stackoverflow.com/a/40799750/1587329 , Ein gradler Einzeiler wäre

SERVER_PORT=9090 gradle bootRun

"server.port = 808" funktioniert nur, wenn Ihre Anwendung über die Hauptmethode als JAR ausgeführt wird.

Diese Konfiguration funktioniert nicht, wenn Sie diese Anwendung als War-Datei über den Tomcat-Container ausführen.

wenn Ihre Portnummer zufällig sein kann, können Sie die Zufallsfunktion in Ihrem application.propertiesserver.port=${random.int(4)} verwenden.

Abgesehen von allen Antworten möchte ich darauf hinweisen, dass die meisten IDE (IntelliJ with Spring Plugin, STS) eine Funktion haben, die alle von SpringBoot unterstützten Konfigurationsschlüssel vorschlägt. (d. h. alle bewerteten Konfigurationsschlüsselwörter)

Spring Plugin für Intellij

Das hat bei mir funktioniert:

Eine benutzerdefinierte Containerklasse wurde hinzugefügt:

@Component
public class CustomContainer implements EmbeddedServletContainerCustomizer {

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

}

Dies benutzte aber immer noch nicht Port 8888.

Dann habe ich die Eigenschaft "scanBasePackages" für die Klasse "@SpringBootApplication" in meiner Hauptmethode wie folgt festgelegt: (scanBasePackages = {"custom container package"})

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

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

Und es fing an, den in Custom Container eingestellten Port aufzunehmen.

Beim Spring-Boot können Sie den Service-Exposing-Port einfach in der Datei application.properties konfigurieren.

server.port=portnumber

wenn Sie keinen bestimmten Port festlegen, wird versucht, den Service mit Port 80 zu öffnen. Wenn es bereits verwendet wird, wird der Dienst für den eingebetteten Container nicht gestartet.

In meinem Fall eine ergänzende Aussage

server.port=${port:8081}

überschreiben Sie den Standard-Tomcat-Server-Port.

server.port = 0 für zufälligen Port

server.port = 8080 für benutzerdefinierten 8080-Port

Der Standardport ist: 8080, aber wir können die Portnummer in application.properties wie unten gezeigt anpassen

application.properties

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