Jak skonfigurować port dla aplikacji Spring Boot

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

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

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

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

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

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 .

możesz również skonfigurować port programowo

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

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

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

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

server:
     port: 9000

i oczywiście 0 dla losowego portu.

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

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

server.port=8080

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

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.

W application.propertiespliku obecnym w zasobach:

server.port=8082

Aby rozszerzyć inne odpowiedzi:

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

• 41.3 Testowanie aplikacji Spring Boot
• 41.3.3 Praca z losowymi portami

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

}

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.

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

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

Istnieje wiele innych rzeczy, które możesz zmienić w konfiguracji serwera, zmieniając application.properties. Jak limit czasu sesji, adres i port itp. Zobacz poniższy post

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

Użyłem kilku z nich jak poniżej.

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

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ść)

Dodaj to do swojego application.propertiespliku

server.port= 8080

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

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

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

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)

Mam nadzieję, że ta jedna pomoc

application.properties => 

server.port = 8090

application.yml => 

serwer
  port: 8090

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

 server.port = 8080

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

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

1. Uruchom -> sekcja Konfiguracje

2. W application.xmldodatkuserver.port=XXXX

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

server.port = 8090

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

server.port=****

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

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

    }

}

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.