Comment définir l'URL de base pour le repos dans Spring Boot?

J'essaie de mélanger mvc et me reposer dans un seul projet de démarrage à ressort.

Je veux définir le chemin de base pour tous les contrôleurs de repos (par exemple, example.com/api) en un seul endroit (je ne veux pas annoter chaque contrôleur avec @RequestMapping('api/products'), à la place, juste @RequestMapping('/products').

Les contrôleurs MVC doivent être accessibles par example.com/whatever

C'est possible?

(Je n'utilise pas de repos de données à ressort, juste à ressort mvc)

Avec Spring Boot 1.2+ (<2.0), il suffit d'une seule propriété dans application.properties:

spring.data.rest.basePath=/api

lien de référence: https://docs.spring.io/spring-data/rest/docs/current/reference/html/#getting-started.changing-base-uri

Pour 2.x, utilisez

server.servlet.context-path=/api

Un peu tard mais la même question m'a amené ici avant d'arriver à la réponse alors je la poste ici. Créez (si vous ne l'avez toujours pas) une application.properties et ajoutez

server.contextPath=/api

Donc, dans l'exemple précédent, si vous avez un RestController, @RequestMapping("/test")vous y accéderez commelocalhost:8080/api/test/{your_rest_method}

source de la question: comment choisir l'URL de mon application Web Spring Boot

Pour la version du framework Spring Boot 2.0.4.RELEASE+. Ajouter cette ligne àapplication.properties

server.servlet.context-path=/api

Comme il s'agit du premier hit google pour le problème et je suppose que plus de gens le rechercheront. Il existe une nouvelle option depuis Spring Boot '1.4.0'. Il est désormais possible de définir un RequestMappingHandlerMapping personnalisé qui permet de définir un chemin différent pour les classes annotées avec @RestController

Une version différente avec des annotations personnalisées qui combine @RestController avec @RequestMapping peut être trouvée dans ce billet de 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);
                    }
                };
            }
        };
    }
}

Je ne pouvais pas croire à quel point la réponse à cette question apparemment simple est compliquée. Voici quelques références:

• Billet printemps JIRA
• Une autre question SO
• Encore une autre question SO
• Très beau GitRepository qui présente le problème

Il y a beaucoup de choses différentes à considérer:

1. En définissant server.context-path=/apidans, application.propertiesvous pouvez configurer un préfixe pour tout (son chemin server.context et non server.contextPath!)
2. Les contrôleurs Spring Data annotés avec @RepositoryRestController qui exposent un référentiel en tant que point de terminaison de repos utiliseront la variable d'environnement spring.data.rest.base-pathdans application.properties. Mais tout simplement @RestControllerne prendra pas cela en compte. Selon la documentation du repos de données de printemps, il existe une annotation @BasePathAwareControllerque vous pouvez utiliser pour cela. Mais j'ai des problèmes avec Spring-security lorsque j'essaye de sécuriser un tel contrôleur. On ne le trouve plus.

Une autre solution de contournement est une astuce simple. Vous ne pouvez pas préfixer une chaîne statique dans une annotation, mais vous pouvez utiliser des expressions comme celle-ci:

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

Pour Boot 2.0.0+, cela fonctionne pour moi: server.servlet.context-path = / api

J'ai trouvé une solution propre, qui n'affecte que les contrôleurs de repos.

@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 enregistrera deux servlets de dispatcher - par défaut dispatcherServletpour les contrôleurs, et restApidispatcher pour @RestControllersdéfini dans 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 [/]

L'exemple 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>

Mais, vous n'êtes pas limité à :

• use XmlWebApplicationContext, vous pouvez utiliser tout autre type de contexte disponible, ie. AnnotationConfigWebApplicationContext, GenericWebApplicationContext, GroovyWebApplicationContext, ...
• définir jsonMessageConverter, les messageConvertersbeans en contexte de repos, ils peuvent être définis dans le contexte parent

Vous pouvez créer une annotation personnalisée pour vos contrôleurs:

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

Utilisez-le à la place du @RestController habituel sur vos classes de contrôleur et annotez les méthodes avec @RequestMapping.

Juste testé - fonctionne au printemps 4.2!

Je suis peut-être un peu en retard, MAIS ... je pense que c'est la meilleure solution. Configurez-le dans votre application.yml (ou fichier de configuration analogique):

spring:
    data:
        rest:
            basePath: /api

Si je me souviens bien, c'est tout - tous vos référentiels seront exposés sous cet URI.

Essayez d'utiliser un PathMatchConfigurer (Spring Boot 2.x):

@Configuration
public class WebMvcConfig implements WebMvcConfigurer  {

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

Vous pouvez créer une classe de base avec des @RequestMapping("rest")annotations et étendre toutes vos autres classes avec cette classe de base.

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

Désormais, toutes les classes qui étendent cette classe de base seront accessibles sur rest/**.

Pour ceux qui utilisent la configuration YAML (application.yaml).

Remarque : cela ne fonctionne que pourSpring Boot 2.x.x

server:
  servlet:
    contextPath: /api

Si vous utilisez toujours Spring Boot 1.x

server:
  contextPath: /api

Avec spring-boot 2.x, vous pouvez configurer dans application.properties:

spring.mvc.servlet.path=/api

server.servlet.context-path=/apiserait la solution je suppose. J'ai eu le même problème et cela m'a résolu. J'ai utilisé server.context-path. Cependant, cela semblait être obsolète et j'ai trouvé que cela server.servlet.context-pathrésout le problème maintenant. Une autre solution de contournement que j'ai trouvée a été d'ajouter une balise de base à mes pages frontales (H5). J'espère que cela aide quelqu'un là-bas.

À votre santé

Cette solution s'applique si:

1. Vous voulez préfixer RestControllermais pas Controller.

2. Vous n'utilisez pas 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);
       }
   }

   }

Ceci est similaire à la solution publiée par mh-dev, mais je pense que c'est un peu plus propre et que cela devrait être pris en charge sur n'importe quelle version de Spring Boot 1.4.0+, y compris 2.0.0+.

Par documentation REST Spring Data , si vous utilisez application.properties , utilisez cette propriété pour définir votre chemin de base:

spring.data.rest.basePath=/api

Mais notez que Spring utilise une reliure détendue , donc cette variante peut être utilisée:

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

... ou celui-ci si vous préférez:

spring.data.rest.base_path=/api

Si vous utilisez application.yml , vous utiliseriez deux points pour les séparateurs de clé:

spring:
  data:
    rest:
      basePath: /api

(Pour référence, un ticket associé a été créé en mars 2018 pour clarifier les documents.)

a travaillé server.contextPath = / chemin

Vous pouvez créer une annotation personnalisée pour vos contrôleurs:

Utilisez-le à la place du @RestController habituel sur vos classes de contrôleur et annotez les méthodes avec @RequestMapping.

Fonctionne bien au printemps 4.2!