Esempio di Spring MVC

Tutorial
Spring

Benvenuti all’esempio di Spring MVC. Tempo fa nel Tutorial di Spring MVC , ho spiegato come creare un’applicazione Spring MVC usando Spring Tool Suite. Ma oggi, creerò un’applicazione Spring MVC di base “hello world” usando Maven ed Eclipse.

Esempio di Spring MVC

Spring MVC si basa sull’architettura Model-View-Controller. L’immagine seguente mostra l’architettura di Spring MVC a un livello elevato. DispatcherServlet è la classe controller front-end che gestisce tutte le richieste e inizia a elaborarle. Dobbiamo configurarlo nel file web.xml. Il suo compito è passare la richiesta alla classe controller appropriata e inviare la risposta quando le pagine di visualizzazione hanno generato la pagina di risposta. HomeController.java sarà l’unica classe controller nel nostro esempio di applicazione Spring MVC. home.jsp , user.jsp sono le pagine di visualizzazione nel nostro esempio di applicazione “hello world” di Spring MVC. User.java sarà l’unica classe modello che avremo nella nostra applicazione web di esempio di Spring MVC.

Esempio di progetto Hello World di Spring MVC in Eclipse

Di seguito l’immagine mostra il nostro progetto di esempio di Spring MVC in Eclipse. Cominciamo e creiamo il nostro progetto proprio da zero.

Configurazione del progetto Eclipse di esempio di Spring MVC

Dal momento che si tratta di un’applicazione web e vogliamo utilizzare Maven per la gestione delle dipendenze, prima di tutto dobbiamo creare un’applicazione web dinamica e poi convertirla in un progetto Maven. Di seguito sono riportate le immagini che mostrano come fare questo e ottenere la struttura del progetto pronto. Fare clic con il pulsante destro del mouse sulla finestra dell’esploratore di progetti e fare clic su “Nuovo -> Progetto Web Dinamico” come mostrato nell’immagine sottostante. Fornire il nome come “spring-mvc-example” nella pagina di popup successiva, il resto delle cose non dovrebbe essere necessario modificare. Nella pagina successiva, fornire la cartella delle sorgenti come “src/main/java”. Potrebbe essere necessario rimuovere la cartella “src” dall’elenco prima di aggiungerla. Successivamente è la pagina del modulo web, fornire il contesto radice dell’applicazione come “spring-mvc-example” e assicurarsi di selezionare l’opzione “Generare descrittore di distribuzione web.xml”. Fare clic su Fine e avrai un nuovo Progetto Web Dinamico nell’esploratore di progetti di Eclipse.

Convertire un progetto Web dinamico in un progetto Maven

Vogliamo utilizzare Maven per gestire facilmente le nostre dipendenze spring mvc. Quindi convertiamo il nostro progetto web in un progetto Maven. Fare clic con il pulsante destro del mouse sul progetto e selezionare “Configura -> Converti in progetto Maven”. Successivamente fornire le configurazioni del file pom.xml come mostrato di seguito. Il codice scheletro del nostro progetto di applicazione web Maven è pronto. Ora possiamo iniziare a fare modifiche ad esso e creare il nostro esempio di applicazione hello world di spring mvc.

Dipendenze di Spring MVC nel file pom.xml

Dobbiamo aggiungere le dipendenze spring-web e spring-webmvc nel file pom.xml, aggiungere anche le dipendenze servlet-api, jsp-api e jstl. Il nostro file pom.xml finale sarà come segue.

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.journaldev.spring.mvc</groupId>
	<artifactId>spring-mvc-example</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>
	<name>Spring MVC Example</name>
	<description>Spring MVC Hello World Example</description>

	<!-- Add Spring Web and MVC dependencies -->
	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>4.3.9.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>4.3.9.RELEASE</version>
		</dependency>
		<!-- Servlet -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet.jsp</groupId>
			<artifactId>jsp-api</artifactId>
			<version>2.1</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.6.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
			<plugin>
				<artifactId>maven-war-plugin</artifactId>
				<version>3.0.0</version>
				<configuration>
					<warSourceDirectory>WebContent</warSourceDirectory>
				</configuration>
			</plugin>
		</plugins>
		<finalName>${project.artifactId}</finalName> <!-- added to remove Version from WAR file -->
	</build>
</project>

Nota la configurazione finalName nel build, in modo che il nome del nostro file WAR non contenga dettagli sulla versione. Quando il progetto viene compilato da Eclipse, noterai che tutti i file JAR appaiono nella sezione delle dipendenze di Maven.

DispatcherServlet di Spring MVC come controller frontale

Dobbiamo aggiungere il framework Spring MVC alla nostra applicazione web, per questo dobbiamo configurare DispatcherServlet in web.xml come mostrato di seguito.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns="https://java.sun.com/xml/ns/javaee" xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
  <display-name>spring-mvc-example</display-name>

	<!-- Add Spring MVC DispatcherServlet as front controller -->
	<servlet>
        <servlet-name>spring</servlet-name>
        <servlet-class>
                org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <init-param>
       		<param-name>contextConfigLocation</param-name>
       		<param-value>/WEB-INF/spring-servlet.xml</param-value>
    		</init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>spring</servlet-name>
        <url-pattern>/</url-pattern> 
    </servlet-mapping>
    
 </web-app>

Il parametro di inizializzazione contextConfigLocation viene utilizzato per fornire la posizione del file di configurazione dei bean di Spring.

File di configurazione dell’esempio di bean di Spring MVC

Il passo successivo è creare il file di configurazione dei bean di Spring spring-servlet.xml come mostrato di seguito.

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="https://www.springframework.org/schema/mvc"
	xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:beans="https://www.springframework.org/schema/beans"
	xmlns:context="https://www.springframework.org/schema/context"
	xsi:schemaLocation="https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
		https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

	<!-- DispatcherServlet Context: defines this servlet's request-processing 
		infrastructure -->

	<!-- Enables the Spring MVC @Controller programming model -->
	<annotation-driven />
	<context:component-scan base-package="com.journaldev.spring" />

	<!-- Resolves views selected for rendering by @Controllers to .jsp resources 
		in the /WEB-INF/views directory -->
	<beans:bean
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<beans:property name="prefix" value="/WEB-INF/views/" />
		<beans:property name="suffix" value=".jsp" />
	</beans:bean>

</beans:beans>

Ci sono tre configurazioni importanti.

  1. annotation-driven dice a DispatcherServlet di cercare le classi del controller utilizzando l’annotazione @Controller.
  2. context:component-scan dice a DispatcherServlet dove cercare le classi del controller.
  3. Configurazione del bean InternalResourceViewResolver per specificare la posizione delle pagine di visualizzazione e il suffisso utilizzato. I metodi della classe del controller restituiscono il nome della pagina di visualizzazione e quindi il suffisso viene aggiunto per determinare la pagina di visualizzazione da utilizzare per la generazione della risposta.

Classe del controller di Spring MVC

Abbiamo una singola classe di controller per gestire due URI: “/” per la pagina principale e “/user” per la pagina dell’utente.

package com.journaldev.spring.controller;

import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.journaldev.spring.model.User;

@Controller
public class HomeController {

	/**
	 * Simply selects the home view to render by returning its name.
	 */
	@RequestMapping(value = "/", method = RequestMethod.GET)
	public String home(Locale locale, Model model) {
		System.out.println("Home Page Requested, locale = " + locale);
		Date date = new Date();
		DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);

		String formattedDate = dateFormat.format(date);

		model.addAttribute("serverTime", formattedDate);

		return "home";
	}

	@RequestMapping(value = "/user", method = RequestMethod.POST)
	public String user(@Validated User user, Model model) {
		System.out.println("User Page Requested");
		model.addAttribute("userName", user.getUserName());
		return "user";
	}
}

Si noti che per semplicità, non è stato utilizzato alcun framework di logging come log4j.

Classe del modello di Spring MVC

Abbiamo una semplice classe di modello con una singola variabile e i suoi metodi getter-setter. È una semplice classe POJO.

package com.journaldev.spring.model;

public class User {
	private String userName;

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}
}

Pagine di visualizzazione di Spring MVC

Abbiamo due pagine di visualizzazione definite come segue. home.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%@ taglib uri="https://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@ page session="false"%>
<html>
<head>
<title>Home</title>
</head>
<body>
	<h1>Hello world!</h1>

	<P>The time on the server is ${serverTime}.</p>

	<form action="user" method="post">
		<input type="text" name="userName"><br> <input
			type="submit" value="Login">
	</form>
</body>
</html>

user.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>User Home Page</title>
</head>
<body>
<h3>Hi ${userName}</h3>
</body>
</html>

Nota che Spring MVC si occupa di mappare le variabili del modulo alle variabili della classe del modello, ecco perché abbiamo lo stesso nome di variabile in entrambi i posti. Ecco, il nostro progetto di esempio di Spring MVC è pronto per essere distribuito e testato.

Deploy del Progetto di Esempio di Spring MVC su Eclipse

Possiamo utilizzare l’opzione di esportazione come file WAR di Eclipse per distribuirlo direttamente nella directory webapps di qualsiasi server tomcat in esecuzione. Tuttavia, è anche possibile utilizzare la riga di comando per compilare il progetto e quindi copiarlo nella directory di distribuzione del tuo servlet container preferito.

Test dell’Esempio di Spring MVC

Una volta che il progetto spring mvc è stato distribuito, possiamo accedere alla homepage su https://localhost:8080/spring-mvc-example/. Cambiare la porta e il contesto di Tomcat di conseguenza. Questo è tutto per l’esempio di Spring MVC, ho cercato di mantenerlo il più semplice possibile. Ma se incontri comunque problemi, per favore fammelo sapere attraverso i commenti e cercherò di aiutarti. Puoi scaricare il progetto finale di esempio di Spring MVC dal seguente link.

Scarica il Progetto di Esempio di Spring MVC

Riferimenti: Pagina Ufficiale

Source:
https://www.digitalocean.com/community/tutorials/spring-mvc-example