Jak ustawić podstawowy adres URL do odpoczynku w wiosennym rozruchu?

Próbuję połączyć mvc i resztę w jednym projekcie buta sprężynowego.

Chcę ustawić ścieżkę bazową dla wszystkich pozostałych kontrolerów (np. Example.com/api) w jednym miejscu (nie chcę @RequestMapping('api/products')zamiast tego przypisywać do każdego kontrolera adnotacji po prostu @RequestMapping('/products').

Dostęp do kontrolerów MVC powinien być możliwy pod adresem example.com/cokolwiek

Czy to możliwe?

(Nie używam sprężynowej podpórki danych, tylko sprężynowe MVC)

W przypadku Spring Boot 1.2+ (<2.0) wystarczy jedna właściwość w application.properties:

spring.data.rest.basePath=/api

odnośnik: https://docs.spring.io/spring-data/rest/docs/current/reference/html/#getting-started.changing-base-uri

W przypadku wersji 2.x użyj

server.servlet.context-path=/api

Trochę późno, ale to samo pytanie przywiodło mnie tutaj, zanim dotarłem do odpowiedzi, więc zamieszczam je tutaj. Utwórz (jeśli nadal go nie masz) plik application.properties i dodaj

server.contextPath=/api

Więc w poprzednim przykładzie, jeśli masz RestController, @RequestMapping("/test")uzyskasz do niego dostęp jaklocalhost:8080/api/test/{your_rest_method}

źródło pytania: jak wybrać adres URL mojej aplikacji webowej rozruchowej wiosny

Do wersji szkieletowej do butów sprężynowych 2.0.4.RELEASE+. Dodaj tę linię doapplication.properties

server.servlet.context-path=/api

Ponieważ jest to pierwsze trafienie Google dotyczące problemu i zakładam, że więcej osób będzie tego szukało. Pojawiła się nowa opcja od wersji Spring Boot „1.4.0”. Można teraz zdefiniować niestandardowy RequestMappingHandlerMapping, który pozwala zdefiniować inną ścieżkę dla klas z adnotacją @RestController

Inną wersję z niestandardowymi adnotacjami, która łączy @RestController z @RequestMapping, można znaleźć w tym poście na blogu

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

Nie mogłem uwierzyć, jak skomplikowana jest odpowiedź na to pozornie proste pytanie. Oto kilka odniesień:

• Wiosenny bilet na JIRA
• Kolejne pytanie SO
• Jeszcze jedno SO pytanie
• Bardzo ładne GitRepository, które pokazuje problem

Należy wziąć pod uwagę wiele różnych kwestii:

1. Ustawiając server.context-path=/apiw application.properties, możesz skonfigurować prefiks dla wszystkiego (jego server.context-path, a nie server.contextPath!)
2. Kontrolery Spring Data z adnotacją @RepositoryRestController, które ujawniają repozytorium jako punkt końcowy reszty, będą używać zmiennej środowiskowej spring.data.rest.base-pathw application.properties. Ale zwykły @RestControllernie weźmie tego pod uwagę. Zgodnie z dokumentacją danych sprężynowych istnieje adnotacja @BasePathAwareController, której można użyć do tego. Ale mam problemy w związku z zabezpieczeniami Springa, kiedy próbuję zabezpieczyć taki kontroler. Już go nie znaleziono.

Innym obejściem jest prosta sztuczka. Nie możesz poprzedzić statycznego ciągu znaków w adnotacji, ale możesz użyć takich wyrażeń:

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

W przypadku Boot 2.0.0+ działa to dla mnie: server.servlet.context-path = / api

Znalazłem czyste rozwiązanie, które dotyczy tylko odpoczynku kontrolerów.

@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 zarejestruje dwa serwlety dyspozytorskie - domyślnie dispatcherServletdla kontrolerów i restApidyspozytora dla @RestControllerszdefiniowanych w 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 [/]

Przykład 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>

Ale nie jesteś ograniczony do :

• użyj XmlWebApplicationContext, możesz użyć dowolnego innego dostępnego typu kontekstu, tj. AnnotationConfigWebApplicationContext, GenericWebApplicationContext, GroovyWebApplicationContext, ...
• define jsonMessageConverter, messageConvertersfasola w kontekście spoczynku, mogą być zdefiniowane w kontekście nadrzędnym

Możesz utworzyć niestandardową adnotację dla swoich kontrolerów:

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

Użyj go zamiast zwykłego @RestController w klasach kontrolera i dodaj adnotacje za pomocą @RequestMapping.

Właśnie przetestowane - działa w Spring 4.2!

Mogę się trochę spóźnić, ALE ... Uważam, że to najlepsze rozwiązanie. Ustaw to w pliku application.yml (lub analogicznym pliku konfiguracyjnym):

spring:
    data:
        rest:
            basePath: /api

O ile pamiętam, to wszystko - wszystkie twoje repozytoria zostaną ujawnione pod tym identyfikatorem URI.

Spróbuj użyć PathMatchConfigurer (Spring Boot 2.x):

@Configuration
public class WebMvcConfig implements WebMvcConfigurer  {

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

Możesz utworzyć klasę bazową z @RequestMapping("rest")adnotacjami i rozszerzyć wszystkie inne klasy o tę klasę bazową.

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

Teraz wszystkie klasy, które rozszerzają tę klasę bazową, będą dostępne pod adresem rest/**.

Dla tych, którzy używają konfiguracji YAML (application.yaml).

Uwaga : to działa tylko dlaSpring Boot 2.x.x

server:
  servlet:
    contextPath: /api

Jeśli nadal używasz Spring Boot 1.x

server:
  contextPath: /api

W przypadku spring-boot 2.x możesz skonfigurować w application.properties:

spring.mvc.servlet.path=/api

server.servlet.context-path=/apibyłoby rozwiązaniem, jak sądzę. Miałem ten sam problem i to mnie rozwiązało. Użyłem server.context-path. Wydawało się jednak, że jest to przestarzałe i stwierdziłem, że server.servlet.context-pathteraz rozwiązuje problem. Innym rozwiązaniem, które znalazłem, było dodanie tagu podstawowego do moich stron w interfejsie (H5). Mam nadzieję, że to komuś pomoże.

Twoje zdrowie

To rozwiązanie ma zastosowanie, jeśli:

1. Chcesz przedrostek, RestControllerale nie Controller.

2. Nie używasz 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);
       }
   }

   }

Jest to podobne do rozwiązania opublikowanego przez mh-dev, ale myślę, że jest trochę czystsze i powinno być obsługiwane w każdej wersji Spring Boot 1.4.0+, w tym 2.0.0+.

Zgodnie z dokumentami REST Spring Data , jeśli używasz application.properties , użyj tej właściwości, aby ustawić ścieżkę podstawową:

spring.data.rest.basePath=/api

Pamiętaj jednak, że Spring używa luźnego wiązania , więc można użyć tej odmiany:

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

... lub ten, jeśli wolisz:

spring.data.rest.base_path=/api

Jeśli używasz application.yml , użyjesz dwukropków jako separatorów kluczy:

spring:
  data:
    rest:
      basePath: /api

(Dla porównania, powiązany bilet został utworzony w marcu 2018 r., Aby wyjaśnić dokumenty.)

działał server.contextPath = / path

Możesz utworzyć niestandardową adnotację dla swoich kontrolerów:

Użyj go zamiast zwykłego @RestController w klasach kontrolera i dodaj adnotacje za pomocą @RequestMapping.

Działa dobrze na wiosnę 4.2!