Agregar ruta de contexto a la aplicación Spring Boot


174

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?

Respuestas:


382

¿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 bien su respuesta es correcta (quiero decir, puede personalizar las propiedades del contenedor de servlets mediante el archivo de propiedades de la aplicación), ¿por qué hay un método setContextPath (ruta), es decir, si la ruta no se aplica, ¿para qué sirve? Por cierto, lo mismo ocurre con el setContextPath (...) en el EmbeddedServletContainerCustomizer
Modi

2
Yo esperaría que el de EmbeddedServletContainerCustomizertambién funcione. Pero me gustaría ir a lo que se proporciona en lugar de tratar de escapar por su cuenta. La razón por la cual su solución no funciona tiene que ver con el comportamiento predeterminado programado (¿accidentalmente?) En ServerProperties, el predeterminado configurado contextPathes ""(y lo comprueba nully no "". Este último anula su configuración explícita contextPath.
M. Deinum

Las propiedades han cambiado, vea mi respuesta a continuación.
Michael Simons

55
Supongo que la propiedad en Spring Boot 2.0 es "server.servlet.context-path"
IamVickyAV

34

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


22

Si usa Spring Boot 2.0.0 use:

server.servlet.context-path

2
esto no funciona para archivos de guerra implementados en tomcat externo
pise

1
Para mí esto no funcionó (Spring Boot 2.1.2), pero funcionó:server.servlet.contextPath=/api
lospejos

2
@pise, ¿sabías cómo solucionarlo para el archivo war en tomcat externo?
mohax

11

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


¿Alguien ha descubierto cómo configurar esto cuando se implementa en un tomcat externo como wararchivo usando springboot v2.xy tomcat v8.5?
Solución simple el

@abdel incluso estoy buscando la respuesta, ¿qué pasa si estamos implementando el archivo war en tomcat externo? ¿Cómo establecer la ruta de contexto?
pise

Lo estaba probando. Es exactamente como se dijo en el enlace de arriba. Cambie el valor de atributo build -> finalName a su ruta de contexto. El archivo war resultante utilizará la ruta de contexto como nombre de archivo, que luego será utilizado por tomcat para servir como ruta de contexto.
DriLLFreAK100

La única forma en que puedo pensar para desplegarme como guerra en tomcat externo es asegurando que el nombre de guerra coincida con el contexto que estás buscando. así, por ejemplo, si quieres que el contexto sea '/ xyzwebapp', entonces tu guerra debe llamarse xyzwebapp.war. Para lograr esto, puede agregar lo siguiente al elemento <build> en su pom.xml: <finalName> xyzwebapp </finalName>.
abdel

9

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.


Muchas gracias
hema chandra

2

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

1

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;

1

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>

1

En Spring Boot 1.5:

Agregue la siguiente propiedad en application.properties:

server.context-path=/demo

Nota: /demoes su URL de ruta de contexto.


1

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 

también podemos agregar el puerto del servidor mediante programación
Ghulam Murtaza


0

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

0

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.


0
<!-- Server port-->

server.port=8080

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

server.servlet.context-path=/ems

El puerto del servidor será 8080. si desea cualquier otro puerto, puede reemplazar el 8080. Para la ruta de contexto de la aplicación, he configurado ems. Puede establecer otro camino según sus requisitos
Bordoloi Parth

1
Esa es información útil, ¿por qué no la agrega a su respuesta en lugar de un comentario?
k-den

0

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


-1

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.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.