Spring MVC Tutorial

1. Översikt

Detta är en enkel Spring MVC-handledning som visar hur man ställer in ett Spring MVC-projekt, både med en Java-baserad konfiguration och med XML-konfiguration.

Maven-beroenden för ett Spring MVC-projekt beskrivs i detalj i artikeln om vår MVC-beroenden.

2. Vad är Spring MVC?

Som namnet antyder är det en modul i vårramen som handlar om Model-View-Controller eller MVC-mönster . Den kombinerar alla fördelar med MVC-mönstret med bekvämligheten med våren.

Fjäder implementerar MVC med det främre styrmönstret med dess DispatcherServlet .

I ett nötskal fungerar DispatcherServlet som huvudkontroll för att dirigera förfrågningar till deras avsedda destination. Modellen är ingenting annat än data i vår applikation, och vyn representeras av någon av de olika mallmotorerna. Vi tittar på JSP i vårt exempel på ett tag.

3. Spring MVC med Java-konfiguration

För att aktivera Spring MVC-stöd genom en Java-konfigurationsklass är allt vi behöver göra att lägga till @EnableWebMvc- anteckningen :

@EnableWebMvc @Configuration public class WebConfig { /// ... }

Detta kommer att ställa in det grundläggande stödet vi behöver för ett MVC-projekt, som att registrera styrenheter och mappningar, typomvandlare, valideringsstöd, meddelandekonverterare och undantagshantering.

Om vi ​​vill anpassa den här konfigurationen måste vi implementera gränssnittet WebMvcConfigurer :

@EnableWebMvc @Configuration public class WebConfig implements WebMvcConfigurer { @Override public void addViewControllers(ViewControllerRegistry registry) { registry.addViewController("/").setViewName("index"); } @Bean public ViewResolver viewResolver() { InternalResourceViewResolver bean = new InternalResourceViewResolver(); bean.setViewClass(JstlView.class); bean.setPrefix("/WEB-INF/view/"); bean.setSuffix(".jsp"); return bean; } }

I det här exemplet har vi registrerat en ViewResolver- böna som returnerar .jsp- vyer från / WEB-INF / view- katalogen.

Mycket viktigt här är att vi kan registrera visningskontrollanter som skapar en direkt mappning mellan webbadressen och visningsnamnet med ViewControllerRegistry. På det här sättet finns det inget behov av någon kontroller mellan de två.

Om vi ​​också vill definiera och skanna kontrollerklasser kan vi lägga till @ComponentScan- anteckningen med paketet som innehåller styrenheterna:

@EnableWebMvc @Configuration @ComponentScan(basePackages = { "com.baeldung.web.controller" }) public class WebConfig implements WebMvcConfigurer { // ... }

För att starta en applikation som laddar den här konfigurationen behöver vi också en initialiseringsklass:

public class MainWebAppInitializer implements WebApplicationInitializer { @Override public void onStartup(final ServletContext sc) throws ServletException { AnnotationConfigWebApplicationContext root = new AnnotationConfigWebApplicationContext(); root.scan("com.baeldung"); sc.addListener(new ContextLoaderListener(root)); ServletRegistration.Dynamic appServlet = sc.addServlet("mvc", new DispatcherServlet(new GenericWebApplicationContext())); appServlet.setLoadOnStartup(1); appServlet.addMapping("/"); } }

Observera att för versioner tidigare än vår 5 måste vi använda klassen WebMvcConfigurerAdapter istället för gränssnittet.

4. Vår-MVC med XML-konfiguration

Alternativt till Java-konfigurationen ovan kan vi också använda en ren XML-konfiguration:

Om vi ​​vill använda en ren XML-konfiguration måste vi också lägga till en web.xml- fil för att starta applikationen. För mer information om detta tillvägagångssätt, kolla in vår tidigare artikel.

5. Styrenhet och vyer

Låt oss ta en titt på ett exempel på en grundläggande styrenhet:

@Controller public class SampleController { @GetMapping("/sample") public String showForm() { return "sample"; } }

Och motsvarande jsp-resurs är filen sample.jsp :

De JSP-baserade vyfilerna ligger under / WEB-INF- mappen i projektet, så de är bara tillgängliga för vårinfrastrukturen och inte genom direkt URL-åtkomst.

6. Vår-MVC med bagageutrymme

Spring Boot är ett tillskott till Spring Platform vilket gör det väldigt enkelt att komma igång och skapa fristående applikationer av produktionskvalitet. Kängan är inte avsedd att ersätta våren utan att göra arbetet med den snabbare och enklare.

6.1. Spring Boot Starters

Det nya ramverket ger praktiska beroenden - som är beroendebeskrivare som kan ta med all nödvändig teknik för en viss funktion.

Dessa har fördelen att vi inte längre behöver ange en version för varje beroende utan istället låta startaren hantera beroenden för oss.

Det snabbaste sättet att komma igång är genom att lägga till spring-boot-starter- parent pom.xml:

 org.springframework.boot spring-boot-starter-parent 2.2.2.RELEASE 

Detta kommer att ta hand om beroendehantering.

6.2. Vårens startpunkt

Varje applikation byggd med Spring Boot behöver bara definiera huvudingångspunkten. Detta är vanligtvis en Java-klass med huvudmetoden, kommenterad med @SpringBootApplication :

@SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } 

Den här anteckningen lägger till följande andra anteckningar:

  • @Configuration - som markerar klassen som en källa till definitioner av bönor
  • @EnableAutoConfiguration - som säger att ramverket ska lägga till bönor baserat på beroenden på klassstigen automatiskt
  • @ComponentScan - som söker efter andra konfigurationer och bönor i samma paket som applikationsklassen eller nedan

Med Spring Boot kan vi ställa in frontend med Thymeleaf eller JSP utan att använda ViewResolver enligt definitionen i avsnitt 3. Genom att lägga till fjäder-boot-starter-thymeleaf- beroende till vår pom.xml blir Thymeleaf aktiverad och ingen extra konfiguration är nödvändig.

Källkoden för Boot-appen är som alltid tillgänglig på GitHub.

Slutligen, om du vill komma igång med Spring Boot, ta en titt på vårt referensintro här.

7. Slutsats

I det här exemplet konfigurerade vi ett enkelt och funktionellt Spring MVC-projekt med Java-konfiguration.

Implementeringen av denna enkla Spring MVC-handledning finns i GitHub-projektet.

När projektet körs lokalt kan sample.jsp nås på // localhost: 8080 / spring-mvc-basics / sample.