Comment configurer le port pour une application Spring Boot

Question

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

Answer 1

Comme dit dans docs soit définir server.port en tant que propriété système à l'aide de l'option de ligne de commande sur jvm -Dserver.port=8090, soit ajouter application.properties à /src/main/resources/ avec

server.port=8090

Pour une utilisation de port aléatoire

server.port=0

Answer 2

Il existe deux méthodes principales pour modifier le port dans Tomcat intégré dans une application de démarrage Spring.

Modifiez application.properties

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

server.port = 8090

Modifier une option VM

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 vm arg:

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

-Dserver.port=8090

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

Answer 3

Comme Spring Boot fournit divers mécanismes d'externalisation de la configuration (via diverses implémentations PropertySource et/ou processeurs connectés à un objet Environment dans l'ordre), vous pouvez définir toute propriété. en dehors de de votre archive JAR en appliquant les méthodes suivantes:

1. Transmettez la propriété via l'argument de ligne de commande en tant qu'argument d'application

   Java -jar <path/to/my/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 U * IX Shell:

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

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

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

   • Passer l'argument de 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 variable d'environnement de système d'exploitation

   • U * IX Shell

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

   • Les fenêtres

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

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

   server.port=7788
   

   et courir:

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

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

   server:
       port: 7788
   

   et courir:

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

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

   server.port=7788
   

   et courir:

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

8. Placez 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 la configuration précédente dans 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 va démarrer et écouter sur le port 7788.

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

Soyez avisé dès la sortie de la boîte, mais éliminez-vous rapidement lorsque les exigences commencent à diverger des valeurs par défaut.

---

SERVER_NAME à server.name la conversion a été effectuée par Reliure Reliée .

Answer 4

aussi, vous pouvez configurer le port par programme

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

Answer 5

Vous pouvez définir le port dans le 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

Answer 6

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

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

À partir de Spring Boot 2.0 , voici la commande qui fonctionne (les indices étaient ici ):

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

Answer 7

Si vous utilisez application.yml ajoutez les lignes suivantes

server:
     port: 9000

et bien sur 0 pour le port aléatoire.

Answer 8

Comme expliqué dans documentation Spring , il existe plusieurs façons 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 le fichier 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 voulez imposer le port dans le fichier de propriétés quelle que soit la variable d'environnement, il vous suffit d'écrire:

server.port=8888

Answer 9

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

server.port=8080

Answer 10

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

Answer 11

Vous pouvez spécifier un port en remplaçant le bean EmbeddedServletContainerFactory dans votre configuration (Java ou XML). Vous pouvez y spécifier le port du conteneur de servlet intégré utilisé. Veuillez vous reporter au paragraphe Spring Boot - Core "Prise en charge du conteneur de servlets incorporé" et à cet exemple. J'espère que cela t'aides.

Answer 12

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

server.port=8082

Answer 13

Lorsque l'application de démarrage 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 y a plusieurs façons de changer le port du serveur par défaut.

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

Pour changer le port du serveur en utilisant le 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 va commencer avec le port 8585. Pour obtenir un port de serveur aléatoire, attribuez 0 à la propriété.

server.port = 0

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

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

server:
  port: 8585 

Le serveur commencera par le port 8585.

Pour un port aléatoire, attribuez 0.

server:
  port: 0 

Utilisation de Java Commande avec --server.port ou -Dserver.port

Supposons que nous ayons un fichier JAR exécutable nommé my-app.jar. Ensuite, 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 commencera par le port 8585.

Utilisation de Java Commande avec --port ou -Dport en bref

Pour résumer --server.port et -Dserver.port, nous pouvons supprimer le mot clé server et en faire un 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 ce faire, nous devons configurer un 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 en tant qu'argument, le serveur par défaut commence par 8282. Si nous voulons un port différent, nous devons passer l'argument du port souhaité 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 -Dport

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

Le serveur commencera par le port 8585.

Utilisation de SERVER_PORT avec SpringApplication par programme

SpringApplication a une méthode comme setDefaultProperties () utilisée pour modifier les propriétés par défaut de Spring Spring. Supposons que nous voulions changer le port par défaut, 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(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 du printemps démarrera le serveur avec le port 8585.

Answer 14

Pour prolonger d'autres réponses:

Une section de la documentation destinée aux tests 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 @SpringBootTest et des valeurs webEnvironment.

---

Port aléatoire:

@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)

Vous pouvez injecter la valeur en utilisant @LocalServerPort qui est 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 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 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() {
    }

}

Answer 15

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

a) Si vous utilisez application.properties ensemble de fichiers

server.port = 8090

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

server:
     port: 8090

c) Vous pouvez également définir la propriété en tant que propriété System dans le méthode principale

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

Answer 16

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'ai utilisé peu d'entre eux comme ci-dessous.

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

Answer 17

Dans le fichier application.properties, ajoutez cette ligne:

server.port = 65535

où placer ce fichier:

24.3 Fichiers de propriétés d'application

SpringApplication charge les propriétés à partir 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 aux emplacements situés plus haut dans la liste remplacent celles définies aux emplacements inférieurs).

Dans mon cas, je le mets dans le répertoire où se trouve le fichier jar.

De:

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

Answer 18

Ajoutez ceci dans votre fichier application.properties

server.port= 8080

Answer 19

1. Comme tout le monde l'a dit, vous pouvez spécifier dans application.properties
   server.port = 90 (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 voulez le changer, alors dans application.properties, mentionnez
   management.port = 9001 (peut être n'importe quelle autre valeur)

Answer 20

Par défaut, l'application Spring Boot démarre avec le serveur Tomcat intégré sur le port 8080 par défaut. Spring vous propose une personnalisation différente. Vous pouvez en choisir une.

NOTE - vous pouvez utiliser server.port = le démarrage de printemps trouvera tout port aléatoire http non attribué pour nous.

1) application.properties

server.port=2020

2) application.yml

server:  
     port : 2020

) Modifier le port du serveur par programme

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

.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

Answer 21

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 réellement Spring Properties Editor pour ouvrir le fichier de propriétés.

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

Answer 22

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 voulez héberger l'application"

Answer 23

J'espère que cette aide

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

Answer 24

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

SERVER_PORT=8080

Depuis printemps botte est en mesure de remplacer "." pour "_" et inférieur au casse 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 cette variable d’environnement sans ajouter/éditer application.properties ni transmettre les propriétés du système via la ligne de commande (i.e -Dserver.port=$PORT)

Answer 25

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

/ src/main/resources/application.properties

server.port = 8888

Mise à jour via un fichier yaml.

   server:

     port: 8888

EmbeddedServletContainerCustomizer

@Component
public class CustomContainer implements EmbeddedServletContainerCustomizer {

    @Override
    public void customize(ConfigurableEmbeddedServletContainer container) {

        container.setPort(8888);

    }

}

Answer 26

Juste un application.properties dans src/main/resources du projet et donnez-y

server.port=****

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

Answer 27

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

1. Exécuter -> section Configurations

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

Answer 28

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

server.port = 8090

Answer 29

Vous pouvez également utiliser la variable d’environnement SERVER_PORT pour configurer le port d’amorçage Spring. 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 sur l'ensemble du système, vous devez exécuter l'application de démarrage sur la même session.

Answer 30

Springboot fonctionne principalement sur port:8080 en raison de l'intégration de Tomcat. Dans certains cas, il peut générer une erreur port 8080 already in use. Pour éviter ce genre de problèmes, nous pouvons configurer le port du serveur.

Utilisation de application.properties

ajouter server.port=9898

Sur la configuration d'exécution

lancez votre application avec les arguments ci-dessous.

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

Answer 31

Vous pouvez configurer votre port dans le fichier application.properties du dossier de ressources de votre projet de démarrage printanier.

server.port="port which you need"

Answer 32

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éfinir la propriété du port du serveur dans le fichier application.yml

server:
     port: 8090

3 Définissez la propriété en tant que propriété système dans la méthode main

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

Answer 33

Si vous souhaitez exécuter des applications sous forme de fichier jar dans un environnement de commande, entrez simplement "SERVER_PORT = ***" comme préfixe. La commande complète à exécuter ressemblera à celle ci-dessous:

SERVER_PORT=8080 Java -jar ***.jar

Si vous voulez exécuter une application en arrière-plan sous Linux, la commande avec 'Nohup' ressemblera à celle ci-dessous:

SERVER_PORT=8080 Nohup Java -jar ***.jar &

Answer 34

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.

Answer 35

Si vous travaillez sur des projets d'amorçage et que vous souhaitez configurer le port, vous pouvez entrer les données dans le fichier application.properties telles que REMARQUE: le fichier de propriétés doit se trouver sous src/main/resource

Propriétés du printemps

server.port = 9999 Si vous utilisez le CMD, suivez cette commande - Dserver.port = 9999 Pour le port par défaut, son server.port = 0 Assurez-vous qu'aucun port n'utilise ce port numéro de port

Answer 36

Dans les propriétés de l'application, il suffit d'ajouter 1 ligne

server.port = 8090

Answer 37

Cette question est le premier résultat si vous recherchez Google Gradle Spring Port .

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

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

Pour une réponse plus sophistiquée s'il vous plaît voir ma réponse ici .

Answer 38

Similaire à https://stackoverflow.com/a/36865796/1587329 et https://stackoverflow.com/a/40799750/1587329 , une ligne sur une ligne serait

SERVER_PORT=9090 gradle bootRun

Answer 39

"server.port = 808" ne fonctionnera que si votre application en cours d'exécution en tant que jar via la méthode principale,

Cette configuration ne fonctionnera pas si vous exécutez cette application en tant que fichier war via le conteneur Tomcat.

Answer 40

si votre numéro de port peut être aléatoire, vous pouvez utiliser une fonction aléatoire dans votre application.propertiesserver.port=${random.int(4)}

Answer 41

Outre toutes les réponses, je voudrais souligner que la plupart des IDE (IntelliJ avec plugin Spring, STS) ont une fonctionnalité qui suggère toutes les clés de configuration prises en charge par SpringBoot. (c'est-à-dire tous les mots-clés de configuration exprimés)

Spring Plugin pour Intellij

Answer 42

Cela a fonctionné pour moi:

Ajout d'une classe de conteneur personnalisée:

@Component
public class CustomContainer implements EmbeddedServletContainerCustomizer {

    @Override
    public void customize(ConfigurableEmbeddedServletContainer configurableEmbeddedServletContainer) {
       configurableEmbeddedServletContainer.setPort(8888);
    }

}

Mais ce n'était toujours pas utiliser le port 8888.

Ensuite, j'ai défini la propriété "scanBasePackages" comme ceci sur la classe "@SpringBootApplication" de ma méthode principale: (scanBasePackages = {"custom container package"})

@SpringBootApplication(scanBasePackages = {"com.javabrains.util"})
public class CourseApiApp {

    public static void main (String args []) {
        SpringApplication.run(CourseApiApp.class, args);
    }
}

Et il a commencé à prendre le port défini dans le conteneur personnalisé.

Answer 43

Au démarrage de printemps, vous pouvez facilement configurer le port d’exposition de service dans le fichier application.properties.

server.port=portnumber

si vous ne définissez pas de port spécifique, il essaiera d'ouvrir le service avec le port 80. dans le cas où il est déjà utilisé, le service ne sera pas démarré sur le conteneur incorporé.

Answer 44

Dans mon cas, ajouter une déclaration

server.port=${port:8081}

remplacer le port du serveur Tomcat par défaut.

Answer 45

server.port = 0 pour port aléatoire

server.port = 8080 pour le port 8080 personnalisé

Answer 46

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

application.properties

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