Spring MVC Beispiel

Tutorials
Spring

Willkommen zum Spring MVC Beispiel. Vor einiger Zeit in Spring MVC Tutorial habe ich erklärt, wie man eine Spring MVC-Anwendung mit dem Spring Tool Suite erstellt. Aber heute werde ich eine grundlegende „Hallo Welt“ Spring MVC-Anwendung mit Maven und Eclipse erstellen.

Spring MVC Beispiel

Spring MVC basiert auf der Model-View-Controller-Architektur. Das folgende Bild zeigt die Spring MVC-Architektur auf hoher Ebene. Die DispatcherServlet-Klasse ist die Front-Controller-Klasse, um alle Anfragen entgegenzunehmen und mit der Verarbeitung zu beginnen. Wir müssen sie in der web.xml-Datei konfigurieren. Ihre Aufgabe ist es, die Anfrage an die entsprechende Controller-Klasse weiterzuleiten und die Antwort zurückzusenden, wenn die Ansichtsseiten die Antwortseite gerendert haben. HomeController.java wird die einzige Controller-Klasse in unserer Spring MVC-Beispielanwendung sein. home.jsp und user.jsp sind die Ansichtsseiten in unserem „Hallo Welt“ Spring MVC Beispiel. User.java wird die einzige Modellklasse sein, die wir in unserer Spring MVC-Beispiel-Webanwendung haben werden.

Spring MVC Beispiel Hallo Welt Eclipse Projekt

Unten sehen Sie unser Beispielprojekt für Spring MVC in Eclipse. Lassen Sie uns beginnen und unser Projekt von Grund auf erstellen.

Spring MVC Beispiel Eclipse Projekt Setup

Da es sich um eine Webanwendung handelt und wir Maven zur Verwaltung von Abhängigkeiten verwenden möchten, müssen wir zunächst eine dynamische Webanwendung erstellen und sie dann in ein Maven-Projekt konvertieren. Die folgenden Bilder zeigen, wie dies gemacht wird und wie die Projekt-Skelettstruktur erstellt wird. Klicken Sie mit der rechten Maustaste auf das Projekt-Explorer-Fenster und wählen Sie „Neu -> Dynamisches Webprojekt“, wie im folgenden Bild gezeigt. Geben Sie im nächsten Popup-Fenster den Namen „spring-mvc-example“ ein, der Rest sollte nicht geändert werden müssen. Auf der nächsten Seite geben Sie den Quellordner als „src/main/java“ an. Möglicherweise müssen Sie den Ordner „src“ aus der Liste entfernen, bevor Sie diesen hinzufügen. Als Nächstes folgt die Webmodulseite. Geben Sie den Kontextstamm der Anwendung als „spring-mvc-example“ an und stellen Sie sicher, dass die Option „Web.xml-Bereitstellungsbeschreibung generieren“ aktiviert ist. Klicken Sie auf Fertig stellen, und Sie haben ein neues dynamisches Webprojekt in Ihrem Eclipse-Projekt-Explorer.

Konvertierung eines Dynamic Webprojekts in ein Maven-Projekt

Wir möchten Maven verwenden, um unsere Spring MVC-Abhängigkeiten einfach zu verwalten. Also konvertieren wir unser Webprojekt in Maven. Klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie „Konfigurieren -> In Maven-Projekt konvertieren“. Geben Sie als Nächstes die pom.xml-Konfigurationen wie unten gezeigt ein. Unser Maven-Webanwendungsprojekt-Skelettcode ist bereit. Jetzt können wir Änderungen daran vornehmen und unsere Spring MVC Hello-World-Beispielanwendung erstellen.

Spring MVC-Abhängigkeiten zur pom.xml hinzufügen

Wir müssen die Abhängigkeiten spring-web und spring-webmvc in der pom.xml hinzufügen und auch die Abhängigkeiten servlet-api, jsp-api und jstl hinzufügen. Unsere endgültige pom.xml-Datei wird wie folgt aussehen.

<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>

Beachten Sie die Konfiguration finalName im Build, damit der Name unserer WAR-Datei keine Versionsdetails enthält. Wenn das Projekt von Eclipse erstellt wird, werden Sie feststellen, dass alle Jars im Abschnitt der Maven-Abhängigkeiten angezeigt werden.

Spring MVC DispatcherServlet als Front-Controller

Wir müssen das Spring MVC-Framework zu unserer Webanwendung hinzufügen. Dazu müssen wir den DispatcherServlet in der web.xml wie unten gezeigt konfigurieren. 

<?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>

Der init-param contextConfigLocation wird verwendet, um den Speicherort der Spring-Bean-Konfigurationsdatei anzugeben.

Beispiel für eine Spring MVC Bean-Konfigurationsdatei

Der nächste Schritt besteht darin, die Spring-Bean-Konfigurationsdatei spring-servlet.xml wie unten gezeigt zu erstellen. 

<?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>

Es gibt drei wichtige Konfigurationen.

  1. annotation-driven sagt dem DispatcherServlet, nach Controller-Klassen mit der @Controller Annotation zu suchen.
  2. context:component-scan sagt dem DispatcherServlet, wo es nach Controller-Klassen suchen soll.
  3. InternalResourceViewResolver-Bean-Konfiguration, um den Speicherort der Ansichtsseiten und das verwendete Suffix anzugeben. Die Methoden der Controller-Klasse geben den Namen der Ansichtsseite zurück, und dann wird das Suffix hinzugefügt, um die Ansichtsseite für die Darstellung der Antwort zu ermitteln.

Spring MVC Controller-Klasse

Wir haben eine einzige Controller-Klasse, die auf zwei URIs reagiert – „/ „für die Startseite und „/user“ für die Benutzerseite.

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";
	}
}

Beachten Sie, dass ich aus Gründen der Einfachheit kein Logging-Framework wie log4j verwendet habe.

Spring MVC Model-Klasse

Wir haben eine einfache Model-Klasse mit einer einzigen Variable und den Getter-Setter-Methoden. Es handelt sich um eine einfache POJO-Klasse.

package com.journaldev.spring.model;

public class User {
	private String userName;

	public String getUserName() {
		return userName;
	}

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

Spring MVC Ansichtsseiten

Wir haben zwei Ansichtsseiten wie unten definiert. 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>

Beachten Sie, dass Spring MVC sich um das Zuordnen von Formvariablen zu Variablen der Modelklasse kümmert, deshalb haben wir denselben Variablennamen an beiden Stellen. Das war’s, unser Beispielprojekt für Spring MVC ist bereit, bereitgestellt und getestet zu werden.

Spring MVC Eclipse Projektbereitstellung

Wir können die Option „Als WAR-Datei exportieren“ in Eclipse verwenden, um sie direkt in das Verzeichnis „webapps“ eines laufenden Tomcat-Servers zu bereitstellen. Alternativ können Sie auch die Befehlszeile verwenden, um das Projekt zu erstellen und es dann in das Bereitstellungsverzeichnis Ihres bevorzugten Servlet-Containers zu kopieren.

Spring MVC Beispieltest

Sobald das Spring MVC-Projekt bereitgestellt ist, können wir auf die Startseite unter https://localhost:8080/spring-mvc-example/ zugreifen. Ändern Sie den Tomcat-Port und den Kontextpfad entsprechend. Das ist alles für das Spring MVC-Beispiel. Ich habe versucht, es so einfach wie möglich zu halten. Wenn Sie dennoch auf Probleme stoßen, lassen Sie es mich bitte über Kommentare wissen, und ich werde versuchen, Ihnen zu helfen. Sie können das endgültige Spring MVC-Beispielprojekt über den folgenden Link herunterladen.

Spring MVC Beispielprojekt herunterladen

Referenzen: Offizielle Seite

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