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

921

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

4
  • 6
    Si alguien está interesado, aquí se muestra cómo tener varios puertos - stackoverflow.com/questions/36357135/… 8 de febrero de 2018 a las 13:21
  • si usa el archivo "yml" para la configuración, entonces puede usar este servidor: puerto: 8081 También anote su clase principal como "@SpringBootApplication" y elimine @ EnableAutoConfiguration
    Keaz
    23/06/18 a las 7:52
  • su proyecto [application.properties] para agregar el server.port = 8080 8/10/19 a las 11:07
  • establecido server.port=8080en las propiedades de la aplicación. esta configuración está en la ServerProperties.classclase bajo org.springframework.boot.autoconfigure.web.
    Atif
    11/03/20 a las 10:12
1379

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

Del mismo modo añadir application.ymlen /src/main/resources/la

server:
  port : 8090
13
  • 62
    Cuando se utiliza un puerto aleatorio, la información del puerto se puede obtener con @Value("${local.server.port}") 23/07/2015 a las 12:46
  • 48
    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/…
    alpert
    19 de agosto de 2015 a las 6:39
  • 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
    2 oct 2015 a las 19:37
  • 15
    -Dserver.port = XXXX no funcionó para mí. Usé el modo de variable de entorno del sistema operativo: $ SERVER_PORT=8090 java -jar <path/to/my/jar> 8/10/2015 a las 7:38
  • 13
    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 que Spring Boot Externalized Configuration es tan encantadora.
    tan9
    29/11/2016 a las 16:28
239

Hay dos formas principales de cambiar el puerto en el Tomcat integrado 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 vm arg:

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

-Dserver.port=8090

Cambiar el puerto con un 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

1
  • En STS 4 está en ejecución -> configuraciones de ejecución -> principal, luego desplácese hacia abajo hasta la Tabla con el nombre y el valor del parámetro 28/04/19 a las 13:00
180

Dado que Spring Boot proporciona varios mecanismos de externalización de configuración (a través de varias PropertySourceimplementaciones y / o procesadores conectados al 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. Desde 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>
      
    • Utilizando la propiedad del sistema Java:

      java -Dspring.application.json='{"server.port":7788}' -jar <path/to/my/jar>
      
    • Pase a través del argumento de la línea de comando:

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

    java -Dserver.port=7788 -jar <path/to/my/jar>
    
  4. Definir la variable de entorno del sistema operativo

    • Concha U * IX

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

      SET SERVER_PORT=7788
      java -jar <path/to/my/jar>
      
  5. Coloque la propiedad en el ./config/application.properties archivo de configuración

    server.port=7788
    

    y correr:

     java -jar <path/to/my/jar>
    
  6. Coloque la propiedad en ./config/application.yaml

    server:
        port: 7788
    

    y correr:

     java -jar <path/to/my/jar>
    
  7. Coloque la propiedad en ./application.properties

    server.port=7788
    

    y correr:

     java -jar <path/to/my/jar>
    
  8. Coloque la propiedad en ./application.yaml

    server:
        port: 7788
    

    y correr:

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

Puede combinar los métodos anteriores todos juntos, 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 precedencia (y generalmente empaquetadas en el archivo o codificadas en la fuente) y luego anularlas en el entorno de ejecución. Y es la filosofía de diseño de Spring Boot:

Be opinionated out of the box, but get out of the way quickly as requirements start to diverge from the defaults.


SERVER_NAMEa la server.nameconversión se realizó mediante Relaxed Binding .

0
125

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

Para Spring Boot 2.xx:

@Configuration
public class CustomContainer implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
  public void customize(ConfigurableServletWebServerFactory factory){
    factory.setPort(8042);
  }
}

Para versiones anteriores:

@Configuration
public class ServletConfig {
    @Bean
    public EmbeddedServletContainerCustomizer containerCustomizer() {
        return (container -> {
            container.setPort(8012);
        });
    }
}
8
  • 2
    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
    8 de noviembre de 2015 a las 9:48
  • 5
    Esto fue útil cuando necesitaba implementar una aplicación en un servicio de AWS Elastic Beanstalk para obtener el puerto de una variable de entorno. 19/11/15 a las 12:51
  • Esto es muy útil cuando todo lo que desea es una unidad autónoma o una prueba de integración, +1. 28/04/2016 a las 10:34
  • Muy útil cuando la variable env para el puerto ya está definida con un nombre diferente.
    higuaro
    18 de agosto de 2016 a las 8:27
  • 2
    ¿No es el en @Configurationlugar de @Controller? Actualice si es así.
    Lucky
    13 de septiembre de 2016 a las 11:52
89

Puede configurar el puerto en el 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 parámetro de línea de comando:

-Dserver.port=9999
1
  • El uso de HashMap solo funcionará si no se configura ningún puerto en applications.properties o .yml.
    Milgo
    25/04/19 a las 11:28
89

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
  • 2
    A partir de Spring Boot 2, debe usar spring-boot.run.jvmArguments.
    mapm
    12/04/18 a las 2:57
57

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

server:
     port: 9000

y por supuesto 0 para puerto aleatorio.

1
  • 1
    esto no pareció funcionar. Usé server.port en application.yml y funcionó 5 mar.15 a las 13:11
52

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 application.properties

server.port=${port:4588}

o (en application.yml con sintaxis yaml)

server:
   port: ${port:4588}

Si el puerto pasado por -Dport (o -Dserver.port) está configurado en la línea de comando, este puerto se tendrá en cuenta. De lo contrario, el puerto será el 4588 de forma predeterminada.

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

server.port=8888
41

Incluir debajo de la propiedad en application.properties

server.port=8080
27

Cuando necesite una forma programática de hacerlo, puede configurarla 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 tenga un lindo día

2
  • 2
    System.setProperty("server.port", 80); es otra forma de lograr lo mismo.
    hd1
    11/02/2017 a las 20:34
  • @ hd1, agregué nuestras respuestas a la respuesta principal, compruébelo y modifíquelo como mejor le parezca, por favor 30/12/19 a las 14:40
20

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. Por favor, consulte el párrafo y el ejemplo de Spring Boot - Core "Soporte de contenedor de servlet integrado". Espero que esto ayude.

2
20

En application.propertiesarchivo presente en recursos:

server.port=8082
20

Para ampliar otras respuestas:

Hay una sección en los documentos para las 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 usando @LocalServerPortque 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 mediante @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 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() {
    }

}
20

si está utilizando gradle como la 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
2
  • para application.properties su server.port = 8291 5/12/19 a las 9:52
  • ¿Qué tienen que ver Maven y Gradle con si usa un archivo de propiedades o YAML? El proceso de compilación (Maven) es completamente diferente al marco de la aplicación (Spring Boot). 3 de junio a las 9:01
18

Hay tres formas de hacerlo según el 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 el archivo application.yml , configure la propiedad del puerto del servidor en formato YAML como se indica a continuación

server:
     port: 8090

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

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

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

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

Usé algunos de ellos como se muestra a continuación.

server.session.timeout=1
server.port = 3029
server.address= deepesh
14
  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, de manera predeterminada apunta a
    8080, y si desea cambiarlo, en application.properties mencione
    management.port = 9001 (podría ser cualquier otro valor)

14

Agregue esto en su application.propertiesarchivo

server.port= 8080
2
  • 2
    Bienvenido a SO :-), consulte Cómo responder 17 de junio de 2016 a las 10:03
  • ¿Por qué agregar la misma respuesta un año después? y la server.port 8080sintaxis es incorrecta para el archivo de propiedades de Java ... 8 de febrero de 2018 a las 13:19
14

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

server.port = 65535

donde colocar esa fie:

24.3 Application Property Files

SpringApplication loads properties from application.properties files in the following locations and adds them to the Spring Environment:

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

The list is ordered by precedence (properties defined in locations higher in the list override those defined in lower locations).

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

De:

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

14

De forma predeterminada, la aplicación de arranque de primavera comienza con el servidor Tomcat integrado en el puerto predeterminado 8080. Spring le proporciona las siguientes personalizaciones diferentes, puede elegir una de ellas.

NOTE – you can use server.port=0 spring boot will find any unassigned http random port for us.

1) application.properties

server.port=2020

2) application.yml

server:  
     port : 2020

3) Cambie el puerto del servidor mediante programación

3.1) Implementando 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) Usando la opción de línea de comando

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

De forma predeterminada, el módulo spring-web proporciona un servidor Tomcat integrado que se ejecuta con el número de puerto 8080. Si necesita cambiar el número de puerto de la aplicación, vaya al application.propertiesarchivo y configure el número de puerto utilizando server.portproperty.

  server.port= 9876

entonces su aplicación se está ejecutando bajo el puerto 9876.

11

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

Si está utilizando STS como IDE, a partir de la versión 3.6.7, en realidad 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
  • 1
    O también, si está utilizando Intellij IDEA, el autocompletado también funciona. ;)
    Lucky
    13 de septiembre de 2016 a las 11:53
10

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

SERVER_PORT=8080

Dado que la bota de resorte es capaz de reemplazar "." para "_" y mayúsculas y minúsculas para las 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 comando (es decir -Dserver.port=$PORT)

1
  • SERVER_PORT=8081 mvn spring-boot:run 17 de septiembre de 2018 a las 4:11
9

Espero que esto ayude

application.properties=> 

server.port=8090

application.yml=> 

server
  port:8090
1
  • application.yml => servidor: puerto: 8090
    geek
    23 de mayo de 2018 a las 17:36
9

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

 server.port = 8080

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

8

Puede agregar el puerto en los métodos siguientes.

  1. Ejecutar -> sección Configuraciones

  2. En application.xmlañadirserver.port=XXXX

1
  • 1
    ¿Quieres decir application.ymly qué IDE estás usando? Por favor sea especifico.
    Lucky
    13 de septiembre de 2016 a las 11:56
8

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

server.port = 8090
8

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

server.port=****

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

8

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

/src/main/resources/application.properties

server.port = 8888

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

    }

}
7

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 establece esas variables de entorno en todo el sistema, debe ejecutar la aplicación de arranque en la misma sesión.