Cloud-Lösungen der Zukunft - Testen!

Revolutionäre Cloud-Technologie, ganz ohne versteckte Kosten. Profitieren Sie von unserer Testphase und entdecken Sie umfassende Funktionen. Der Anmeldeprozess ist transparent und unkompliziert. Starten Sie jetzt Ihre Reise in die Cloud - Kostenfrei!

Mit E-Mail anmeldenMit Google anmeldenMit GitHub anmelden
Mit E-Mail anmeldenMit Google anmeldenMit GitHub anmelden

Kategorien

Apache

Databases

Docker

JavaScript

Kubernetes

Linux Basis

MySQL

Python

React

Security

Ubuntu

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.

Copy Code 


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

Copy Code 


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

Copy 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 />
  <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.

Copy Code 


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.

Copy Code 


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

Copy Code 


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

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

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.

Starten Sie Ihre Kostenlose Testversion und Steigern Sie Ihr Cloud-Erlebnis Heute!

Bereit, Ihre Cloud-Erfahrung zu transformieren? Nehmen Sie an unserer praxisnahen Testversion teil und entdecken Sie die Leistungsfähigkeit und Flexibilität unserer Cloud-Lösungen.

Try for free!

You might be interested in:

https://www.centron.de/tutorial/verwendung-der-funktion-puts-in-c-c/

https://www.centron.de/en/tutorial/container-an-introduction/