streamalism.org

1. Bemutatkozás

Ebben a cikkben a Spring MVC - Controllers alapkoncepciójára fogunk koncentrálni.

2. Áttekintés

Kezdjük azzal, hogy visszalépünk egy pillantással a. fogalma Első vezérlő a tipikus tavasszal Model View Controller építészet.

Nagyon magas szinten itt vannak a fő feladatok, amelyeket megvizsgálunk:

• Elfogja a beérkező kéréseket
• Átalakítja a kérelem hasznos terhelését az adatok belső szerkezetére
• Az adatokat elküldi a címre Modell további feldolgozásra
• A feldolgozott adatokat a Modell és továbbítja ezeket az adatokat a Kilátás a rendereléshez

Itt van egy gyors ábra a magas szintű beáramlásról Tavaszi MVC:

Mint láthatja, a DispatcherServlet szerepet játszik Első vezérlő az építészetben.

A diagram mind a tipikus MVC vezérlőkhöz, mind a RESTful vezérlőkhöz alkalmazható - néhány apró különbséggel (az alábbiakban leírjuk).

A hagyományos megközelítésben MVC az alkalmazások nem szolgáltatásorientáltak, ezért van View Resolver amely az a-tól kapott adatok alapján teszi a végső nézeteket Vezérlő.

Nyugalmas az alkalmazásokat úgy alakítottuk ki, hogy szolgáltatásorientáltak legyenek és nyers adatokat adjanak vissza (általában JSON / XML). Mivel ezek az alkalmazások nem végeznek nézetmegjelenítést, nincsenek Megoldók megtekintése - a Vezérlő általában elvárják, hogy közvetlenül a HTTP-válaszon keresztül küldjön adatokat.

Kezdjük az MVC0 stílusú vezérlőkkel.

3. Maven-függőségek

Annak érdekében, hogy együtt lehessen dolgozni Tavaszi MVC, először foglalkozzunk a Maven-függőségekkel:

 org.springframework spring-webmvc 5.0.6.KÖZLEMÉNY 

A könyvtár legújabb verziójának megtekintéséhez tekintse meg a spring-webmvc oldalt a Maven Central webhelyen.

4. Projekt webkonfiguráció

Mielőtt magukat a vezérlőket néznénk meg, először fel kell állítanunk egy egyszerű webprojektet, és gyorsan elvégeznünk Servlet konfiguráció.

Először megnézzük, hogy a DispatcherServlet használat nélkül beállítható web.xml - de ehelyett inicializálót használ:

public class StudentControllerConfig implementálja a WebApplicationInitializer {@Orride public void onStartup (ServletContext sc) dobja a ServletException {AnnotationConfigWebApplicationContext root = new AnnotationConfigWebApplicationContext (); root.register (WebConfig.class); root.refresh (); root.setServletContext (sc); sc.addListener (új ContextLoaderListener (root)); DispatcherServlet dv = new DispatcherServlet (új GenericWebApplicationContext ()); ServletRegistration.Dynamic appServlet = sc.addServlet ("test-mvc", dv); appServlet.setLoadOnStartup (1); appServlet.addMapping ("/ test / *"); }}

Ha XML nélkül szeretné beállítani a dolgokat, győződjön meg róla, hogy rendelkezik-e servlet-api 3.1.0 az osztályúton.

Itt van, hogyan web.xml a következőképpen nézne ki:

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

Beállítjuk a contextConfigLocation ingatlan itt - mutatva a XML a Spring kontextus betöltésére használt fájl. Ha az ingatlan nincs ott, a Spring egy megnevezett fájlt keres {servlet_name} -servlet.xml.

Esetünkben a szervlet_neve van teszt-mvc és így ebben a példában a DispatcherServlet nevű fájlt keresne test-mvc-servlet.xml.

Végül állítsuk be a DispatcherServlet és feltérképezi egy adott helyre URL - befejezni a dolgunkat Első vezérlő alapú rendszer itt:

 test-mvc / test / * 

Így ebben az esetben a DispatcherServlet az összes kérést a mintán belül elfogja /teszt/* .

5. Tavaszi MVC Web Config

Most nézzük meg, hogyan Dispatcher Servlet segítségével állítható be Tavaszi konfigur:

@Configuration @EnableWebMvc @ComponentScan (basePackages = {"com.baeldung.controller.controller", "com.baeldung.controller.config"}) public class WebConfig implementálja a WebMvcConfigurer {@Override public void configureDefaultServletHandable (); } @Bean public ViewResolver viewResolver () {InternalResourceViewResolver bean = new InternalResourceViewResolver (); bean.setPrefix ("/ WEB-INF /"); bean.setSuffix (". jsp"); visszatérő bab; }}

Most nézzük meg a Dispatcher Servlet felhasználásával XML . Pillanatkép a DispatcherServlet XML fájl - az XML fájl, amelyet a DispatcherServlet felhasználás az egyéni betöltéshez vezérlők és egyéb Tavaszientitások az alábbiakban látható:

    / WEB-INF / .jsp 

Ezen egyszerű konfiguráció alapján a keretrendszer természetesen inicializálja az összes vezérlőbabot, amelyet az osztályúton talál.

Figyelje meg, hogy meghatározzuk a nézetmegjelenítőt is, amely felelős a nézetek megjelenítéséért - a tavaszit fogjuk használni InternalResourceViewResolver itt. Ez elvárja az a nevét Kilátás meg kell oldani, ami azt jelenti, hogy megtalálja a megfelelő oldalt az előtag és az utótag használatával (mindkettőt a XML konfiguráció).

Tehát például, ha a Vezérlő visszatér a Kilátás nevezett "Üdvözöljük", a Kilátásmegoldó nevű oldalt megpróbálja megoldani „Welcome.jsp” ban,-ben WEB-INF mappába.

6. Az MVC vezérlő

Vezessük végre végre az MVC stílusú vezérlőt.

Figyeljük meg, hogyan térünk vissza a ModelAndView objektum - amely tartalmazza a modelltérkép és a objektum megtekintése; mindkettőt a V fogja használniiew Resolver adatmegjelenítéshez:

@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"); visszatérés mv; }}

Szóval, mit állítottunk itt pontosan.

Először létrehoztunk egy nevű vezérlőt TestController és feltérképezte a "/teszt" pálya. Az osztályban létrehoztunk egy metódust, amely visszaadja a ModelAndView objektumot, és a KAP kérjen tehát minden olyan URL-hívást, amely ateszt”Útvonalát a DispatcherServlet hoz getTestData módszer a TestController.

És természetesen visszaadjuk a ModelAndView objektum néhány modelladattal a jó mérés érdekében.

A nézetobjektum neve „Üdvözöljük“. Amint fentebb említettük, a Megoldó megtekintése keresni fog egy oldalt a WEB-INF mappaszívesen.jsp“.

Az alábbiakban egy példa eredményét láthatja KAP művelet:

Vegye figyelembe, hogy a URL végződik "teszt". A minta URL van "/teszt“.

Az első "/teszt" a Servlet-ből származik, a második pedig a vezérlő leképezéséből származik.

7. További tavaszi függőségek a REST-hez

Most kezdjünk el egy RESTful vezérlőt nézni. Természetesen jó hely a kiinduláshoz az extra Maven-függőségek, amelyekre szükségünk van:

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

Kérjük, olvassa el a jackson-core, a spring-webmvc és a rugó-web linkeket ezen függőségek legújabb verzióihoz.

Jackson itt természetesen nem kötelező, de minden bizonnyal jó módszer a JSON támogatás engedélyezésére. Ha érdekel, hogy jobban belemerüljön ebbe a támogatásba, nézze meg az üzenetátalakítók cikket itt.

8. A REST vezérlő

A beállítás a Tavasz RESTful alkalmazás megegyezik a MVC alkalmazás azzal a különbséggel, hogy nincs View Resolvers és nem modelltérkép.

Az API általában egyszerűen visszaadja a nyers adatokat az ügyfélnek - XML és JSON reprezentációk általában - és így a DispatcherServlet megkerüli a nézetmegoldók és az adatokat közvetlenül a HTTP választörzsben adja vissza.

Vessünk egy pillantást egy egyszerű RESTful vezérlő megvalósítására:

@Controller public class RestController {@GetMapping (value = "/ student / {studentId}") public @ResponseBody Student getTestData (@PathVariable Integer studentId) {Student student = new Student (); student.setName ("Péter"); student.setId (studentId); visszatérő hallgató; }}

Vegye figyelembe a @ResponseBody kommentár a módszerről - amely utasítja Springet, hogy kerülje meg a metódust nézetmegoldó és lényegében közvetlenül írja be a kimenetet a HTTP válasz törzsébe.

A kimenet gyors pillanatképe az alábbiakban látható:

A fenti kimenet a KAP kérés az API-val a hallgatóval id nak,-nek 1.

Itt egy gyors megjegyzés: a @RequestMapping az annotáció egyike azoknak a központi kommentároknak, amelyeket valóban meg kell vizsgálnia, hogy teljes mértékben kiaknázhassa.

9. Tavaszi csizma és a @RestController Megjegyzés

A @RestController a Spring Boot kommentárja alapvetően egy gyors parancsikon, amely megment minket attól, hogy mindig meg kell határoznunk @ResponseBody.

Íme az előző példa vezérlő, amely ezt az új kommentárt használja:

@RestController public class RestAnnotatedController {@GetMapping (value = "/ annotated / student / {studentId}") public Student getData (@PathVariable Integer studentId) {Student student = new Student (); student.setName ("Péter"); student.setId (studentId); visszatérő hallgató; }}

10. Következtetés

Ebben az útmutatóban a vezérlők tavaszi használatának alapjait tárjuk fel, mind egy tipikus MVC alkalmazás, mind egy RESTful API szempontjából.

Természetesen a cikk összes kódja elérhető a GitHubon.