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


798

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


55
Si alguien interesado, aquí se muestra cómo tener múltiples puertos - stackoverflow.com/questions/36357135/…
Betlista

si usa el archivo "yml" para la configuración, puede usar este servidor: puerto: 8081 También anote su clase principal como "@SpringBootApplication" y elimine @ EnableAutoConfiguration
Keaz

su proyecto [application.properties] para agregar el server.port = 8080
Lahiru Samishka

establecido server.port=8080en las propiedades de la aplicación. esta configuración está en ServerProperties.classclase bajo org.springframework.boot.autoconfigure.web.
Atif

Respuestas:


1227

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

47
Cuando se utiliza un puerto aleatorio, la información del puerto se puede obtener@Value("${local.server.port}")
azizunsal

42
En realidad, la opción de línea de comando es --server.port = 8090 no -Dserver.port = 8090. docs.spring.io/spring-boot/docs/current/reference/html/…
Opster ES Ninja - Alper

1
Como complemento a esta respuesta: de acuerdo con los documentos de primavera, hay otros caminos que puede seguir application.properties. En mi caso eso ayudó mucho.
sargas

14
-Dserver.port = XXXX no funcionó para mí. Utilicé el modo variable de entorno del sistema operativo: $ SERVER_PORT=8090 java -jar <path/to/my/jar>
Soumya Kanti

10
Ambos (1) java -Dserver.port=XXXX -jar <path/to/my/jar>y (2) java -jar <path/to/my/jar> --server.port=YYYYfuncionan. El primer comando define la server.portpropiedad del sistema, y ​​el segundo comando pasa la propiedad a través de los argumentos de la línea de comando ( String... argsen el mainmétodo). Además, si ejecuta con java -Dserver.port=XXXX -jar <path/to/my/jar> --server.port=YYYY, YYYYtiene prioridad sobre XXXX, esta es la razón por la cual Spring Boot Externalized Configuration es tan encantadora.
tan9

210

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

archivo application.properties

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

Cambiar puerto con vm arg

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


En STS 4 está en ejecución -> configuraciones de ejecución -> principal, luego desplácese hacia abajo hasta Tabla con nombre y valor de parámetro
serv-inc

155

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 .


108

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

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

Esto funciona y es muy útil cuando tiene un puerto en su propio archivo de configuración y desea configurarlo durante el tiempo de ejecución.
Xdg

44
Esto fue útil cuando necesitaba implementar una aplicación en un servicio AWS Elastic Beanstalk, para obtener el puerto desde una variable de entorno.
Martin Hansen

Esto es súper útil cuando todo lo que desea es una unidad autónoma o una prueba de integración, +1.
Priidu Neemre

Muy útil cuando la variable env para el puerto ya está definida con un nombre diferente.
higuaro

2
¿No es el en @Configurationlugar de @Controller? Por favor actualice si es así.
Lucky

82

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

El uso de HashMap funcionará solo si no se establece ningún puerto en aplicaciones.properties o .yml.
Milgo

79

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

1
A partir de Spring Boot 2, debe usar spring-boot.run.jvmArguments.
mapm

54

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

server:
     port: 9000

y por supuesto 0 para puerto aleatorio.


1
Esto no parecía funcionar. Usé server.port en application.yml y funcionó
yathirigan

47

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

39

Incluir a continuación la propiedad en application.properties

server.port=8080

23

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


2
System.setProperty("server.port", 80);Es otra forma de lograr lo mismo.
hd1

@ hd1, agregué nuestras respuestas a la respuesta principal, compruébelo y modifíquelo como le parezca, por favor
Luis Mauricio

18

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.



Aquí hay un enlace actual a la sección de anulación programática: docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/…
jocull


17

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:


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

}

17

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.


17

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

15

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

para application.properties itsserver.port = 8291
iQuestProgrammer


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


12

Agregue esto en su application.propertiesarchivo

server.port= 8080

2
Bienvenido a SO :-), mira Cómo responder
JimHawkins

¿Por qué agregar lo mismo un año después? y server.port 8080es una sintaxis incorrecta para el archivo de propiedades Java ...
Betlista

12

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


12

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

10

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.


1
O también, si está utilizando Intellij IDEA, el autocompletado también funciona. ;)
Lucky

9

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)


SERVER_PORT=8081 mvn spring-boot:run
nobar

8

Espero que esta ayuda

application.properties => 

server.port = 8090

application.yml => 

servidor
  puerto: 8090

application.yml => servidor: puerto: 8090
geek

8

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"


7

Puede agregar el puerto en los siguientes métodos.

  1. Ejecutar -> sección Configuraciones

  2. En application.xmlagregarserver.port=XXXX


1
¿Quieres decir application.ymly qué IDE estás usando? Por favor sea especifico.
Lucky

7

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

server.port = 8090

7

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

server.port=****

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


7

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

    }

}

6

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.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.