Como configurar a porta para um aplicativo Spring Boot

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

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

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

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

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

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 .

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

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

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

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

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

server:
     port: 9000

e, claro, 0 para porta aleatória.

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

Incluir propriedade abaixo em application.properties

server.port=8080

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

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.

No application.propertiesarquivo presente nos recursos:

server.port=8082

Para estender outras respostas:

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

• 41.3 Testando aplicativos Spring Boot
• 41.3.3 Trabalhando com portas aleatórias

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

}

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.

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

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

Existem muitos outros itens que você pode alterar na configuração do servidor, alterando application.properties. Como tempo limite da sessão, endereço e porta etc. Consulte a postagem abaixo

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

Eu usei alguns deles como abaixo.

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

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)

Adicione isso ao seu application.propertiesarquivo

server.port= 8080

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

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

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.

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)

Espero que este ajude

application.properties => 

server.port = 8090

application.yml => 

servidor
  porta: 8090

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"

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

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

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

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

server.port = 8090

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

server.port=****

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

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

    }

}

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.