Guide rapide des contrôleurs à ressort

1. Introduction

Dans cet article, nous allons nous concentrer sur un concept de base dans Spring MVC - Contrôleurs.

2. Aperçu

Commençons par prendre un pas en arrière et avoir un regard sur le concept du Front Controller dans le typique Spring Model View Controller Architecture .

À un niveau très élevé, voici les principales responsabilités que nous examinons:

  • Intercepte les demandes entrantes
  • Convertit la charge utile de la requête en structure interne des données
  • Envoie les données à Model pour un traitement ultérieur
  • Obtient les données traitées du modèle et avance ces données vers la vue pour le rendu

Voici un diagramme rapide du flux de haut niveau dans Spring MVC :

Comme vous pouvez le voir, le DispatcherServlet joue le rôle du contrôleur frontal dans l'architecture.

Le diagramme est applicable à la fois aux contrôleurs MVC typiques ainsi qu'aux contrôleurs RESTful - avec quelques petites différences (décrites ci-dessous).

Dans l'approche traditionnelle, les applications MVC ne sont pas orientées services, il existe donc un résolveur de vue qui rend les vues finales en fonction des données reçues d'un contrôleur .

Les applications RESTful sont conçues pour être orientées services et renvoyer des données brutes (JSON / XML généralement). Étant donné que ces applications ne font aucun rendu de vue, il n'y a pas de résolveurs de vue - le contrôleur est généralement censé envoyer des données directement via la réponse HTTP.

Commençons par les contrôleurs de style MVC0.

3. Dépendances de Maven

Afin de pouvoir travailler avec Spring MVC , traitons d'abord les dépendances Maven:

 org.springframework spring-webmvc 5.0.6.RELEASE 

Pour obtenir la dernière version de la bibliothèque, jetez un œil à spring-webmvc sur Maven Central.

4. Project Web Config

Maintenant, avant de regarder les contrôleurs eux-mêmes, nous devons d'abord configurer un projet Web simple et faire une configuration rapide du servlet .

Voyons d'abord comment le DispatcherServlet peut être configuré sans utiliser web.xml - mais à la place en utilisant un initialiseur:

public class StudentControllerConfig implements WebApplicationInitializer { @Override public void onStartup(ServletContext sc) throws ServletException { AnnotationConfigWebApplicationContext root = new AnnotationConfigWebApplicationContext(); root.register(WebConfig.class); root.refresh(); root.setServletContext(sc); sc.addListener(new ContextLoaderListener(root)); DispatcherServlet dv = new DispatcherServlet(new GenericWebApplicationContext()); ServletRegistration.Dynamic appServlet = sc.addServlet("test-mvc", dv); appServlet.setLoadOnStartup(1); appServlet.addMapping("/test/*"); } }

Pour configurer les choses sans XML, assurez-vous d'avoir servlet-api 3.1.0 sur votre chemin de classe.

Voici à quoi ressemblerait le fichier web.xml :

 test-mvc  org.springframework.web.servlet.DispatcherServlet  1  contextConfigLocation /WEB-INF/test-mvc.xml   

Nous définissons ici la propriété contextConfigLocation - pointant vers le fichier XML utilisé pour charger le contexte Spring. Si la propriété n'est pas là, Spring recherchera un fichier nommé {servlet_name} -servlet.xml .

Dans notre cas, le nom_servlet est test-mvc et donc, dans cet exemple, le DispatcherServlet recherche un fichier appelé test-mvc-servlet.xml .

Enfin, configurons DispatcherServlet et mappons-le à une URL particulière - pour terminer notre système basé sur Front Controller ici:

 test-mvc /test/* 

Ainsi, dans ce cas, le DispatcherServlet intercepterait toutes les requêtes dans le pattern / test / * .

5. Configuration Web Spring MVC

Voyons maintenant comment le servlet Dispatcher peut être configuré à l'aide de Spring Config :

@Configuration @EnableWebMvc @ComponentScan(basePackages= { "com.baeldung.controller.controller", "com.baeldung.controller.config" }) public class WebConfig implements WebMvcConfigurer { @Override public void configureDefaultServletHandling( DefaultServletHandlerConfigurer configurer) { configurer.enable(); } @Bean public ViewResolver viewResolver() { InternalResourceViewResolver bean = new InternalResourceViewResolver(); bean.setPrefix("/WEB-INF/"); bean.setSuffix(".jsp"); return bean; } }

Examinons maintenant la configuration du servlet Dispatcher à l' aide de XML . Un instantané du fichier XML DispatcherServlet - le fichier XML que le DispatcherServlet utilise pour charger des contrôleurs personnalisés et d'autres entités Spring est illustré ci-dessous:

    /WEB-INF/   .jsp  

Sur la base de cette configuration simple, le framework va bien sûr initialiser tout bean contrôleur qu'il trouvera sur le classpath.

Notez que nous définissons également le résolveur de vue, responsable du rendu de vue - nous utiliserons ici le InternalResourceViewResolver de Spring . Cela s'attend à ce qu'un nom de vue soit résolu, ce qui signifie trouver une page correspondante en utilisant le préfixe et le suffixe (tous deux définis dans la configuration XML ).

Par exemple, si le contrôleur renvoie une vue nommée « bienvenue» , le résolveur de vue essaiera de résoudre une page appelée «bienvenue.jsp» dans le dossier WEB-INF .

6. Le contrôleur MVC

Implémentons maintenant enfin le contrôleur de style MVC.

Remarquez comment nous renvoyons un objet ModelAndView - qui contient une carte de modèle et un objet de vue ; les deux seront utilisés par le V iew Resolver pour le rendu des données:

@Controller @RequestMapping(value = "/test") public class TestController { @GetMapping public ModelAndView getTestData() { ModelAndView mv = new ModelAndView(); mv.setViewName("welcome"); mv.getModel().put("data", "Welcome home man"); return mv; } }

Alors, qu'avons-nous mis en place exactement ici.

Tout d'abord, nous avons créé un contrôleur appelé TestController et l' avons mappé sur le chemin «/ test» . Dans la classe , nous avons créé une méthode qui retourne un ModelAndView objet et est mis en correspondance avec une GET demande donc un appel d'URL se terminant par « essai » serait acheminé par le DispatcherServlet à la getTestData méthode dans le TestController .

And of course we're returning the ModelAndView object with some model data for good measure.

The view object has a name set to “welcome“. As discussed above, the View Resolver will search for a page in the WEB-INF folder called “welcome.jsp“.

Below you can see the result of an example GET operation:

Note that the URL ends with “test”. The pattern of the URL is “/test/test“.

The first “/test” comes from the Servlet, and the second one comes from the mapping of the controller.

7. More Spring Dependencies for REST

Let's now start looking at a RESTful controller. Of course, a good place to start is the extra Maven dependencies we need for it:

  org.springframework spring-webmvc 5.0.6.RELEASE   org.springframework spring-web 5.0.6.RELEASE   com.fasterxml.jackson.core jackson-databind 2.9.5   

Please refer to jackson-core, spring-webmvc and spring-web links for the newest versions of those dependencies.

Jackson is of course not mandatory here, but it's certainly a good way to enable JSON support. If you're interested to dive deeper into that support, have a look at the message converters article here.

8. The REST Controller

The setup for a Spring RESTful application is the same as the one for the MVC application with the only difference being that there is no View Resolvers and no model map.

The API will generally simply return raw data back to the client – XML and JSON representations usually – and so the DispatcherServlet bypasses the view resolvers and returns the data right in the HTTP response body.

Let's have a look at a simple RESTful controller implementation:

@Controller public class RestController { @GetMapping(value = "/student/{studentId}") public @ResponseBody Student getTestData(@PathVariable Integer studentId) { Student student = new Student(); student.setName("Peter"); student.setId(studentId); return student; } }

Note the @ResponseBody annotation on the method – which instructs Spring to bypass the view resolver and essentially write out the output directly to the body of the HTTP response.

A quick snapshot of the output is displayed below:

The above output is a result of sending the GET request to the API with the student id of 1.

One quick note here is – the @RequestMapping annotation is one of those central annotations that you'll really have to explore in order to use to its full potential.

9. Spring Boot and the @RestController Annotation

The @RestController annotation from Spring Boot is basically a quick shortcut that saves us from always having to define @ResponseBody.

Here's the previous example controller using this new annotation:

@RestController public class RestAnnotatedController { @GetMapping(value = "/annotated/student/{studentId}") public Student getData(@PathVariable Integer studentId) { Student student = new Student(); student.setName("Peter"); student.setId(studentId); return student; } }

10. Conclusion

Dans ce guide, nous explorons les bases de l'utilisation des contrôleurs dans Spring, à la fois du point de vue d'une application MVC typique et d'une API RESTful.

Bien sûr, tout le code de l'article est disponible sur GitHub.