TOC

Guide rapide des régulateurs à ressort

Guide rapide des contrôleurs de ressort

1. introduction

Dans cet article, nous allons nous concentrer sur un concept de base de Spring MVC: les contrôleurs.

2. Vue d'ensemble

Commençons par prendre du recul et jetons un œil àthe concept of the Front Controller in the typical 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 demande en structure interne des données

  • Envoie les données àModel pour un traitement ultérieur

  • Obtient les données traitées desModel et les avance vers lesView pour le rendu

Voici un diagramme rapide du débit de haut niveau enSpring MVC:

SpringMVC

Comme vous pouvez le voir, leDispatcherServlet joue le rôle duFront Controller dans l'architecture.

Le diagramme s’applique aussi bien aux contrôleurs MVC classiques qu’aux contrôleurs RESTful - avec quelques petites différences (décrites ci-dessous).

Dans l'approche traditionnelle, les applicationsMVC ne sont pas orientées services, il existe donc un View Resolver qui rend les vues finales en fonction des données reçues d'unController.

Les applicationsRESTful 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 deView Resolvers - leController 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 Maven

Afin de pouvoir travailler avecSpring 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 on Maven Central.

4. Projet 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 deServlet.

Voyons d'abord comment lesDispatcherServlet peuvent être configurés sans utiliserweb.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'avoirservlet-api 3.1.0 sur votre chemin de classe.

Voici à quoi ressembleraient lesweb.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 fichierXML 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, leservlet_name esttest-mvc et donc, dans cet exemple, leDispatcherServlet rechercherait un fichier appelétest-mvc-servlet.xml.

Enfin, définissons leDispatcherServlet et mappons-le à unURL particulier - pour terminer notre système basé surFront Controller ici: 


    test-mvc
    /test/*

Ainsi, dans ce cas, leDispatcherServlet intercepterait toutes les demandes dans le modèle/test/*.

5. Configuration Web Spring MVC

Voyons maintenant comment lesDispatcher Servlet peuvent être configurés en utilisantSpring Config: 

@Configuration
@EnableWebMvc
@ComponentScan(basePackages= {
  "org.example.controller.controller",
  "org.example.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;
    }
}

Voyons maintenant la configuration desDispatcher Servlet en utilisantXML. Un instantané du fichierDispatcherServlet XML - le fichierXML que leDispatcherServlet utilise pour charger descontrollers personnalisés et d'autresSpringentities est illustré ci-dessous: 




    
        /WEB-INF/
    
    
        .jsp

Sur la base de cette configuration simple, la structure initialisera bien sûr tout bean de contrôleur qu’elle trouvera sur le chemin de classe.

Notez que nous définissons également le résolveur de vue, responsable du rendu de la vue - nous utiliserons ici lesInternalResourceViewResolverde Spring. Cela s'attend à ce qu'un nom d'unview 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 deXML).

Par exemple, si leController renvoie unview nommé «welcome”*,*, leviewresolver essaiera de résoudre une page appelée“welcome.jsp” dans leWEB-INF dossier.

6. Le contrôleur MVC

N'implémentons pas enfin le contrôleur de style MVC.

Remarquez comment nous renvoyons un objetModelAndView - qui contient unmodel map et unview object; les deux seront utilisés par les View Resolverpour 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'est-ce que nous avons exactement mis en place 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 renvoie un objetModelAndView et est mappée à une requêteGET donc tout appel URL se terminant par «test» serait acheminé par leDispatcherServlet à la méthodegetTestData dans lesTestController.

Et bien sûr, nous renvoyons l'objetModelAndView avec des données de modèle pour faire bonne mesure.

L'objet de vue a un nom défini sur «welcome». Comme indiqué ci-dessus, lesView Resolver rechercheront une page dans le dossierWEB-INF appelée «welcome.jsp».

Ci-dessous vous pouvez voir le résultat d'un exemple d'opérationGET:

result_final

Notez que leURL se termine par“test”. Le motif desURL est“/test/test ».

Le premier“/test” provient du servlet et le second du mappage du contrôleur.

7. Plus de dépendances Spring pour REST

Voyons maintenant un contrôleur RESTful. Bien sûr, les dépendances Maven supplémentaires dont nous avons besoin sont un bon point de départ: 


    
        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

Veuillez vous référer aux liensjackson-core,spring-webmvc etspring-web pour les dernières versions de ces dépendances.

Jackson n'est bien sûr pas obligatoire ici, mais c'est certainement un bon moyen d'activer le support JSON. Si vous souhaitez approfondir cette assistance, jetez un œil auxmessage converters article here.

8. Le contrôleur REST

La configuration d'une applicationSpring RESTful est la même que celle de l'applicationMVC, la seule différence étant qu'il n'y a pas de View Resolvers et pas demodel map.

L'API renverra généralement simplement les données brutes au client - les représentationsXML etJSON généralement - et ainsi leDispatcherServlet contourne lesview resolvers etreturns the data right in the HTTP response body.

Jetons un coup d'œil à une implémentation simple de contrôleur RESTful: 

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

Notez l'annotation@ResponseBody sur la méthode - qui demande à Spring de contourner lesview resolver etessentially write out the output directly to the body of the HTTP response.

Un aperçu de la sortie est affiché ci-dessous:

16th_july

La sortie ci-dessus est le résultat de l'envoi de la requêteGET à l'API avec l'élèveid de1.

Une note rapide ici est -the @RequestMapping annotation est l'une de ces annotations centrales que vous devrez vraiment explorer pour utiliser pleinement son potentiel.

9. Spring Boot et l'annotation@RestController

L'annotation@RestController de Spring Boot est essentiellement un raccourci rapide qui nous évite d'avoir toujours à définir@ResponseBody.

Voici l'exemple de contrôleur précédent utilisant cette nouvelle 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 disponibleover on GitHub.

Related