Cómo configurar el puerto para una aplicación Spring Boot

¿Cómo configuro el puerto TCP / IP escuchado por una aplicación Spring Boot, para que no use el puerto predeterminado de 8080?

Como se dijo en documentos bien establecidas server.portcomo propiedad del sistema mediante la opción de línea de comandos para JVM -Dserver.port=8090o añadir application.propertiesen /src/main/resources/la

server.port=8090

Para uso de puerto aleatorio

server.port=0

Hay dos formas principales de cambiar el puerto en Embedded Tomcat en una aplicación Spring Boot.

Modificar application.properties

Primero puede probar el archivo application.properties en la carpeta / resources:

server.port = 8090

Modificar una opción de VM

La segunda forma, si desea evitar modificar cualquier archivo y registrar algo que solo necesita en su local, puede usar un argumento vm:

Vaya a Ejecutar -> Editar configuraciones -> Opciones de VM

-Dserver.port=8090

Además, si necesita más información, puede ver la siguiente publicación de blog aquí: Cambiar el puerto en una aplicación Spring Boot

Dado que Spring Boot proporciona varios mecanismos de externalización de configuración (a través de diversas PropertySourceimplementaciones y / o procesadores conectados a un Environmentobjeto en orden), puede establecer cualquier propiedad fuera de su archivo jar a través de los siguientes métodos:

1. Pase la propiedad a través del argumento de la línea de comando como argumento de la aplicación

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

2. De la propiedad en SPRING_APPLICATION_JSON(Spring Boot 1.3.0+)

   • Defina la variable de entorno en el shell U * IX:

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

   • Al usar la propiedad del sistema Java:

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

   • Pase por el argumento de la línea de comando:

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

3. Definir propiedad del sistema JVM

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

4. Definir variable de entorno del sistema operativo

   • U * IX Shell

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

   • Ventanas

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

5. Colocar propiedad en ./config/application.properties archivo de configuración

   server.port=7788

   y correr:

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

6. Colocar propiedad en ./config/application.yaml

   server:
       port: 7788

   y correr:

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

7. Colocar propiedad en ./application.properties

   server.port=7788

   y correr:

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

8. Colocar propiedad en ./application.yaml

   server:
       port: 7788

   y correr:

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

Puede combinar todos los métodos anteriores, y la configuración anterior en la lista tiene prioridad sobre la última.

Por ejemplo:

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

El servidor se iniciará y escuchará en el puerto 7788.

Esto es muy útil al proporcionar propiedades predeterminadas en PropertySources con menor prioridad (y generalmente empaquetadas en el archivo comprimido o codificadas en la fuente), y luego anularlas en el entorno de tiempo de ejecución. Y es la filosofía de diseño de Spring Boot:

Sea obstinado fuera de la caja, pero salga del camino rápidamente ya que los requisitos comienzan a diferir de los valores predeterminados.

SERVER_NAMEa la server.nameconversión se realizó por Enlace Relajado .

Además, puede configurar el puerto mediante programación

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

Puede configurar el puerto en código java:

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

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

O en application.yml:

server:
    port: 9999

O en application.properties:

server.port=9999

O como un parámetro de línea de comando:

-Dserver.port=9999

Si desea ejecutarlo localmente, use esto:

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

A partir de Spring Boot 2.0 , aquí está el comando que funciona (las pistas estaban aquí ):

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

En caso de que esté utilizando, application.ymlagregue las siguientes líneas

server:
     port: 9000

y por supuesto 0 para puerto aleatorio.

Como se explica en la documentación de Spring , hay varias formas de hacerlo:

O configura el puerto en la línea de comando (por ejemplo, 8888)

-Dserver.port=8888 o --server.port=8888

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

O configura el puerto en la aplicación.

server.port=${port:4588}

o (en application.yml con sintaxis yaml)

server:
   port: ${port:4588}

Si el puerto pasado por -Dport (o -Dserver.port) se establece en la línea de comando, este puerto se tendrá en cuenta. Si no, entonces el puerto será 4588 por defecto.

Si desea aplicar el puerto en el archivo de propiedades, sea cual sea la variable de entorno, solo tiene que escribir:

server.port=8888

Incluir a continuación la propiedad en application.properties

server.port=8080

Cuando necesite una forma programática de hacerlo, puede configurarlo durante el inicio:

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

Esto podría ayudar para cosas como el puerto dependiente del entorno. Que tengas un buen día

Puede especificar el puerto anulando el EmbeddedServletContainerFactorybean dentro de su configuración (basado en Java o XML). Allí puede especificar el puerto para el contenedor de servlet incorporado utilizado. Consulte el apartado Spring Boot - Core "Embedded Servlet Container Support" y el ejemplo aquí. Espero que esto ayude.

En application.propertiesarchivo presente en recursos:

server.port=8082

Para extender otras respuestas:

Hay una sección en los documentos para pruebas que explica cómo configurar el puerto en las pruebas de integración:

• 41.3 Prueba de aplicaciones Spring Boot
• 41.3.3 Trabajar con puertos aleatorios

En las pruebas de integración, la configuración del puerto se realiza utilizando la anotación @SpringBootTesty los webEnvironmentvalores.

Puerto aleatorio:

@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)

Puede inyectar el valor utilizando @LocalServerPortcual es el mismo que @Value("${local.server.port}").

• Ejemplo:

Configuración de prueba de puerto aleatorio:

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

Puerto definido:

@SpringBootTest(webEnvironment=WebEnvironment.DEFINED_PORT)

Toma el valor de server.portsi está definido.

• Si se define usando @TestPropertySource(properties = "server.port=9192"), anula otros valores definidos.
• Si no, toma el valor de src/test/resources/application.properties(si existe).
• Y finalmente, si no está definido, comienza con el valor predeterminado 8080.

Ejemplo:

Configuración de prueba de puerto definida:

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

    @Test
    public void contextLoads() {
    }

}

Cuando se inicia la aplicación Spring Boot, el servidor incorporado, como Tomcat, comienza con un puerto predeterminado. El tomcat incorporado comienza con el puerto 8080 como predeterminado. Hay muchas formas de cambiar el puerto predeterminado del servidor.

Uso del archivo de propiedades (.properties / .yml)

Para cambiar el puerto del servidor usando el archivo de propiedades, necesitamos configurar la propiedad server.port .

a. Uso de application.properties en classpath como src \ main \ resources \ application.properties

server.port = 8585

El servidor comenzará con el puerto 8585. Para obtener un puerto de servidor aleatorio, asigne 0 a la propiedad.

server.port = 0

Ahora Spring Boot iniciará el servidor en un puerto que ningún servidor del sistema esté utilizando actualmente.

si. Usando application.yml en classpath como src \ main \ resources \ application.yml.

server:
  port: 8585 

El servidor comenzará con el puerto 8585.

Para puerto aleatorio, asigne 0.

server:
  port: 0 

Uso del comando java con --server.port o -Dserver.port

Supongamos que tenemos un JAR ejecutable llamado my-app.jar, luego, al iniciar la aplicación de arranque de primavera usando el comando java, podemos usar el argumento de la siguiente manera.

Usando --server.port

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

Usando -Dserver.port

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

El servidor comenzará con el puerto 8585.

Usando Java Command con --port o -Dport en resumen

Para resumir --server.port y -Dserver.port, podemos eliminar la palabra clave del servidor y convertirla en una palabra clave breve como --port y -Dport. Podemos usar cualquier palabra clave corta. Aquí estamos usando port como palabra clave corta. Para lograrlo, necesitamos configurar el marcador de posición en el archivo de propiedades de la siguiente manera.

Usando application.properties

server.port=${port:8282}

Usando application.yml

server:
   port: ${port:8282}

Si no pasamos el puerto como argumento, por defecto el servidor comenzará con 8282. Si queremos un puerto diferente, entonces necesitamos pasar el puerto deseado en el argumento de la siguiente manera. Supongamos que tenemos un JAR ejecutable llamado my-app.jar.

Usando --port

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

Usando -Dport

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

El servidor comenzará con el puerto 8585.

Usando SERVER_PORT con SpringApplication mediante programación

SpringApplication tiene un método como setDefaultProperties () que se usa para cambiar las propiedades predeterminadas de arranque de Spring. Supongamos que queremos cambiar el puerto predeterminado, entonces necesitamos crear un Mapa y colocar un puerto con la clave SERVER_PORT. Encuentra el ejemplo.

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 iniciará el servidor con el puerto 8585.

Hay tres formas de hacerlo, dependiendo del archivo de configuración de la aplicación que esté utilizando.

a) Si está utilizando el conjunto de archivos application.properties

server.port = 8090

b) Si está utilizando la propiedad del puerto del servidor del conjunto de archivos application.yml en formato YAML como se indica a continuación

server:
     port: 8090

c) También puede establecer la propiedad como propiedad del sistema en el método principal

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

si está utilizando gradle como herramienta de compilación, puede configurar el puerto del servidor en su archivo application.yml como:

server:
  port: 8291

Si está utilizando Maven, el puerto se puede configurar en su archivo application.properties como:

server.port: 8291

Hay muchas otras cosas que puede modificar en la configuración del servidor cambiando application.properties. Como tiempo de espera de sesión, dirección y puerto, etc. Consulte la siguiente publicación

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

Utilicé algunos de ellos como a continuación.

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

1. Como todos dijeron, puede especificar en application.properties
   server.port = 9000 (podría ser cualquier otro valor)

2. Si está utilizando un actuador de resorte en su proyecto, por defecto apunta a
   8080, y si desea cambiarlo, en application.properties mencione
   management.port = 9001 (podría ser cualquier otro valor)

Agregue esto en su application.propertiesarchivo

server.port= 8080

En el application.propertiesarchivo, agregue esta línea:

server.port = 65535

donde colocar ese fie:

24.3 Archivos de propiedades de la aplicación

SpringApplication carga propiedades de los archivos application.properties en las siguientes ubicaciones y las agrega al Spring Environment:

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

La lista está ordenada por precedencia (las propiedades definidas en ubicaciones superiores en la lista anulan las definidas en ubicaciones inferiores).

En mi caso, lo puse en el directorio donde se encuentra el jararchivo.

Desde:

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

De forma predeterminada, la aplicación de inicio de Spring comienza con el servidor Tomcat incorporado, comienza en el puerto predeterminado 8080. Spring le proporciona la siguiente personalización diferente, puede elegir uno de ellos.

NOTA : puede usar server.port = 0 spring boot encontrará cualquier puerto aleatorio http no asignado para nosotros.

1) aplicaciones.propiedades

server.port=2020

2) application.yml

server:  
     port : 2020

3) Cambiar el puerto del servidor mediante programación

3.1) Al implementar la interfaz 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 la interfaz EmbeddedServletContainerCustomizer - Spring 1.x

@Component
public class CustomizationBean implements EmbeddedServletContainerCustomizer {

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

4) Al usar la opción de línea de comando

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

De hecho, la forma más fácil es establecer la propiedad server.port .

Si está utilizando STS como IDE, desde la versión 3.6.7 realmente tiene Spring Properties Editor para abrir el archivo de propiedades.

Este editor proporciona autocompletado para todas las propiedades de Spring Boot. Si escribe puerto y presiona CTRL + ESPACIO, server.port será la primera opción.

Usar la propiedad server.port = 8080, por ejemplo, como se menciona en otras respuestas, definitivamente es un camino a seguir. Solo quería mencionar que también podría exponer una propiedad de entorno:

SERVER_PORT=8080

Dado que la bota de primavera puede reemplazar "." para "_" y menor a MAYÚSCULAS para variables de entorno en versiones recientes. Esto es especialmente útil en contenedores donde todo lo que tiene que hacer es definir esa variable de entorno sin agregar / editar application.propertieso pasar propiedades del sistema a través de la línea de comandos (es decir -Dserver.port=$PORT)

Espero que esta ayuda

application.properties => 

server.port = 8090

application.yml => 

servidor
  puerto: 8090

Proporcionar el número de puerto en el archivo application.properties resolverá el problema

 server.port = 8080

"el puerto depende de su elección, dónde desea alojar la aplicación"

Puede agregar el puerto en los siguientes métodos.

1. Ejecutar -> sección Configuraciones

2. En application.xmlagregarserver.port=XXXX

Puede configurarlo en application.properties en / src / main / resources /

server.port = 8090

Apenas tenga una application.propertiesen src/main/resourcesel proyecto y dar allí

server.port=****

donde se ****refiere al número de puerto.

1.1 Actualización a través de un archivo de propiedades.

/src/main/resources/application.properties

server.port = 8888

Actualización a través de un archivo yaml.

   server:

     port: 8888

EmbeddedServletContainerCustomizer

@Component
public class CustomContainer implements EmbeddedServletContainerCustomizer {

    @Override
    public void customize(ConfigurableEmbeddedServletContainer container) {

        container.setPort(8888);

    }

}

También puede usar SERVER_PORTla variable de entorno para configurar el puerto Spring Boot. Simplemente configure la variable de entorno y reinicie la aplicación:

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

Tenga en cuenta que si no configura esas variables de entorno en todo el sistema, debe ejecutar la aplicación de arranque en la misma sesión.