Cum să configurați port pentru o Primavara aplicație de Boot

Ca a spus în docs fie setat serverul.portca sistemul proprietatea, folosind opțiunea de linie de comandă pentru a jvm-Dserver.port=8090sau adauga cerere.properties din `/src/main/resurse/ cu

server.port=8090

Pentru port aleator utilizare

server.port=0

Există două moduri principale de a schimba portul in Încorporat Tomcat într-o Primăvară Aplicație de Boot.

Modifica cererea.proprietăți

În primul rând, puteți încerca aplicația.properties în directorul /directorul de resurse:

server.port = 8090

Modifica un BAN opțiune

Cel de-al doilea mod, dacă doriți, pentru a evita modificarea fișierelor și verificarea în ceva de care ai nevoie doar pe dvs. locale, puteți utiliza un vm arg:

Du-te la Run -> Edit config -> VM opțiuni

-Dserver.port=8090

În plus, dacă aveți nevoie de mai multe informații puteți vizualiza următorul mesaj pe blog aici: Schimba portul pe un arc de Boot Cerere

Începând din Primăvara anului Boot oferă diverse de configurare externalizarea mecanism (prin diverse PropertySource implementări și/sau procesoare cu fir în "Mediu" obiect în ordine), puteți seta orice proprietate exterior de borcan de arhivă prin următoarele metode:

1. Trec de proprietate prin linie de comandă argument ca cerere argument

java-jar <calea/catre/mea/borcan> --server.port=7788

2. De proprietate în SPRING_APPLICATION_JSON (Spring Boot 1.3.0+)

• Definiți variabila de mediu în U*IX shell:

SPRING_APPLICATION_JSON='{"server.port":7788}' java-jar <calea/catre/mea/borcan>

• Prin utilizarea Java sistem de proprietate:

java -Dspring.aplicație.json='{"server.port":7788}' -borcan <calea/catre/mea/borcan>

• Trece prin argument în linia de comandă:

java-jar <calea/catre/mea/borcan> --primăvară.aplicație.json='{"server.port":7788}'

3. Defini JVM sistem de proprietate

java -Dserver.port=7788 -borcan <calea/catre/mea/borcan>

4. Defini OS variabila de mediu

• U*IX Shell

SERVER_PORT=7788 java-jar <calea/catre/mea/borcan>

• Windows

SET SERVER_PORT=7788 java-jar <calea/catre/mea/borcan>

5. De proprietate, în ./config/aplicație.proprietăți configuration file

server.port=7788

și a alerga:

java-jar <calea/catre/mea/borcan>

6. De proprietate, în ./config/aplicație.yaml

server: port: 7788

și a alerga:

java-jar <calea/catre/mea/borcan>

7. De proprietate, în ./aplicație.proprietăți

server.port=7788

și a alerga:

java-jar <calea/catre/mea/borcan>

8. De proprietate, în ./aplicație.yaml

server: port: 7788

și a alerga:

java-jar <calea/catre/mea/borcan>

Puteți combina metodele de mai sus toate împreună, și fostul configurare în lista prevalează în raport cu unul.

De exemplu:

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

Serverul va începe și de a asculta pe portul 7788.

Acest lucru este foarte util oferind proprietăți implicite în PropertySources cu mai mică prioritate (și, de obicei, ambalate in arhiva sau codificate în sursă), și apoi trece peste în mediul runtime. Și aceasta este filosofia de design de Primăvară Boot:

Fie dogmatic afară de la cutie, dar ieși din modul rapid și cerințele începe să se abată de la valorile implicite.

SERVER_NAME la `server.numele de conversie a fost făcut de către Relaxat Obligatoriu.

de asemenea, puteți configura portul programatic

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

Puteți seta portul în cod java:

HashMap props = new HashMap();
props.put("server.port", 9999);

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

Sau în aplicație.yml:

server:
    port: 9999

Sau în aplicație.proprietăți:

server.port=9999

Sau ca un parametru de linie de comandă:

-Dserver.port=9999

Dacă doriți să rulați la nivel local, utilizați această -

mvn primavara-boot:run-Be.jvmArguments='-Dserver.port=8085'

Ca de Spring Boot 2.0, aici's de comandă care funcționează (indicii au fost aici):

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

În cazul în care se utilizează aplicarea.yml` adăugați Următoarele linii la ea

server:
     port: 9000

și, desigur, 0 pentru port aleator.

Așa cum sa explicat în Primăvara documentația, există mai multe moduri de a face asta:

Ori ai setat portul în linia de comandă (de exemplu 8888)

-Dserver.port=8888 " sau " --server.port=8888

Exemplu: java-jar -Dserver.port=8888 test.jar`

Sau ai setat portul în cerere.proprietăți

server.port=${port:4588}

sau (în aplicație.yml cu yaml sintaxa)

server:
   port: ${port:4588}

Dacă portul a trecut de -Dport (sau -Dserver.port) este setat în linia de comandă, atunci acest port vor fi luate în considerare. Dacă nu, atunci portul va fi 4588 în mod implicit.

Dacă doriți să pună în aplicare port în fișierul de proprietăți indiferent de variabila de mediu, trebuie doar să scrie:

server.port=8888

Includ mai jos de proprietate în aplicare.proprietăți`

server.port=8080

Atunci când ai nevoie de un programatic mod de a face aceasta, puteți seta timpul de pornire:

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

Acest lucru ar putea ajuta pentru lucruri cum ar fi mediul dependente de port. Să ai o zi frumoasă

În aplicația.proprietăți` de fișiere prezente în resurse:

server.port=8082

Puteți specifica portul de imperative `EmbeddedServletContainerFactory de fasole în configurația (bazate pe java sau xml). Acolo puteți specifica portul de folosit încorporat container de servlet. Vă rugăm, consultați Spring Boot - Core "Încorporat Servlet Container Suport" punctul și exemplu. Sper că acest lucru vă ajută.

Când primăvara boot aplicația pornește, încorporat server, cum ar fi Tomcat începe cu un port implicit. Încorporat tomcat începe cu portul 8080 ca implicit. Există multe modalități de a schimba implicit portul serverului.

Folosind Proprietatea De Fișier (.proprietăți/.yml)

Pentru a schimba portul serverului folosind fișierul de proprietăți, trebuie să configurați de server.port de proprietate.

un. Folosind aplicația.proprietăți în clase, cum ar fi src\principal\resources\application.proprietăți

server.port = 8585

Serverul va începe cu 8585 port. Pentru a obține aleatoare port server, atribui 0 la proprietate.

server.port = 0

Acum, primăvara caravana va porni serverul pe un port care nu este utilizat în prezent de către orice server în sistem.

b. Folosind aplicația.yml în clase, cum ar fi src\principal\resources\application.yml.

server:
  port: 8585 

Serverul va începe cu 8585 port.

Pentru port aleator, atribui 0.

server:
  port: 0 

Folosind Comanda java cu-server.sau port -Dserver.port

Să presupunem că avem un JAR executabil numit ca my-app.jar atunci, în timp ce incepand de primăvară aplicație de boot folosind comanda java putem folosi argumentul după cum urmează.

Folosind --server.port

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

Folosind -Dserver.port

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

Serverul va începe cu 8585 port.

Folosind Comanda java cu ... sau port -Dport în Scurt

Pentru a face --server.port și -Dserver.port pe scurt, putem elimina server de cuvinte cheie și de a face nici un scurt cuvânt cheie cum ar fi: babord și -Dport. Putem folosi orice scurte cuvinte cheie. Aici suntem folosind port cât mai scurt de cuvinte cheie. Pentru a realiza aceasta avem nevoie pentru a configura substituent în proprietate de fișiere după cum urmează.

Folosind aplicația.proprietăți

server.port=${port:8282}

Folosind aplicația.yml

server:
   port: ${port:8282}

Dacă nu vom trece port ca argument, atunci în mod implicit serverul va începe cu 8282. Dacă vrem un alt port, atunci avem nevoie pentru a trece portul dorit în argument, după cum urmează. Să presupunem că avem un JAR executabil numit ca my-app.jar.

Folosind --port

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

Folosind -Dport

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

Serverul va începe cu 8585 port.

Utilizarea SERVER_PORT cu SpringApplication Programatic

SpringApplication are o metoda ca setDefaultProperties (), care este folosit pentru a schimba spring boot default proprietăți. Să presupunem că doriți să modificați portul implicit atunci avem nevoie pentru a crea o Hartă și a pus-o port cu SERVER_PORT cheie. Găsiți exemplu.

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 map = new HashMap();
        map.put("SERVER_PORT", "8585");
        application.setDefaultProperties(map);
        application.run(args);
        }     
} 

Spring boot va porni serverul cu 8585 port.

Să se extindă la alte răspunsuri:

Există o secțiune în documentele de testare care explică cum să configurați portul de teste de integrare:

• 41.3 Testarea Spring Boot aplicații
• 41.3.3 Lucrează cu porturi aleatorii

La testele de integrare, portul de configurare se face folosind adnotarea `@SpringBootTest " și " webEnvironment valorilor.

Port aleator:

@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)

Vă puteți injecta valoare folosind @LocalServerPort care este la fel ca @Valoare("${locală.server.portul}").

• Exemplu:

Port aleator test de configurare:

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

Port definite:

@SpringBootTest(webEnvironment=WebEnvironment.DEFINED_PORT)

Se ia valoarea de la server.port` dacă este definit.

• Dacă este definită utilizând @TestPropertySource(proprietăți = "server.port=9192"), se înlătură alte valori definite.
• Dacă nu, se ia valoarea de la src/test/resurse/aplicație.properties (dacă există).
• Și în cele din urmă, dacă nu este definit acesta începe cu default 8080.

Exemplu:

Port definite test de configurare:

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

    @Test
    public void contextLoads() {
    }

}

Există trei moduri de a face în funcție de aplicația de configurare fișier pe care îl utilizați

a) Dacă utilizați aplicație.proprietăți set de fișiere

server.port = 8090

b) Dacă sunt utilizați aplicație.yml set de fișiere portul serverului de proprietate în YAML format prezentate mai jos

server:
     port: 8090

c) de asemenea, puteți Seta proprietatea ca Sistemul de proprietate în principala metodă

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

Există multe alte umpluturi puteți modifica în serverul de configurare prin modificarea cererii.proprietăți. Ca sesiune de time-out, adresă și port etc. Consultați mai jos post

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

Am folosit cateva dintre ele mai jos.

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

În aplicația.proprietăți de fișier, adăugați această linie:

server.port = 65535

în cazul în care locul pe care fie:

24.3 Aplicarea Fișiere de Proprietăți

SpringApplication mulțime de proprietăți de la aplicare.fișierele de proprietăți în următoarele locații și le adaugă la Primăvară Mediu:

Un /config subdirector din directorul curent directorul curent O clase /config pachet classpath rădăcină

lista este ordonată de prioritate (proprietăți definite în locații mai mare în lista suprascrie cele definite în locații mai mici).

În cazul meu am pus-o în directorul unde " jar " fișier standuri.

De la:

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

Adăugați acest la aplicație.proprietăți de fișier

server.port= 8080

1. Cum toată lumea a spus, puteți să specificați în cerere.proprietăți
   de server.port = 9000 (ar putea fi orice altă valoare)

2. Dacă utilizați primăvară de acționare în proiectul dumneavoastră, implicit puncte pentru a 8080, și, dacă doriți să-l modificați, apoi în aplicare.proprietăți menționa
   management.port = 9001 (ar putea fi orice altă valoare)

În mod implicit spring boot app începe cu încorporat server tomcat începe de la default portul 8080. primăvara vă oferă următoarele diferite de personalizare puteți alege una dintre ele.

NOTĂ – puteți utiliza de server.port=0 spring boot va găsi orice neatribuite http port aleator pentru noi.

1) cererea.proprietăți

server.port=2020

2) cererea.yml

server:  
     port : 2020

3) Schimbarea portului de server programatic

3.1) De punere în aplicare WebServerFactoryCustomizer interfață - Primavara 2.x

@Component
public class MyTomcatWebServerCustomizer implements WebServerFactoryCustomizer {

    @Override
    public void customize(TomcatServletWebServerFactory factory) {
        // customize the factory here
        factory.setPort(2020);
    }
}

3.2) Prin punerea în Aplicare a EmbeddedServletContainerCustomizer interfață - Primăvară 1.x

@Component
public class CustomizationBean implements EmbeddedServletContainerCustomizer {

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

4) folosind opțiunea de linie de comandă

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