Comment configurer le port pour une application Spring Boot

Comment configurer le port TCP / IP écouté par une application Spring Boot pour qu'il n'utilise pas le port par défaut 8080.

Comme dit dans docs soit mis server.portcomme propriété système en utilisant l' option de ligne de commande pour jvm -Dserver.port=8090ou ajouter application.propertiesdans /src/main/resources/des

server.port=8090

Pour une utilisation aléatoire du port

server.port=0

Il existe deux façons principales de modifier le port dans le Tomcat intégré dans une application Spring Boot.

Modifier application.properties

Vous pouvez d'abord essayer le fichier application.properties dans le dossier / resources:

server.port = 8090

Modifier une option de machine virtuelle

La deuxième façon, si vous voulez éviter de modifier des fichiers et d'archiver quelque chose dont vous n'avez besoin que sur votre local, vous pouvez utiliser un argument vm:

Allez dans Exécuter -> Modifier les configurations -> Options VM

-Dserver.port=8090

De plus, si vous avez besoin de plus d'informations, vous pouvez consulter le billet de blog suivant ici: Modification du port sur une application Spring Boot

Étant donné que Spring Boot fournit divers mécanismes d'externalisation de la configuration (via diverses PropertySourceimplémentations et / ou processeurs câblés dans l' Environmentordre), vous pouvez définir n'importe quelle propriété en dehors de votre archive jar à l'aide des méthodes suivantes:

1. Passer la propriété via l'argument de ligne de commande comme argument d' application

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

2. Depuis la propriété de SPRING_APPLICATION_JSON(Spring Boot 1.3.0+)

   • Définissez la variable d'environnement dans le shell U * IX:

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

   • En utilisant la propriété système Java:

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

   • Passez l'argument de la ligne de commande:

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

3. Définir la propriété du système JVM

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

4. Définir la variable d'environnement OS

   • Coque U * IX

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

   • les fenêtres

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

5. Placer la propriété dans le ./config/application.properties fichier de configuration

   server.port=7788

   et courir:

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

6. Placer la propriété dans ./config/application.yaml

   server:
       port: 7788

   et courir:

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

7. Placer la propriété dans ./application.properties

   server.port=7788

   et courir:

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

8. Placer la propriété dans ./application.yaml

   server:
       port: 7788

   et courir:

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

Vous pouvez combiner toutes les méthodes ci-dessus, et l'ancienne configuration de la liste a priorité sur la dernière.

Par exemple:

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

Le serveur démarre et écoute sur le port 7788.

Ceci est très utile pour fournir des propriétés par défaut dans PropertySources avec une priorité inférieure (et généralement empaquetées dans l'archive ou codées dans la source), puis les remplacer dans l'environnement d'exécution. Et c'est la philosophie de conception de Spring Boot:

Soyez d'opinion dès le départ, mais dégagez-vous rapidement lorsque les exigences commencent à diverger des valeurs par défaut.

SERVER_NAMEà la server.nameconversion a été effectuée par Relaxed Binding .

vous pouvez également configurer le port par programmation

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

Vous pouvez définir le port en code java:

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

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

Ou dans application.yml:

server:
    port: 9999

Ou dans application.properties:

server.port=9999

Ou comme paramètre de ligne de commande:

-Dserver.port=9999

Si vous souhaitez l'exécuter localement, utilisez ceci -

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

Depuis Spring Boot 2.0 , voici la commande qui fonctionne (des indices étaient là ):

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

Si vous utilisez, application.ymlajoutez-y les lignes suivantes

server:
     port: 9000

et bien sûr 0 pour un port aléatoire.

Comme expliqué dans la documentation Spring , il existe plusieurs façons de procéder:

Soit vous définissez le port dans la ligne de commande (par exemple 8888)

-Dserver.port=8888 ou --server.port=8888

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

Ou vous définissez le port dans l'application.properties

server.port=${port:4588}

ou (dans application.yml avec la syntaxe yaml)

server:
   port: ${port:4588}

Si le port passé par -Dport (ou -Dserver.port) est défini en ligne de commande, ce port sera pris en compte. Sinon, le port sera 4588 par défaut.

Si vous souhaitez appliquer le port dans le fichier de propriétés quelle que soit la variable d'environnement, il vous suffit d'écrire:

server.port=8888

Inclure la propriété ci-dessous dans application.properties

server.port=8080

Lorsque vous avez besoin d'un moyen de le faire par programme, vous pouvez le définir au démarrage:

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

Cela pourrait aider pour des choses comme le port dépendant de l'environnement. Bonne journée

Vous pouvez spécifier le port en remplaçant le EmbeddedServletContainerFactorybean dans votre configuration (basé sur java ou xml). Là, vous pouvez spécifier le port pour le conteneur de servlet intégré utilisé. Veuillez consulter le paragraphe et l'exemple de Spring Boot - Core "Embedded Servlet Container Support". J'espère que cela t'aides.

Dans le application.propertiesdossier présent dans les ressources:

server.port=8082

Pour étendre d'autres réponses:

Il existe une section dans les documents pour les tests qui explique comment configurer le port lors des tests d'intégration:

• 41.3 Test des applications Spring Boot
• 41.3.3 Travailler avec des ports aléatoires

Lors des tests d'intégration, la configuration du port est effectuée à l'aide de l'annotation @SpringBootTestet des webEnvironmentvaleurs.

Port aléatoire:

@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)

Vous pouvez injecter la valeur en utilisant @LocalServerPortqui est la même que @Value("${local.server.port}").

• Exemple:

Configuration de test de port aléatoire:

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

Port défini:

@SpringBootTest(webEnvironment=WebEnvironment.DEFINED_PORT)

Il prend la valeur de server.portif est défini.

• Si est défini à l'aide de @TestPropertySource(properties = "server.port=9192"), il remplace les autres valeurs définies.
• Sinon, il prend la valeur de src/test/resources/application.properties(s'il existe).
• Et enfin, s'il n'est pas défini, il commence par défaut 8080.

Exemple:

Configuration de test de port définie:

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

    @Test
    public void contextLoads() {
    }

}

Lorsque l'application de démarrage de printemps démarre, le serveur intégré tel que Tomcat démarre avec un port par défaut. Le tomcat intégré commence avec le port 8080 par défaut. Il existe plusieurs façons de modifier le port du serveur par défaut.

Utilisation du fichier de propriétés (.properties / .yml)

Pour modifier le port du serveur à l'aide du fichier de propriétés, nous devons configurer la propriété server.port .

une. Utilisation de application.properties dans le chemin de classe tel que src \ main \ resources \ application.properties

server.port = 8585

Le serveur démarre avec le port 8585. Pour obtenir un port de serveur aléatoire, affectez 0 à la propriété.

server.port = 0

Maintenant, le démarrage au printemps démarrera le serveur sur un port qui n'est actuellement utilisé par aucun serveur du système.

b. Utilisation de application.yml dans le chemin de classe tel que src \ main \ resources \ application.yml.

server:
  port: 8585 

Le serveur démarrera avec le port 8585.

Pour un port aléatoire, attribuez 0.

server:
  port: 0 

Utilisation de la commande java avec --server.port ou -Dserver.port

Supposons que nous ayons un fichier JAR exécutable nommé my-app.jar, puis lors du démarrage de l'application de démarrage de printemps à l'aide de la commande java, nous pouvons utiliser l'argument comme suit.

Utilisation de --server.port

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

Utilisation de -Dserver.port

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

Le serveur démarrera avec le port 8585.

Utilisation de la commande java avec --port ou -Dport en bref

Pour créer --server.port et -Dserver.port en bref, nous pouvons supprimer le mot-clé server et en faire n'importe quel mot-clé court tel que --port et -Dport. Nous pouvons utiliser n'importe quel mot clé court. Ici, nous utilisons port comme mot clé court. Pour y parvenir, nous devons configurer l'espace réservé dans le fichier de propriétés comme suit.

Utilisation de application.properties

server.port=${port:8282}

Utilisation de application.yml

server:
   port: ${port:8282}

Si nous ne transmettons pas le port comme argument, par défaut, le serveur commencera par 8282. Si nous voulons un port différent, nous devons passer l'argument souhaité comme suit. Supposons que nous ayons un fichier JAR exécutable nommé my-app.jar.

Utilisation de --port

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

Utilisation de -Dport

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

Le serveur démarrera avec le port 8585.

Utilisation de SERVER_PORT avec SpringApplication par programme

SpringApplication a une méthode comme setDefaultProperties () qui est utilisée pour changer les propriétés par défaut du démarrage de printemps. Supposons que nous voulons changer le port par défaut, alors nous devons créer une carte et mettre un port avec la clé SERVER_PORT. Trouvez l'exemple.

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

Le démarrage au printemps démarrera le serveur avec le port 8585.

Il existe trois façons de le faire en fonction du fichier de configuration d'application que vous utilisez

a) Si vous utilisez l' ensemble de fichiers application.properties

server.port = 8090

b) Si vous utilisez la propriété de port de serveur du jeu de fichiers application.yml au format YAML comme indiqué ci-dessous

server:
     port: 8090

c) Vous pouvez également définir la propriété comme propriété système dans la méthode principale

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

si vous utilisez gradle comme outil de génération, vous pouvez définir le port du serveur dans votre fichier application.yml comme:

server:
  port: 8291

Si vous utilisez maven, le port peut être défini dans votre fichier application.properties comme:

server.port: 8291

Il existe de nombreux autres éléments que vous pouvez modifier dans la configuration du serveur en modifiant application.properties. Comme le délai de session, l'adresse et le port, etc.

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

J'en ai utilisé peu comme ci-dessous.

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

1. Comme tout le monde l'a dit, vous pouvez spécifier dans application.properties
   server.port = 9000 (peut être n'importe quelle autre valeur)

2. Si vous utilisez un actionneur à ressort dans votre projet, il pointe par défaut sur
   8080 et si vous souhaitez le modifier, dans application.properties, mentionnez
   management.port = 9001 (il peut s'agir de n'importe quelle autre valeur)

Ajoutez ceci dans votre application.propertiesfichier

server.port= 8080

Dans le application.propertiesfichier, ajoutez cette ligne:

server.port = 65535

où placer ce fie:

24.3 Fichiers de propriétés d'application

SpringApplication charge les propriétés des fichiers application.properties aux emplacements suivants et les ajoute à l'environnement Spring:

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

La liste est classée par ordre de priorité (les propriétés définies dans les emplacements supérieurs de la liste remplacent celles définies dans les emplacements inférieurs).

Dans mon cas, je l'ai mis dans le répertoire où se trouve le jarfichier.

De:

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

Par défaut, l'application de démarrage de Spring démarre avec le serveur Tomcat intégré au port par défaut 8080. Spring vous propose différentes personnalisations, vous pouvez en choisir une.

REMARQUE - vous pouvez utiliser server.port = 0 Spring Boot trouvera pour nous tout port aléatoire http non attribué.

1) application.properties

server.port=2020

2) application.yml

server:  
     port : 2020

3) Changer le port du serveur par programmation

3.1) En implémentant l'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) En implémentant l'interface EmbeddedServletContainerCustomizer - Spring 1.x

@Component
public class CustomizationBean implements EmbeddedServletContainerCustomizer {

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

4) En utilisant l'option de ligne de commande

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

En effet, le moyen le plus simple consiste à définir la propriété server.port .

Si vous utilisez STS comme IDE, à partir de la version 3.6.7, vous avez en fait Spring Properties Editor pour ouvrir le fichier de propriétés.

Cet éditeur fournit la saisie semi-automatique pour toutes les propriétés Spring Boot. Si vous écrivez port et appuyez sur CTRL + ESPACE, server.port sera la première option.

Utiliser la propriété server.port = 8080 par exemple, comme mentionné dans d'autres réponses, est définitivement un moyen d'aller. Je voulais juste mentionner que vous pouvez également exposer une propriété d'environnement:

SERVER_PORT=8080

Étant donné que la botte à ressort peut remplacer "." pour "_" et inférieur à la majuscule pour les variables d'environnement dans les versions récentes. Ceci est particulièrement utile dans les conteneurs où tout ce que vous devez faire est de définir cette variable d'environnement sans ajouter / éditer application.propertiesou passer les propriétés système via la ligne de commande (ie -Dserver.port=$PORT)

J'espère que cette aide

application.properties => 

server.port = 8090

application.yml => 

serveur
  port: 8090

Fournir le numéro de port dans le fichier application.properties résoudra le problème

 server.port = 8080

"le port dépend de votre choix, où vous souhaitez héberger l'application"

Vous pouvez ajouter le port dans les méthodes ci-dessous.

1. Exécuter -> section Configurations

2. En application.xmlplusserver.port=XXXX

Vous pouvez définir cela dans application.properties sous / src / main / resources /

server.port = 8090

Juste un application.propertiesdans src/main/resourcesdu projet et y donner

server.port=****

où ****fait référence au numéro de port.

1.1 Mise à jour via un fichier de propriétés.

/src/main/resources/application.properties

server.port = 8888

Mettre à jour via un fichier yaml.

   server:

     port: 8888

EmbeddedServletContainerCustomizer

@Component
public class CustomContainer implements EmbeddedServletContainerCustomizer {

    @Override
    public void customize(ConfigurableEmbeddedServletContainer container) {

        container.setPort(8888);

    }

}

Vous pouvez également utiliser SERVER_PORTla variable d'environnement pour configurer le port Spring Boot. Définissez simplement la variable d'environnement et redémarrez l'application:

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

Veuillez noter que si vous ne définissez pas ces variables d'environnement à l'échelle du système, vous devez exécuter l'application de démarrage sur la même session.