Spring MVC教程

Spring MVC è un framework Java utilizzato per costruire applicazioni web. Segue il modello di progettazione Model-View-Controller. Implementa tutte le funzionalità di base del framework Spring, come l'inversione di controllo e l'iniezione di dipendenze.

Spring MVC attraverso DispatcherServlet Fornisce una soluzione elegante per utilizzare MVC nel framework Spring. >. Ecco qui, DispatcherServlet È una classe utilizzata per ricevere le richieste in arrivo e mapparle ai risorse corrispondenti, come il controller, il modello e la vista.

Spring Web Model-View-Controller

Model- Il modello contiene i dati dell'applicazione. I dati possono essere un singolo oggetto o una raccolta di oggetti. Controller- Il controller contiene la logica aziendale dell'applicazione. Qui, l'annotazione @Controller viene utilizzata per marcare la classe come controller. View- La vista rappresenta le informazioni fornite in un formato specifico. Di solito, JSP + JSTL vengono utilizzati per creare le pagine di vista. Anche Spring supporta altre tecnologie di vista, come Apache Velocity, Thymeleaf e FreeMarker. Front Controller- In Spring Web MVC, la classe DispatcherServlet viene utilizzata come controller frontend. Si occupa della gestione del flusso dell'applicazione Spring MVC.

Comprendere il flusso di Spring Web MVC

Come mostrato nell'immagine, tutte le richieste in entrata vengono intercettate dal DispatcherServlet del controller frontend. DispatcherServlet ottiene le voci delle mappature dei gestori dal file XML e reindirizza le richieste al controller. Il controller restituisce l'oggetto ModelAndView. DispatcherServlet verifica le voci del risolvere la vista nel file XML e chiama il componente della vista specificato.

Vantaggi del framework Spring MVC

Ecco alcuni vantaggi del framework Spring MVC: -

Separazione dei ruoli- Spring MVC separa ogni ruolo, tra cui possono essere implementati oggetti specializzati per oggetti modello, controller, oggetti di comando, risolvere la vista, DispatcherServlet, validatori, ecc. Leggero- Utilizza un container servlet leggero per sviluppare e distribuire la tua applicazione. Configurazione potente- Fornisce una configurazione affidabile per il framework e le classi dell'applicazione, inclusi riferimenti facili tra contesti, come da controller web a oggetti di business e validatori. Sviluppo rapido- Spring MVC promuove uno sviluppo rapido e parallelo. Codice aziendale riutilizzabile- Senza creare nuovi oggetti, ci permette di utilizzare oggetti di business esistenti. Facile da testare- In Spring, di solito creiamo classi JavaBeans, che ti permettono di iniettare dati di test utilizzando i metodi setter. Mappatura flessibile- Fornisce annotazioni specifiche per la ridirezione delle pagine facili.

Esempio di framework Spring Web MVC

Ecco un esempio semplice del framework Spring Web MVC. I passaggi sono i seguenti:

Carica i file jar di Spring in Maven o aggiungi le dipendenze Crea la classe del controller Fornisci l'entry del controller nel file web.xml Definisci il bean in un file XML separato Mostra il messaggio nella pagina JSP Avvia il server e depura il progetto

Struttura di directory di Spring MVC

Struttura di directory di Spring MVC utilizzando Maven

File jar necessari o dipendenze Maven

Per eseguire questo esempio, è necessario caricare:

File jar di Spring Core File jar di Spring Web File jar di JSP + JSTL (se si utilizza altra tecnologia di visualizzazione, caricare il relativo file jar).

Scarica tutti i file jar di Spring, inclusi JSP e JSTL.

Se stai utilizzando Maven, non è necessario aggiungere file jar. Ora, devi aggiungere le dipendenze Maven al file pom.xml.

1、在pom.xml文件中提供项目信息和配置。

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
　　xsi:schemaLocation="http://maven.apache.org/POM/4.0.0　http://maven.apache.org/maven-v4_0_0.xsd">
　　<modelVersion>4.0.0</modelVersion>
　　<groupId>com.w3codebox</groupId>
　　<artifactId>SpringMVC</artifactId>
　　<packaging>war</packaging>
　　<version>0.0.1-SNAPSHOT</version>
　　<name>SpringMVC　Maven　Webapp</name>
　　<url>http://maven.apache.org</url>
　　<dependencies>
　　　　<dependency>
　　　　　　<groupId>junit</groupId>
　　　　　　<artifactId>junit</artifactId>
　　　　　　<version>3.8.1</version>
　　　　　　<scope>test</scope>
　　　　</dependency>
　　　　
　　　　<!--　https://mvnrepository.com/artifact/org.springframework/spring-webmvc　-->
<dependency>
　　　　<groupId>org.springframework</groupId>
　　　　<artifactId>spring-webmvc</artifactId>
　　　　<version>5.1.1.RELEASE</version>
</dependency>
<!--　https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api　-->
<dependency>　　
　　　　<groupId>javax.servlet</groupId>　　
　　　　<artifactId>servlet-api</artifactId>　　
　　　　<version>3.0-alpha-1</version>　　
</dependency>
　　</dependencies>
　　<build>
　　　　<finalName>SpringMVC</finalName>
　　</build>
</project>

2、Creare la classe controller

Per creare la classe controller, utilizziamo due annotazioni @Controller e @RequestMapping.

@Controller annotazione utilizzata per marcare la classe come Controller.

@RequestMapping annotazione viene utilizzata per mappare la classe con il nome URL specificato.

HelloController.java

package com.w3codebox;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class HelloController {
@RequestMapping("/")
　　public String display()
　　{
　　　　return "index";
　　}　
}

3、Nella file web.xml fornire l'entry del controller

In questo file XML, specificiamo la classe Servlet DispatcherServlet come il controller front-end di Spring Web MVC. Tutte le richieste in entrata agli html file vengono inoltrate al DispatcherServlet.

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
　　<display-name>SpringMVC</display-name>
　　　<servlet>　　
　　　　<servlet-name>spring</servlet-name>　　
　　　　<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>　　
　　　　<load-on-startup>1</load-on-startup>　　　　
</servlet>　　
<servlet-mapping>　　
　　　　<servlet-name>spring</servlet-name>　　
　　　　<url-pattern>/</url-pattern>　　
</servlet-mapping>　　
</web-app>

4、Definire bean nel file XML.

Questo è un file di configurazione importante in cui è necessario specificare i componenti di visualizzazione.

L'elemento context:component-scan definisce il pacchetto di base del DispatcherServlet. Cercherà le classi del controller.

Questo file XML dovrebbe essere situato nella directory WEB-INF.

spring-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
　　xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"　
　　xmlns:context="http://www.springframework.org/schema/context"
　　xmlns:mvc="http://www.springframework.org/schema/mvc"
　　xsi:schemaLocation="
　　　　http://www.springframework.org/schema/beans
　　　　　　http://www.springframework.org/schema/beans/spring-beans.xsd
　　　　　　http://www.springframework.org/schema/context
　　　　　　http://www.springframework.org/schema/context/spring-context.xsd
　　　　　　http://www.springframework.org/schema/mvc
　　　　　　　　http://www.springframework.org/schema/mvc/spring-mvc.xsd">
　　<!--Fornire supporto per la scansione dei componenti-->
　　
　　<!--Fornire supporto per la conversione, formattazione e validazione-->',
　　<mvc:annotation-driven/>
</beans>

5, visualizzazione messaggi nella pagina JSP

Questa è una semplice pagina JSP che mostra il messaggio restituito dal Controller.

index.jsp

<html>
<body>
<p>Benvenuti nel tutorial Spring MVC</p>
</body>
</html>

output:

indiceMVC