streamalism.org

1. Introduksjon

I denne artikkelen fokuserer vi på et kjernekonsept i Spring MVC - Controllers.

2. Oversikt

La oss starte med å ta et skritt tilbake og se på konseptet med Frontkontroller i den typiske våren Model View-kontroller arkitektur.

På et veldig høyt nivå er her hovedansvaret vi ser på:

• Avlytter innkommende forespørsler
• Konverterer nyttelasten til forespørselen til den interne strukturen til dataene
• Sender dataene til Modell for videre behandling
• Får behandlede data fra Modell og viderefører disse dataene til Utsikt for gjengivelse

Her er et raskt diagram for innstrømning på høyt nivå Vår MVC:

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

Diagrammet kan brukes både på typiske MVC-kontrollere så vel som RESTful-kontrollere - med noen små forskjeller (beskrevet nedenfor).

I den tradisjonelle tilnærmingen, MVC applikasjoner er ikke serviceorienterte, derfor er det en Vse Resolver som gjengir endelige visninger basert på data mottatt fra a Kontroller.

Avslappende applikasjoner er designet for å være serviceorienterte og returnere rådata (JSON / XML vanligvis). Siden disse applikasjonene ikke gjør gjengivelse, er det ingen Vis Resolvers - den Kontroller forventes generelt å sende data direkte via HTTP-responsen.

La oss starte med MVC0-stil kontrollere.

3. Maven-avhengigheter

For å kunne jobbe med Vår MVC, la oss takle Maven-avhengighetene først:

 org.springframework spring-webmvc 5.0.6.RELEASE 

For å få den nyeste versjonen av biblioteket, ta en titt på vår-webmvc på Maven Central.

4. Project Web Config

Nå, før vi ser på kontrollerne selv, må vi først sette opp et enkelt webprosjekt og gjøre et raskt Servlet konfigurasjon.

La oss først se hvordan DispatcherServlet kan settes opp uten bruk web.xml - men i stedet for å bruke 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 = new DispatcherServlet (new GenericWebApplicationContext ()); ServletRegistration.Dynamic appServlet = sc.addServlet ("test-mvc", dv); appServlet.setLoadOnStartup (1); appServlet.addMapping ("/ test / *"); }}

For å sette opp ting uten XML, må du sørge for å ha servlet-api 3.1.0 på klassestien din.

Slik gjør du web.xml vil se ut som:

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

Vi setter inn contextConfigLocation eiendom her - peker på XML fil som brukes til å laste inn vårkonteksten. Hvis eiendommen ikke er der, vil Spring søke etter en fil som heter {servlet_name} -servlet.xml.

I vårt tilfelle servlet_name er test-mvc og så, i dette eksemplet DispatcherServlet vil søke etter en fil som heter test-mvc-servlet.xml.

Til slutt, la oss stille inn DispatcherServlet opp og kartlegge den til en bestemt URL - for å fullføre Frontkontroller basert system her:

 test-mvc / test / * 

Dermed i dette tilfellet DispatcherServlet ville avskjære alle forespørsler i mønsteret /test/* .

5. Spring MVC Web Config

La oss nå se på hvordan Dispatcher Servlet kan settes opp med Vårkonfig:

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

La oss nå se på å sette opp Dispatcher Servlet ved hjelp av XML . Et øyeblikksbilde av DispatcherServlet XML fil - den XML filen som DispatcherServlet bruker for lasting av tilpasset kontrollere og annen Vårenheter er vist nedenfor:

    / WEB-INF / .jsp 

Basert på denne enkle konfigurasjonen vil rammeverket selvfølgelig initialisere enhver kontrollerbønne som den finner på klassestien.

Legg merke til at vi også definerer View Resolver, som er ansvarlig for visningsgjengivelse - vi bruker Spring's InternalResourceViewResolver her. Dette forventer et navn på en utsikt som skal løses, noe som betyr å finne en tilsvarende side ved å bruke prefiks og suffiks (begge er definert i XML konfigurasjon).

Så for eksempel hvis Kontroller returnerer a utsikt heter “Velkommen", de utsiktresolver vil prøve å løse en side som heter “Velkommen.jsp” i WEB-INF mappe.

6. MVC-kontrolleren

La oss nå endelig implementere MVC-stilkontrolleren.

Legg merke til hvordan vi returnerer en ModelAndView objekt - som inneholder en modellkart og en vis objekt; begge vil bli brukt av Vse Resolver for gjengivelse av data:

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

Så, hva satte vi opp her.

Først opprettet vi en kontroller kalt Testkontroll og kartla den til "/test" sti. I klassen har vi laget en metode som returnerer a ModelAndView objekt og er kartlagt til en FÅ be om en URL-samtale som slutter med “test”Ville bli dirigert av DispatcherServlet til getTestData metoden i Testkontroll.

Og selvfølgelig returnerer vi ModelAndView objekt med noen modelldata for godt mål.

Visningsobjektet har et navn satt til “Velkommen“. Som diskutert ovenfor, Vis Resolver vil søke etter en side i WEB-INF mappe som heter “velkommen.jsp“.

Nedenfor kan du se resultatet av et eksempel FÅ operasjon:

Merk at URL slutter med "test". Mønsteret til URL er “/ Test / test“.

Den første "/test" kommer fra Servlet, og den andre kommer fra kartleggingen av kontrolleren.

7. Flere våravhengigheter for REST

La oss nå begynne å se på en RESTful kontroller. Selvfølgelig er et godt sted å starte de ekstra Maven-avhengighetene vi trenger for 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-lenker for de nyeste versjonene av disse avhengighetene.

Jackson er selvfølgelig ikke obligatorisk her, men det er absolutt en god måte å aktivere JSON-støtte på. Hvis du er interessert i å dykke dypere inn i den støtten, kan du ta en titt på artikkelen om meldingsomformere her.

8. REST-kontrolleren

Oppsettet for en Våren RESTful applikasjonen er den samme som den for MVC applikasjon med den eneste forskjellen at det ikke er noen Vse Resolvers og nei modellkart.

API vil vanligvis bare returnere rådata tilbake til klienten - XML og JSON representasjoner vanligvis - og så den DispatcherServlet går utenom se resolver og returnerer dataene rett i HTTP-responsorganet.

La oss ta en titt på en enkel RESTful kontrollerimplementering:

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

Legg merke til @ResponseBody merknad om metoden - som pålegger våren å omgå visningsoppløseren og egentlig skrive ut utdata direkte til kroppen av HTTP-respons.

Et raskt øyeblikksbilde av utgangen vises nedenfor:

Ovennevnte utdata er et resultat av sending av FÅ forespørsel til API med studenten id av 1.

En rask kommentar her er - @RequestMapping kommentar er en av de sentrale merknadene som du virkelig må utforske for å kunne utnytte det fulle potensialet.

9. Spring Boot and the @RestController Kommentar

De @RestController kommentar fra Spring Boot er i utgangspunktet en rask snarvei som sparer oss for å alltid måtte definere @ResponseBody.

Her er forrige eksempelkontroller som bruker denne nye kommentaren:

@RestController offentlig klasse RestAnnotatedController {@GetMapping (verdi = "/ kommentert / student / {studentId}") offentlig Student getData (@PathVariable Heltal studentId) {Studentstudent = ny student (); student.setName ("Peter"); student.setId (studentId); returstudent; }}

10. Konklusjon

I denne guiden utforsker vi det grunnleggende om å bruke kontrollere om våren, både fra et typisk MVC-applikasjonssynspunkt og en RESTful API.

Selvfølgelig er all koden i artikkelen tilgjengelig på GitHub.