Dodaj ścieżkę kontekstową do aplikacji Spring Boot

Próbuję programowo ustawić kontekstowy katalog główny aplikacji Spring Boot. Powodem istnienia kontekstowego katalogu głównego jest to, że chcemy, aby aplikacja była dostępna localhost:port/{app_name}i wszystkie ścieżki kontrolera były do ​​niej dołączone.

Oto plik konfiguracyjny aplikacji internetowej.

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

Oto kontroler indeksu dla strony głównej.

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

}

Nowy katalog główny aplikacji powinien znajdować się pod adresem localhost:12378/mainstay, ale nadal znajduje się pod adresem localhost:12378.

Czego mi brakuje, co powoduje, że Spring Boot nie dołącza kontekstowego katalogu głównego przed mapowaniem żądania?

Dlaczego próbujesz stworzyć własne rozwiązanie. Spring-boot już to obsługuje.

Jeśli jeszcze go nie masz, dodaj application.propertiesplik do src\main\resources. W tym pliku właściwości dodaj 2 właściwości:

server.contextPath=/mainstay
server.port=12378

UPDATE (Spring Boot 2.0)

Począwszy od Spring Boot 2.0 (ze względu na obsługę zarówno Spring MVC, jak i Spring WebFlux) contextPath, zmieniono na następujące:

server.servlet.contextPath=/mainstay

Następnie można usunąć konfigurację niestandardowego kontenera serwletów. Jeśli chcesz wykonać dodatkowe przetwarzanie na kontenerze, możesz dodać plikEmbeddedServletContainerCustomizer implementację do swojej konfiguracji (na przykład, aby dodać strony błędów).

Zasadniczo właściwości wewnątrz application.propertiesusługi jako domyślne możesz zawsze nadpisać, używając innego application.propertiesobok dostarczanego artefaktu lub dodając parametry maszyny JVM (-Dserver.port=6666 ).

Zobacz także Poradnik, zwłaszcza sekcję dotyczącą właściwości .

Klasa ServerPropertiesimplementuje EmbeddedServletContainerCustomizer. Wartość domyślna contextPathto "". W przykładowym kodzie ustawiasz contextPathbezpośrednio na TomcatEmbeddedServletContainerFactory. Następnie ServerPropertiesinstancja przetworzy tę instancję i zresetuje ją ze ścieżki do "". ( Ta linia robi nullczek ale jako domyślny jest ""zawsze niepowodzeniem i ustawić kontekst ""i zastępując swoje).

Jeśli używasz Spring Boot, nie musisz konfigurować właściwości serwera poprzez inicjalizację Vean.

Zamiast tego, jeśli jedna funkcjonalność jest dostępna dla podstawowej konfiguracji, można ją ustawić w pliku „właściwości” o nazwie application, który powinien znajdować się src\main\resourcesw strukturze aplikacji. Plik „właściwości” jest dostępny w dwóch formatach

1. .yml

2. .properties

Sposób określania lub ustawiania konfiguracji różni się w zależności od formatu.

W twoim konkretnym przypadku, jeśli zdecydujesz się użyć rozszerzenia .properties, będziesz miał plik o nazwie application.propertiesunder src\main\resourcesz następującymi ustawieniami konfiguracji

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

OTOH, jeśli zdecydujesz się na użycie .ymlrozszerzenia (tj. application.yml), Musisz ustawić konfiguracje w następującym formacie (tj. YAML):

server:
    port: 8080
    contextPath: /context-path

Aby uzyskać więcej typowych właściwości Spring Boot, skorzystaj z poniższego łącza:

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

Jeśli używasz Spring Boot 2.0.0, użyj:

server.servlet.context-path

pamiętaj, że właściwości "server.context-path" lub "server.servlet.context-path" [począwszy od springboot 2.0.x] będą działać tylko wtedy, gdy wdrażasz do kontenera osadzonego, np. embedded tomcat. Te właściwości nie przyniosą efektu, jeśli na przykład wdrażasz aplikację jako wojnę na zewnętrznym urządzeniu Tomcat.

zobacz tę odpowiedź tutaj: https://stackoverflow.com/a/43856300/4449859

Prawidłowe właściwości to

server.servlet.path

aby skonfigurować ścieżkę do DispatcherServlet

i

server.servlet.context-path

aby skonfigurować ścieżkę kontekstu aplikacji poniżej.

Możemy zmienić kontekstową ścieżkę główną za pomocą prostego wpisu w pliku właściwości.

application.properties

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

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

Możemy to ustawić w application.propertiesas API_CONTEXT_ROOT=/therootpath

Dostęp do niego uzyskujemy w klasie Java, jak wspomniano poniżej

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

server.contextPath = / mainstay

działa dla mnie, gdybym miał jeden plik wojenny w JBOSS. Wśród wielu plików wojennych, z których każdy zawierał jboss-web.xml, nie działał. Musiałem umieścić jboss-web.xml w katalogu WEB-INF z zawartością

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

Dodaj następującą właściwość w application.properties:

server.context-path=/demo

Uwaga: /demoto adres URL ścieżki kontekstowej.

Możesz to zrobić, dodając port i ścieżkę kontekstu, aby dodać konfigurację w pliku [src \ main \ resources] .properties, a także w pliku .yml

Konfiguracja pliku application.porperties

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

Konfiguracja pliku application.yml

server:
port: 8084
contextPath: /context-path

Możemy to również zmienić programowo podczas rozruchu wiosennego.

@Component
public class ServerPortCustomizer implements     WebServerFactoryCustomizer<EmbeddedServletContainerCustomizer > {

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

}

Możemy też dodać inny sposób

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

używając java command spring boot 1.X

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

używając java command spring boot 2.X

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

Jeśli używasz application.yml i wersji Spring powyżej 2.0, skonfiguruj w poniższy sposób.

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

Teraz całe wywołanie api będzie wyglądać następująco : http: // localhost: 8081 / demo-api /

Możemy to ustawić za pomocą WebServerFactoryCustomizer. Można to dodać bezpośrednio w głównej klasie metody rozruchu sprężyny, która uruchamia Spring ApplicationContext.

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

Jeśli używasz Spring Boot 2.x i chcesz przekazać właściwość ścieżki kontekstu w wierszu poleceń, powinieneś umieścić podwójne // w ten sposób:

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

To zadziałało w przypadku mnie w oknach.

<!-- Server port-->

server.port=8080

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

server.servlet.context-path=/ems

Musi to być: server.servlet.context-path = / demo uwaga, że ​​nie ma cudzysłowów, tylko wartość poprzedzona znakiem „/” ta wartość jest umieszczana w pliku application.properties

ścieżka kontekstu może być bezpośrednio zintegrowana z kodem, ale nie jest to zalecane, ponieważ nie można jej ponownie użyć, więc napisz w pliku application.properties server.contextPath = / nazwa folderu, w którym umieściłeś kod contextPath = nazwa folderu, w którym umieściłeś kod / Uwaga: uważnie obserwuj ukośnik.