Fügen Sie der Spring Boot-Anwendung einen Kontextpfad hinzu

Ich versuche, einen Spring Boot-Anwendungskontextstamm programmgesteuert festzulegen. Der Grund für das Kontextstammverzeichnis ist, dass auf die App zugegriffen werden soll localhost:port/{app_name}und alle Controller-Pfade daran angehängt werden sollen.

Hier ist die Anwendungskonfigurationsdatei für die Web-App.

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

Hier ist der Index-Controller für die Hauptseite.

@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";
  }

}

Das neue Stammverzeichnis der Anwendung sollte sich bei befinden localhost:12378/mainstay, befindet sich jedoch weiterhin bei localhost:12378.

Was fehlt mir, was dazu führt, dass Spring Boot den Kontextstamm nicht vor der Anforderungszuordnung anfügt?

Warum versuchen Sie, Ihre eigene Lösung zu entwickeln? Spring-Boot unterstützt das bereits.

Wenn Sie noch keine haben, fügen Sie eine application.propertiesDatei hinzu src\main\resources. Fügen Sie in dieser Eigenschaftendatei zwei Eigenschaften hinzu:

server.contextPath=/mainstay
server.port=12378

UPDATE (Spring Boot 2.0)

Ab Spring Boot 2.0 (aufgrund der Unterstützung von Spring MVC und Spring WebFlux) contextPathwurde Folgendes geändert:

server.servlet.contextPath=/mainstay

Anschließend können Sie Ihre Konfiguration für den benutzerdefinierten Servlet-Container entfernen. Wenn Sie eine Nachbearbeitung für den Container durchführen müssen, können Sie EmbeddedServletContainerCustomizerIhrer Konfiguration eine Implementierung hinzufügen (z. B. um die Fehlerseiten hinzuzufügen).

Grundsätzlich können Sie die Eigenschaften innerhalb des application.propertiesDienstes standardmäßig überschreiben, indem Sie application.propertiesneben dem von Ihnen gelieferten Artefakt ein anderes verwenden oder JVM-Parameter hinzufügen ( -Dserver.port=6666).

Siehe auch Das Referenzhandbuch, insbesondere den Abschnitt Eigenschaften .

Die Klasse ServerPropertiesimplementiert die EmbeddedServletContainerCustomizer. Der Standardwert für contextPathist "". In Ihrem Codebeispiel setzen Sie das contextPathdirekt auf das TomcatEmbeddedServletContainerFactory. Als nächstes verarbeitet die ServerPropertiesInstanz diese Instanz und setzt sie von Ihrem Pfad zu zurück "". ( Diese Zeile macht anull Überprüfung durch, aber standardmäßig"" sie immer fehl und setzt den Kontext auf ""und überschreibt somit Ihren).

Wenn Sie Spring Boot verwenden, müssen Sie die Servereigenschaften nicht über die Vean-Initialisierung konfigurieren.

Wenn stattdessen eine Funktionalität für die Grundkonfiguration verfügbar ist, kann sie in einer "Eigenschaften" -Datei namens "Eigenschaften" festgelegt werden application, die sich src\main\resourcesin Ihrer Anwendungsstruktur befinden sollte. Die Datei "Eigenschaften" ist in zwei Formaten verfügbar

1. .yml

2. .properties

Die Art und Weise, wie Sie die Konfigurationen festlegen oder festlegen, unterscheidet sich von Format zu Format.

Wenn Sie sich in Ihrem speziellen Fall für die Verwendung der Erweiterung entscheiden, wird .propertieseine Datei mit den folgenden Konfigurationseinstellungen application.propertiesunter aufgerufensrc\main\resources

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

OTOH, wenn Sie sich für die Verwendung der .ymlErweiterung (dh application.yml) entscheiden, müssen Sie die Konfigurationen im folgenden Format (dh YAML) festlegen :

server:
    port: 8080
    contextPath: /context-path

Weitere allgemeine Eigenschaften von Spring Boot finden Sie unter dem folgenden Link:

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

Wenn Sie Spring Boot 2.0.0 verwenden, verwenden Sie:

server.servlet.context-path

Beachten Sie, dass die Eigenschaften "server.context-path" oder "server.servlet.context-path" [ab springboot 2.0.x] nur funktionieren, wenn Sie sie in einem eingebetteten Container, z. B. eingebettetem Tomcat, bereitstellen. Diese Eigenschaften haben keine Auswirkung, wenn Sie Ihre Anwendung beispielsweise als War für einen externen Tomcat bereitstellen.

Diese Antwort finden Sie hier: https://stackoverflow.com/a/43856300/4449859

Die richtigen Eigenschaften sind

server.servlet.path

um den Pfad des DispatcherServlet zu konfigurieren

und

server.servlet.context-path

um den Pfad des Anwendungskontexts darunter zu konfigurieren.

Wir können den Kontextstammpfad mithilfe eines einfachen Eintrags in der Eigenschaftendatei ändern.

application.properties

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

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

Wir können es im application.propertiesas einstellenAPI_CONTEXT_ROOT=/therootpath

Und wir greifen in der Java-Klasse darauf zu, wie unten erwähnt

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

server.contextPath = / mainstay

funktioniert für mich, wenn ich eine Kriegsdatei in JBOSS hatte. Unter mehreren Kriegsdateien, in denen jede jboss-web.xml enthält, hat es nicht funktioniert. Ich musste jboss-web.xml mit Inhalt in das WEB-INF-Verzeichnis stellen

<?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>

In Spring Boot 1.5:

Fügen Sie die folgende Eigenschaft hinzu application.properties:

server.context-path=/demo

Hinweis: /demoist Ihre Kontextpfad-URL.

Sie können dies tun, indem Sie den Port und den Kontextpfad einfach hinzufügen, um die Konfiguration in der .properties-Datei [src \ main \ resources] und in der .yml-Datei hinzuzufügen

Konfiguration der Datei application.porperties

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

Konfiguration der Datei application.yml

server:
port: 8084
contextPath: /context-path

Wir können es auch programmgesteuert im Spring Boot ändern.

@Component
public class ServerPortCustomizer implements     WebServerFactoryCustomizer<EmbeddedServletContainerCustomizer > {

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

}}

Wir können auch einen anderen Weg hinzufügen

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

mit dem Java-Befehl spring boot 1.X.

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

mit dem Java-Befehl spring boot 2.X.

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

Wenn Sie application.yml und Spring Version über 2.0 verwenden, konfigurieren Sie diese wie folgt.

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

Jetzt wird der gesamte API-Aufruf wie folgt lauten : http: // localhost: 8081 / demo-api /

Wir können es mit einstellen WebServerFactoryCustomizer. Dies kann direkt in die Spring Boot-Hauptmethodenklasse eingefügt werden, die den Spring ApplicationContext startet.

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

Wenn Sie Spring Boot 2.x verwenden und die Kontextpfadeigenschaft in der Befehlszeile übergeben möchten, sollten Sie double // wie folgt einfügen:

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

Das hat bei mir in Windows funktioniert.

<!-- Server port-->

server.port=8080

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

server.servlet.context-path=/ems

Es muss sein: server.servlet.context-path = / demo Beachten Sie, dass es keine Anführungszeichen enthält, sondern nur den Wert, dem '/' vorangestellt ist. Dieser Wert wird in Ihre Datei application.properties aufgenommen

Der Kontextpfad kann direkt in den Code integriert werden, ist jedoch nicht ratsam, da er nicht wiederverwendet werden kann. Schreiben Sie daher in die Datei application.properties server.contextPath = / Name des Ordners, in dem Sie den Code platziert haben. contextPath = Name des Ordners, in dem Sie ihn platziert haben Code / Hinweis: Achten Sie sorgfältig auf den Schrägstrich.