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:
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
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:
Passer la propriété via un argument de ligne de commande comme argument d’ application
java -jar --server.port=7788
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}'
Définir la propriété du système JVM
java -Dserver.port=7788 -jar
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
Placez la propriété dans le fichier de configuration ./config/application.properties
server.port=7788
et courir:
java -jar
Placez la propriété dans ./config/application.yaml
server: port: 7788
et courir:
java -jar
Placez la propriété dans ./application.properties
server.port=7788
et courir:
java -jar
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:
server.port=9090
Définissez server.port par programmation en implémentant l’interface EmbeddedServletContainerCustomizer .
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:
Lors des tests d’intégration, la configuration du port est effectuée à l’aide de l’annotation @SpringBootTest
et des valeurs webEnvironment
.
@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)
Vous pouvez injecter la valeur à l’aide de @LocalServerPort
identique à @Value("${local.server.port}")
.
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; }
@SpringBootTest(webEnvironment=WebEnvironment.DEFINED_PORT)
Il prend la valeur de server.port
si est défini.
@TestPropertySource(properties = "server.port=9192")
, il remplace d’autres valeurs définies. src/test/resources/application.properties
(s’il existe). 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
Comme tout le monde l’a dit, vous pouvez spécifier dans application.properties
server.port = 9000 (peut être toute autre valeur)
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=****
où ****
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.
Exécuter -> section Configurations
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.
append server.port=9898
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 .