Come impostare l'URL di base per il riposo durante l'avvio primaverile?

Sto cercando di mescolare mvc e rest in un unico progetto di avvio a molla.

Voglio impostare il percorso di base per tutti i controller rest (es. Example.com/api) in un unico posto (non voglio annotare ogni controller con @RequestMapping('api/products'), invece, solo @RequestMapping('/products').

I controller Mvc dovrebbero essere accessibili da example.com/wunque

È possibile?

(Non uso il resto dei dati della molla, solo il mvc della molla)

Con Spring Boot 1.2+ (<2.0) tutto ciò che serve è una singola proprietà in application.properties:

spring.data.rest.basePath=/api

link di riferimento: https://docs.spring.io/spring-data/rest/docs/current/reference/html/#getting-started.changing-base-uri

Per 2.x, usa

server.servlet.context-path=/api

Un po 'tardi ma la stessa domanda mi ha portato qui prima di arrivare alla risposta, quindi la posto qui. Crea (se ancora non ce l'hai) un application.properties e aggiungi

server.contextPath=/api

Quindi nell'esempio precedente, se hai un RestController con, @RequestMapping("/test")lo accederai comelocalhost:8080/api/test/{your_rest_method}

fonte della domanda: come faccio a scegliere l'URL per la mia webapp di avvio primaverile

Per la versione del framework di avvio a molla 2.0.4.RELEASE+. Aggiungi questa riga aapplication.properties

server.servlet.context-path=/api

Poiché questo è il primo risultato di Google per il problema e presumo che più persone lo cercheranno. C'è una nuova opzione da Spring Boot "1.4.0". È ora possibile definire un RequestMappingHandlerMapping personalizzato che consente di definire un percorso diverso per le classi annotate con @RestController

Una versione diversa con annotazioni personalizzate che combina @RestController con @RequestMapping può essere trovata in questo post del 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);
                    }
                };
            }
        };
    }
}

Non potevo credere quanto fosse complicata la risposta a questa domanda apparentemente semplice. Ecco alcuni riferimenti:

• Biglietto JIRA di primavera
• Un'altra domanda SO
• Ancora un'altra domanda SO
• GitRepository molto carino che mostra il problema

Ci sono molte cose diverse da considerare:

1. Impostando server.context-path=/apiin application.propertiespuoi configurare un prefisso per tutto (il suo percorso server.context non server.contextPath!)
2. I controller Spring Data annotati con @RepositoryRestController che espongono un repository come endpoint rest utilizzeranno la variabile di ambiente spring.data.rest.base-pathin application.properties. Ma plain @RestControllernon ne terrà conto. Secondo la documentazione relativa ai dati di primavera, esiste un'annotazione @BasePathAwareControllerche puoi utilizzare per questo. Ma ho problemi con Spring-security quando cerco di proteggere un controller di questo tipo. Non si trova più.

Un'altra soluzione alternativa è un semplice trucco. Non è possibile aggiungere un prefisso a una stringa statica in un'annotazione, ma è possibile utilizzare espressioni come questa:

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

Per Boot 2.0.0+ questo funziona per me: server.servlet.context-path = / api

Ho trovato una soluzione pulita, che riguarda solo i controller di riposo.

@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 registrerà due servlet del dispatcher: predefinito dispatcherServletper i controller e restApidispatcher per @RestControllersdefinito in 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'esempio 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>

Ma non sei limitato a :

• use XmlWebApplicationContext, puoi utilizzare qualsiasi altro tipo di contesto disponibile, ad es. AnnotationConfigWebApplicationContext, GenericWebApplicationContext, GroovyWebApplicationContext, ...
• definire jsonMessageConverter, i messageConvertersfagioli nel contesto di riposo, possono essere definiti nel contesto genitore

Puoi creare un'annotazione personalizzata per i tuoi controller:

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

Usalo invece del solito @RestController sulle classi del tuo controller e annota i metodi con @RequestMapping.

Appena testato - funziona nella primavera 4.2!

Potrei essere un po 'in ritardo, MA ... credo che sia la soluzione migliore. Impostalo nel tuo application.yml (o file di configurazione analogico):

spring:
    data:
        rest:
            basePath: /api

Come posso ricordare, è tutto: tutti i tuoi repository saranno esposti sotto questo URI.

Prova a utilizzare PathMatchConfigurer (Spring Boot 2.x):

@Configuration
public class WebMvcConfig implements WebMvcConfigurer  {

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

Puoi creare una classe base con @RequestMapping("rest")annotazioni ed estendere tutte le altre classi con questa classe base.

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

Ora tutte le classi che estendono questa classe base saranno accessibili in rest/**.

Per coloro che utilizzano la configurazione YAML (application.yaml).

Nota : funziona solo perSpring Boot 2.x.x

server:
  servlet:
    contextPath: /api

Se stai ancora utilizzando Spring Boot 1.x

server:
  contextPath: /api

Con spring-boot 2.x puoi configurare in application.properties:

spring.mvc.servlet.path=/api

server.servlet.context-path=/apisarebbe la soluzione immagino. Ho avuto lo stesso problema e questo mi ha risolto. Ho usato server.context-path. Tuttavia, sembrava essere deprecato e ho scoperto che server.servlet.context-pathora risolve il problema. Un'altra soluzione alternativa che ho trovato è stata l'aggiunta di un tag di base alle mie pagine front-end (H5). Spero che questo aiuti qualcuno là fuori.

Saluti

Questa soluzione si applica se:

1. Vuoi aggiungere un prefisso RestControllerma non Controller.

2. Non stai utilizzando 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);
       }
   }

   }

È simile alla soluzione pubblicata da mh-dev, ma penso che sia un po 'più pulita e dovrebbe essere supportata su qualsiasi versione di Spring Boot 1.4.0+, inclusa la 2.0.0+.

Secondo i documenti REST di Spring Data , se si utilizza application.properties , utilizzare questa proprietà per impostare il percorso di base:

spring.data.rest.basePath=/api

Ma nota che Spring utilizza legature rilassate , quindi questa variazione può essere utilizzata:

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

... o questo se preferisci:

spring.data.rest.base_path=/api

Se usi application.yml , dovresti usare i due punti per i separatori di chiavi:

spring:
  data:
    rest:
      basePath: /api

(Per riferimento, un ticket correlato è stato creato nel marzo 2018 per chiarire i documenti.)

ha funzionato server.contextPath = / percorso

Puoi creare un'annotazione personalizzata per i tuoi controller:

Usalo invece del solito @RestController sulle classi del tuo controller e annota i metodi con @RequestMapping.

Funziona bene nella primavera 4.2!