In diesem Spring MVC-Tutorial lernen wir, wie man eine Spring MVC-Webanwendung mit dem Spring Tool Suite entwickelt. Das Spring MVC-Framework wird weitgehend für Java-Webanwendungen verwendet.
Spring MVC
Ähnlich wie das Struts Framework basiert auch Spring MVC auf den Java EE-Technologien Servlet und JSP und setzt das Model–View–Controller-Entwurfsmuster um.
Spring MVC-Tutorial
Wir haben bereits gesehen, wie die Spring Dependency Injection funktioniert, und in diesem Tutorial werden wir lernen, wie man eine einfache Webanwendung mit dem Spring MVC Framework erstellt. Wir können Eclipse oder IntelliJ IDE für die Entwicklung von Spring-Projekten verwenden, aber SpringSource bietet auch das Spring Tool Suite (STS) an, das eine IDE auf Eclipse-Basis ist und mit einem integrierten VMware vFabric tc Server geliefert wird, der auf dem Apache Tomcat-Container aufbaut und für Spring-basierte Anwendungen optimiert ist. Ich würde STS für das Spring MVC Tutorial und andere zukünftige Tutorials verwenden, weil es das Leben eines Entwicklers erleichtert, indem es folgende Funktionen bietet:
- Unterstützung bei der Erstellung von Skelett-Spring-Anwendungen (MVC, Rest, Batch usw.), gut geeignet für den Projektstart von Grund auf. Wir werden gleich in diesem Spring MVC Tutorial sehen, wie einfach es ist, ein Spring MVC-Projekt zu erstellen.
- Bietet nützliche Funktionen wie das Erstellen von Spring-Konfigurationsdateien, das Parsen von Konfigurationsdateien und Klassen, um nützliche Informationen darüber bereitzustellen.
- Automatische Validierung von Spring-Anwendungen
- Unterstützung beim Refactoring, um Projektänderungen leicht vorzunehmen, die Änderungen werden auch in den Konfigurationsdateien widergespiegelt.
- Code-Assistenz nicht nur für Klassen, sondern auch für Konfigurationsdateien, ich mag diese Funktion sehr, weil wir meistens wissen müssen, was wir verwenden können und deren Details.
- Beste Unterstützung für Aspektorientierte Programmierung (AOP) durch die Integration von AspectJ.
Angesichts aller Funktionen, die STS bietet, war ich davon überzeugt und habe mich entschieden, es für meine Spring-Anwendung zu verwenden. Laden Sie einfach das STS von der STS Official Download Page herunter und installieren Sie es. Ich benutze STS 3.4.0.RELEASE, das auf Eclipse 4.3.1 basiert. 
Wenn Sie STS nicht verwenden möchten und die Funktionen in Ihrer bestehenden Eclipse-Umgebung nutzen möchten, müssen Sie das Plugin aus dem Eclipse Marketplace installieren. Verwenden Sie das unten stehende Bild als Referenz und stellen Sie sicher, die richtige STS-Version für die Installation auszuwählen. Das folgende Plugin eignet sich gut für Eclipse Kepler. 
Falls Sie den SpringSource-Server nicht nutzen möchten, können Sie die Anwendung in einem anderen Java-EE-Container wie Tomcat, JBoss usw. bereitstellen. Für dieses Tutorial werde ich den Server verwenden, der mit STS geliefert wird, aber ich habe die Anwendung auch erfolgreich als WAR-Datei in einem separaten Tomcat-Server getestet. Jetzt, da unsere Serverumgebung und IDE bereit sind, können wir mit der Erstellung unseres ersten Spring MVC-Projekts fortfahren. Die folgenden Schritte gelten sowohl für STS als auch für Eclipse mit STS-Plugins.
Erstellen einer Spring MVC-Anwendung in STS oder Eclipse
Schritt 1: Erstellen Sie ein neues Spring-Projekt aus dem Menü heraus. 
Schritt 2: Geben Sie im neuen Projektfenster den Namen „SpringMVCExample“ ein und wählen Sie die Vorlage „Spring MVC Project“ aus. Wenn Sie diese Vorlage zum ersten Mal verwenden, wird sie von der SpringSource-Website heruntergeladen. Wenn Sie möchten, können Sie das Projekt einer Arbeitsgruppe hinzufügen. 
Schritt 3: Wenn die Vorlage heruntergeladen wurde, müssen Sie im nächsten Bildschirm den Namen des Top-Level-Pakets angeben. Dieses Paket wird als Basispaket für Spring-Komponenten verwendet. 
Schritt 4: Sobald das Projekt von der Spring MVC-Vorlage erstellt wurde, wird es wie im folgenden Bild aussehen. 
Machen Sie sich keine Sorgen, wenn Sie die Klasse User.java, die Dateien login.jsp und user.jsp nicht sehen, sie wurden später von mir hinzugefügt. Wenn Ihr Projekt nicht kompiliert ist und Sie einige Fehler sehen, führen Sie Maven/Update Project aus. Stellen Sie sicher, dass die Optionen „Force update of Snapshots/Releases“ aktiviert sind, siehe untenstehendes Bild. 
Das Gesamtprojekt sieht aus wie jede andere mavenbasierte Webanwendung mit einigen Spring-Konfigurationsdateien. Jetzt ist es an der Zeit, die verschiedenen Teile des Projekts zu analysieren und es ein wenig zu erweitern.
Spring MVC Abhängigkeiten
Unsere generierte pom.xml-Datei sieht wie folgt aus.
<?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 wird für die Webanwendung servlet-context sein, daher können Sie es ändern, wenn Sie etwas anderes möchten. Es sind einige Eigenschaften für die Spring Framework-, AspectJ- und SLF4j-Versionen definiert. Ich habe festgestellt, dass sie nicht die neuesten Versionen widerspiegeln, daher habe ich sie auf die neueste stabile Version geändert, die heute verfügbar ist. Die Projektabhängigkeiten, die mich interessieren, sind;
- spring-context: Spring Core-Abhängigkeit. Beachten Sie das Ausschließen von Commons Logging zugunsten von SLF4J.
- spring-webmvc: Spring-Artefakt für MVC-Unterstützung
- aspectjrt: AspectJ API-Referenz
- SLF4J und Log4j: Für Protokollzwecke ist Spring sehr einfach für log4j oder Java Logging API zu konfigurieren, aufgrund der SLF4J-Integration.
- javax.inject – JSR330 API für Dependency Injection
Es gibt einige andere Abhängigkeiten, wie Servlet, JSP, JSTL und JUnit API, aber für die Starteranwendung können wir sie übersehen.
Spring MVC Tutorial – Log4j Konfiguration
Die generierte log4j.xml-Datei sieht wie folgt aus.
<?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>
Beachten Sie, dass alles auf die Konsole gedruckt wird. Wir können problemlos Appender hinzufügen, um die Protokollierung in Dateien umzuleiten.
Spring MVC Tutorial – Bereitstellungskonfiguration des Bereitstellungsdeskriptors
Lassen Sie uns unsere web.xml ansehen und analysieren.
<?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 bindet den ApplicationContext-Lebenszyklus an den ServletContext-Lebenszyklus und automatisiert die Erstellung des ApplicationContext. Der ApplicationContext ist der Ort für Spring-Beans, und wir können seine Konfiguration über den contextConfigLocation-Kontextparameter bereitstellen. Die Datei root-context.xml enthält die Konfigurationsdetails für WebApplicationContext. DispatcherServlet ist die Controller-Klasse für die Spring MVC-Anwendung, und alle Client-Anfragen werden von diesem Servlet bearbeitet. Die Konfiguration wird aus der Datei servlet-context.xml geladen.
Spring MVC Tutorial – Konfigurationsdateien
root-context.xml-Datei:
<?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>
Hier können wir gemeinsam genutzte Beans definieren, aber momentan ist noch nichts darin enthalten. servlet-context.xml-Code:
<?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>
So sieht die Standard-Spring-Konfigurationsdatei aus. Stellen Sie sich einfach vor, Sie würden das alles selbst schreiben, und Sie werden das STS-Tool mögen. Das annotation-driven-Element wird verwendet, um dem Controller-Servlet mitzuteilen, dass Annotationen für Bean-Konfigurationen verwendet werden. Das Ressourcen-Element definiert den Speicherort, an dem wir statische Dateien wie Bilder, HTML-Seiten usw. ablegen können, die wir nicht über das Spring-Framework abrufen möchten. InternalResourceViewResolver ist der Ansichtsresolver. Wir können den Speicherort der Ansichtsseiten über die Präfix- und Suffix-Eigenschaften angeben. Alle unsere JSP-Seiten sollten sich also im Verzeichnis /WEB-INF/views/ befinden. Das context:component-scan-Element wird verwendet, um den Basis-Paketstandort für das Scannen von Controller-Klassen anzugeben. Denken Sie daran, den Wert des Top-Level-Pakets bei der Projekterstellung anzugeben. Hier wird derselbe Wert verwendet.
Spring MVC Controller-Klasse
Der HomeController wird automatisch mit der Methode home() erstellt, obwohl ich ihn ein wenig erweitert habe, indem ich die Methoden loginPage() und login() hinzugefügt habe. Die
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";
}
}
@Controller-Annotation wird verwendet, um anzuzeigen, dass es sich um eine Web-Controller-Klasse handelt. Die @RequestMapping-Annotation wird mit Klassen und Methoden verwendet, um die Client-Anfrage an eine bestimmte Handler-Methode umzuleiten. Beachten Sie, dass Handler-Methoden einen String zurückgeben, dies sollte der Name der anzuzeigenden View-Seite als Antwort sein. Wie Sie sehen können, haben wir drei Methoden, die unterschiedliche Strings zurückgeben, daher müssen wir JSP-Seiten mit dem gleichen Namen erstellen. Beachten Sie, dass die Methode login() mit der HTTP-Methode POST aufgerufen wird, daher erwarten wir hier Formulardaten. Daher haben wir die User-Modellklasse und sie ist mit der @Validated-Annotation zur Validierung markiert. Jede Methode enthält Model als Argument und wir können Attribute setzen, die später in den JSP-Antwortseiten verwendet werden sollen. Die
Spring MVC-Modellklassen
Modellklassen werden verwendet, um Formularvariablen zu halten, unser User-Modell-Bean sieht wie folgt aus.
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.
Spring MVC-Tutorial – View-Seiten
Wir haben drei JSP-Seiten wie unten. Code für die 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>
Beachten Sie die Verwendung von JSP Expression Language, um die Attributwerte zu erhalten. Code für die 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>
Einfache Startseite für den Benutzer, auf der der Benutzername angezeigt wird. Beachten Sie, dass wir dieses Attribut in der Anmeldemethode setzen.
Spring MVC Beispielanwendungstest
Unsere Anwendung ist bereit zur Ausführung, führen Sie sie einfach auf dem VMware tc Server oder einem anderen Servlet-Container Ihrer Wahl aus, und Sie erhalten die folgenden Seiten als Antwort. 
Das ist alles für das Spring MVC Tutorial, Sie können sehen, wie einfach es ist, eine Spring MVC-Anwendung mit STS-Plugins zu erstellen. Der Code ist sehr klein und die meisten Konfigurationen werden von Spring MVC behandelt, sodass wir uns auf die Geschäftslogik konzentrieren können. Laden Sie das Beispielprojekt für Spring MVC über den folgenden Link herunter und probieren Sie es aus.
Source:
https://www.digitalocean.com/community/tutorials/spring-mvc-tutorial