Como definir o url básico para descanso na bota primavera

Estou tentando misturar mvc e descanso em um único projeto de inicialização de mola.

Quero definir o caminho base para todos os controladores de resto (por exemplo, example.com/api) em um único lugar (não quero anotar cada controlador @RequestMapping('api/products'), em vez disso, apenas @RequestMapping('/products').

Os controladores Mvc devem ser acessados ​​por example.com/whatever

É possível?

(Eu não uso o descanso de dados da primavera, apenas o mvc da primavera)

Com Spring Boot 1.2+ (<2.0), tudo o que é necessário é uma única propriedade em application.properties:

spring.data.rest.basePath=/api

link de referência: https://docs.spring.io/spring-data/rest/docs/current/reference/html/#getting-started.changing-base-uri

Para 2.x, use

server.servlet.context-path=/api

Um pouco tarde, mas a mesma pergunta me trouxe aqui antes de chegar a resposta, então eu a posto aqui. Crie (se ainda não tiver) um application.properties e adicione

server.contextPath=/api

Então, no exemplo anterior, se você tiver um RestController com @RequestMapping("/test")você irá acessá-lo comolocalhost:8080/api/test/{your_rest_method}

fonte da pergunta: como faço para escolher o url para meu webapp de boot do Spring

Para a versão do framework de boot de primavera 2.0.4.RELEASE+. Adicione esta linha aapplication.properties

server.servlet.context-path=/api

Uma vez que esta é a primeira resposta do Google para o problema e presumo que mais pessoas pesquisarão por isso. Existe uma nova opção desde o Spring Boot '1.4.0'. Agora é possível definir um RequestMappingHandlerMapping personalizado que permite definir um caminho diferente para as classes anotadas com @RestController

Uma versão diferente com anotações personalizadas que combina @RestController com @RequestMapping pode ser encontrada nesta postagem do blog

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

Eu não conseguia acreditar como a resposta a esta pergunta aparentemente simples é complicada. Aqui estão algumas referências:

• Ingresso Spring JIRA
• Outra pergunta SO
• Ainda outra pergunta SO
• GitRepository muito bom que mostra o problema

Existem muitas coisas diferentes a serem consideradas:

1. Ao definir server.context-path=/apiem, application.propertiesvocê pode configurar um prefixo para tudo . (Seu server.context-path não server.contextPath!)
2. Controladores Spring Data anotados com @RepositoryRestController que expõem um repositório como ponto final de descanso usarão a variável de ambiente spring.data.rest.base-pathem application.properties. Mas o plain @RestControllernão vai levar isso em conta. De acordo com a documentação do Spring Data Rest, há uma anotação @BasePathAwareControllerque você pode usar para isso. Mas eu tenho problemas em conexão com o Spring-security quando tento proteger esse controlador. Não foi mais encontrado.

Outra solução alternativa é um truque simples. Você não pode prefixar uma String estática em uma anotação, mas pode usar expressões 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+ isso funciona para mim: server.servlet.context-path = / api

Eu encontrei uma solução limpa, que afeta apenas os controladores de descanso.

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

O Spring boot registrará dois servlets dispatcher - padrão dispatcherServletpara controladores e restApidispatcher para @RestControllersdefinidos em 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 [/]

O exemplo 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>

Mas você não está limitado a :

• usar XmlWebApplicationContext, você pode usar qualquer outro tipo de contexto disponível, ou seja, AnnotationConfigWebApplicationContext, GenericWebApplicationContext, GroovyWebApplicationContext, ...
• definir jsonMessageConverter, messageConvertersfeijão no contexto de repouso, eles podem ser definidos no contexto pai

Você pode criar uma anotação personalizada para seus controladores:

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

Use-o em vez do @RestController usual em suas classes de controlador e anote métodos com @RequestMapping.

Acabei de testar - funciona no Spring 4.2!

Posso chegar um pouco tarde, MAS ... acredito que seja a melhor solução. Configure-o em seu application.yml (ou arquivo de configuração analógico):

spring:
    data:
        rest:
            basePath: /api

Como posso me lembrar, é isso - todos os seus repositórios serão expostos abaixo deste URI.

Tente usar um PathMatchConfigurer (Spring Boot 2.x):

@Configuration
public class WebMvcConfig implements WebMvcConfigurer  {

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

Você pode criar uma classe base com @RequestMapping("rest")anotações e estender todas as outras classes com esta classe base.

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

Agora, todas as classes que estendem esta classe base estarão acessíveis em rest/**.

Para quem usa a configuração YAML (application.yaml).

Nota : isso funciona apenas paraSpring Boot 2.x.x

server:
  servlet:
    contextPath: /api

Se você ainda está usando Spring Boot 1.x

server:
  contextPath: /api

Com o spring-boot 2.x você pode configurar em application.properties:

spring.mvc.servlet.path=/api

server.servlet.context-path=/apiseria a solução, eu acho. Eu tive o mesmo problema e isso me resolveu. Eu usei server.context-path. No entanto, parecia estar obsoleto e descobri que server.servlet.context-pathagora resolve o problema. Outra solução alternativa que encontrei foi adicionar uma tag base às minhas páginas de front end (H5). Eu espero que isto ajude alguém lá fora.

Felicidades

Esta solução se aplica se:

1. Você quer prefixar, RestControllermas não Controller.

2. Você não está usando 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);
       }
   }

   }

Isso é semelhante à solução postada por mh-dev, mas acho que é um pouco mais limpo e deve ser compatível com qualquer versão do Spring Boot 1.4.0+, incluindo 2.0.0+.

De acordo com os documentos REST do Spring Data , se estiver usando application.properties , use esta propriedade para definir seu caminho base:

spring.data.rest.basePath=/api

Mas observe que o Spring usa ligação relaxada , então esta variação pode ser usada:

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

... ou este se preferir:

spring.data.rest.base_path=/api

Se usar application.yml , você usaria dois pontos para separadores de chave:

spring:
  data:
    rest:
      basePath: /api

(Para referência, um tíquete relacionado foi criado em março de 2018 para esclarecer os documentos.)

funcionou server.contextPath = / path

Você pode criar uma anotação personalizada para seus controladores:

Use-o em vez do @RestController usual em suas classes de controlador e anote métodos com @RequestMapping.

Funciona bem no Spring 4.2!