Beknopte handleiding voor veercontrollers

1. Inleiding

In dit artikel zullen we ons concentreren op een kernconcept in Spring MVC - Controllers.

2. Overzicht

Laten we beginnen met een stap terug te doen en een kijkje te nemen het concept van de Voorste controller in de typische lente Model View Controller architectuur.

Op een zeer hoog niveau zijn hier de belangrijkste verantwoordelijkheden waar we naar kijken:

  • Onderschept inkomende verzoeken
  • Converteert de payload van het verzoek naar de interne structuur van de gegevens
  • Stuurt de gegevens naar Model voor verdere verwerking
  • Haalt verwerkte gegevens op van het Model en verplaatst die gegevens naar de Visie voor weergave

Hier is een snel diagram voor de instroom op hoog niveau Lente MVC:

Zoals u kunt zien, is de DispatcherServlet speelt de rol van de Voorste controller in de architectuur.

Het diagram is van toepassing op zowel typische MVC-controllers als op RESTful-controllers - met enkele kleine verschillen (hieronder beschreven).

In de traditionele benadering, MVC applicaties zijn niet servicegericht en daarom is er een View Resolver die definitieve weergaven oplevert op basis van gegevens die zijn ontvangen van een Controller.

RUSTIG applicaties zijn ontworpen om servicegericht te zijn en ruwe data te retourneren (typisch JSON / XML). Aangezien deze toepassingen geen weergaven renderen, zijn er geen Bekijk resolvers - de Controller wordt over het algemeen verwacht dat het gegevens rechtstreeks via het HTTP-antwoord verzendt.

Laten we beginnen met de controllers in MVC0-stijl.

3. Maven afhankelijkheden

Om mee te kunnen werken Lente MVC, laten we eerst de Maven-afhankelijkheden behandelen:

 org.springframework spring-webmvc 5.0.6.RELEASE 

Bekijk spring-webmvc op Maven Central om de nieuwste versie van de bibliotheek te downloaden.

4. Project Web Config

Nu, voordat we naar de controllers zelf kijken, moeten we eerst een eenvoudig webproject opzetten en snel doen Servlet configuratie.

Laten we eerst kijken hoe het DispatcherServlet kan worden ingesteld zonder te gebruiken web.xml - maar in plaats daarvan een initialisatieprogramma gebruiken:

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

Om dingen in te stellen zonder XML, moet u ervoor zorgen dat u servlet-api 3.1.0 op je klassenpad.

Hier is hoe de web.xml zou eruit zien als:

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

We stellen de contextConfigLocation eigenschap hier - wijzend naar de XML bestand dat wordt gebruikt om de Spring-context te laden. Als de eigenschap er niet is, zoekt Spring naar een bestand met de naam {servlet_name} -servlet.xml.

In ons geval de servlet_name is test-mvc en dus, in dit voorbeeld de DispatcherServlet zou zoeken naar een bestand met de naam test-mvc-servlet.xml.

Laten we tot slot de DispatcherServlet up en wijs het toe aan een bepaald URL - om ons af te maken Voorste controller gebaseerd systeem hier:

 test-mvc / test / * 

Dus in dit geval de DispatcherServlet zou alle verzoeken binnen het patroon onderscheppen /test/* .

5. Spring MVC Web Config

Laten we nu eens kijken hoe de Verzender Servlet kan worden ingesteld met Spring Config:

@Configuration @EnableWebMvc @ComponentScan (basePackages = {"com.baeldung.controller.controller", "com.baeldung.controller.config"}) public class WebConfig implementeert WebMvcConfigurer {@Override public void configureDefaultServletHandling (DefaultServletHandling) configuratiedefaultServletHandling (DefaultServletHandling) (); } @Bean openbare ViewResolver viewResolver () {InternalResourceViewResolver bean = nieuwe InternalResourceViewResolver (); bean.setPrefix ("/ WEB-INF /"); bean.setSuffix (". jsp"); terugkeer boon; }}

Laten we nu kijken naar het opzetten van het Verzender Servlet gebruik makend van XML . Een momentopname van het XML van DispatcherServlet bestand - het XML bestand dat het DispatcherServlet gebruikt voor het laden van aangepaste controllers en andere Voorjaarentiteiten wordt hieronder getoond:

    / WEB-INF / .jsp 

Op basis van deze eenvoudige configuratie zal het framework natuurlijk elke controller bean initialiseren die het op het classpath vindt.

Merk op dat we ook de View Resolver definiëren, die verantwoordelijk is voor weergave van weergaven - we zullen die van Spring gebruiken InternalResourceViewResolver hier. Dit verwacht een naam van een visie op te lossen, wat betekent dat een overeenkomstige pagina moet worden gezocht met behulp van een voorvoegsel en achtervoegsel (beide gedefinieerd in het XML configuratie).

Dus bijvoorbeeld als de Controller geeft een terug visie genaamd "Welkom", de visieresolver zal proberen een pagina met de naam op te lossen "Welcome.jsp" in de WEB-INF map.

6. De MVC-controller

Laten we nu eindelijk de MVC-stijlcontroller implementeren.

Merk op hoe we een ModelAndView object - dat een model kaart en een bekijk object; beide zullen worden gebruikt door de View Resolver voor gegevensweergave:

@Controller @RequestMapping (value = "/ test") openbare klasse TestController {@GetMapping openbaar ModelAndView getTestData () {ModelAndView mv = nieuw ModelAndView (); mv.setViewName ("welkom"); mv.getModel (). put ("data", "Welcome home man"); terug mv; }}

Dus, wat hebben we hier precies opgezet?

Eerst hebben we een controller gemaakt met de naam TestController en toegewezen aan de "/test" pad. In de klas hebben we een methode gemaakt die een retourneert ModelAndView object en wordt toegewezen aan een KRIJGEN verzoek dus elke URL-aanroep die eindigt op 'test”Zou worden gerouteerd door de DispatcherServlet naar de getTestData methode in de TestController.

En natuurlijk retourneren we de ModelAndView object met enkele modelgegevens voor een goede meting.

Het view-object heeft een naam die is ingesteld op 'Welkom“. Zoals hierboven besproken, is het Bekijk Resolver zoekt naar een pagina in het WEB-INF map met de naam ‘welkom.jsp“.

Hieronder ziet u het resultaat van een voorbeeld KRIJGEN operatie:

Merk op dat de URL eindigt met "test". Het patroon van de URL is “/ Test / test“.

De eerste "/test" komt van de Servlet, en de tweede komt van de mapping van de controller.

7. Meer afhankelijkheden van de lente voor REST

Laten we nu eens kijken naar een RESTful-controller. Een goede plek om te beginnen zijn natuurlijk de extra Maven-afhankelijkheden die we ervoor nodig hebben:

  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 

Raadpleeg de jackson-core, spring-webmvc en spring-web links voor de nieuwste versies van deze afhankelijkheden.

Jackson is hier natuurlijk niet verplicht, maar het is zeker een goede manier om JSON-ondersteuning in te schakelen. Als je geïnteresseerd bent om dieper in die ondersteuning te duiken, bekijk dan het artikel over berichtconverters hier.

8. De REST-controller

De opzet voor een Lente RUSTIG toepassing is dezelfde als die voor de MVC toepassing met als enige verschil dat er geen V isiew Resolvers en nee model kaart.

De API retourneert over het algemeen gewoon onbewerkte gegevens naar de klant - XML en JSON representaties meestal - en dus de DispatcherServlet omzeilt de bekijk resolvers en retourneert de gegevens rechtstreeks in de hoofdtekst van het HTTP-antwoord.

Laten we eens kijken naar een eenvoudige implementatie van RESTful-controller:

@Controller openbare klasse RestController {@GetMapping (value = "/ student / {studentId}") openbaar @ResponseBody Student getTestData (@PathVariable Integer studentId) {Student student = nieuwe student (); student.setName ("Peter"); student.setId (studentId); terugkeer student; }}

Merk op @ResponseBody annotatie op de methode - die Spring instrueert om het bekijk resolver en schrijf de uitvoer in wezen rechtstreeks naar de hoofdtekst van de HTTP-reactie.

Een korte momentopname van de output wordt hieronder weergegeven:

De bovenstaande uitvoer is het resultaat van het verzenden van de KRIJGEN verzoek aan de API met de student ID kaart van 1.

Een korte opmerking hier is - de @RequestMapping annotatie is een van die centrale annotaties die je echt moet verkennen om het volledige potentieel te benutten.

9. Spring Boot en de @RestController Annotatie

De @RestController annotatie van Spring Boot is in feite een snelle snelkoppeling waarmee we niet altijd hoeven te definiëren @ResponseBody.

Hier is de vorige voorbeeldcontroller die deze nieuwe annotatie gebruikt:

@RestController openbare klasse RestAnnotatedController {@GetMapping (value = "/ annotated / student / {studentId}") openbaar Student getData (@PathVariable Geheel getal studentId) {Student student = nieuwe student (); student.setName ("Peter"); student.setId (studentId); terugkeer student; }}

10. Conclusie

In deze gids verkennen we de basisprincipes van het gebruik van controllers in Spring, zowel vanuit het oogpunt van een typische MVC-applicatie als vanuit een RESTful API.

Natuurlijk is alle code in het artikel beschikbaar op GitHub.