In questo Tutorial di Spring MVC, impareremo a sviluppare un’applicazione web Spring MVC utilizzando Spring Tool Suite. Spring MVC framework è ampiamente utilizzato per le applicazioni web java.
Spring MVC
Proprio come il Framework Struts, anche Spring MVC si basa sulle tecnologie Java EE Servlet e JSP e implementa il pattern di progettazione Modello–Vista–Controller.
Tutorial di Spring MVC
Abbiamo già visto come funziona l’Injection delle Dipendenze di Spring e in questo tutorial impareremo come creare una semplice applicazione web utilizzando il framework Spring MVC. Possiamo utilizzare Eclipse o IntelliJ IDE per lo sviluppo dei progetti Spring, ma SpringSource fornisce anche Spring Tool Suite (STS), un IDE basato su Eclipse che include un VMware vFabric tc Server costruito sopra il container Apache Tomcat e ottimizzato per le applicazioni basate su Spring. Utilizzerò STS per il tutorial di Spring MVC e per i futuri tutorial, poiché semplifica la vita dello sviluppatore offrendo le seguenti caratteristiche:
- Supporto per la creazione di scheletri di applicazioni Spring (MVC, Rest, Batch, ecc.), ideale per iniziare il progetto da zero. Vedremo presto in questo tutorial su Spring MVC quanto sia facile creare un progetto Spring MVC.
- Offre funzionalità utili come la creazione di file di configurazione Spring, l’analisi dei file di configurazione e delle classi per fornire informazioni utili su di essi.
- Validazione automatica dell’applicazione Spring
- Supporto per il refactoring per apportare facilmente modifiche al progetto, le modifiche vengono riflesse anche nei file di configurazione.
- Assistenza al codice non solo per le classi, ma anche per i file di configurazione. Questa caratteristica mi piace molto perché spesso è necessario sapere cosa possiamo utilizzare e i suoi dettagli.
- Miglior supporto per la Programmazione Orientata agli Aspetti (AOP) attraverso l’integrazione di AspectJ.
Guardando tutte le funzionalità fornite da STS, sono stato convinto da questo e ho deciso di utilizzarlo per l’applicazione Spring e fino ad ora sono molto contento. Basta scaricare STS dalla pagina di download ufficiale di STS e installarlo. Sto utilizzando STS 3.4.0.RELEASE che si basa sul rilascio di Eclipse 4.3.1. 
Se non vuoi utilizzare STS e desideri ottenere le sue funzionalità nell’Eclipse esistente, allora è necessario installare il suo plugin dal Marketplace di Eclipse. Utilizza l’immagine seguente come riferimento e assicurati di scegliere la versione corretta di STS per l’installazione. Il plugin seguente è buono per Eclipse Kepler. 
Se non vuoi utilizzare il server di SpringSource, puoi distribuire l’applicazione in qualsiasi altro container Java EE come Tomcat, JBoss, ecc. Per questo tutorial, utilizzerò il server fornito con STS, ma ho testato l’applicazione esportandola come file WAR in un server Tomcat separato ed è funzionante. Ora che il nostro ambiente server e l’IDE sono pronti, procediamo con la creazione del nostro primo progetto Spring MVC. I seguenti passaggi sono validi sia per STS che per Eclipse con i plugin di STS.
Creazione di un’applicazione Spring MVC in STS o Eclipse
Passaggio 1: Crea un nuovo progetto Spring dal menu. 
Passaggio 2: Nella finestra del nuovo progetto, inserisci il nome come “SpringMVCExample” e scegli il modello come “Spring MVC Project”. Se stai utilizzando questo modello per la prima volta, STS lo scaricherà dal sito web di SpringSource. Se vuoi, puoi aggiungere il progetto a qualsiasi insieme di lavoro. 
Passaggio 3: Quando il modello viene scaricato, nella schermata successiva devi fornire il nome del pacchetto di primo livello. Questo pacchetto verrà utilizzato come base per i componenti Spring. 
Passaggio 4: Una volta che il progetto è creato dal modello Spring MVC, assomiglierà all’immagine qui sotto. 
Non preoccuparti se non vedi la classe User.java, i file login.jsp e user.jsp, li ho aggiunti successivamente. Se il tuo progetto non è compilato e vedi degli errori, esegui Maven/Aggiorna Progetto. Assicurati di controllare le opzioni “Aggiornamento forzato di Snapshots/Releases”, consulta l’immagine qui sotto. 
Nel complesso, il progetto assomiglia a qualsiasi altra applicazione web basata su Maven con alcuni file di configurazione di Spring. Ora è il momento di analizzare le diverse parti dei progetti ed estenderle un po’.
Dipendenze di Spring MVC
Il nostro file pom.xml generato appare come segue.
<?xml version="1.0" encoding="UTF-8"?>
<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/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.journaldev</groupId>
<artifactId>SpringMVCExample</artifactId>
<name>SpringMVCExample</name>
<packaging>war</packaging>
<version>1.0.0-BUILD-SNAPSHOT</version>
<properties>
<java-version>1.6</java-version>
<org.springframework-version>4.0.0.RELEASE</org.springframework-version>
<org.aspectj-version>1.7.4</org.aspectj-version>
<org.slf4j-version>1.7.5</org.slf4j-version>
</properties>
<dependencies>
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${org.springframework-version}</version>
<exclusions>
<!-- Exclude Commons Logging in favor of SLF4j -->
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${org.springframework-version}</version>
</dependency>
<!-- AspectJ -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>${org.aspectj-version}</version>
</dependency>
<!-- Logging -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${org.slf4j-version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${org.slf4j-version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.15</version>
<exclusions>
<exclusion>
<groupId>javax.mail</groupId>
<artifactId>mail</artifactId>
</exclusion>
<exclusion>
<groupId>javax.jms</groupId>
<artifactId>jms</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jdmk</groupId>
<artifactId>jmxtools</artifactId>
</exclusion>
<exclusion>
<groupId>com.sun.jmx</groupId>
<artifactId>jmxri</artifactId>
</exclusion>
</exclusions>
<scope>runtime</scope>
</dependency>
<!-- @Inject -->
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</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>
<!-- Test -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.7</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.9</version>
<configuration>
<additionalProjectnatures>
<projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
</additionalProjectnatures>
<additionalBuildcommands>
<buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
</additionalBuildcommands>
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.5.1</version>
<configuration>
<source>1.6</source>
<target>1.6</target>
<compilerArgument>-Xlint:all</compilerArgument>
<showWarnings>true</showWarnings>
<showDeprecation>true</showDeprecation>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.2.1</version>
<configuration>
<mainClass>org.test.int1.Main</mainClass>
</configuration>
</plugin>
</plugins>
</build>
</project>
artifactId sarà il servlet-context per l’applicazione web, quindi puoi cambiarlo se desideri qualcos’altro. Ci sono poche proprietà definite per le versioni di Spring Framework, AspectJ e SLF4j, ho notato che non riflettevano le ultime versioni, quindi le ho cambiate con l’ultima versione stabile di oggi. Le dipendenze del progetto che mi interessano sono;
- spring-context: dipendenza di Spring Core. Notare l’esclusione di commons logging a favore di SLF4J.
- spring-webmvc: artefatto Spring per il supporto MVC
- aspectjrt: riferimento API di AspectJ
- SLF4J e Log4j: per scopi di logging, Spring è molto facile da configurare per log4j o Java Logging API a causa dell’integrazione di SLF4J.
- javax.inject – API JSR330 per l’iniezione di dipendenze
Ci sono alcune altre dipendenze aggiunte, come Servlet, JSP, JSTL e JUnit API ma per l’applicazione iniziale, possiamo trascurarle.
Guida alla configurazione di Log4j nel tutorial Spring MVC
Il file log4j.xml generato appare come segue.
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration PUBLIC "-//APACHE//DTD LOG4J 1.2//EN" "log4j.dtd">
<log4j:configuration xmlns:log4j="https://jakarta.apache.org/log4j/">
<!-- Appenders -->
<appender name="console" class="org.apache.log4j.ConsoleAppender">
<param name="Target" value="System.out" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p: %c - %m%n" />
</layout>
</appender>
<!-- Application Loggers -->
<logger name="com.journaldev.spring">
<level value="info" />
</logger>
<!-- 3rdparty Loggers -->
<logger name="org.springframework.core">
<level value="info" />
</logger>
<logger name="org.springframework.beans">
<level value="info" />
</logger>
<logger name="org.springframework.context">
<level value="info" />
</logger>
<logger name="org.springframework.web">
<level value="info" />
</logger>
<!-- Root Logger -->
<root>
<priority value="warn" />
<appender-ref ref="console" />
</root>
</log4j:configuration>
Notare che sta stampando tutto sulla console, possiamo facilmente aggiungere degli appender per reindirizzare il logging su file.
Configurazione del descrittore di distribuzione nel tutorial Spring MVC
Vediamo il nostro web.xml e analizziamolo.
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="https://java.sun.com/xml/ns/javaee"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<!-- The definition of the Root Spring Container shared by all Servlets and Filters -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/root-context.xml</param-value>
</context-param>
<!-- Creates the Spring Container shared by all Servlets and Filters -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- Processes application requests -->
<servlet>
<servlet-name>appServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>appServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
ContextLoaderListener collega il ciclo di vita di ApplicationContext al ciclo di vita di ServletContext e automatizza la creazione di ApplicationContext. ApplicationContext è il luogo per i bean Spring e possiamo fornire la sua configurazione tramite il parametro di contesto contextConfigLocation. Il file root-context.xml fornisce i dettagli di configurazione per WebApplicationContext. DispatcherServlet è la classe controller per l’applicazione Spring MVC e tutte le richieste dei client vengono gestite da questo servlet. La configurazione viene caricata dal file servlet-context.xml.
Tutorial di Spring MVC – File di configurazione
File root-context.xml:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="https://www.springframework.org/schema/beans"
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- Root Context: defines shared resources visible to all other web components -->
</beans>
Possiamo definire qui i bean condivisi, per ora non c’è nulla. Codice del file servlet-context.xml:
<?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 />
<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
<resources mapping="/resources/**" location="/resources/" />
<!-- 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>
<context:component-scan base-package="com.journaldev.spring" />
</beans:beans>
Ecco come appare il file di configurazione standard di Spring, immagina di scriverlo tutto da solo e inizierai a gradire lo strumento STS. L’elemento annotation-driven viene utilizzato per far sapere al servlet del Controller che verranno utilizzate annotazioni per le configurazioni dei bean. L’elemento resources definisce la posizione in cui possiamo inserire file statici come immagini, pagine HTML, ecc. che non vogliamo ottenere tramite il framework Spring. InternalResourceViewResolver è il risolutore della vista, possiamo fornire la posizione delle pagine di vista tramite le proprietà di prefisso e suffisso. Quindi tutte le nostre pagine JSP dovrebbero trovarsi nella directory /WEB-INF/views/. L’elemento context:component-scan viene utilizzato per fornire la posizione del pacchetto di base per la scansione delle classi Controller. Ricorda il valore del pacchetto di livello superiore dato al momento della creazione del progetto, è lo stesso valore utilizzato qui.
Classe Controller Spring MVC
HomeController viene creato automaticamente con il metodo home(), anche se l’ho esteso un po’ aggiungendo i metodi loginPage() e login().
package com.journaldev.spring;
import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;
/**
* Handles requests for the application home page.
*/
@Controller
public class HomeController {
private static final Logger logger = LoggerFactory.getLogger(HomeController.class);
/**
* Simply selects the home view to render by returning its name.
*/
@RequestMapping(value = "/", method = RequestMethod.GET)
public String home(Locale locale, Model model) {
logger.info("Welcome home! The client locale is {}.", 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 = "/login", method = RequestMethod.GET)
public String loginPage(Locale locale, Model model) {
return "login";
}
@RequestMapping(value = "/home", method = RequestMethod.POST)
public String login(@Validated User user, Model model) {
model.addAttribute("userName", user.getUserName());
return "user";
}
}
L’annotazione @Controller viene utilizzata per indicare che si tratta di una classe di controller web. @RequestMapping viene utilizzato con classi e metodi per reindirizzare la richiesta del client a un metodo handler specifico. Notare che i metodi handler restituiscono una Stringa, che dovrebbe essere il nome della pagina di visualizzazione da utilizzare come risposta. Come si può vedere, abbiamo tre metodi che restituiscono diverse stringhe, quindi è necessario creare pagine JSP con lo stesso nome. Notare che il metodo login() verrà chiamato con il metodo HTTP POST, quindi ci aspettiamo dei dati del modulo qui. Abbiamo quindi una classe di modello User e viene contrassegnata per la validazione utilizzando l’annotazione @Validated. Ogni metodo contiene Model come argomento e possiamo impostare attributi da utilizzare successivamente nelle pagine di risposta JSP.
Classi Model di Spring MVC
Le classi Model vengono utilizzate per contenere le variabili del modulo, il nostro modello di bean User assomiglia a quanto segue.
package com.journaldev.spring;
public class User {
private String userName;
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
}
A simple java bean with the variable name and its getter and setter methods.
Tutorial di Spring MVC – Pagine di visualizzazione
Abbiamo tre pagine JSP come segue. Codice home.jsp:
<%@ 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>
</body>
</html>
Osserva l’uso di Linguaggio di Espressione JSP per ottenere i valori degli attributi. Codice login.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>Login Page</title>
</head>
<body>
<form action="home" method="post">
<input type="text" name="userName"><br>
<input type="submit" value="Login">
</form>
</body>
</html>
A simple JSP page for the user to provide the userName as input. Notice that form variable name is same as User class variable name. Also, form action is “home” and method is “post”. It’s clear that HomeController login() method will handle this request. user.jsp code:
<%@ 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>
Pagina iniziale semplice per l’utente dove viene visualizzato il nome utente, nota che stiamo impostando questo attributo nel metodo di accesso.
Esempio di Applicazione di Test Spring MVC
La nostra applicazione è pronta per l’esecuzione, basta eseguirla su VMware tc Server o su qualsiasi altro contenitore servlet di tua scelta, otterrai le seguenti pagine come risposta. 
Ecco fatto per il Tutorial di Spring MVC, puoi vedere quanto sia facile creare un’applicazione Spring MVC utilizzando i plugin di STS. Le dimensioni del codice sono molto ridotte e la maggior parte della configurazione è gestita da Spring MVC in modo che possiamo concentrarci sulla logica di business. Scarica l’esempio di progetto Spring MVC dal link sottostante e divertiti a sperimentarlo.
Source:
https://www.digitalocean.com/community/tutorials/spring-mvc-tutorial