¿Cómo configurar la URL base para descansar en Spring Boot?

Estoy tratando de mezclar mvc y descansar en un solo proyecto de arranque de primavera.

Quiero establecer la ruta base para todos los controladores de descanso (por ejemplo, example.com/api) en un solo lugar (no quiero anotar cada controlador con @RequestMapping('api/products'), en su lugar, solo @RequestMapping('/products').

Se debe poder acceder a los controladores MVC mediante example.com/whatever

¿Es posible?

(No uso el descanso de datos de primavera, solo mvc de primavera)

Con Spring Boot 1.2+ (<2.0), todo lo que se necesita es una propiedad única en application.properties:

spring.data.rest.basePath=/api

enlace de referencia: https://docs.spring.io/spring-data/rest/docs/current/reference/html/#getting-started.changing-base-uri

Para 2.x, utilice

server.servlet.context-path=/api

Un poco tarde, pero la misma pregunta me trajo aquí antes de llegar a la respuesta, así que la publico aquí. Crea (si aún no lo tienes) un application.properties y agrega

server.contextPath=/api

Entonces, en el ejemplo anterior, si tiene un RestController @RequestMapping("/test"), accederá a él comolocalhost:8080/api/test/{your_rest_method}

fuente de la pregunta: ¿cómo elijo la URL para mi aplicación web de arranque de primavera?

Para la versión de marco de arranque de primavera 2.0.4.RELEASE+. Agregar esta línea aapplication.properties

server.servlet.context-path=/api

Dado que este es el primer resultado de Google para el problema, supongo que más personas buscarán esto. Hay una nueva opción desde Spring Boot '1.4.0'. Ahora es posible definir un RequestMappingHandlerMapping personalizado que permite definir una ruta diferente para las clases anotadas con @RestController

En esta publicación del blog se puede encontrar una versión diferente con anotaciones personalizadas que combina @RestController con @RequestMapping

@Configuration
public class WebConfig {

    @Bean
    public WebMvcRegistrationsAdapter webMvcRegistrationsHandlerMapping() {
        return new WebMvcRegistrationsAdapter() {
            @Override
            public RequestMappingHandlerMapping getRequestMappingHandlerMapping() {
                return new RequestMappingHandlerMapping() {
                    private final static String API_BASE_PATH = "api";

                    @Override
                    protected void registerHandlerMethod(Object handler, Method method, RequestMappingInfo mapping) {
                        Class<?> beanType = method.getDeclaringClass();
                        if (AnnotationUtils.findAnnotation(beanType, RestController.class) != null) {
                            PatternsRequestCondition apiPattern = new PatternsRequestCondition(API_BASE_PATH)
                                    .combine(mapping.getPatternsCondition());

                            mapping = new RequestMappingInfo(mapping.getName(), apiPattern,
                                    mapping.getMethodsCondition(), mapping.getParamsCondition(),
                                    mapping.getHeadersCondition(), mapping.getConsumesCondition(),
                                    mapping.getProducesCondition(), mapping.getCustomCondition());
                        }

                        super.registerHandlerMethod(handler, method, mapping);
                    }
                };
            }
        };
    }
}

No podía creer lo complicada que es la respuesta a esta pregunta aparentemente simple. A continuación se muestran algunas referencias:

• Entrada Primavera JIRA
• Otra pregunta SO
• Sin embargo, otra pregunta SO
• Muy buen GitRepository que muestra el problema

Hay muchas cosas diferentes a considerar:

1. Al establecer server.context-path=/apien el application.propertiesque puede configurar un prefijo para todo . (Su-server.context camino no server.contextPath!)
2. Los controladores de Spring Data anotados con @RepositoryRestController que exponen un repositorio como punto final de descanso usarán la variable de entorno spring.data.rest.base-pathen application.properties. Pero plain @RestControllerno tendrá esto en cuenta. De acuerdo con la documentación del resto de datos de primavera, hay una anotación @BasePathAwareControllerque puede usar para eso. Pero tengo problemas en relación con Spring-security cuando trato de asegurar dicho controlador. Ya no se encuentra.

Otra solución es un truco simple. No puede prefijar una cadena estática en una anotación, pero puede usar expresiones como esta:

@RestController
public class PingController {

  /**
   * Simple is alive test
   * @return <pre>{"Hello":"World"}</pre>
   */
  @RequestMapping("${spring.data.rest.base-path}/_ping")
  public String isAlive() {
    return "{\"Hello\":\"World\"}";
  }
}

Para Boot 2.0.0+ esto me funciona: server.servlet.context-path = / api

Encontré una solución limpia, que afecta solo a los controladores de reposo.

@SpringBootApplication
public class WebApp extends SpringBootServletInitializer {

    @Autowired
    private ApplicationContext context;

    @Bean
    public ServletRegistrationBean restApi() {
        XmlWebApplicationContext applicationContext = new XmlWebApplicationContext();
        applicationContext.setParent(context);
        applicationContext.setConfigLocation("classpath:/META-INF/rest.xml");

        DispatcherServlet dispatcherServlet = new DispatcherServlet();
        dispatcherServlet.setApplicationContext(applicationContext);

        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(dispatcherServlet, "/rest/*");
        servletRegistrationBean.setName("restApi");

        return servletRegistrationBean;
    }

    static public void main(String[] args) throws Exception {
        SpringApplication.run(WebApp.class,args);
    }
}

Spring boot registrará dos servlets de despachador - predeterminado dispatcherServletpara controladores y restApidespachador para @RestControllersdefinido en rest.xml:

2016-06-07 09:06:16.205  INFO 17270 --- [           main] o.s.b.c.e.ServletRegistrationBean        : Mapping servlet: 'restApi' to [/rest/*]
2016-06-07 09:06:16.206  INFO 17270 --- [           main] o.s.b.c.e.ServletRegistrationBean        : Mapping servlet: 'dispatcherServlet' to [/]

El ejemplo rest.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
  http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
  http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

    <context:component-scan base-package="org.example.web.rest"/>
    <mvc:annotation-driven/>

    <!-- Configure to plugin JSON as request and response in method handler -->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <ref bean="jsonMessageConverter"/>
            </list>
        </property>
    </bean>

    <!-- Configure bean to convert JSON to POJO and vice versa -->
    <bean id="jsonMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
    </bean>
</beans>

Pero no estás limitado a :

• utilizar XmlWebApplicationContext, puede utilizar cualquier otro tipo de contexto disponible, es decir. AnnotationConfigWebApplicationContext, GenericWebApplicationContext, GroovyWebApplicationContext, ...
• definir jsonMessageConverter, messageConvertersfrijoles en contexto de reposo, se pueden definir en contexto padre

Puede crear una anotación personalizada para sus controladores:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@RestController
@RequestMapping("/test")
public @interface MyRestController {
}

Úselo en lugar del @RestController habitual en sus clases de controlador y anote métodos con @RequestMapping.

Recién probado, ¡funciona en Spring 4.2!

Puede que llegue un poco tarde, PERO ... creo que es la mejor solución. Configúrelo en su application.yml (o archivo de configuración analógica):

spring:
    data:
        rest:
            basePath: /api

Como puedo recordar, eso es todo: todos sus repositorios estarán expuestos debajo de este URI.

Intente utilizar PathMatchConfigurer (Spring Boot 2.x):

@Configuration
public class WebMvcConfig implements WebMvcConfigurer  {

    @Override
    public void configurePathMatch(PathMatchConfigurer configurer) {
        configurer.addPathPrefix("api", HandlerTypePredicate.forAnnotation(RestController.class));
    }
}

Puede crear una clase base con @RequestMapping("rest")anotaciones y ampliar todas las demás clases con esta clase base.

@RequestMapping("rest")
public abstract class BaseController {}

Ahora se podrá acceder a todas las clases que amplíen esta clase base en rest/**.

Para aquellos que usan la configuración YAML (application.yaml).

Nota : esto solo funciona paraSpring Boot 2.x.x

server:
  servlet:
    contextPath: /api

Si todavía está usando Spring Boot 1.x

server:
  contextPath: /api

Con spring-boot 2.x puede configurar en application.properties:

spring.mvc.servlet.path=/api

server.servlet.context-path=/apisería la solución, supongo. Tuve el mismo problema y esto me resolvió. Usé server.context-path. Sin embargo, eso parecía estar desaprobado y descubrí que server.servlet.context-pathahora resuelve el problema. Otra solución que encontré fue agregar una etiqueta base a mis páginas frontales (H5). Espero que esto ayude a alguien.

Salud

Esta solución se aplica si:

1. Quiere prefijar RestControllerpero no Controller.

2. No está utilizando Spring Data Rest.

   @Configuration
   public class WebConfig extends WebMvcConfigurationSupport {
   
   @Override
   protected RequestMappingHandlerMapping createRequestMappingHandlerMapping() {
       return new ApiAwareRequestMappingHandlerMapping();
   }
   
   private static class ApiAwareRequestMappingHandlerMapping extends RequestMappingHandlerMapping {
   
       private static final String API_PATH_PREFIX = "api";
   
       @Override
       protected void registerHandlerMethod(Object handler, Method method, RequestMappingInfo mapping) {
           Class<?> beanType = method.getDeclaringClass();
           if (AnnotationUtils.findAnnotation(beanType, RestController.class) != null) {
               PatternsRequestCondition apiPattern = new PatternsRequestCondition(API_PATH_PREFIX)
                       .combine(mapping.getPatternsCondition());
   
               mapping = new RequestMappingInfo(mapping.getName(), apiPattern, mapping.getMethodsCondition(),
                       mapping.getParamsCondition(), mapping.getHeadersCondition(), mapping.getConsumesCondition(),
                       mapping.getProducesCondition(), mapping.getCustomCondition());
           }
           super.registerHandlerMethod(handler, method, mapping);
       }
   }

   }

Esto es similar a la solución publicada por mh-dev, pero creo que es un poco más limpia y debería ser compatible con cualquier versión de Spring Boot 1.4.0+, incluida la 2.0.0+.

Según los documentos REST de Spring Data , si usa application.properties , use esta propiedad para establecer su ruta base:

spring.data.rest.basePath=/api

Pero tenga en cuenta que Spring usa un enlace relajado , por lo que esta variación se puede usar:

spring.data.rest.base-path=/api

... o este si lo prefieres:

spring.data.rest.base_path=/api

Si usa application.yml , usaría dos puntos para los separadores de clave:

spring:
  data:
    rest:
      basePath: /api

(Como referencia, se creó un ticket relacionado en marzo de 2018 para aclarar los documentos).

funcionó server.contextPath = / ruta

Puede crear una anotación personalizada para sus controladores:

Úselo en lugar del @RestController habitual en sus clases de controlador y anote métodos con @RequestMapping.

¡Funciona bien en Spring 4.2!