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.

Paul Verest
źródło
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
Paul Verest
źródło
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

anatalioki
źródło
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 .

tan9
źródło
108

możesz również skonfigurować port programowo

@Configuration
public class ServletConfig {
    @Bean
    public EmbeddedServletContainerCustomizer containerCustomizer() {
        return (container -> {
            container.setPort(8012);
        });
    }
}
makerj
źródło
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
ayurchuk
źródło
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
itwarilal
źródło
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.

gatolgaj
źródło
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
OlivierTerrien
źródło
39

Uwzględnij poniżej właściwości w application.properties

server.port=8080
Chandramouli
źródło
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

Luis Mauricio
źródło
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.

nndru
źródło
Oto aktualny link do sekcji nadpisywania programowego: docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/…
jocull
18

W application.propertiespliku obecnym w zasobach:

server.port=8082
Amit gudżarathi
źródło
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() {
    }

}
Pau
źródło
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.

Humoyun Ahmad
źródło
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");
Praneeth
źródło
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
VSharma
źródło
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ść)

Rakesh
źródło
12

Dodaj to do swojego application.propertiespliku

server.port= 8080
Sridhar Battala
źródło
2
Witamy w SO :-) proszę spojrzeć na Jak odpowiedzieć
JimHawkins
Po co dodawać ten sam asnwer rok później?!? i server.port 8080jest zła składnia pliku właściwości Java ...
Betlista
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

ZhaoGang
źródło
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
anandchaugule
źródło
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ą.

Adrian Cosma
źródło
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)

Ulises
źródło
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
Sagar Mal Shankhala
źródło
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ę”

Ashwini
źródło
7

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

  1. Uruchom -> sekcja Konfiguracje

  2. W application.xmldodatkuserver.port=XXXX

gkarthiks
źródło
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
Abhijeet
źródło
7

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

server.port=****

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

Shubham Khurana
źródło
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);

    }

}
Buddhika Lakshan
źródło
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.

Ali Dehghani
źródło