Agregar ruta de contexto a la aplicación Spring Boot

Estoy tratando de establecer una raíz de contexto de aplicaciones Spring Boot mediante programación. El motivo de la raíz de contexto es que queremos que se acceda a la aplicación y que se agreguen localhost:port/{app_name}todas las rutas del controlador.

Aquí está el archivo de configuración de la aplicación para la aplicación 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;
  }
}

Aquí está el controlador de índice para la página principal.

@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 nueva raíz de la aplicación debe estar en localhost:12378/mainstay, pero todavía se encuentra en localhost:12378.

¿Qué me falta que hace que Spring Boot no agregue la raíz de contexto antes de la asignación de solicitud?

¿Por qué estás tratando de lanzar tu propia solución? Spring-boot ya es compatible con eso.

Si aún no tiene uno, agregue un application.propertiesarchivo a src\main\resources. En ese archivo de propiedades, agregue 2 propiedades:

server.contextPath=/mainstay
server.port=12378

ACTUALIZACIÓN (Spring Boot 2.0)

A partir de Spring Boot 2.0 (debido al soporte de Spring MVC y Spring WebFlux), contextPathse ha cambiado a lo siguiente:

server.servlet.contextPath=/mainstay

Luego puede eliminar su configuración para el contenedor de servlet personalizado. Si necesita realizar un procesamiento posterior en el contenedor, puede agregar una EmbeddedServletContainerCustomizerimplementación a su configuración (por ejemplo, para agregar las páginas de error).

Básicamente, las propiedades dentro del application.propertiesservidor son predeterminadas, siempre puede anularlas utilizando otro application.propertiesjunto al artefacto que entrega o agregando parámetros JVM ( -Dserver.port=6666).

Consulte también la Guía de referencia, especialmente la sección de propiedades .

La clase ServerPropertiesimplementa el EmbeddedServletContainerCustomizer. El valor predeterminado para contextPathes "". En su ejemplo de código, está configurando contextPathdirectamente en TomcatEmbeddedServletContainerFactory. A continuación, la ServerPropertiesinstancia procesará esta instancia y la restablecerá desde su ruta a "". ( Esta línea hace una nullcomprobación pero, como valor predeterminado "", siempre falla y establece el contexto ""y, por lo tanto, anula el tuyo).

Si está utilizando Spring Boot, entonces no tiene que configurar las propiedades del servidor a través de la inicialización de Vean.

En cambio, si hay una funcionalidad disponible para la configuración básica, se puede establecer en un archivo de "propiedades" llamado application, que debe residir src\main\resourcesen la estructura de su aplicación. El archivo de "propiedades" está disponible en dos formatos.

1. .yml

2. .properties

La forma en que especifica o establece las configuraciones difiere de un formato a otro.

En su caso específico, si decide usar la extensión .properties, entonces tendría un archivo llamado application.propertiesbajo src\main\resourcescon los siguientes ajustes de configuración

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

OTOH, si decide usar la .ymlextensión (es decir application.yml), necesitará establecer las configuraciones con el siguiente formato (es decir YAML):

server:
    port: 8080
    contextPath: /context-path

Para conocer las propiedades más comunes de Spring Boot, consulte el siguiente enlace:

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

Si usa Spring Boot 2.0.0 use:

server.servlet.context-path

tenga en cuenta que las propiedades "server.context-path" o "server.servlet.context-path" [a partir de springboot 2.0.x] solo funcionarán si está implementando en un contenedor incorporado, por ejemplo, Tomcat incorporado. Estas propiedades no tendrán efecto si está implementando su aplicación como una guerra a un gato externo, por ejemplo.

vea esta respuesta aquí: https://stackoverflow.com/a/43856300/4449859

Las propiedades correctas son

server.servlet.path

configurar la ruta del DispatcherServlet

y

server.servlet.context-path

para configurar la ruta del contexto de las aplicaciones debajo de eso.

Podemos cambiar la ruta raíz del contexto utilizando una entrada simple en el archivo de propiedades.

application.properties

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

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

Podemos configurarlo application.propertiescomo API_CONTEXT_ROOT=/therootpath

Y accedemos a él en la clase Java como se menciona a continuación

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

server.contextPath = / mainstay

funciona para mí si tuviera un archivo war en JBOSS. Entre los múltiples archivos war donde cada uno contiene jboss-web.xml no funcionó. Tuve que poner jboss-web.xml dentro del directorio WEB-INF con contenido

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

En Spring Boot 1.5:

Agregue la siguiente propiedad en application.properties:

server.context-path=/demo

Nota: /demoes su URL de ruta de contexto.

Puede hacerlo agregando el puerto y la ruta contextual fácilmente para agregar la configuración en el archivo [src \ main \ resources] .properties y también el archivo .yml

configuración del archivo application.porperties

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

configuración del archivo application.yml

server:
port: 8084
contextPath: /context-path

También podemos cambiarlo programáticamente en el arranque de primavera.

@Component
public class ServerPortCustomizer implements     WebServerFactoryCustomizer<EmbeddedServletContainerCustomizer > {

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

}

También podemos agregar otra forma

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

usando el comando java spring boot 1.X

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

usando el comando java spring boot 2.X

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

Si está utilizando application.yml y la versión de primavera anterior a 2.0, configure de la siguiente manera.

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

Ahora todas las llamadas a la API serán como http: // localhost: 8081 / demo-api /

Podemos configurarlo usando WebServerFactoryCustomizer. Esto se puede agregar directamente en la clase de método principal de inicio de Spring que inicia Spring ApplicationContext.

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

Si usa Spring Boot 2.xy desea pasar la propiedad de ruta de contexto en la línea de comando, debe poner doble // como este:

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

Eso funcionó para mí corriendo en Windows.

<!-- Server port-->

server.port=8080

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

server.servlet.context-path=/ems

Debe ser: server.servlet.context-path = / demo tenga en cuenta que no tiene comillas solo el valor precedido por '/' este valor va en su archivo application.properties

la ruta de contexto se puede integrar directamente al código, pero no es aconsejable, ya que no se puede reutilizar, así que escriba en el archivo application.properties server.contextPath = / name de la carpeta donde colocó el código contextPath = nombre de la carpeta donde colocó el código / Nota: mire la barra con cuidado.