Voorbeeld van Spring MVC

Handleidingen
Spring

Welkom bij het Spring MVC Voorbeeld. Enige tijd geleden in de Spring MVC Zelfstudie, legde ik uit hoe je een Spring MVC-toepassing kunt maken met behulp van Spring Tool Suite. Maar vandaag zal ik een eenvoudige hello world Spring MVC-toepassing maken met behulp van maven en Eclipse.

Spring MVC Voorbeeld

Spring MVC is gebaseerd op de Model-View-Controller-architectuur. Onderstaande afbeelding toont de Spring MVC-architectuur op een hoog niveau. DispatcherServlet is de front-controllerklasse om alle verzoeken te ontvangen en te starten met verwerken. We moeten het configureren in het web.xml-bestand. Het heeft als taak om het verzoek door te sturen naar de juiste controllerklasse en de reactie terug te sturen wanneer de weergavepagina’s de reactiepagina hebben gerenderd. HomeController.java zal de enkele controllerklasse zijn in ons voorbeeld van een Spring MVC-toepassing. home.jsp, user.jsp zijn de weergavepagina’s in ons voorbeeld van een Spring MVC-hallo wereldtoepassing. User.java zal de enige modelklasse zijn die we zullen hebben in onze webtoepassing van het voorbeeld van Spring MVC.

Voorbeeld van Spring MVC Hello World Eclipse-project

Onderstaande afbeelding toont ons voorbeeldproject van Spring MVC in Eclipse. Laten we beginnen en ons project helemaal opnieuw maken.

Spring MVC Voorbeeld Eclipse Project Setup

Aangezien het een webtoepassing is en we Maven willen gebruiken voor het beheer van afhankelijkheden, moeten we eerst een dynamische webtoepassing maken en deze vervolgens converteren naar een Maven-project. Onderstaande afbeeldingen laten zien hoe je dit moet doen en hoe je de structuur van ons project skelet gereed kunt maken. Klik met de rechtermuisknop op het projectverkenner-venster en klik op “Nieuw -> Dynamisch Web Project”, zoals weergegeven in onderstaande afbeelding. Geef de naam op als “spring-mvc-example” in het volgende pop-upvenster, de rest van de zaken hoeven niet te worden gewijzigd. Op de volgende pagina geef je de bronmap op als “src/main/java”. Mogelijk moet je “src” uit de lijst verwijderen voordat je dit toevoegt. Vervolgens is er de webmodulepagina, geef de context-root van de toepassing op als “spring-mvc-example” en zorg ervoor dat de optie “Genereer web.xml-implementatiebeschrijving” is aangevinkt. Klik op Voltooien en je hebt een nieuw Dynamisch Web Project in je Eclipse-projectverkenner.

Het converteren van een Dynamisch Webproject naar een Maven-project

We willen Maven gebruiken om onze Spring MVC-afhankelijkheden eenvoudig te beheren. Laten we dus ons webproject converteren naar Maven. Klik met de rechtermuisknop op het project en selecteer “Configureren -> Converteren naar Maven-project”. Vervolgens verstrekken we de configuraties in het pom.xml-bestand zoals hieronder weergegeven. De skeletcode van ons Maven-webapplicatieproject is gereed. Nu kunnen we wijzigingen aanbrengen en ons voorbeeld van een “Spring MVC Hello World”-toepassing maken.

Spring MVC-afhankelijkheden toevoegen aan pom.xml

We moeten spring-web en spring-webmvc-afhankelijkheden toevoegen aan het pom.xml-bestand, evenals servlet-api, jsp-api en jstl-afhankelijkheden. Ons uiteindelijke pom.xml-bestand ziet er als volgt uit.

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

Let op de configuratie van finalName in het buildproces, zodat onze WAR-bestandsnaam geen versiegegevens bevat. Wanneer het project wordt gebouwd met Eclipse, zul je merken dat alle jars verschijnen in de maven-afhankelijkheden sectie.

Spring MVC DispatcherServlet als Front Controller

We moeten het Spring MVC-framework toevoegen aan onze webtoepassing, hiervoor moeten we DispatcherServlet configureren in web.xml zoals hieronder getoond.

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

contextConfigLocation init-param wordt gebruikt om de locatie van het voorjaarsbean-configuratiebestand op te geven.

Voorbeeld van Spring MVC Bean-configuratiebestand

De volgende stap is om het Spring bean-configuratiebestand spring-servlet.xml zoals hieronder getoond, te maken.

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

Er zijn drie belangrijke configuraties.

  1. annotation-driven vertelt DispatcherServlet om Controller-klassen te zoeken met behulp van @Controller annotatie.
  2. context:component-scan vertelt DispatcherServlet waar het moet zoeken naar controllerklassen.
  3. InternalResourceViewResolver bonenconfiguratie om de locatie van de weergavepagina’s en het achtervoegsel te specificeren dat wordt gebruikt. Methoden van de controllerklasse retourneren de naam van de weergavepagina en vervolgens wordt het achtervoegsel toegevoegd om de weergavepagina te bepalen die wordt gebruikt voor het renderen van de respons.

Spring MVC Controller-klasse

We hebben een enkele controllerklasse om te reageren op twee URIs – “/” voor de startpagina en “/gebruiker” voor de gebruikerspagina.

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

Merk op dat ik voor eenvoud geen logboekregistratieraamwerk zoals log4j heb gebruikt.

Spring MVC Modelklasse

We hebben een eenvoudige modelklasse met een enkele variabele en de getter-setter-methoden. Het is een eenvoudige 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-weergavepagina’s

We hebben twee weergavepagina’s zoals hieronder gedefinieerd. 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>

Merk op dat Spring MVC zorgt voor het koppelen van formuliervariabelen aan variabelen in het modelclass, daarom hebben we dezelfde variabelenaam op beide plaatsen. Dat is het, ons Spring MVC-voorbeeldproject is klaar om te worden ingezet en getest.

Implementatie van Spring MVC Eclipse-project

We kunnen de optie “Exporteren als WAR-bestand” van Eclipse gebruiken om het rechtstreeks naar de webapps-map van een draaiende Tomcat-server te implementeren. U kunt echter ook de opdrachtregel gebruiken om het project te bouwen en het vervolgens naar uw favoriete implementatiemap voor servletcontainers te kopiëren.

Test voorbeeld Spring MVC

Zodra het Spring MVC-project is geïmplementeerd, kunnen we de startpagina openen op https://localhost:8080/spring-mvc-voorbeeld/. Pas de Tomcat-poort en de context-root dienovereenkomstig aan. Dat is alles voor het Spring MVC-voorbeeld, ik heb geprobeerd het zo eenvoudig mogelijk te houden. Maar als je toch problemen tegenkomt, laat het me dan weten via opmerkingen en ik zal proberen je te helpen. Je kunt het definitieve Spring MVC-voorbeeldproject downloaden vanaf onderstaande link.

Download Spring MVC-voorbeeldproject

Referenties: Officiële Pagina

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