web-dev-qa-db-fra.com

Comment configurer Spring MVC avec une configuration purement basée sur Java?

J'ai ce que je considérerais comme une configuration assez simple de Spring MVC. Mon applicationContext.xml est la suivante:

<mvc:annotation-driven />
<mvc:resources mapping="/css/**" location="/css/" />
<context:property-placeholder location="classpath:controller-test.properties" />
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
    p:prefix="/WEB-INF/views/" p:suffix=".jsp" />

Mon web.xml est actuellement ceci:

  <servlet>
   <servlet-name>springDispatcherServlet</servlet-name>
   <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
   <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:applicationContext.xml</param-value>
   </init-param>
   <load-on-startup>1</load-on-startup>
  </servlet>

  <!-- Map all requests to the DispatcherServlet for handling -->
  <servlet-mapping>
    <servlet-name>springDispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

J'essaie de convertir cette configuration en une configuration basée sur Java. J'ai effectué des recherches sur le Web et, jusqu'à présent, j'ai trouvé des éléments expliquant (en partie quoi) comment utiliser la configuration Java mais n'expliquant pas comment enregistrer cette configuration Java dans l'environnement, c'est-à-dire le contexte Web.

Ce que j'ai jusqu'à présent en termes de @Configuration est la suivante:

 @Configuration
 @EnableWebMvc
 @PropertySource("classpath:controller.properties")
 @ComponentScan("com.project.web")
 public class WebSpringConfig extends WebMvcConfigurerAdapter {

 @Override
 public void addResourceHandlers(ResourceHandlerRegistry registry) {
    registry.addResourceHandler("/css/**").addResourceLocations("/css/");
 }

 @Bean
 public ViewResolver configureViewResolver() {
     InternalResourceViewResolver viewResolve = new InternalResourceViewResolver();
     viewResolve.setPrefix("/WEB-INF/views/");
     viewResolve.setSuffix(".jsp");

     return viewResolve;
 }

 @Override
 public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer){
   configurer.enable();
 }
}

Comment puis-je enregistrer cela avec le conteneur Web? J'utilise le dernier printemps (4.02).

Merci!

javaspringspring-mvc
32
user1902183

Vous devez apporter les modifications suivantes à web.xml afin de prendre en charge la configuration basée sur Java. Ceci indiquera à la DispatcherServlet de charger la configuration à l'aide de la configuration Java basée sur les annotations AnnotationConfigWebApplicationContext. il vous suffit de transmettre l'emplacement de votre fichier javaconfig à contextConfigLocation param. comme ci-dessous

<servlet>
  <servlet-name>springDispatcherServlet</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <init-param>
    <param-name>contextClass</param-name>
    <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
   </init-param>
   <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/*path to your WebSpringConfig*/ </param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
</servlet>

Update: faire la même chose sans apporter de modifications à web.xml

Vous pouvez même y accéder sans web.xml car la spécification Servlet 3.0 rend le web.xml facultatif. Il vous suffit d'implémenter/configurer l'interface WebApplicationInitializer pour configurer la ServletContext qui vous permettra de créer, configurer, l'enregistrement de DispatcherServlet par programme. La bonne chose est que WebApplicationInitializer est détecté automatiquement.

Le résumé est celui qui doit être implémenté WebApplicationInitializer pour se débarrasser de web.xml.

 public class MyWebAppInitializer implements WebApplicationInitializer {

 @Override
 public void onStartup(ServletContext container) {
  // Create the 'root' Spring application context
  AnnotationConfigWebApplicationContext rootContext =
                       new AnnotationConfigWebApplicationContext();
  rootContext.register(WebSpringConfig.class);

  // Manage the lifecycle of the root application context
  container.addListener(new ContextLoaderListener(rootContext));

  // Create the dispatcher servlet's Spring application context
  AnnotationConfigWebApplicationContext dispatcherContext =
                     new AnnotationConfigWebApplicationContext();
  dispatcherContext.register(DispatcherConfig.class);

  // Register and map the dispatcher servlet
  ServletRegistration.Dynamic dispatcher =
    container.addServlet("dispatcher", new DispatcherServlet(dispatcherContext));
    dispatcher.setLoadOnStartup(1);
    dispatcher.addMapping("/");
  }
}

Mise à jour: à partir des commentaires
Une explication un peu plus compliquée est également incluse dans la référence officielle de Spring maintenant Spring 4 Release Reference:

http://docs.spring.io/spring/docs/3.1.x/javadoc-api/org/springframework/web/WebApplicationInitializer.html

44
Santosh Joshi

Configuration basée sur Java sans ajouter d'élément à web.xml. WebApplicationInitializer convient parfaitement aux classes @Configuration basées sur le code de Spring

WebApplicationInitializer «Interface à implémenter dans Servlet 3.0+ environments afin de configurer le ServletContext par programme - par opposition à (ou éventuellement en conjonction avec) l'approche traditionnelle basée sur web.xml. Implementations of this SPI will be detected automatically by SpringServletContainerInitializer, which itself is bootstrapped automatically by any Servlet 3.0 container. Utilisation de Servlet Spec 3.0 de Tomcat 7

A partir de Spring 3.2, une classe abstraite qui implémentait WebApplicationInitializer et qui sera détectée automatiquement par SrevletContainer a été répertoriée.

AbstractAnnotationConfigDispatcherServletInitializer extends
AbstractDispatcherServletInitializer extends
AbstractContextLoaderInitializer implements WebApplicationInitializer

Utilisation de la version Spring 4.1.6.RELEASE avec les modules core, web, webmvc, beans.

public class WebXML_DispatcherServletInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[] { MvcServletXMLConfigurer.class };
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return null;
    }

    @Override
    protected String[] getServletMappings() {
        return new String[] { "/" };
    }

}

Configuration basée sur Java pour servir des ressources statiques avec Spring. Botte de printemps

@Configuration
@EnableWebMvc // <mvc:annotation-driven />
@ComponentScan(value = {"com.github.yash777.controllers"})
// <context:component-scan base-package="com.github.yash777" />
public class MvcServletXMLConfigurer extends WebMvcConfigurerAdapter implements WebMvcConfigurer {

    /**
     * <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" 
     * p:prefix="/WEB-INF/jsp/" p:suffix=".jsp" />
     * 
     * @return InternalResourceViewResolver as a bean configuration.
     */
    @Bean
    public InternalResourceViewResolver getInternalResourceViewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/jsp/");
        resolver.setSuffix(".jsp");
        return resolver;
    }

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        System.out.println("WebMvcConfigurer - addResourceHandlers() function get loaded...");

        // <mvc:resources mapping="/styles/**" location="/css/" />
        registry
            .addResourceHandler("/styles/**") 
            .addResourceLocations("/css/") // webapp/css/
            .setCachePeriod(3600)
            .resourceChain(true) // Spring 4.1
            .addResolver(new GzipResourceResolver()) // Spring 4.1
            .addResolver(new PathResourceResolver()); // Spring 4.1

        // <mvc:resources mapping="/static/**" location="/static/" />
        registry.addResourceHandler("/static/**")
                .addResourceLocations("/static/", "classpath:/static/") // src/main/resources/static/
                .setCachePeriod(3600)
                .resourceChain(true)
                .addResolver(new PathResourceResolver());
    }
}

Répertorié un exemple de contrôleur: 

@Controller
@RequestMapping(value = { "/controller", "/c" })
public class Test extends HttpServlet {
    private static final long serialVersionUID = 1L;

    @RequestMapping(value = {"/message", "/m"}, method = RequestMethod.GET )
    public void message(HttpServletRequest request, HttpServletResponse response ) throws IOException {
        System.out.println("@Controller Get method called.");
    }

    @RequestMapping(value = "/getView", method = RequestMethod.GET )
    public ModelAndView setViewName( Model model ) {
        System.out.println("GET... /getView");
        ModelAndView mav = new ModelAndView();
        mav.setViewName("test");
        return mav;
    }
}

WEB-INF/web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://Java.Sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
</web-app>
0
Yash