Ajouter un chemin de contexte à l'application Spring Boot

J'essaie de définir une racine de contexte d'applications Spring Boot par programmation. La raison de la racine de contexte est que nous voulons que l'application soit accessible à partir de localhost:port/{app_name}et que tous les chemins de contrôleur y soient ajoutés.

Voici le fichier de configuration de l'application pour l'application Web.

@Configuration
public class ApplicationConfiguration {

  Logger logger = LoggerFactory.getLogger(ApplicationConfiguration.class);

  @Value("${mainstay.web.port:12378}")
  private String port;

  @Value("${mainstay.web.context:/mainstay}")
  private String context;

  private Set<ErrorPage> pageHandlers;

  @PostConstruct
  private void init(){
      pageHandlers = new HashSet<ErrorPage>();
      pageHandlers.add(new ErrorPage(HttpStatus.NOT_FOUND,"/notfound.html"));
      pageHandlers.add(new ErrorPage(HttpStatus.FORBIDDEN,"/forbidden.html"));
  }

  @Bean
  public EmbeddedServletContainerFactory servletContainer(){
      TomcatEmbeddedServletContainerFactory factory = new TomcatEmbeddedServletContainerFactory();
      logger.info("Setting custom configuration for Mainstay:");
      logger.info("Setting port to {}",port);
      logger.info("Setting context to {}",context);
      factory.setPort(Integer.valueOf(port));
      factory.setContextPath(context);
      factory.setErrorPages(pageHandlers);
      return factory;
  }

  public String getPort() {
      return port;
  }

  public void setPort(String port) {
      this.port = port;
  }
}

Voici le contrôleur d'index de la page principale.

@Controller
public class IndexController {

  Logger logger = LoggerFactory.getLogger(IndexController.class);

  @RequestMapping("/")
  public String index(Model model){
      logger.info("Setting index page title to Mainstay - Web");
      model.addAttribute("title","Mainstay - Web");
      return "index";
  }

}

La nouvelle racine de l'application doit être à localhost:12378/mainstay, mais elle se trouve toujours à localhost:12378.

Que me manque-t-il qui empêche Spring Boot d'ajouter la racine de contexte avant le mappage de la demande?

Pourquoi essayez-vous de lancer votre propre solution. Spring-boot prend déjà en charge cela.

Si vous n'en avez pas déjà un, ajoutez un application.propertiesfichier à src\main\resources. Dans ce fichier de propriétés, ajoutez 2 propriétés:

server.contextPath=/mainstay
server.port=12378

MISE À JOUR (Spring Boot 2.0)

À partir de Spring Boot 2.0 (en raison de la prise en charge de Spring MVC et de Spring WebFlux), la version contextPatha été modifiée comme suit:

server.servlet.contextPath=/mainstay

Vous pouvez ensuite supprimer votre configuration pour le conteneur de servlet personnalisé. Si vous devez effectuer un post-traitement sur le conteneur, vous pouvez ajouter une EmbeddedServletContainerCustomizerimplémentation à votre configuration (par exemple pour ajouter les pages d'erreur).

Fondamentalement, les propriétés à l'intérieur du application.propertiesservent par défaut, vous pouvez toujours les remplacer en utilisant une application.propertiesautre à côté de l'artefact que vous fournissez ou en ajoutant des paramètres JVM ( -Dserver.port=6666).

Voir également le Guide de référence, en particulier la section des propriétés .

La classe ServerPropertiesimplémente le EmbeddedServletContainerCustomizer. La valeur par défaut pour contextPathest "". Dans votre exemple de code, vous définissez contextPathdirectement sur le TomcatEmbeddedServletContainerFactory. Ensuite, l' ServerPropertiesinstance traitera cette instance et la réinitialisera de votre chemin vers "". ( Cette ligne effectue une nullvérification, mais par défaut, ""elle échoue toujours et définit le contexte sur ""et remplace ainsi le vôtre).

Si vous utilisez Spring Boot, vous n'avez pas à configurer les propriétés du serveur via l'initialisation de Vean.

Au lieu de cela, si une fonctionnalité est disponible pour la configuration de base, elle peut être définie dans un fichier «propriétés» appelé application, qui doit résider sous src\main\resourcesdans la structure de votre application. Le fichier "propriétés" est disponible en deux formats

1. .yml

2. .properties

La façon dont vous spécifiez ou définissez les configurations diffère d'un format à l'autre.

Dans votre cas spécifique, si vous décidez d'utiliser l'extension .properties, vous auriez un fichier appelé application.propertiessous src\main\resourcesavec les paramètres de configuration suivants

server.port = 8080
server.contextPath = /context-path

OTOH, si vous décidez d'utiliser l' .ymlextension (ie application.yml), vous devrez définir les configurations en utilisant le format suivant (ie YAML):

server:
    port: 8080
    contextPath: /context-path

Pour les propriétés plus courantes de Spring Boot, reportez-vous au lien ci-dessous:

https://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html

Si vous utilisez Spring Boot 2.0.0, utilisez:

server.servlet.context-path

veuillez noter que les propriétés "server.context-path" ou "server.servlet.context-path" [à partir de springboot 2.0.x] ne fonctionneront que si vous déployez vers un conteneur intégré, par exemple, un tomcat intégré. Ces propriétés n'auront aucun effet si vous déployez votre application en tant que war sur un tomcat externe par exemple.

voir cette réponse ici: https://stackoverflow.com/a/43856300/4449859

Les bonnes propriétés sont

server.servlet.path

pour configurer le chemin du DispatcherServlet

et

server.servlet.context-path

pour configurer le chemin du contexte des applications en dessous.

Nous pouvons changer le chemin de la racine du contexte en utilisant une simple entrée dans le fichier de propriétés.

application.properties

### Spring boot 1.x #########
server.contextPath=/ClientApp

### Spring boot 2.x #########
server.servlet.context-path=/ClientApp

Nous pouvons le mettre en application.propertiestant que API_CONTEXT_ROOT=/therootpath

Et nous y accédons dans la classe Java comme mentionné ci-dessous

@Value("${API_CONTEXT_ROOT}")
private String contextRoot;

server.contextPath = / mainstay

fonctionne pour moi si j'avais un fichier de guerre dans JBOSS. Parmi plusieurs fichiers war où chacun contient jboss-web.xml, cela ne fonctionnait pas. J'ai dû mettre jboss-web.xml dans le répertoire WEB-INF avec le contenu

<?xml version="1.0" encoding="UTF-8"?>
<jboss-web xmlns="http://www.jboss.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.jboss.com/xml/ns/javaee http://www.jboss.org/j2ee/schema/jboss-web_5_1.xsd">
    <context-root>mainstay</context-root>
</jboss-web>

Dans Spring Boot 1.5:

Ajoutez la propriété suivante dans application.properties:

server.context-path=/demo

Remarque: /demoest votre URL de chemin de contexte.

Vous pouvez le faire en ajoutant facilement le port et le chemin de contexte pour ajouter la configuration dans le fichier [src \ main \ resources] .properties et aussi le fichier .yml

configuration du fichier application.porperties

server.port = 8084
server.contextPath = /context-path

configuration du fichier application.yml

server:
port: 8084
contextPath: /context-path

Nous pouvons également le changer par programme dans Spring Boot.

@Component
public class ServerPortCustomizer implements     WebServerFactoryCustomizer<EmbeddedServletContainerCustomizer > {

@Override
public void customize(EmbeddedServletContainerCustomizer factory) {
    factory.setContextPath("/context-path");
    factory.setPort(8084);
}

}

On peut aussi ajouter une autre manière

@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {SpringApplication application =     new pringApplication(MyApplication.class);
    Map<String, Object> map = new HashMap<>();
    map.put("server.servlet.context-path", "/context-path");
    map.put("server.port", "808");
    application.setDefaultProperties(map);
    application.run(args);
    }       
}

en utilisant la commande java spring boot 1.X

java -jar my-app.jar --server.contextPath=/spring-boot-app     --server.port=8585 

en utilisant la commande java spring boot 2.X

java -jar my-app.jar --server.servlet.context-path=/spring-boot-app --server.port=8585 

Si vous utilisez application.yml et la version Spring au-dessus de 2.0, configurez-les de la manière ci-dessous.

server:
  port: 8081
  servlet:
     context-path: /demo-api

Maintenant, tous les appels d'API seront comme http: // localhost: 8081 / demo-api /

Nous pouvons le définir en utilisant WebServerFactoryCustomizer. Cela peut être ajouté directement dans la classe de méthode principale de spring boot qui démarre le Spring ApplicationContext.

@Bean
    public WebServerFactoryCustomizer<ConfigurableServletWebServerFactory>
      webServerFactoryCustomizer() {
        return factory -> factory.setContextPath("/demo");
}

Si vous utilisez Spring Boot 2.x et que vous souhaitez transmettre la propriété de chemin de contexte dans la ligne de commande, vous devez mettre double // comme ceci:

--server.servlet.context-path=//your-path

Cela a fonctionné pour moi sous Windows.

<!-- Server port-->

server.port=8080

<!--Context Path of the Application-->

server.servlet.context-path=/ems

Il doit être: server.servlet.context-path = / demo notez qu'il n'a pas de guillemets uniquement la valeur précédée de '/' cette valeur va dans votre fichier application.properties

le chemin de contexte peut être directement intégré au code mais ce n'est pas conseillé car il ne peut pas être réutilisé donc écrivez dans le fichier application.properties server.contextPath = / nom du dossier où vous avez placé le code contextPath = nom du dossier où vous avez placé le code / Remarque: regardez attentivement la barre oblique.