Jak skonfigurować port dla aplikacji Spring Boot


796

Jak skonfigurować port TCP / IP nasłuchiwany przez aplikację Spring Boot, aby nie używała domyślnego portu 8080.


5
Jeśli ktoś jest zainteresowany, tutaj pokazano, jak mieć wiele portów - stackoverflow.com/questions/36357135/…
— Betlista

jeśli użyjesz pliku „yml” do konfiguracji, możesz użyć tego serwera: port: 8081 Adnotuj też swoją klasę główną jako „@SpringBootApplication” i usuń @ EnableAutoConfiguration
— Keaz

twój projekt [application.properties] do dodania server.port = 8080
— Lahiru Samishka

ustawiony server.port=8080we właściwościach aplikacji. ta konfiguracja jest w ServerProperties.classklasie pod org.springframework.boot.autoconfigure.web.
— Atif

Odpowiedzi:


1226

Jak powiedział w docs albo ustawić server.portjako własność systemu za pomocą opcji wiersza poleceń do JVM -Dserver.port=8090lub dodać application.propertiesw /src/main/resources/z

server.port=8090

Do losowego użycia portu

server.port=0

47
Gdy używany jest losowy port, informacje o porcie można uzyskać za pomocą@Value("${local.server.port}")
— azizunsal

42
W rzeczywistości opcja wiersza poleceń to --server.port = 8090, a nie -Dserver.port = 8090. docs.spring.io/spring-boot/docs/current/reference/html/…
— Opster ES Ninja - Alper

1
Jako uzupełnienie tej odpowiedzi: zgodnie z dokumentami wiosennymi istnieją inne ścieżki, które można obrać application.properties. W moim przypadku to bardzo pomogło.
— sargas

14
-Dserver.port = XXXX nie działało dla mnie. Użyłem trybu zmiennej środowiskowej systemu operacyjnego: $ SERVER_PORT=8090 java -jar <path/to/my/jar>
— Soumya Kanti

10
Działa zarówno (1), jak java -Dserver.port=XXXX -jar <path/to/my/jar>i (2) java -jar <path/to/my/jar> --server.port=YYYY. Pierwsze polecenie definiuje server.portwłaściwość systemową, a drugie polecenie przekazuje właściwość przez argumenty wiersza poleceń ( String... argsw mainmetodzie). Ponadto, jeśli biegniesz z java -Dserver.port=XXXX -jar <path/to/my/jar> --server.port=YYYY, YYYYma pierwszeństwo przed XXXX, dlatego zewnętrzna konfiguracja Spring Boot jest tak urocza.
— tan9,

209

Istnieją dwa główne sposoby zmiany portu w Embedded Tomcat w aplikacji Spring Boot.

Zmodyfikuj application.properties

Najpierw możesz wypróbować plik application.properties w folderze / resources:

server.port = 8090

plik application.properties

Zmodyfikuj opcję maszyny wirtualnej

Drugi sposób, jeśli chcesz uniknąć modyfikowania jakichkolwiek plików i wpisywania czegoś, czego potrzebujesz tylko na swoim komputerze lokalnym, możesz użyć vm arg:

Idź do Uruchom -> Edytuj konfiguracje -> Opcje VM

-Dserver.port=8090

Zmień port za pomocą argumentu vm

Ponadto, jeśli potrzebujesz więcej informacji, możesz wyświetlić następujący post na blogu: Zmiana portu w aplikacji Spring Boot


W STS 4 jest on uruchamiany -> konfiguracje uruchamiania -> główny, a następnie przewiń w dół do tabeli z nazwą i wartością parametru
— serv-inc

155

Ponieważ Spring Boot udostępnia różne mechanizmy eksternalizacji konfiguracji (poprzez różne PropertySourceimplementacje i / lub procesory podłączone do Environmentobiektu w kolejności), możesz ustawić dowolną właściwość poza archiwum jar za pomocą następujących metod:

  1. Przekaż właściwość przez argument wiersza poleceń jako argument aplikacji

    java -jar <path/to/my/jar> --server.port=7788
  2. Z nieruchomości w SPRING_APPLICATION_JSON(Spring Boot 1.3.0+)

    • Zdefiniuj zmienną środowiskową w powłoce U * IX:

      SPRING_APPLICATION_JSON='{"server.port":7788}' java -jar <path/to/my/jar>
    • Za pomocą właściwości systemowej Java:

      java -Dspring.application.json='{"server.port":7788}' -jar <path/to/my/jar>
    • Przekaż argument wiersza poleceń:

      java -jar <path/to/my/jar> --spring.application.json='{"server.port":7788}'
  3. Zdefiniuj właściwość systemową JVM

    java -Dserver.port=7788 -jar <path/to/my/jar>
  4. Zdefiniuj zmienną środowiskową systemu operacyjnego

    • U * IX Shell

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

      SET SERVER_PORT=7788
      java -jar <path/to/my/jar>
  5. Umieść właściwość w ./config/application.properties pliku konfiguracyjnym

    server.port=7788

    i biegnij:

     java -jar <path/to/my/jar>
  6. Umieść nieruchomość w ./config/application.yaml

    server:
        port: 7788

    i biegnij:

     java -jar <path/to/my/jar>
  7. Umieść nieruchomość w ./application.properties

    server.port=7788

    i biegnij:

     java -jar <path/to/my/jar>
  8. Umieść nieruchomość w ./application.yaml

    server:
        port: 7788

    i biegnij:

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

Możesz łączyć powyższe metody razem, a pierwsza konfiguracja na liście ma pierwszeństwo przed drugą.

Na przykład:

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

Serwer uruchomi się i nasłuchuje na porcie 7788.

Jest to bardzo przydatne, ponieważ zapewnia właściwości domyślne w PropertySources o niższym priorytecie (zwykle pakowane w archiwum lub zakodowane w źródle), a następnie zastępuje je w środowisku wykonawczym. Jest to filozofia projektowania Spring Boot:

Wykazywanie opinii po wyjęciu z pudełka, ale zejdź z drogi, gdy wymagania zaczną odbiegać od domyślnych.


SERVER_NAMEdo server.namekonwersji zostało wykonane przez Relaxed Binding .


108

możesz również skonfigurować port programowo

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

Działa to i jest bardzo przydatne, gdy masz port we własnym pliku konfiguracyjnym i chcesz go ustawić w czasie wykonywania.
— Xdg,

4
Było to pomocne, gdy potrzebowałem wdrożyć aplikację do usługi AWS Elastic Beanstalk, aby uzyskać port ze zmiennej środowiskowej.
— Martin Hansen

Jest to bardzo przydatne, gdy wszystko, czego potrzebujesz, to samodzielny test jednostkowy lub integracyjny +1.
— Priidu Neemre

Bardzo przydatne, gdy zmienna env dla portu jest już zdefiniowana pod inną nazwą.
— higuaro,

2
Czy to @Configurationnie zamiast @Controller? Proszę zaktualizować, jeśli tak.
— Lucky

82

Możesz ustawić port w kodzie Java:

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

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

Lub w application.yml:

server:
    port: 9999

Lub w application.properties:

server.port=9999

Lub jako parametr wiersza poleceń:

-Dserver.port=9999

Korzystanie z HashMap będzie działać tylko wtedy, gdy nie zostanie ustawiony żaden port w application.properties lub .yml.
— Milgo

79

Jeśli chcesz uruchomić go lokalnie, użyj tego -

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

Począwszy od Spring Boot 2.0 , oto polecenie, które działa (wskazówki były tutaj ):

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

1
Począwszy od Spring Boot 2, powinieneś użyć spring-boot.run.jvmArguments.
— mapm

54

Jeśli używasz, application.ymldodaj do niego następujące linie

server:
     port: 9000

i oczywiście 0 dla losowego portu.


1
to nie działało. Użyłem server.port w application.yml i zadziałało
— yathirigan

47

Jak wyjaśniono w dokumentacji Spring , istnieje kilka sposobów, aby to zrobić:

Albo ustaw port w linii poleceń (na przykład 8888)

-Dserver.port=8888 lub --server.port=8888

Przykład: java -jar -Dserver.port=8888 test.jar

Lub ustaw port w pliku application.properties

server.port=${port:4588}

lub (w application.yml ze składnią yaml)

server:
   port: ${port:4588}

Jeśli port przekazany przez -Dport (lub -Dserver.port) jest ustawiony w linii poleceń, port ten zostanie wzięty pod uwagę. Jeśli nie, port będzie domyślnie 4588.

Jeśli chcesz wymusić port w pliku właściwości niezależnie od zmiennej środowiskowej, wystarczy napisać:

server.port=8888


23

Jeśli potrzebujesz programowo tego zrobić, możesz ustawić go podczas uruchamiania:

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

Może to pomóc w takich rzeczach, jak port zależny od środowiska. Miłego dnia


2
System.setProperty("server.port", 80);jest innym sposobem na osiągnięcie tego samego.
— hd1

@ hd1, dodałem nasze odpowiedzi do głównej odpowiedzi, sprawdź ją i zmodyfikuj według własnego uznania
— Luis Mauricio

18

Możesz określić port, zastępując komponent EmbeddedServletContainerFactorybean w konfiguracji (Java lub XML). Tam możesz określić port dla używanego osadzonego kontenera serwletu. Zobacz akapit „ Boot Boot - Core „ Embedded Servlet Container Support ”i przykład tam. Mam nadzieję że to pomoże.



Oto aktualny link do sekcji nadpisywania programowego: docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/…
— jocull


17

Aby rozszerzyć inne odpowiedzi:

Dokumentacja do testowania zawiera sekcję, która wyjaśnia, jak skonfigurować port do testów integracyjnych:


Podczas testów integracyjnych konfiguracja portu odbywa się za pomocą adnotacji @SpringBootTesti webEnvironmentwartości.


Losowy port:

@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)

Możesz wstrzyknąć wartość, @LocalServerPortktóra jest taka sama jak @Value("${local.server.port}").

  • Przykład:

Losowa konfiguracja testu portu:

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

Zdefiniowany port:

@SpringBootTest(webEnvironment=WebEnvironment.DEFINED_PORT)

Pobiera wartość z server.portif jest zdefiniowane.

  • Jeśli jest zdefiniowany za pomocą @TestPropertySource(properties = "server.port=9192"), zastępuje inne zdefiniowane wartości.
  • Jeśli nie, pobiera wartość z src/test/resources/application.properties(jeśli istnieje).
  • I wreszcie, jeśli nie jest zdefiniowane, zaczyna się od wartości domyślnej 8080.

Przykład:

Zdefiniowana konfiguracja testu portu:

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

    @Test
    public void contextLoads() {
    }

}

17

Po uruchomieniu aplikacji Spring Boot serwer osadzony, taki jak Tomcat, uruchamia się z domyślnym portem. Osadzony tomcat zaczyna się domyślnie od portu 8080. Istnieje wiele sposobów zmiany domyślnego portu serwera.

Korzystanie z pliku właściwości (.properties / .yml)

Aby zmienić port serwera za pomocą pliku właściwości, musimy skonfigurować właściwość server.port .

za. Korzystanie z application.properties w ścieżce klasy, takiej jak src \ main \ resources \ application.properties

server.port = 8585

Serwer uruchomi się z portem 8585. Aby uzyskać losowy port serwera, przypisz 0 do właściwości.

server.port = 0

Teraz wiosenny rozruch uruchomi serwer na porcie, który nie jest aktualnie używany przez żaden serwer w systemie.

b. Korzystanie z application.yml w ścieżce klas, takiej jak src \ main \ resources \ application.yml.

server:
  port: 8585 

Serwer uruchomi się z portem 8585.

Dla losowego portu przypisz 0.

server:
  port: 0 

Używanie polecenia Java z --server.port lub -Dserver.port

Załóżmy, że mamy wykonywalny plik JAR o nazwie my-app.jar, a następnie podczas uruchamiania aplikacji Spring Boot za pomocą komendy java możemy użyć argumentu w następujący sposób.

Korzystanie z --server.port

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

Korzystanie z -Dserver.port

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

Serwer uruchomi się z portem 8585.

Używanie polecenia Java z --port lub -Dport w skrócie

W skrócie --server.port i -Dserver.port, możemy usunąć słowo kluczowe serwera i uczynić go dowolnym krótkim słowem kluczowym, takim jak --port i -Dport. Możemy użyć dowolnego krótkiego słowa kluczowego. Tutaj używamy portu jako krótkiego słowa kluczowego. Aby to osiągnąć, musimy skonfigurować symbol zastępczy w pliku właściwości w następujący sposób.

Korzystanie z application.properties

server.port=${port:8282}

Korzystanie z application.yml

server:
   port: ${port:8282}

Jeśli nie podamy portu jako argumentu, wówczas domyślnie serwer zacznie od 8282. Jeśli chcemy innego portu, musimy przekazać żądany port jako argument w następujący sposób. Załóżmy, że mamy wykonywalny plik JAR o nazwie my-app.jar.

Używanie --port

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

Korzystanie z -Dport

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

Serwer uruchomi się z portem 8585.

Za pomocą SERVER_PORT z SpringApplication programowo

SpringApplication ma metodę setDefaultProperties (), która służy do zmiany domyślnych właściwości rozruchu wiosennego. Załóżmy, że chcemy zmienić domyślny port, a następnie musimy utworzyć mapę i umieścić port z kluczem SERVER_PORT. Znajdź przykład.

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 uruchomi serwer z portem 8585.


17

Można to zrobić na trzy sposoby, w zależności od używanego pliku konfiguracji aplikacji

a) Jeśli używasz zestawu plików application.properties

server.port = 8090

b) Jeśli używasz pliku application.yml , ustaw właściwość portu serwera w formacie YAML, jak podano poniżej

server:
     port: 8090

c) Możesz także ustawić właściwość jako właściwość System w metodzie głównej

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

15

jeśli używasz gradle jako narzędzia kompilacji, możesz ustawić port serwera w pliku application.yml jako:

server:
  port: 8291

Jeśli używasz maven, port można ustawić w pliku application.properties jako:

server.port: 8291

dla application.properties jegoserver.port = 8291
— iQuestProgrammer


13
  1. Jak wszyscy mówili, możesz określić w application.properties
    server.port = 9000 (może to być dowolna inna wartość)

  2. Jeśli używasz siłownika sprężynowego w swoim projekcie, domyślnie wskazuje on
    8080, a jeśli chcesz go zmienić, to we wniosku application.properties
    management.port = 9001 (może to być dowolna inna wartość)



12

W application.propertiespliku dodaj ten wiersz:

server.port = 65535

gdzie umieścić tego fie:

24.3 Pliki właściwości aplikacji

SpringApplication ładuje właściwości z plików application.properties w następujących lokalizacjach i dodaje je do środowiska Spring:

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

Lista jest uporządkowana według priorytetu (właściwości zdefiniowane w lokalizacjach znajdujących się wyżej na liście zastępują właściwości zdefiniowane w lokalizacjach niższych).

W moim przypadku umieszczam go w katalogu, w którym znajduje się jarplik.

Od:

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


12

Domyślnie wiosenna aplikacja rozruchowa uruchamia się z wbudowanym serwerem tomcat, zaczynając od domyślnego portu 8080. Spring oferuje następujące różne dostosowania, możesz wybrać jeden z nich.

UWAGA - możesz użyć server.port = 0 Spring boot znajdzie dla nas dowolny nieprzypisany losowy port http.

1) application.properties

server.port=2020

2) application.yml

server:  
     port : 2020

3) Zmień port serwera programowo

3.1) Wdrażając interfejs 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) Wdrażając interfejs EmbeddedServletContainerCustomizer - Spring 1.x

@Component
public class CustomizationBean implements EmbeddedServletContainerCustomizer {

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

4) Korzystając z opcji wiersza poleceń

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

10

Rzeczywiście, najłatwiejszym sposobem jest ustawienie właściwości server.port .

Jeśli używasz STS jako IDE, od wersji 3.6.7 faktycznie masz Spring Properties Editor do otwierania pliku właściwości.

Ten edytor zapewnia autouzupełnianie dla wszystkich właściwości Spring Boot. Jeśli napiszesz port i wciśniesz CTRL + SPACJA, server.port będzie pierwszą opcją.


1
Lub Jeśli używasz Intellij IDEA, autouzupełnianie również działa. ;)
— Lucky

9

Na przykład skorzystanie z właściwości server.port = 8080, jak wspomniano w innych odpowiedziach. Chciałem tylko wspomnieć, że możesz również ujawnić właściwość środowiska:

SERVER_PORT=8080

Ponieważ wiosenny rozruch może zastąpić „.” dla „_” i niższej do DUŻEJ wielkości dla zmiennych środowiskowych w najnowszych wersjach. Jest to szczególnie przydatne w kontenerach, w których wszystko, co musisz zrobić, to zdefiniować tę zmienną środowiskową bez dodawania / edytowania application.propertieslub przekazywania właściwości systemu za pomocą wiersza poleceń (tj. -Dserver.port=$PORT)


SERVER_PORT=8081 mvn spring-boot:run
— nobar

8

Mam nadzieję, że ta jedna pomoc

application.properties => 

server.port = 8090

application.yml => 

serwer
  port: 8090

application.yml => server: port: 8090
— maniak

8

Podanie numeru portu w pliku application.properties rozwiąże problem

 server.port = 8080

„port zależy od twojego wyboru, gdzie chcesz hostować aplikację”


7

Możesz dodać port za pomocą poniższych metod.

  1. Uruchom -> sekcja Konfiguracje

  2. W application.xmldodatkuserver.port=XXXX


1
Masz na myśli application.ymli jakiego IDE używasz? Proszę, bądź konkretny.
— Lucky

7

Możesz ustawić to w application.properties w / src / main / resources /

server.port = 8090

7

Po prostu weź udział application.propertiesw src/main/resourcesprojekcie i daj tam

server.port=****

gdzie ****odnosi się do numeru portu.


7

1.1 Aktualizacja za pomocą pliku właściwości.

/src/main/resources/application.properties

server.port = 8888

Zaktualizuj za pomocą pliku yaml.

   server:

     port: 8888

EmbeddedServletContainerCustomizer

@Component
public class CustomContainer implements EmbeddedServletContainerCustomizer {

    @Override
    public void customize(ConfigurableEmbeddedServletContainer container) {

        container.setPort(8888);

    }

}

6

Możesz także użyć SERVER_PORTzmiennej środowiskowej, aby skonfigurować port Spring Boot. Wystarczy ustawić zmienną środowiskową i ponownie uruchomić aplikację:

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

Należy pamiętać, że jeśli te zmienne środowiskowe nie zostaną ustawione dla całego systemu, należy uruchomić aplikację rozruchową w tej samej sesji.

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.