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




port tomcat (25)

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


Answers

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

Puede establecer 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 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) se establece en la línea de comandos, este puerto se tendrá en cuenta. Si no, entonces el puerto será 4588 por defecto.

Si desea imponer el puerto en el archivo de propiedades independientemente de la variable de entorno, solo tiene que escribir:

server.port=8888

Puedes 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

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

    }

}

En el archivo application.properties presente en los recursos:

server.port=8082

Hay tres formas de hacerlo.

1 Establecer la propiedad server.port en el archivo application.properties

server.port = 8090

2 Establecer la propiedad del puerto del servidor en el archivo application.yml

server:
     port: 8090

3 Establecer la propiedad como propiedad del sistema en el método main

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

El uso de 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 de entorno:

SERVER_PORT=8080

Desde la bota de primavera es capaz de reemplazar "." para "_" e inferior al caso SUPERIOR para variables de entorno en versiones recientes. Esto es especialmente útil en contenedores donde todo lo que tienes que hacer es definir esa variable de entorno sin agregar / editar application.properties o pasar las propiedades del sistema a través de la línea de comandos (es decir, -Dserver.port=$PORT )


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

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

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


  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)


Puedes agregar el puerto en los siguientes métodos.

  1. Ejecutar -> sección Configuraciones

  2. En application.xml agrega server.port=XXXX


Dado que Spring Boot proporciona varios mecanismos de externalización de configuración (a través de varias implementaciones y / o procesadores de PropertySource conectados al objeto de Environment en orden), puede establecer cualquier propiedad fuera de su archivo jar a través de los siguientes métodos:

  1. Pasar propiedad a través de argumento de línea de comando como argumento de 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>
      
    • Mediante el uso de la propiedad del sistema Java:

      java -Dspring.application.json='{"server.port":7788}' -jar <path/to/my/jar>
      
    • Pasar 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 variable de entorno OS

    • U * IX Shell

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

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

    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 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 normalmente 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:

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

SERVER_NAME conversión de SERVER_NAME a server.name se realizó mediante enlace relajado .


Si está trabajando en proyectos de arranque y desea configurar el puerto, puede ingresar la entrada en el archivo application.properties como NOTA: el archivo de propiedades debe estar bajo src / main / resource

Propiedades de primavera

server.port = 9999 Si usa el CMD, siga este comando -Dserver.port = 9999 Para el puerto predeterminado, su server.port = 0 Asegúrese de que ningún puerto esté usando este número de puerto


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 del servidor predeterminado.

Usando el 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 no está siendo utilizado actualmente por ningún servidor en el sistema.

segundo. Usar application.yml en classpath como src \ main \ resources \ application.yml.

server:
  port: 8585 

El servidor comenzará con el puerto 8585.

Para puerto aleatorio, asigna 0.

server:
  port: 0 

Usando el 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 Spring con el comando java, podemos usar el argumento de la siguiente manera.

Utilizando --server.port

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

Utilizando -Dserver.port

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

El servidor comenzará con el puerto 8585.

Usando el comando java con --port o -Dport en corto

Para hacer --server.port y -Dserver.port en breve, podemos eliminar las palabras clave del servidor y convertirlas en cualquier palabra clave corta, como --port y -Dport. Podemos usar cualquier palabra clave corta. Aquí estamos usando el puerto 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, entonces el servidor predeterminado comenzará con 8282. Si queremos un puerto diferente, debemos pasar el puerto deseado en el argumento de la siguiente manera. Supongamos que tenemos un JAR ejecutable llamado my-app.jar.

Utilizando --port

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

Usando -Dport

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

El servidor comenzará con el puerto 8585.

Uso de 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 tecla 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 8585 puertos.


Esta pregunta es el primer resultado si buscas en Google para Gradle Spring Port .

Si usa gradle, puede hacer algo como esto si ya tiene el complemento Spring Boot Gradle:

bootRun {
    args += ["--server.port=[PORT]"]
}

Para una respuesta más sofisticada, por favor vea mi respuesta here .


Puede especificar puerto anulando el bean EmbeddedServletContainerFactory dentro de su configuración (basado en java o xml). Allí puede especificar el puerto para el contenedor de servlet incorporado. Por favor, vea el párrafo " Spring Boot - Core " Embedded Servlet Container Support "y el ejemplo allí. Espero que esto ayude.


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

server.port = 8090


Agregue esto en su archivo application.properties

server.port= 8080

El puerto predeterminado es: 8080 pero podemos personalizar el número de puerto en application.properties como se muestra a continuación

spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp
server.port = 5050 -- #here we can give any port number.

Para extender otras respuestas:

Hay una sección en la documentación 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 mediante la anotación @SpringBootTest y los valores de webEnvironment .

Puerto aleatorio:

@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)

Puede inyectar el valor utilizando @LocalServerPort que es lo 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.port si está definido.

  • Si se define utilizando @TestPropertySource(properties = "server.port=9192") , reemplaza 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 8080 predeterminado.

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

}

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

Modificar application.properties

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

Modificar una opción de máquina virtual

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 del blog aquí: Cambiar el puerto en una aplicación Spring Boot


Espero que esta ayuda

application.properties=> 

server.port=8090

application.yml=> 

server
  port:8090

Principalmente, springboot se ejecuta en el port:8080 debido a Tomcat integrado. En algunos puede lanzar un port 8080 already in use error port 8080 already in use . Para evitar este tipo de problemas podemos configurar el puerto del servidor.

Usando application.properties

agregar server.port=9898

En la configuración de tiempo de ejecución

ejecute su aplicación con los siguientes argumentos.

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


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 here ):

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

También, puede configurar el puerto programáticamente

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

Podemos establecerlo en application.properties como API_CONTEXT_ROOT=/therootpath

Y accedemos a ella en la clase Java como se menciona a continuación

@Value("${API_CONTEXT_ROOT}")
private String contextRoot;




java spring spring-boot