Comment configurer le port pour une application Spring Boot

798

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

Paul Verest
la source
5
Si quelqu'un est intéressé, voici comment avoir plusieurs ports - stackoverflow.com/questions/36357135/…
Betlista
si vous utilisez le fichier "yml" pour la configuration, vous pouvez utiliser ce serveur: port: 8081 Annotez également votre classe principale en tant que "@SpringBootApplication" et supprimez @ EnableAutoConfiguration
Keaz
votre projet [application.properties] pour ajouter le server.port = 8080
Lahiru Samishka
définir server.port=8080dans les propriétés de l'application. cette configuration est en ServerProperties.classclasse sous org.springframework.boot.autoconfigure.web.
Atif

Réponses:

1227

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
Paul Verest
la source
47
Lorsqu'un port aléatoire est utilisé, les informations sur le port peuvent être @Value("${local.server.port}")
obtenues
42
En fait, l'option de ligne de commande est --server.port = 8090 pas -Dserver.port = 8090. docs.spring.io/spring-boot/docs/current/reference/html/…
Opster ES Ninja - Alper
1
En complément de cette réponse: Selon les documents du printemps, il existe d'autres chemins que vous pouvez emprunter application.properties. Dans mon cas, cela a beaucoup aidé.
sargas
14
-Dserver.port = XXXX n'a ​​pas fonctionné pour moi. J'ai utilisé le mode variable d'environnement OS: $ SERVER_PORT=8090 java -jar <path/to/my/jar>
Soumya Kanti
10
Les deux (1) java -Dserver.port=XXXX -jar <path/to/my/jar>et (2) java -jar <path/to/my/jar> --server.port=YYYYfonctionnent. La première commande définit la server.portpropriété système et la deuxième commande transmet la propriété via les arguments de ligne de commande ( String... argsdans la mainméthode). De plus, si vous exécutez avec java -Dserver.port=XXXX -jar <path/to/my/jar> --server.port=YYYY, YYYYa priorité sur XXXX, c'est pourquoi Spring Boot Externalized Configuration est si charmant.
tan9
210

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

fichier application.properties

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

Changer de port avec un argument vm

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

anataliocs
la source
Dans STS 4, il est exécuté -> exécuter les configurations -> principal, puis faites défiler jusqu'à Table avec le nom et la valeur du paramètre
serv-inc le
155

É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 .

tan9
la source
108

vous pouvez également configurer le port par programmation

@Configuration
public class ServletConfig {
    @Bean
    public EmbeddedServletContainerCustomizer containerCustomizer() {
        return (container -> {
            container.setPort(8012);
        });
    }
}
makerj
la source
Cela fonctionne et est très utile lorsque vous avez un port dans votre propre fichier de configuration et que vous souhaitez le définir pendant l'exécution.
Xdg
4
Cela a été utile lorsque j'avais besoin de déployer une application sur un service AWS Elastic Beanstalk, pour obtenir le port à partir d'une variable d'environnement.
Martin Hansen
C'est très utile lorsque tout ce que vous voulez est un test unitaire ou d'intégration autonome, +1.
Priidu Neemre
Très utile lorsque la variable env pour port est déjà définie sous un nom différent.
higuaro
2
N'est-ce pas le @Configurationlieu de @Controller? Veuillez le mettre à jour si oui.
Lucky
82

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
ayurchuk
la source
L'utilisation de HashMap ne fonctionnera que si aucun port n'est défini dans applications.properties ou .yml.
Milgo
79

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

mvn spring-boot:run -Dspring-boot.run.arguments=--server.port=8085
itwarilal
la source
1
À partir de Spring Boot 2, vous devez utiliser spring-boot.run.jvmArguments.
mapm
54

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

server:
     port: 9000

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

gatolgaj
la source
1
cela ne semblait pas fonctionner. J'ai utilisé server.port dans le fichier application.yml et cela a fonctionné
yathirigan
47

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
OlivierTerrien
la source
39

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

server.port=8080
Chandramouli
la source
23

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

Luis Mauricio
la source
2
System.setProperty("server.port", 80);est une autre façon de faire la même chose.
hd1
@ hd1, j'ai ajouté nos réponses à la réponse principale, vérifiez-la et modifiez-la à votre guise
Luis Mauricio
18

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.

nndru
la source
Voici un lien actuel vers la section de remplacement programmatique: docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/…
jocull
18

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

server.port=8082
Amit Gujarathi
la source
17

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:


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

}
Pau
la source
17

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.

Humoyun Ahmad
la source
17

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");
Praneeth
la source
15

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
VSharma
la source
for application.properties itsserver.port = 8291
iQuestProgrammer
13
  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)

Rakesh
la source
12

Ajoutez ceci dans votre application.propertiesfichier

server.port= 8080
Sridhar Battala
la source
2
Bienvenue à SO :-) s'il vous plaît regardez comment répondre
JimHawkins
Pourquoi ajouter la même réponse un an plus tard?!? et la server.port 8080syntaxe est incorrecte pour le fichier de propriétés Java ...
Betlista
12

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

ZhaoGang
la source
12

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
anandchaugule
la source
10

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.

Adrian Cosma
la source
1
Ou aussi si vous utilisez Intellij IDEA, la saisie semi-automatique fonctionne également. ;)
Lucky
9

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)

Ulises
la source
SERVER_PORT=8081 mvn spring-boot:run
nobar
8

J'espère que cette aide

application.properties => 

server.port = 8090

application.yml => 

serveur
  port: 8090
Sagar Mal Shankhala
la source
application.yml => serveur: port: 8090
geek
8

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"

Ashwini
la source
7

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

  1. Exécuter -> section Configurations

  2. En application.xmlplusserver.port=XXXX

gkarthiks
la source
1
Voulez-vous dire application.ymlet quel IDE utilisez-vous? Soyez précis s'il vous plait.
Lucky
7

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

server.port = 8090
Abhijeet
la source
7

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

server.port=****

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

Shubham Khurana
la source
7

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

    }

}
Buddhika Lakshan
la source
6

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.

Ali Dehghani
la source