Jak skonfigurować port dla aplikacji Spring Boot

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

Modyfikuj aplikację.właściwości

Najpierw możesz wypróbować aplikację.Plik Właściwości w folderze / resources:

Modyfikuj opcję VM

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

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

-Dserver.port=8090

Dodatkowo, jeśli potrzebujesz więcej informacji, możesz zobaczyć następujący wpis na blogu tutaj: Zmiana portu w aplikacji Spring Boot

Można również programowo skonfigurować port

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

Ponieważ Spring Boot zapewnia różne mechanizmy eksternalizacji konfiguracji (poprzez różne implementacje PropertySource i / lub procesory podłączone do obiektu Environment w kolejności), możesz ustawić dowolną właściwość poza twojego archiwum jar za pomocą następujących metod:{[30]]}

1. Przekazuj właściwość przez argument linii poleceń jako argument aplikacji

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

2. From property in 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>
     

   • Używając właściwości Java system:

     java -Dspring.application.json='{"server.port":7788}' -jar <path/to/my/jar>
     

   • Podaj argument wiersza poleceń:

     java -jar <path/to/my/jar> --spring.application.json='{"server.port":7788}'
     

3. Define właściwość systemu JVM

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

4. Define zmienna środowiskowa OS

   • U*IX Shell

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

   • Okna

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

5. Umieść nieruchomość w ./config/application.properties plik konfiguracyjny

   server.port=7788
   

   I uruchomić:

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

6. Umieść nieruchomość w ./config/application.yaml

   server:
       port: 7788
   

   I uruchomić:

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

7. Umieść nieruchomość w ./application.properties

   server.port=7788
   

   I uruchomić:

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

8. Umieść nieruchomość w ./application.yaml

   server:
       port: 7788
   

   I uruchomić:

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

Możesz połączyć powyższe metody wszystkie 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łucha na porcie 7788.

Jest to bardzo użyteczne, ponieważ w właściwościach PropertySources o niższym priorytecie (zwykle pakowane w archiwum lub zakodowane w źródle), a następnie nadpisywane w środowisku runtime. I jest to filozofia projektowania Spring Boot: {]}

Be po wyjęciu z pudełka, ale szybko zejdź z drogi, ponieważ wymagania zaczynają odbiegać od domyślnych.

SERVER_NAME do server.name konwersja została dokonana przez luźne Wiązanie.

Możesz ustawić port w kodzie Javy:

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

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

Lub w aplikacji.yml:

server:
    port: 9999

Lub w aplikacji.właściwości:

server.port=9999

Lub jako parametr wiersza poleceń:

-Dserver.port=9999

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

server:
     port: 9000

I oczywiście 0 dla portu losowego.

Jak wyjaśniono w dokumentacja sprężyny , istnieje kilka sposobów, aby to zrobić:

Albo ustawiasz port w wierszu poleceń (na przykład 8888)

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

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

Lub ustawiasz port w aplikacji.właściwości

server.port=${port:4588}

Lub (w zastosowaniu.yml ze składnią yaml)

server:
   port: ${port:4588}

Jeśli port przeszedł przez-Dport (lub-Dserver.port) jest ustawiony w wierszu poleceń, wtedy ten port będzie brany pod uwagę. Jeśli nie, to 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

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 Komenda, która działa (wskazówki były tutaj):

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

Include below property in application.properties

server.port=8080

Gdy potrzebujesz programu, możesz go ustawić podczas uruchamiania:

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

To może pomóc w takich sprawach jak port zależny od środowiska. Miłego dnia

Możesz określić port poprzez nadpisanie EmbeddedServletContainerFactory bean w swojej konfiguracji (opartej na Javie lub xml). Tam możesz określić port dla używanego osadzonego kontenera serwleta. Zobacz Spring Boot - Core "Embedded Servlet Container Support" akapit i przykład. Mam nadzieję, że to pomoże.

Aby rozszerzyć inne odpowiedzi:

W dokumentach testowych znajduje się sekcja, która wyjaśnia, jak skonfigurować port w testach integracyjnych:

• 41.3 testowanie aplikacji Spring Boot
• 41.3.3 praca z przypadkowymi portami

W testach integracyjnych Konfiguracja portu jest dokonywana przy użyciu wartości adnotacji @SpringBootTest i webEnvironment.

Losowy port:

@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)

Możesz wprowadzić wartość za pomocą @LocalServerPort który jest taki sam jak @Value("${local.server.port}").

• przykład:

Konfiguracja testu portu losowego:

@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.port jeśli jest zdefiniowana.

• jeśli jest zdefiniowana za pomocą @TestPropertySource(properties = "server.port=9192"), nadpisuje inne zdefiniowane wartości.
• jeśli nie, to pobiera wartość z src/test/resources/application.properties (jeśli istnieje).
• i wreszcie, jeśli nie jest zdefiniowana, zaczyna się od domyślnego 8080.

Przykład:

Zdefiniowany port konfiguracja testu:

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

    @Test
    public void contextLoads() {
    }

}

W pliku application.properties obecnym w zasobach:

server.port=8082

Po uruchomieniu aplikacji spring boot serwer osadzony, taki jak Tomcat, uruchamia się z domyślnym portem. Osadzony tomcat zaczyna się od portu 8080 jako domyślnego. Istnieje wiele sposobów na zmianę domyślnego portu serwera.

Using Property File (.właściwości/yml)

Aby zmienić port serwera używając pliku właściwości, musimy skonfigurować serwer.port własność.

A. Korzystanie z aplikacji.właściwości w classpath, takie jak src\main \ resources\application.właściwości

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 spring boot uruchomi serwer na porcie, który nie jest obecnie używany przez żaden serwer w systemie.

B. Korzystanie z aplikacji.yml w klasach takich jak src\main \ resources\application.yml.

server:
  port: 8585 

Serwer uruchomi się z portem 8585.

Dla portu losowego Przypisz 0.

server:
  port: 0 

użycie polecenia java Z --server.port lub-Dserver.port

Załóżmy, że mamy plik wykonywalny o nazwie my-app.jar, następnie uruchamiając aplikację spring boot używając polecenia java możemy użyć argumentu w następujący sposób.

Użycie --server.port

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

Używanie -Dserver.port

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

Serwer uruchomi się z portem 8585.

za pomocą polecenie java w skrócie z --port lub-Dport

Aby zrobić -- serwer.port i-Dserver.port w skrócie, możemy usunąć słowo kluczowe server i uczynić je 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ć Element Zastępczy w pliku właściwości w następujący sposób.

Korzystanie z aplikacji.właściwości

server.port=${port:8282}

Korzystanie z aplikacji.yml

server:
   port: ${port:8282}

Jeśli zrobimy nie przekazuje portu jako argumentu, wtedy domyślnie serwer rozpocznie się od 8282. Jeśli chcemy mieć inny port, to musimy przekazać pożądany port w argumencie w następujący sposób. Załóżmy, że mamy plik wykonywalny o nazwie my-app.słoik.

Użycie --port

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

Using-Dport

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

Serwer uruchomi się z portem 8585.

używanie SERVER_PORT z programem SpringApplication

SpringApplication ma metoda setDefaultProperties () używana do zmiany domyślnych właściwości spring boot. Załóżmy, że chcemy zmienić domyślny port, wtedy musimy utworzyć mapę i umieścić port z kluczem SERVER_PORT. Znajdź przykład.

/ align = "left" / 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.

Istnieje wiele innych rzeczy, które można zmienić w konfiguracji serwera, zmieniając aplikację.właściwości. Jak przerwa w 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 każdy powiedział, można określić w aplikacji.właściwości
   Serwer.port = 9000 (może być dowolną inną wartością)

2. Jeśli używasz siłownika sprężyny w swoim projekcie, domyślnie wskazuje on na
   8080, a jeśli chcesz go zmienić, to w aplikacji.właściwości
   Zarządzanie.port = 9001 (może być dowolną inną wartością)

Rzeczywiście, najprostszym sposobem jest ustawienie serwera .port własność.

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

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

Dodaj to do pliku application.properties

server.port= 8080

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

/src / main / resources / application.właściwości

Serwer.port = 8888

Aktualizacja za pomocą pliku yaml.

   server:

     port: 8888

EmbeddedServletContainerCustomizer

@Component
public class CustomContainer implements EmbeddedServletContainerCustomizer {

    @Override
    public void customize(ConfigurableEmbeddedServletContainer container) {

        container.setPort(8888);

    }

}

Hope this one help

application.properties=> 

server.port=8090

application.yml=> 

server
  port:8090

Wystarczy mieć application.properties w src/main/resources projektu i dać tam

server.port=****

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

Korzystanie z serwera właściwości.na przykład port=8080, jak wspomniano w innych odpowiedziach, jest zdecydowanie dobrym rozwiązaniem. Chciałem tylko wspomnieć, że można również ujawnić właściwość środowiska:

SERVER_PORT=8080

Ponieważ spring boot jest w stanie wymienić"."for" _ " i małe na wielkie litery dla zmiennych środowiskowych w ostatnich wersjach. Jest to szczególnie przydatne w kontenerach, w których wystarczy zdefiniować zmienną środowiskową bez dodawania / edycji application.properties lub przekazywania właściwości systemu za pomocą polecenia line (i.e -Dserver.port=$PORT)

Możesz dodać port w poniższych metodach.

1. Run - > sekcja konfiguracji

2. In application.xml dodaj server.port=XXXX

Możesz to ustawić w aplikacji.właściwości pod /src / main/resources /

server.port = 8090

Głównie springboot działa na port:8080 ze względu na wbudowany Tomcat. W niektórych może to spowodować błąd port 8080 already in use. Aby uniknąć tego typu problemów możemy skonfigurować port serwera.

Korzystanie z aplikacji.właściwości

Dodaj server.port=9898

On Runtime config

Uruchom aplikację z poniższymi argumentami.

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

Są trzy sposoby, aby to zrobić

1 ustawiony serwer.właściwość portu w pliku application.properties

server.port = 8090

2 ustaw właściwość portu serwera w pliku application.yml

server:
     port: 8090

3 ustaw właściwość jako właściwość systemową w metodzie main

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

Możesz również użyć zmiennej środowiskowej SERVER_PORT do skonfigurowania portu rozruchowego Spring. Po prostu ustaw zmienną środowiskową i uruchom ponownie aplikację:

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

Należy pamiętać, że jeśli nie ustawisz tych zmiennych środowiskowych dla całego systemu, należy uruchomić aplikację rozruchową na tej samej sesji.

Domyślny port to: 8080, ale możemy dostosować numer portu w aplikacji.właściwości jak pokazano poniżej

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

To pytanie jest pierwszym wynikiem, jeśli wygooglujesz Gradle Spring Port .

Jeśli używasz gradle, możesz zrobić coś takiego, jeśli masz już zastosowaną wtyczkę Spring Boot Gradle:

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

Aby uzyskać bardziej wyrafinowaną odpowiedź, zobacz moją odpowiedź tutaj .

Jeśli pracujesz nad projektami rozruchowymi i chcesz skonfigurować port, możesz podać dane wejściowe w aplikacji.plik właściwości jak Uwaga: plik właściwości powinien znajdować się pod src/main / resource

Właściwości sprężyny

Serwer.port = 9999 Jeśli używasz CMD, wykonaj to polecenie - Dserver.port = 9999 Dla domyślnego portu jego serwera.port=0 Upewnij się, że żaden port nie używa tego numeru portu