Como configurar a porta para um aplicativo Spring Boot


798

Como configurar a porta TCP / IP ouvida por um aplicativo Spring Boot, para que ele não use a porta padrão 8080.


5
Se alguém estiver interessado, aqui é mostrado como ter várias portas - stackoverflow.com/questions/36357135/…
Betlista

se você usar o arquivo "yml" para a configuração, então você pode usar este servidor: porta: 8081 também anotar que você classe principal como "@SpringBootApplication" e remove @ EnableAutoConfiguration
Keaz

seu projeto [application.properties] para adicionar o server.port = 8080
Lahiru Samishka 8/19

definido server.port=8080nas propriedades do aplicativo. essa configuração está na ServerProperties.classclasse abaixo org.springframework.boot.autoconfigure.web.
Atif 11/03

Respostas:


1227

Como disse em docs quer definidos server.portcomo propriedade do sistema usando a opção de linha de comando para JVM -Dserver.port=8090ou adicionar application.propertiesem /src/main/resources/com

server.port=8090

Para uso de porta aleatória

server.port=0

47
Quando porta aleatória é usada, informações porta pode começar com@Value("${local.server.port}")
azizunsal

42
Na verdade, a opção de linha de comando é --server.port = 8090 e não -Dserver.port = 8090. docs.spring.io/spring-boot/docs/current/reference/html/…
Opster ES Ninja - Alper

1
Como complemento a esta resposta: De acordo com os documentos da primavera, existem outros caminhos que você pode seguir application.properties. No meu caso, isso ajudou muito.
Sargas

14
-Dserver.port = XXXX não funcionou para mim. Eu modo variável de ambiente OS usados: $ SERVER_PORT=8090 java -jar <path/to/my/jar>
Soumya Kanti

10
Ambos (1) java -Dserver.port=XXXX -jar <path/to/my/jar>e (2) java -jar <path/to/my/jar> --server.port=YYYYfuncionam. O primeiro comando define a server.portpropriedade do sistema e o segundo comando passa a propriedade pelos argumentos da linha de comando ( String... argsno mainmétodo). Além disso, se você executar java -Dserver.port=XXXX -jar <path/to/my/jar> --server.port=YYYY, YYYYtem precedência sobre XXXX, é por isso que a Configuração Externizada de Inicialização da Spring é tão encantadora.
tan9

210

Existem duas maneiras principais de alterar a porta no Tomcat incorporado em um aplicativo de inicialização do Spring.

Modifique application.properties

Primeiro, você pode tentar o arquivo application.properties na pasta / resources:

server.port = 8090

arquivo application.properties

Modificar uma opção de VM

A segunda maneira, se você quiser evitar modificar qualquer arquivo e fazer o check-in de algo que você só precisa no seu local, use um vm arg:

Vá para Executar -> Editar configurações -> Opções da VM

-Dserver.port=8090

Alterar porta com um vm arg

Além disso, se você precisar de mais informações, poderá visualizar a seguinte publicação no blog aqui: Alterando a porta em um aplicativo de inicialização Spring


Em STS 4 é pelo prazo -> configurações de execução -> principal, em seguida, desloque-se para Tabela com Nome do parâmetro e Valor
serv-inc

155

Como o Spring Boot fornece vários mecanismos de externalização de configuração (por meio de várias PropertySourceimplementações e / ou processadores conectados ao Environmentobjeto em ordem), você pode definir qualquer propriedade fora do seu arquivo jar através dos seguintes métodos:

  1. Passe a propriedade pelo argumento da linha de comandos como argumento do aplicativo

    java -jar <path/to/my/jar> --server.port=7788
  2. Da propriedade em SPRING_APPLICATION_JSON(Spring Boot 1.3.0+)

    • Defina a variável de ambiente no shell U * IX:

      SPRING_APPLICATION_JSON='{"server.port":7788}' java -jar <path/to/my/jar>
    • Usando a propriedade do sistema Java:

      java -Dspring.application.json='{"server.port":7788}' -jar <path/to/my/jar>
    • Passe pelo argumento da linha de comando:

      java -jar <path/to/my/jar> --spring.application.json='{"server.port":7788}'
  3. Definir propriedade do sistema JVM

    java -Dserver.port=7788 -jar <path/to/my/jar>
  4. Definir variável de ambiente do SO

    • U * IX Shell

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

      SET SERVER_PORT=7788
      java -jar <path/to/my/jar>
  5. Coloque a propriedade no ./config/application.properties arquivo de configuração

    server.port=7788

    e corra:

     java -jar <path/to/my/jar>
  6. Coloque a propriedade em ./config/application.yaml

    server:
        port: 7788

    e corra:

     java -jar <path/to/my/jar>
  7. Coloque a propriedade em ./application.properties

    server.port=7788

    e corra:

     java -jar <path/to/my/jar>
  8. Coloque a propriedade em ./application.yaml

    server:
        port: 7788

    e corra:

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

Você pode combinar os métodos acima todos juntos, e a configuração anterior na lista tem precedência sobre o último.

Por exemplo:

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

O servidor iniciará e escutará na porta 7788.

Isso é muito útil, fornecendo propriedades padrão no PropertySources com menor precedência (e geralmente empacotadas no arquivo morto ou codificadas na fonte) e substituindo-as no ambiente de tempo de execução. E é a filosofia de design do Spring Boot:

Seja opinativo imediatamente, mas saia do caminho rapidamente, pois os requisitos começam a divergir dos padrões.


SERVER_NAMEa server.nameconversão foi feita pelo Relaxed Binding .


108

Além disso, você pode configurar a porta programaticamente

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

Isso está funcionando e é muito útil quando você tem uma porta no seu próprio arquivo de configuração e deseja configurá-lo durante o tempo de execução.
Xdg

4
Isso foi útil quando eu precisei implantar um aplicativo em um serviço AWS Elastic Beanstalk, para obter a porta de uma variável de ambiente.
Martin Hansen

Isso é super útil quando tudo o que você deseja é uma unidade independente ou um teste de integração, +1.
Priidu Neemre

Muito útil quando a variável env para port já está definida com um nome diferente.
Higuaro

2
Não é o @Configurationlugar de @Controller? Por favor, atualize se sim.
Sorte

82

Você pode definir a porta no código java:

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

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

Ou em application.yml:

server:
    port: 9999

Ou em application.properties:

server.port=9999

Ou como um parâmetro de linha de comando:

-Dserver.port=9999

O uso do HashMap funcionará apenas se nenhuma porta estiver configurada em applications.properties ou .yml.
Milgo

79

Se você deseja executá-lo localmente, use este -

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

A partir do Spring Boot 2.0 , eis o comando que funciona (as dicas estavam aqui ):

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

1
A partir do Spring Boot 2, você deve usar spring-boot.run.jvmArguments.
Map

54

Caso esteja usando, application.ymladicione as seguintes linhas a ele

server:
     port: 9000

e, claro, 0 para porta aleatória.


1
isso não parecia funcionar. Eu costumava server.port na application.yml e funcionou
yathirigan

47

Conforme explicado na documentação do Spring , existem várias maneiras de fazer isso:

Você define a porta na linha de comandos (por exemplo, 8888)

-Dserver.port=8888 ou --server.port=8888

Exemplo: java -jar -Dserver.port=8888 test.jar

Ou você define a porta no application.properties

server.port=${port:4588}

ou (em application.yml com sintaxe yaml)

server:
   port: ${port:4588}

Se a porta passada por -Dport (ou -Dserver.port) for configurada na linha de comando, essa porta será levada em consideração. Caso contrário, a porta será 4588 por padrão.

Se você deseja impor a porta no arquivo de propriedades, independentemente da variável de ambiente, basta escrever:

server.port=8888

39

Incluir propriedade abaixo em application.properties

server.port=8080

23

Quando você precisar de uma maneira programática de fazê-lo, poderá configurá-lo durante a inicialização:

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

Isso pode ajudar em coisas como porta dependente do ambiente. Tenha um bom dia


2
System.setProperty("server.port", 80);é outra maneira de conseguir o mesmo.
hd1

@ hd1, adicionei nossas respostas à resposta principal, verifique-a e modifique-a como desejar, por favor #
Luis Mauricio

18

Você pode especificar a porta substituindo o EmbeddedServletContainerFactorybean em sua configuração (baseado em java ou xml). Lá, você pode especificar a porta para o contêiner de servlet incorporado usado. Por favor, consulte o parágrafo Spring Boot - Core "Embedded Servlet Container Support" e exemplo lá. Espero que isto ajude.



Aqui está um link atual para a seção de substituição programática: docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/…
jocull


17

Para estender outras respostas:

Há uma seção nos documentos para testes que explica como configurar a porta nos testes de integração:


Nos testes de integração, a configuração da porta é feita usando a anotação @SpringBootTeste os webEnvironmentvalores.


Porta aleatória:

@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)

Você pode injetar o valor usando @LocalServerPortqual é o mesmo que @Value("${local.server.port}").

  • Exemplo:

Configuração de teste de porta aleatória:

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

Porta definida:

@SpringBootTest(webEnvironment=WebEnvironment.DEFINED_PORT)

Leva o valor de server.portse for definido.

  • Se for definido usando @TestPropertySource(properties = "server.port=9192"), substitui outros valores definidos.
  • Caso contrário, ele pega o valor de src/test/resources/application.properties(se existir).
  • E, finalmente, se não estiver definido, começa com o padrão 8080.

Exemplo:

Configuração de teste de porta definida:

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

    @Test
    public void contextLoads() {
    }

}

17

Quando o aplicativo de inicialização por mola é iniciado, o servidor incorporado, como o Tomcat, inicia com uma porta padrão. O tomcat incorporado inicia com a porta 8080 como padrão. Existem várias maneiras de alterar a porta do servidor padrão.

Usando o arquivo de propriedades (.properties / .yml)

Para alterar a porta do servidor usando o arquivo de propriedades, precisamos configurar a propriedade server.port .

uma. Usando application.properties no caminho de classe, como src \ main \ resources \ application.properties

server.port = 8585

O servidor começará com a porta 8585. Para obter uma porta aleatória do servidor, atribua 0 à propriedade.

server.port = 0

Agora, a inicialização por primavera iniciará o servidor em uma porta que não está sendo usada atualmente por nenhum servidor no sistema.

b. Usando application.yml no caminho de classe, como src \ main \ resources \ application.yml.

server:
  port: 8585 

O servidor iniciará com a porta 8585.

Para porta aleatória, atribua 0.

server:
  port: 0 

Usando o comando java com --server.port ou -Dserver.port

Suponha que tenhamos um JAR executável chamado my-app.jar e, ao iniciar o aplicativo de inicialização da primavera usando o comando java, podemos usar o argumento da seguinte maneira.

Usando --server.port

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

Usando -Dserver.port

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

O servidor iniciará com a porta 8585.

Usando o comando java com --port ou -Dport em resumo

Para resumir --server.port e -Dserver.port, podemos remover a palavra-chave do servidor e torná-la qualquer palavra-chave curta, como --port e -Dport. Podemos usar qualquer palavra-chave curta. Aqui estamos usando port como palavra-chave curta. Para alcançá-lo, precisamos configurar o espaço reservado no arquivo de propriedades da seguinte maneira.

Usando application.properties

server.port=${port:8282}

Usando application.yml

server:
   port: ${port:8282}

Se não passarmos a porta como argumento, por padrão, o servidor começará com 8282. Se queremos uma porta diferente, precisamos passar a porta desejada no argumento da seguinte maneira. Suponha que tenhamos um JAR executável chamado my-app.jar.

Usando --port

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

Usando -Dport

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

O servidor iniciará com a porta 8585.

Usando SERVER_PORT com SpringApplication programaticamente

SpringApplication tem um método como setDefaultProperties () usado para alterar as propriedades padrão da inicialização por mola. Suponha que desejemos alterar a porta padrão e precisamos criar um mapa e colocar uma porta com a chave SERVER_PORT. Encontre o exemplo.

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

A inicialização por primavera iniciará o servidor com a porta 8585.


17

Existem três maneiras de fazer isso, dependendo do arquivo de configuração do aplicativo que você está usando

a) Se você estiver usando o conjunto de arquivos application.properties

server.port = 8090

b) Se você estiver usando a propriedade da porta do servidor do conjunto de arquivos application.yml no formato YAML, conforme indicado abaixo

server:
     port: 8090

c) Você também pode definir a propriedade como propriedade do sistema no método principal

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

15

se você estiver usando gradle como a ferramenta de construção, poderá definir a porta do servidor no arquivo application.yml como:

server:
  port: 8291

Se você estiver usando o maven, a porta poderá ser configurada no arquivo application.properties como:

server.port: 8291

para application.properties itsserver.port = 8291
iQuestProgrammer


13
  1. Como todos disseram, você pode especificar em application.properties
    server.port = 9000 (pode ser qualquer outro valor)

  2. Se você estiver usando o atuador de mola em seu projeto, por padrão, ele apontará para
    8080 e, se desejar alterá-lo, em application.properties mencione
    management.port = 9001 (pode ser qualquer outro valor)


12

Adicione isso ao seu application.propertiesarquivo

server.port= 8080

2
Bem-vindo ao SO :-), por favor, veja Como responder
JimHawkins

Por que adicionar o mesmo que um ano depois?!? e server.port 8080é sintaxe errada para Java arquivo de propriedade ...
Betlista

12

No application.propertiesarquivo, adicione esta linha:

server.port = 65535

onde colocar esse campo:

24.3 Arquivos de propriedades do aplicativo

SpringApplication carrega propriedades dos arquivos application.properties nos seguintes locais e as adiciona ao Spring Environment:

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

A lista é ordenada por precedência (as propriedades definidas nos locais mais altos da lista substituem as definidas nos locais mais baixos).

No meu caso, eu o coloquei no diretório em que o jararquivo está.

De:

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


12

Por padrão, o aplicativo de inicialização do spring inicia com o servidor do tomcat incorporado, na porta padrão 8080. O spring fornece as seguintes personalizações diferentes, você pode escolher um deles.

NOTA - você pode usar server.port = 0 inicialização por primavera encontrará qualquer porta aleatória http não atribuída para nós.

1) application.properties

server.port=2020

2) application.yml

server:  
     port : 2020

3) Altere a porta do servidor programaticamente

3.1) Implementando a interface 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) Implementando a interface EmbeddedServletContainerCustomizer - Spring 1.x

@Component
public class CustomizationBean implements EmbeddedServletContainerCustomizer {

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

4) Usando a opção de linha de comando

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

10

De fato, a maneira mais fácil é definir a propriedade server.port .

Se você estiver usando o STS como IDE, a partir da versão 3.6.7, você realmente terá o Spring Properties Editor para abrir o arquivo de propriedades.

Este editor fornece preenchimento automático para todas as propriedades do Spring Boot. Se você escrever a porta e pressionar CTRL + ESPAÇO, server.port será a primeira opção.


1
Ou também, se você estiver usando o Intellij IDEA, o preenchimento automático também funcionará. ;)
Sorte

9

Usar a propriedade server.port = 8080, por exemplo, como mencionado em outras respostas, é definitivamente um caminho a percorrer. Só queria mencionar que você também pode expor uma propriedade de ambiente:

SERVER_PORT=8080

Desde que a bota de mola é capaz de substituir "." para "_" e maiúsculas e minúsculas para variáveis ​​de ambiente em versões recentes. Isso é especialmente útil em contêineres onde tudo o que você precisa fazer é definir essa variável de ambiente sem adicionar / editar application.propertiesou passar as propriedades do sistema pela linha de comando (por exemplo -Dserver.port=$PORT)


SERVER_PORT=8081 mvn spring-boot:run
Nobar

8

Espero que este ajude

application.properties => 

server.port = 8090

application.yml => 

servidor
  porta: 8090

application.yml => server: port: 8090
geek

8

Fornecer o número da porta no arquivo application.properties resolverá o problema

 server.port = 8080

"porta depende da sua escolha, onde você deseja hospedar o aplicativo"


7

Você pode adicionar a porta nos métodos abaixo.

  1. Seção Executar -> Configurações

  2. Em application.xmladiçãoserver.port=XXXX


1
Você quer dizer application.ymle qual IDE você está usando? Por favor, seja específico.
Sorte

7

Você pode configurá-lo em application.properties em / src / main / resources /

server.port = 8090

7

Basta ter um application.propertiesin src/main/resourcesdo projeto e dar lá

server.port=****

onde ****se refere ao número da porta.


7

1.1 Atualize através de um arquivo de propriedades.

/src/main/resources/application.properties

server.port = 8888

Atualize através de um arquivo yaml.

   server:

     port: 8888

EmbeddedServletContainerCustomizer

@Component
public class CustomContainer implements EmbeddedServletContainerCustomizer {

    @Override
    public void customize(ConfigurableEmbeddedServletContainer container) {

        container.setPort(8888);

    }

}

6

Você também pode usar SERVER_PORTa variável de ambiente para configurar a porta Spring Boot. Basta definir a variável de ambiente e reiniciar o aplicativo:

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

Observe que, se você não definir essas variáveis ​​de ambiente em todo o sistema, execute o aplicativo de inicialização na mesma sessão.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.