Hurtig vejledning til fjedercontrollere

1. Introduktion

I denne artikel vil vi fokusere på et kernekoncept i Spring MVC - Controllers.

2. Oversigt

Lad os starte med at tage et skridt tilbage og se på begrebet Frontcontroller i det typiske forår Model View-controller arkitektur.

På et meget højt niveau er her de vigtigste ansvarsområder, vi ser på:

  • Aflytter indgående anmodninger
  • Konverterer anmodningens nyttelast til den interne struktur af dataene
  • Sender dataene til Model til yderligere behandling
  • Får behandlede data fra Model og fremfører disse data til Udsigt til gengivelse

Her er et hurtigt diagram for strømmen på højt niveau Forår MVC:

Som du kan se, er DispatcherServlet spiller rollen som Frontcontroller i arkitekturen.

Diagrammet gælder både for typiske MVC-controllere såvel som RESTful-controllere - med nogle små forskelle (beskrevet nedenfor).

I den traditionelle tilgang MVC applikationer er ikke serviceorienterede, derfor er der en Vse Resolver der gengiver endelige synspunkter baseret på data modtaget fra en Controller.

Rolig applikationer er designet til at være serviceorienterede og returnere rådata (typisk JSON / XML). Da disse applikationer ikke gengiver visning, er der ingen Se Resolvere - det Controller forventes generelt at sende data direkte via HTTP-svaret.

Lad os starte med MVC0-stil controllere.

3. Maven-afhængigheder

For at kunne arbejde med Forår MVC, lad os behandle Maven-afhængighederne først:

 org.springframework spring-webmvc 5.0.6.RELEASE 

For at få den nyeste version af biblioteket skal du kigge på spring-webmvc på Maven Central.

4. Project Web Config

Nu, før vi ser på controllerne selv, skal vi først oprette et simpelt webprojekt og gøre et hurtigt Servlet konfiguration.

Lad os først se, hvordan DispatcherServlet kan konfigureres uden brug web.xml - men i stedet for at bruge en initialisering:

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

For at konfigurere ting uden XML skal du sørge for at have servlet-api 3.1.0 på din klassesti.

Sådan gør du web.xml ville se ud som:

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

Vi indstiller contextConfigLocation ejendom her - peger på XML fil, der bruges til at indlæse foråret sammenhæng Hvis ejendommen ikke er der, søger Spring efter en fil med navnet {servlet_name} -servlet.xml.

I vores tilfælde servlet_name er test-mvc og så i dette eksempel DispatcherServlet ville søge efter en fil, der hedder test-mvc-servlet.xml.

Lad os endelig indstille DispatcherServlet op og kortlæg den til en bestemt URL - for at afslutte vores Frontcontroller baseret system her:

 test-mvc / test / * 

Således i dette tilfælde DispatcherServlet ville opfange alle anmodninger inden for mønsteret /prøve/* .

5. Spring MVC Web Config

Lad os nu se på, hvordan Dispatcher Servlet kan konfigureres ved hjælp af Spring Config:

@Configuration @EnableWebMvc @ComponentScan (basePackages = {"com.baeldung.controller.controller", "com.baeldung.controller.config"}) offentlig klasse WebConfig implementerer WebMvcConfigurer {@Override offentlig ugyldig configureDefaultServletHandling konfiguration (StandardConfigurer) (); } @Bean offentlig ViewResolver viewResolver () {InternalResourceViewResolver bean = ny InternalResourceViewResolver (); bean.setPrefix ("/ WEB-INF /"); bean.setSuffix (". jsp"); retur bønne; }}

Lad os nu se på opsætning af Dispatcher Servlet ved brug af XML . Et øjebliksbillede af DispatcherServlet XML fil - den XML fil, som DispatcherServlet bruger til indlæsning af brugerdefineret controllere og andre Forårenheder er vist nedenfor:

    / WEB-INF / .jsp 

Baseret på denne enkle konfiguration initialiserer rammen naturligvis enhver controllerbønne, som den finder på klassestien.

Bemærk, at vi også definerer View Resolver, der er ansvarlig for gengivelse af visning - vi bruger Spring's InternalResourceViewResolver her. Dette forventer et navn på en udsigt skal løses, hvilket betyder at finde en tilsvarende side ved hjælp af præfiks og suffiks (begge defineret i XML konfiguration).

Så for eksempel hvis Controller returnerer a udsigt som hedder "Velkommen", det udsigtresolver vil forsøge at løse en kaldet side “Velkommen.jsp” i WEB-INF folder.

6. MVC-controlleren

Lad os nu endelig implementere MVC-stilcontrolleren.

Læg mærke til, hvordan vi vender tilbage a ModelAndView objekt - som indeholder en modelkort og en se objekt; begge vil blive brugt af Vse Resolver til gengivelse af data:

@Controller @RequestMapping (værdi = "/ test") offentlig klasse TestController {@GetMapping offentlig ModelAndView getTestData () {ModelAndView mv = ny ModelAndView (); mv.setViewName ("velkommen"); mv.getModel (). put ("data", "Velkommen hjem mand"); returnere mv; }}

Så hvad præcist oprettede vi her.

Først oprettede vi en controller kaldet Testkontrol og kortlagt det til "/prøve" sti. I klassen har vi oprettet en metode, der returnerer a ModelAndView objekt og er kortlagt til en anmode således ethvert URL-opkald, der slutter med “prøve”Ville blive dirigeret af DispatcherServlet til getTestData metode i Testkontrol.

Og selvfølgelig returnerer vi ModelAndView objekt med nogle modeldata for godt mål.

Visningsobjektet har et navn indstillet til “Velkommen“. Som diskuteret ovenfor er Se Resolver vil søge efter en side i WEB-INF mappe kaldet “velkommen.jsp“.

Nedenfor kan du se resultatet af et eksempel operation:

Bemærk, at URL ender med "prøve". Mønsteret for URL er “/ Test / test“.

Den første "/prøve" kommer fra Servlet, og den anden kommer fra kortlægningen af ​​controlleren.

7. Flere forårsafhængigheder til REST

Lad os nu begynde at se på en RESTful controller. Selvfølgelig er et godt sted at starte de ekstra Maven-afhængigheder, vi har brug for til det:

  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 

Se jackson-core, spring-webmvc og spring-web links for de nyeste versioner af disse afhængigheder.

Jackson er naturligvis ikke obligatorisk her, men det er bestemt en god måde at aktivere JSON-support på. Hvis du er interesseret i at dykke dybere ned i denne support, skal du kigge på artiklen om meddelelsesomformere her.

8. REST-controlleren

Opsætningen til en Spring RESTful ansøgningen er den samme som for MVC applikation med den eneste forskel er, at der ikke er nogen Vse Resolvere og nej modelkort.

API'en vil normalt blot returnere rådata tilbage til klienten - XML og JSON repræsentationer normalt - og så DispatcherServlet omgår se opløsere og returnerer dataretten i HTTP-responsorganet.

Lad os se på en simpel RESTful controller implementering:

@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); tilbagevendende studerende; }}

Bemærk @ResponseBody bemærkning om metoden - som pålægger Spring at omgå se resolver og skrive i det væsentlige output direkte til kroppen af ​​HTTP-svaret.

Et hurtigt øjebliksbillede af output vises nedenfor:

Ovenstående output er et resultat af at sende anmodning til API'et med den studerende id af 1.

En hurtig note her er - @RequestMapping kommentar er en af ​​de centrale kommentarer, som du virkelig bliver nødt til at udforske for at kunne udnytte det fulde potentiale.

9. Spring Boot og @RestController Kommentar

Det @RestController kommentar fra Spring Boot er dybest set en hurtig genvej, der sparer os for altid at skulle definere @ResponseBody.

Her er den foregående eksempelcontroller, der bruger denne nye kommentar:

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

10. Konklusion

I denne vejledning udforsker vi det grundlæggende ved at bruge controllere om foråret, både set fra en typisk MVC-applikation og en RESTful API.

Selvfølgelig er al kode i artiklen tilgængelig på GitHub.