Spring MVC Beispiel

Vor einiger Zeit habe ich im Spring MVC Tutorial erklärt, wie man eine Spring MVC-Anwendung mit dem Spring Tool Suite erstellt. Aber heute werde ich eine grundlegende Hello-World-Spring-MVC-Anwendung mit Maven und Eclipse erstellen.

Spring MVC basiert auf der Model-View-Controller-Architektur.

DispatcherServlet ist die Front-Controller-Klasse, die alle Anfragen übernimmt und deren Verarbeitung startet. Wir müssen es in der web.xml-Datei konfigurieren. Seine Aufgabe ist es, Anfragen 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, user.jsp sind die Ansichtsseiten in unserer Spring-MVC-Hello-World-Beispielanwendung. User.java wird die einzige Model-Klasse sein, die wir in unserer Spring-MVC-Beispiel-Webanwendung haben werden.

Spring MVC Hello-World-Eclipse-Projekt

Das untenstehende Bild zeigt unser Spring MVC-Beispielprojekt in Eclipse.

Lassen Sie uns beginnen und unser Projekt von Grund auf neu erstellen

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 umwandeln. Die untenstehenden Bilder zeigen, wie dies zu tun ist und wie unser Projektskelett-Struktur fertiggestellt wird. Klicken Sie mit der rechten Maustaste auf das Projektfenster und klicken Sie auf „Neu -> Dynamisches Webprojekt“, wie im untenstehenden Bild gezeigt.

Geben Sie im nächsten Popup-Fenster den Namen „spring-mvc-example“ an, der Rest sollte nicht geändert werden müssen.

Auf der nächsten Seite geben Sie das Quellverzeichnis als „src/main/java“ an. Möglicherweise müssen Sie zuerst den „src“-Ordner aus der Liste entfernen, bevor Sie diesen hinzufügen.

Als Nächstes kommt die Webmodul-Seite, geben Sie den Kontext-Root der Anwendung als „spring-mvc-example“ an und stellen Sie sicher, dass Sie die Option „Generate web.xml deployment descriptor“ aktivieren.

Klicken Sie auf Fertigstellen und Sie werden ein neues Dynamisches Webprojekt in Ihrem Eclipse-Projektfenster haben.

Umwandlung des dynamischen Webprojekts in ein Maven-Projekt

Wir möchten Maven verwenden, um unsere Spring MVC-Abhängigkeiten einfach zu verwalten. Also lassen Sie uns unser Webprojekt in ein Maven-Projekt umwandeln. Klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie „Konfigurieren -> In Maven-Projekt umwandeln“.

Als Nächstes geben Sie die pom.xml-Konfigurationen wie unten gezeigt an.

Unser Maven-Webanwendungsprojekt-Skelettcode ist jetzt fertig. Jetzt können wir damit beginnen, Änderungen daran vorzunehmen und unsere Spring MVC Hello-World-Beispielanwendung zu erstellen.

Abhängigkeiten in pom.xml

Wir müssen spring-web und spring-webmvc Abhängigkeiten in pom.xml hinzufügen, sowie servlet-api, jsp-api und jstl Abhängigkeiten. 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 finalName-Konfiguration im Build, damit unser WAR-Dateiname keine Versionsdetails enthält. Wenn das Projekt von Eclipse erstellt wird, werden Sie feststellen, dass alle Jars im Maven-Abhängigkeiten-Bereich angezeigt werden.

Spring MVC DispatcherServlet als Front Controller

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

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

Spring MVC Beispiel Bean-Konfigurationsdatei

Der nächste Schritt ist die Erstellung der Spring-Bean-Konfigurationsdatei spring-servlet.xml, wie unten gezeigt.

<?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 weist den DispatcherServlet an, nach Controller-Klassen mit der @Controller-Annotation zu suchen.
  2. context:component-scan gibt an, wo der DispatcherServlet nach Controller-Klassen suchen soll.
  3. Die Konfiguration des InternalResourceViewResolver-Beans, um den Speicherort der Ansichtsseiten und den verwendeten Suffix anzugeben. Methoden der Controller-Klasse geben den Namen der Ansichtsseite zurück, und dann wird der Suffix hinzugefügt, um die Ansichtsseite für das Rendern der Antwort zu ermitteln.

Spring MVC Controller-Klasse

Wir haben eine einzige Controller-Klasse, um auf zwei URIs zu reagieren – „/“ 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 der Einfachheit halber kein Logging-Framework wie log4j verwendet habe.

Spring MVC Model-Klasse

Wir haben eine einfache Model-Klasse mit einer einzigen Variablen und deren Getter-Setter-Methoden. Es ist 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 die Zuordnung von Formularvariablen zu Variablen der Model-Klasse übernimmt, deshalb haben wir denselben Variablennamen an beiden Stellen. Das war’s, unser Spring MVC-Beispielprojekt ist bereit, um bereitgestellt und getestet zu werden.

Spring MVC Eclipse-Projektbereitstellung

Wir können die Eclipse-Exportoption als WAR-Datei verwenden, um sie direkt in das Webapps-Verzeichnis eines laufenden Tomcat-Servers zu übertragen. Sie können jedoch auch die Befehlszeile verwenden, um das Projekt zu bauen und es dann in das gewünschte Verzeichnis Ihres 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 entsprechend den Tomcat-Port und den Context-Root.

Das ist alles zum Thema Spring MVC-Beispiel, ich habe versucht, es so einfach wie möglich zu halten.

Kostenlosen Account erstellen

Registrieren Sie sich jetzt und erhalten Sie Zugang zu unseren Cloud Produkten.

Das könnte Sie auch interessieren: