Spring Boot – comment configurer le port

Vous cherchez un moyen de configurer le port dans l’application de démarrage Spring:

@Controller @EnableAutoConfiguration public class SampleController { @RequestMapping("/") @ResponseBody Ssortingng home() { return "Hello World!"; } public static void main(Ssortingng[] args) throws Exception { SpringApplication.run(SampleController.class, args); } } 

C’est toutes les sources 🙂

    Comme indiqué dans docs, définissez server.port comme propriété système en utilisant l’option de ligne de commande jvm --server.port=8090 ou ajoutez application.properties dans /src/main/resources/ with

     server.port = 8090 

    Pour utilisation de port aléatoire

     server.port=0 

    Il existe deux méthodes principales pour modifier le port dans Embedded Tomcat dans une application Spring Boot.

    Modifier application.properties

    Tout d’abord, vous pouvez essayer le fichier application.properties dans le dossier / resources:

    fichier application.properties

    Modifier une option de machine virtuelle

    La deuxième façon, si vous voulez éviter de modifier des fichiers et d’enregistrer quelque chose dont vous n’avez besoin que sur votre version locale, vous pouvez utiliser un vm arg:

    Allez à Exécuter -> Modifier les configurations -> Options de la machine virtuelle

     -Dserver.port=8090 

    Changer de port avec un vm arg

    De plus, si vous avez besoin de plus d’informations, vous pouvez consulter l’article suivant: Changer le port sur une application Spring Boot

    vous pouvez également configurer le port par programmation

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

    Étant donné que Spring Boot fournit divers mécanismes d’externalisation de la configuration (via diverses implémentations PropertySource et / ou processeurs câblés dans un object Environment dans l’ordre), vous pouvez définir n’importe quelle propriété en dehors de votre archive jar par les méthodes suivantes:

    1. Passer la propriété via un argument de ligne de commande comme argument d’ application

       java -jar  --server.port=7788 
    2. De la propriété dans SPRING_APPLICATION_JSON (Spring Boot 1.3.0+)

      • Définir la variable d’environnement dans le shell U * IX:

         SPRING_APPLICATION_JSON='{"server.port":7788}' java -jar  
      • En utilisant la propriété système Java:

         java -Dspring.application.json='{"server.port":7788}' -jar  
      • Passer à travers l’argument de ligne de commande:

         java -jar  --spring.application.json='{"server.port":7788}' 
    3. Définir la propriété du système JVM

       java -Dserver.port=7788 -jar  
    4. Définir la variable d’environnement du système d’exploitation

      • Shell U * IX

         SERVER_PORT=7788 java -jar  
      • les fenêtres

         SET SERVER_PORT=7788 java -jar  
    5. Placez la propriété dans le fichier de configuration ./config/application.properties

       server.port=7788 

      et courir:

        java -jar  
    6. Placez la propriété dans ./config/application.yaml

       server: port: 7788 

      et courir:

        java -jar  
    7. Placez la propriété dans ./application.properties

       server.port=7788 

      et courir:

        java -jar  
    8. Placez la propriété dans ./application.yaml

       server: port: 7788 

      et courir:

        java -jar  

    Vous pouvez combiner les méthodes ci-dessus toutes ensemble, et l’ancienne configuration de la liste a préséance sur la dernière.

    Par exemple:

     SERVER_PORT=2266 java -Dserver.port=5566 -jar  --server.port=7788 

    Le serveur démarrera et écoutera 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ée dans l’archive ou codée dans la source), puis la remplacer dans l’environnement d’exécution. Et c’est la philosophie de conception de Spring Boot:

    Soyez avisé hors de la boîte, mais sortez de la voie rapidement que les exigences commencent à diverger des valeurs par défaut.


    server.name conversion server.name été effectuée par la liaison server.name .

    Vous pouvez définir le port dans le code Java:

     HashMap 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 utilisez application.yml ajoutez-y les lignes suivantes

     server: port: 9000 

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

    Comme expliqué dans la documentation de Spring , il existe plusieurs manières de le faire:

    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 sur la ligne de commande, ce port sera pris en compte. Sinon, le port sera 4588 par défaut.

    Si vous voulez 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 

    Si vous souhaitez le faire en l’exécutant localement plutôt que de l’utiliser –

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

    Par défaut, les applications Spring Boot s’exécutent sur un Tomcat intégré via le port 8080 .

    Pour modifier le port par défaut, il vous suffit de modifier l’atsortingbut server.port qui est automatiquement lu à l’exécution par les applications Spring Boot.

    Vous pouvez le modifier des trois manières suivantes:

    1. Définissez server.port sous application.properties comme suit:
     server.port=9090 
    1. Définissez server.port par programmation en implémentant l’interface EmbeddedServletContainerCustomizer .

    2. Définissez explicitement server.port lors du démarrage de l’application via la ligne de commande comme suit:

    java -Dserver.port = 9090 -jar executable.jar

    java -jar executable.jar –server.port = 9090

    Consultez l’explication des détails ici: Comment changer le port par défaut de l’application Spring Boot

    Lorsque vous en avez besoin par programmation, vous pouvez le définir lors du 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

    Pour prolonger d’autres réponses:

    Il y a une section dans les documents pour les tests qui explique comment configurer le port sur les 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 @SpringBootTest et des valeurs webEnvironment .


    Port aléatoire:

     @SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT) 

    Vous pouvez injecter la valeur à l’aide de @LocalServerPort identique à @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.port si est défini.

    • Si est défini à l’aide de @TestPropertySource(properties = "server.port=9192") , il remplace d’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 la valeur 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() { } } 

    Vous pouvez spécifier le port en remplaçant le bean EmbeddedServletContainerFactory dans votre configuration (basé sur Java ou xml). Vous pouvez y spécifier le port du conteneur de servlet intégré utilisé. S’il vous plaît, voir Spring Boot – Core “Support de conteneur de servlet intégré” et exemple ici. J’espère que cela t’aides.

    Dans le fichier application.properties présent dans les ressources:

     server.port=8082 

    Lorsque l’application d’amorçage printanière démarre, le serveur intégré tel que Tomcat démarre avec un port par défaut. Le tomcat intégré commence par 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, vous devez configurer la propriété server.port .

    une. Utiliser application.properties dans classpath tel que src \ main \ resources \ application.properties

     server.port = 8585 

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

     server.port = 0 

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

    b. Utiliser application.yml dans classpath tel que src \ main \ resources \ application.yml.

     server: port: 8585 

    Le serveur démarrera avec le port 8585.

    Pour un port aléatoire, atsortingbuez la valeur 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, alors que lors du démarrage de l’application Spring Boot à l’aide de la commande Java, nous pouvons utiliser l’argument comme suit.

    Utiliser –server.port

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

    Utiliser -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 abrégé

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

    Utiliser application.properties

     server.port=${port:8282} 

    Utiliser application.yml

     server: port: ${port:8282} 

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

    Utiliser –port

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

    Utiliser -port

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

    Le serveur démarrera avec le port 8585.

    Utilisation de SERVER_PORT avec SpringApplication par programmation

    SpringApplication a une méthode comme setDefaultProperties () qui est utilisée pour modifier les propriétés par défaut du démarrage de spring. Supposons que nous voulions changer le port par défaut, alors nous devons créer une carte et placer 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(Ssortingng[] args) { SpringApplication application = new SpringApplication(MyApplication.class); Map map = new HashMap<>(); map.put("SERVER_PORT", "8585"); application.setDefaultProperties(map); application.run(args); } } 

    Spring boot va démarrer le serveur avec le port 8585.

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

     server.port=8080 

    Il y a beaucoup d’autres choses que vous pouvez modifier dans la configuration du serveur en modifiant application.properties. Comme le temps de session, l’adresse et le port, etc.

    ref: 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 toute autre valeur)

    2. Si vous utilisez un actionneur à ressort dans votre projet, il indique par défaut
      8080, et si vous voulez le changer, alors dans application.properties mentionnez
      management.port = 9001 (peut être toute autre valeur)

    En effet, le plus simple est de définir la propriété server.port .

    Si vous utilisez STS comme IDE, à partir de la version 3.6.7, vous avez réellement l’ éditeur de propriétés de spring pour ouvrir le fichier de propriétés.

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

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

    J’espère que cette aide

     application.properties => 
    
     server.port = 8090
    
     application.yml => 
    
     serveur
       port: 8090
    

    Il suffit d’avoir un application.properties dans src/main/resources du projet et d’y donner

     server.port=**** 

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

    Ajoutez ceci dans votre fichier application.properties

     server.port= 8080 

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

    1. Exécuter -> section Configurations

    2. Dans application.xml ajoutez server.port=XXXX

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

     server.port = 8090 

    Surtout, springboot s’exécute sur le port:8080 raison de l’intégration de Tomcat. Dans certains cas, un port 8080 already in use erreur port 8080 already in use . Pour éviter ce genre de problèmes, nous pouvons configurer le port du serveur.

    Utiliser application.properties

    append server.port=9898

    Sur la configuration à l’exécution

    Exécutez votre application avec les arguments ci-dessous.

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

    Il y a trois façons de le faire

    1 Définissez la propriété server.port dans le fichier application.properties

     server.port = 8090 

    2 Définissez la propriété du port du serveur dans le fichier application.yml

     server: port: 8090 

    3 Définissez la propriété comme propriété système dans main méthode main

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

    Utiliser la propriété server.port = 8080, par exemple, comme mentionné dans d’autres réponses, est certainement une façon de faire. Je voulais juste mentionner que vous pourriez également exposer une propriété d’environnement:

     SERVER_PORT=8080 

    Depuis le démarrage du spring est capable de remplacer “.” pour “_” et inférieur à UPPER pour les variables d’environnement dans les versions récentes. Ceci est particulièrement utile dans les conteneurs où tout ce que vous avez à faire est de définir la variable d’environnement sans append / modifier application.properties ou passer les propriétés du système via la ligne de commande (par exemple -Dserver.port=$PORT )

    Vous pouvez également utiliser la variable d’environnement SERVER_PORT pour configurer le port Spring Boot. Il suffit de définir la variable d’environnement et de redémarrer 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.

    Le port par défaut est: 8080 mais nous pouvons personnaliser le numéro de port dans application.properties comme indiqué ci-dessous.

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

    Cette question est le premier résultat si vous google pour Gradle Spring Port .

    Si vous utilisez gradle, vous pouvez faire quelque chose comme ceci si le plug-in Spring Boot Gradle est déjà appliqué:

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

    Pour une réponse plus sophistiquée, veuillez consulter ma réponse ici .