Najprostszy samouczek Spring MVC Framework – przykład Hello World ze stroną UI (JSP)

Opublikowany: 2019-02-23
Samouczek Spring MVC — samouczek Crunchify

Architektura Model-View-Controller (MVC) zapewnia najprostszy sposób tworzenia elastycznych i luźno powiązanych aplikacji internetowych.

W tym samouczku omówimy, jak utworzyć pierwszą aplikację Spring MVC z bardzo szczegółowymi krokami.

Czy masz któreś z poniższych pytań?

  • Podstawy Spring MVC 5.2.3
  • Tworzenie aplikacji Spring Framework MVC 5 krok po kroku..
  • java – samouczek Spring MVC od podstaw
  • Szybki samouczek Spring MVC
  • Samouczek Spring MVC Framework
  • Pierwszy samouczek aplikacji Spring MVC
  • Spring 5.x MVC Tutorials, AJAX Demo, jQuery Demo, JavaScript Demo, Tips & Tricks Spring 5 MVC

Jesteś we właściwym miejscu. Tutaj zademonstruję prosty Spring MVC framework do budowania aplikacji internetowych.

Po pierwsze – skonfigurujmy środowisko

Ostatnia aktualizacja i weryfikacja samouczka: wrzesień 2020 z poniższymi wersjami narzędzia.

Używam poniższych narzędzi, które być może będziesz musiał pobrać, jeśli jeszcze ich nie masz.

  1. Tomcat 9.0.38 – Pobierz najnowszy Apache Tomcat z tego linku.
  2. Upewnij się, że pobrałeś Eclipse IDE for Java EE Developers (2020-09 R) – link do pobrania. (schemat poniżej)
  3. Spring 5.2.9.RELEASE (nie wymaga pobierania) – użyjemy zależności od Mavena.
  4. JDK 15 – link do pobrania.
Najprostszy samouczek Spring MVC autorstwa Crunchify.com

Upewnij się, że pobrałeś najnowszy zestaw Java EE Developer Kit:

Eclipse Photon IDE 4.8.0

Główny cel

Głównym celem tego samouczka jest stworzenie aplikacji Spring MVC w najprostszy sposób.

Zanim zaczniemy, zobaczmy, co zobaczymy na końcu tego samouczka

Tak będzie wyglądał application result . To jest ostateczny wynik po wykonaniu wszystkich poniższych kroków.

Oto wynik końcowy: Strona powitalna ==> index.jsp

Strona CrunchifySpringMVCTutorial index.jsp

Wynik zwracany z klasy kontrolera

Wiadomość pochodząca od kontrolera

Teraz zacznijmy od samouczka

Krok 1

  • Otwórz zaćmienie
  • Utwórz New Eclipse Workspace — jest to must , aby uniknąć problemów z konfiguracją istniejącego obszaru roboczego.
Utwórz nowy obszar roboczy Eclipse — porady dotyczące Crunchify

Krok 2

  • Kliknij File
  • Kliknij New
  • Wybierz Dynamic Web Project
  • Jedno wyskakujące okienko, Podaj nazwę projektu: CrunchifySpringMVCTutorial
  • Upewnij się, że używasz Target Runtime jako Apache Tomcat 9.0
    • Jeśli nie widzisz Target Runtime, wykonaj następujące kroki
  • Wybierz konfigurację jako Default Configuration
Utwórz dynamiczny projekt internetowy Crunchify Spring MVC

Krok 3

Przekonwertuj projekt na projekt Maven, aby dodać wszystkie wymagane zależności Spring MVC do projektu.

Kroki:

  • Kliknij prawym przyciskiem myszy projekt
  • Konfiguruj
  • Konwertuj na projekt Maven
Konwertuj dynamiczny projekt internetowy na projekt Maven
Konwertuj CrunchifySpringMVCTutorial na projekt Maven

Krok 4

Otwórz plik pom.xml i dodaj poniższe jar dependencies do projektu.

Zależności Crunchify Spring MVC pom.xml

NOTE: Oto mój plik pom.xml . Upewnij się, że zaktualizowałeś wersję Java do 13 , jeśli nie przeszedłeś jeszcze do JDK 13 . Będziemy aktualizować ten samouczek do najnowszej wersji Spring MVC.

Więc poniższy plik pom.xml może mieć inną (najnowszą) wersję zależności Spring MVC niż na powyższym obrazku

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
< project xmlns = "http://maven.apache.org/POM/4.0.0"
xmlns : xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi : schemaLocation = "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" >
< modelVersion > 4.0.0 < / modelVersion >
< groupId > CrunchifySpringMVCTutorial < / groupId >
< artifactId > CrunchifySpringMVCTutorial < / artifactId >
< version > 0.0.1 - SNAPSHOT < / version >
< packaging > war < / packaging >
< build >
< sourceDirectory > src < / sourceDirectory >
< plugins >
< plugin >
< artifactId > maven - compiler - plugin < / artifactId >
< version > 3.8.0 < / version >
< configuration >
< release > 13 < / release >
< / configuration >
< / plugin >
< plugin >
< artifactId > maven - war - plugin < / artifactId >
< version > 3.2.1 < / version >
< configuration >
< warSourceDirectory > WebContent < / warSourceDirectory >
< / configuration >
< / plugin >
< / plugins >
< / build >
< dependencies >
< dependency >
< groupId > org . springframework < / groupId >
< artifactId > spring - core < / artifactId >
< version > 5.2.3.RELEASE < / version >
< / dependency >
< dependency >
< groupId > org . springframework < / groupId >
< artifactId > spring - context < / artifactId >
< version > 5.2.3.RELEASE < / version >
< / dependency >
< dependency >
< groupId > org . springframework < / groupId >
< artifactId > spring - aop < / artifactId >
< version > 5.2.3.RELEASE < / version >
< / dependency >
< dependency >
< groupId > org . springframework < / groupId >
< artifactId > spring - webmvc < / artifactId >
< version > 5.2.3.RELEASE < / version >
< / dependency >
< dependency >
< groupId > org . springframework < / groupId >
< artifactId > spring - web < / artifactId >
< version > 5.2.3.RELEASE < / version >
< / dependency >
 
< dependency >
< groupId > javax . servlet < / groupId >
< artifactId > jstl < / artifactId >
< version > 1.2 < / version >
< / dependency >
< / dependencies >
< / project >

Krok-5

Utwórz nowy plik Bean konfiguracji Spring: /WebContent/WEB-INF/crunchify-servlet.xml

Utwórz plik crunchify-servlet.xml - projekt Spring MVC

crunchify-servlet.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<? xml version = "1.0" encoding = "UTF-8" ?>
< beans xmlns = "http://www.springframework.org/schema/beans"
xmlns : mvc = "http://www.springframework.org/schema/mvc"
xmlns : context = "http://www.springframework.org/schema/context"
xmlns : xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi : schemaLocation = "
        http://www.springframework.org/schema/beans    
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd" >
 
< mvc : annotation - driven / >
< context : component - scan
base - package = "com.crunchify.controller" / >
< mvc : default - servlet - handler / >
 
< bean id = "viewResolver"
class = "org.springframework.web.servlet.view.UrlBasedViewResolver" >
< property name = "viewClass"
value = "org.springframework.web.servlet.view.JstlView" / >
< property name = "prefix" value = "/WEB-INF/jsp/" / >
< property name = "suffix" value = ".jsp" / >
< / bean >
 
< / beans >

W powyższym crunchify-servlet.xml   pliku konfiguracyjnego, zdefiniowaliśmy znacznik <context:component-scan> . Umożliwi to Springowi załadowanie wszystkich komponentów z pakietu com.crunchify.controller i wszystkich jego pakietów podrzędnych.

To załaduje naszą CrunchifyHelloWorld.class . Zdefiniowaliśmy również bean viewResolver . Ten bean rozwiąże widok i doda przedrostek /WEB-INF/jsp/ i sufiks .jsp do widoku w ModelAndView.

Zauważ, że w naszej klasie CrunchifyHelloWorld zwróciliśmy obiekt ModelAndView z nazwą widoku powitalnego.

Zostanie to rozwiązane do ścieżki /WEB-INF/jsp/welcome.jsp .

Krok-6

Utwórz nowy plik web.xml , jeśli jeszcze go tam nie ma. Mapuj Spring MVC w pliku /WebContent/WEB-INF/web.xml .

NOTE: jeśli nie widzisz pliku web.xml w swoim „ dynamic web project ”, wykonaj następujące kroki.

web.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<? xml version = "1.0" encoding = "UTF-8" ?>
< web - app xmlns : xsi = "http://www.w3.org/2001/XMLSchema-instance" xmlns = "http://xmlns.jcp.org/xml/ns/javaee" xsi : schemaLocation = "http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id = "WebApp_ID" version = "4.0" >
   < display - name > CrunchifySpringMVCTutorial < / display - name >
   < welcome - file - list >
     < welcome - file > index . html < / welcome - file >
     < welcome - file > index . htm < / welcome - file >
     < welcome - file > index . jsp < / welcome - file >
     < welcome - file > default . html < / welcome - file >
     < welcome - file > default . htm < / welcome - file >
     < welcome - file > default . jsp < / welcome - file >
   < / welcome - file - list >
  
       < servlet >
         < servlet - name > crunchify < / servlet - name >
         < servlet - class >
             org . springframework . web . servlet . DispatcherServlet
         < / servlet - class >
         < load - on - startup > 1 < / load - on - startup >
     < / servlet >
     < servlet - mapping >
         < servlet - name > crunchify < / servlet - name >
         < url - pattern > / welcome . jsp < / url - pattern >
         < url - pattern > / index . jsp < / url - pattern >
         < url - pattern > / welcome . html < / url - pattern >
         < url - pattern > * . html < / url - pattern >
     < / servlet - mapping >
  
< / web - app >

Powyższy kod w web.xml zmapuje DispatcherServlet z wzorcem url /welcome.jsp . Zauważ również, że zdefiniowaliśmy index.jsp jako plik powitalny.

Należy zwrócić uwagę na nazwę serwletu w <servlet-name> w web.xml . Po zainicjowaniu DispatcherServlet będzie szukał nazwy pliku [servlet-name]-servlet.xml w folderze WEB-INF aplikacji internetowej. W tym przykładzie framework będzie szukał pliku o nazwie crunchify-servlet.xml .

Krok-7

Utwórz klasę kontrolera.

  • Kliknij prawym przyciskiem myszy Java Resources -> src
  • Kliknij New -> Class
  • Pakiet: com.crunchify.controller
  • Nazwa pliku: CrunchifyHelloWorld.java
Utwórz klasę kontrolera wiosny CrunchifyHelloWorld

CrunchifyHelloWorld.java

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com . crunchify . controller ;
 
import org . springframework . stereotype . Controller ;
import org . springframework . web . bind . annotation . RequestMapping ;
import org . springframework . web . servlet . ModelAndView ;
 
/*
* author: Crunchify.com
*
*/
 
@Controller
public class CrunchifyHelloWorld {
 
@RequestMapping ( "/welcome" )
public ModelAndView helloWorld ( ) {
 
String message = "<br><div>"
+ "<h3>********** Hello World, Spring MVC Tutorial</h3>This message is coming from CrunchifyHelloWorld.java **********</div><br><br>" ;
return new ModelAndView ( "welcome" , "message" , message ) ;
}
}

Zauważ, że opisaliśmy klasę CrunchifyHelloWorld za pomocą @Controller i @RequestMapping("/welcome") . Kiedy Spring zeskanuje nasz pakiet, rozpozna ten bean jako kontroler do przetwarzania żądań. Adnotacja @RequestMapping informuje Spring, że ten kontroler powinien przetwarzać wszystkie żądania zaczynające się od /welcome w ścieżce adresu URL. Obejmuje to /welcome/* i /welcome.html .

Metoda helloWorld() zwraca obiekt ModelAndView . Obiekt ModelAndView próbuje rozwiązać problem z widokiem o nazwie „welcome”, a model danych jest przesyłany z powrotem do przeglądarki, dzięki czemu możemy uzyskać dostęp do danych na stronie JSP. Nazwa widoku logicznego zostanie rozwiązana na /WEB-INF/jsp/welcome.jsp . Logiczna nazwa „welcome”, która jest zwracana w obiekcie ModelAndView, jest mapowana na ścieżkę /WEB-INF/jsp/welcome.jsp.

Obiekt ModelAndView zawiera również komunikat z kluczem „message” i wartością Detail. To są dane, które przekazujemy do naszego widoku. Zwykle będzie to obiekt wartości w postaci ziarna java, który będzie zawierał dane, które mają być wyświetlane w naszym widoku. Tutaj po prostu przekazujemy ciąg.

Krok 8

Widok – Utwórz nowy plik /WebContent/index.jsp .

index.jsp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
< html >
< head >
< title > Spring MVC Tutorial Series by Crunchify . com < / title >
<style type ="text/css">
body {
background-image : url ( 'https://cdn.crunchify.com/bg.png' ) ;
}
</style>
< / head >
< body >
< br >
< div style = "text-align: center" >
< h2 >
Hey You . . ! ! This is your 1st Spring MCV Tutorial . . < br > < br >
< / h2 >
< h3 >
< a href = "welcome.html" > Click here to See Welcome Message . . . < / a > ( to
check Spring MVC Controller . . . @ RequestMapping ( "/welcome" ) )
< / h3 >
< / div >
< / body >
< / html >

Utwórz kolejny plik /WebContent/WEB-INF/jsp/welcome.jsp .

NOTE: Nie zapomnij utworzyć folderu jsp i umieścić w nim plik welcome.jsp

witaj.jsp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
< html >
< head >
< title > Spring MVC Tutorial by Crunchify - Hello World Spring MVC
Example < / title >
<style type ="text/css">
body {
background-image : url ( 'https://cdn.crunchify.com/bg.png' ) ;
}
</style>
< / head >
< body > $ { message }
 
< br >
< br >
< div
style = "font-family: verdana; padding: 10px; border-radius: 10px; font-size: 12px; text-align: center;" >
 
Spring MCV Tutorial by < a href = "https://crunchify.com" > Crunchify < / a > .
Click < a href = "https://crunchify.com/category/java-tutorials/"
target = "_blank" > here < / a > for all Java and < a
href = 'https://crunchify.com/category/spring-mvc/' target = '_blank' > here < / a >
for all Spring MVC , Web Development examples . < br >
< / div >
< / body >
< / html >

W końcu tak powinno wyglądać Twoje miejsce pracy.

Najprostsza struktura projektu samouczka Spring MVC — Crunchify

Krok-9

Kliknij prawym przyciskiem myszy Project -> Run As -> Maven Build...

Maven Run-as — Maven wbudowany w środowisko Eclipse IDE

Add Goals : clean install . Kliknij Apply i Run .

Czysty projekt maven Spring

Powinieneś zobaczyć success message kompilacji:

Komunikat o powodzeniu kompilacji czystej instalacji Spring MVC Maven

Gdzie są wszystkie moje pliki .jar?

Zobaczysz wszystkie pliki .jar w folderze /target . Zrzut ekranu.

Krok-10

  • Jeśli don't see serwera Tomcat w zakładce Servers , postępuj zgodnie z instrukcjami, aby dodać Apache Tomcat do Eclipse.
  • Wdróż projekt w Apache Tomcat
    • Kliknij prawym przyciskiem myszy
    • Dodaj i usuń
    • Dodaj projekt do serwera (sekcja po prawej stronie).
  • Kliknij Start.
Uruchom Apache Tomcat w Eclipse — porady dotyczące Crunchify

Upewnij się, że widzisz poniżej dzienniki. Oznacza to, że Twoja aplikacja została pomyślnie wdrożona na serwerze Tomcat Web Server.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
Aug 04 , 2018 9 : 08 : 10 PM org . apache . tomcat . util . digester . SetPropertiesRule begin
WARNING : [ SetPropertiesRule ] { Server / Service / Engine / Host / Context } Setting property 'source' to 'org.eclipse.jst.jee.server:CrunchifySpringMVCTutorial' did not find a matching property .
INFO : Server version :          Apache Tomcat / 9.0.10
INFO : Server built :            Jun 20 2018 17 : 32 : 21 UTC
INFO : Server number :          9.0.10.0
INFO : OS Name :                Mac OS X
INFO : OS Version :              10.13.6
INFO : Architecture :            x86_64
INFO : Java Home :              / Library / Java / JavaVirtualMachines / jdk - 10.0.2.jdk / Contents / Home
INFO : JVM Version :            10.0.2 + 13
INFO : JVM Vendor :              "Oracle Corporation"
INFO : CATALINA_BASE :          / Users / appshah / Documents / jee - photon / workspace / c / . metadata / . plugins / org . eclipse . wst . server . core / tmp0
INFO : CATALINA_HOME :          / Users / appshah / Documents / jee - photon / apache - tomcat - 9.0.10
INFO : Command line argument : - Dcatalina . base =/ Users / appshah / Documents / jee - photon / workspace / c / . metadata / . plugins / org . eclipse . wst . server . core / tmp0
INFO : Command line argument : - Dcatalina . home =/ Users / appshah / Documents / jee - photon / apache - tomcat - 9.0.10
INFO : Command line argument : - Dwtp . deploy =/ Users / appshah / Documents / jee - photon / workspace / c / . metadata / . plugins / org . eclipse . wst . server . core / tmp0 / wtpwebapps
INFO : Command line argument : - Dfile . encoding = UTF - 8
INFO : The APR based Apache Tomcat Native library which allows optimal performance in production environments was not found on the java . library . path : [ / Users / appshah / Library / Java / Extensions : / Library / Java / Extensions : / Network / Library / Java / Extensions : / System / Library / Java / Extensions : / usr / lib / java : . ]
INFO : Initializing ProtocolHandler [ "http-nio-8080" ]
INFO : Using a shared selector for servlet write / read
INFO : Initializing ProtocolHandler [ "ajp-nio-8009" ]
INFO : Using a shared selector for servlet write / read
INFO : Initialization processed in 841 ms
INFO : Starting service [ Catalina ]
INFO : Starting Servlet Engine : Apache Tomcat / 9.0.10
INFO : At least one JAR was scanned for TLDs yet contained no TLDs . Enable debug logging for this logger for a complete list of JARs that were scanned but no TLDs were found in them . Skipping unneeded JARs during scanning can improve startup time and JSP compilation time .
INFO : At least one JAR was scanned for TLDs yet contained no TLDs . Enable debug logging for this logger for a complete list of JARs that were scanned but no TLDs were found in them . Skipping unneeded JARs during scanning can improve startup time and JSP compilation time .
INFO : No Spring WebApplicationInitializer types detected on classpath
INFO : Initializing Spring FrameworkServlet 'crunchify'
INFO : FrameworkServlet 'crunchify' : initialization started
INFO : Refreshing WebApplicationContext for namespace 'crunchify-servlet' : startup date [ Sat Aug 04 21 : 08 : 13 CDT 2018 ] ; root of context hierarchy
INFO : Loading XML bean definitions from ServletContext resource [ / WEB - INF / crunchify - servlet . xml ]
INFO : Mapped "{[/welcome]}" onto public org . springframework . web . servlet . ModelAndView com . crunchify . controller . CrunchifyHelloWorld . helloWorld ( )
INFO : Looking for @ ControllerAdvice : WebApplicationContext for namespace 'crunchify-servlet' : startup date [ Sat Aug 04 21 : 08 : 13 CDT 2018 ] ; root of context hierarchy
INFO : Looking for @ ControllerAdvice : WebApplicationContext for namespace 'crunchify-servlet' : startup date [ Sat Aug 04 21 : 08 : 13 CDT 2018 ] ; root of context hierarchy
INFO : Mapped URL path [ /** ] onto handler 'org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler#0'
INFO : FrameworkServlet 'crunchify' : initialization completed in 1607 ms
INFO : Starting ProtocolHandler [ "http-nio-8080" ]
INFO : Starting ProtocolHandler [ "ajp-nio-8009" ]
INFO : Server startup in 3579 ms

Krok-11. Gotowy.

Odwiedź: http://localhost:8080/CrunchifySpringMVCTutorial/ i wszystko powinno być ustawione.

Hurra.. Teraz znasz Hello World Spring MVC 5 Example . Daj mi znać, jeśli napotkasz wyjątek podczas uruchamiania tego. Więcej przykładów można znaleźć tutaj.

Do you want to include JS, CSS and images into JSP file? Postępuj zgodnie z tym samouczkiem: Najlepszy sposób na dodanie/zintegrowanie JS, CSS i obrazów z plikiem JSP przy użyciu „mvc:resources mapping”.

Mieć problemy? Jakakolwiek sprawa?

Triaging Step-1 – Masz błąd HTTP Status 404?

Upewnij się, że plik welcome.jsp znajduje się w folderze jsp
Ponadto postępuj zgodnie z poniższym samouczkiem:

Triaging step-2 – URL nie działa? Błąd Tomcata?

Upewnij się, że dodałeś serwer Apache Tomcat do Targeted Runtime . Które mogłeś wybrać w Step-1 . Tomcat 7 lub 8 any – serwer powinien działać.

Samouczek Spring MVC — ustawienie środowiska wykonawczego Eclipse Target

Triaging Step-3 – maven błędy?

Pamiętaj, aby zaktualizować wszystkie zależności maven.

Zależności Force Update - samouczek Spring MVC

Zapraszam do e-maila lub komentarza poniżej, jeśli masz jakiś problem z uruchomieniem powyższego samouczka.