Cel mai simplu tutorial Spring MVC Framework – Exemplu Hello World cu pagina UI (JSP).

Publicat: 2019-02-23
Tutorial Spring MVC - Tutorial Crunchify

Arhitectura Model-View-Controller (MVC) oferă cea mai simplă modalitate de a dezvolta aplicații web flexibile și slab cuplate.

În acest tutorial, vom analiza cum să vă creați prima aplicație Spring MVC cu pași foarte detaliați.

Aveți vreo întrebare de mai jos?

  • Fundamentele Spring MVC 5.2.3
  • Dezvoltarea unei aplicații Spring Framework MVC 5 pas cu pas..
  • java – tutorial Spring MVC de la zero
  • Spring MVC Fast Tutorial
  • Tutorial Spring MVC Framework
  • Primul tutorial al aplicației Spring MVC
  • Tutoriale Spring 5.x MVC, AJAX Demo, jQuery Demo, JavaScript Demo, Sfaturi și trucuri Spring 5 MVC

Atunci ești la locul potrivit. Aici voi demonstra un Spring MVC framework simplu pentru construirea de aplicații web.

Primul lucru – Să setăm mediul

Ultima actualizare și verificare a tutorialului: septembrie 2020, cu versiunile instrumentului de mai jos.

Folosesc instrumentele de mai jos pe care poate fi necesar să le descărcați dacă nu le aveți deja.

  1. Tomcat 9.0.38 – Descărcați cel mai recent Apache Tomcat de pe acest link.
  2. Asigurați-vă că descărcați Eclipse IDE for Java EE Developers (2020‑09 R) – Link de descărcare. (diagrama de mai jos)
  3. Spring 5.2.9.RELEASE (Nu este necesară descărcarea) – vom folosi dependența Maven.
  4. JDK 15 – Link de descărcare.
Cel mai simplu tutorial Spring MVC de la Crunchify.com

Asigurați-vă că descărcați cel mai recent kit de dezvoltare Java EE :

Eclipse Photon IDE 4.8.0

Scopul principal

Scopul principal al acestui tutorial de a crea aplicația Spring MVC în cel mai simplu mod.

Înainte de a începe, să vedem ce vom vedea la sfârșitul acestui tutorial

Așa va arăta application result noastre. Acesta este un rezultat final odată ce ați finalizat toți pașii de mai jos.

Iată un rezultat final: Pagina de bun venit ==> index.jsp

Pagina CrunchifySpringMVCTutorial index.jsp

Rezultatele returnează de la Controller Class

Mesaj care vine de la controler

Acum, să începem cu tutorialul

Pasul 1

  • Deschide Eclipse
  • Creați New Eclipse Workspace - Acest lucru este must pentru a evita orice problemă de configurare a spațiului de lucru existent.
Creați un nou spațiu de lucru Eclipse - Sfaturi Crunchify

Pasul 2

  • Faceți clic pe File
  • Faceți clic pe New
  • Alegeți Dynamic Web Project
  • O fereastră pop-up, Furnizați numele proiectului: CrunchifySpringMVCTutorial
  • Asigurați-vă că utilizați Target Runtime ca Apache Tomcat 9.0
    • Dacă nu vedeți Target Runtime, urmați acești pași
  • Alegeți Configurație ca Default Configuration
Creați proiectul web dinamic Crunchify Spring MVC

Pasul 3

Convertiți proiectul în proiectul Maven pentru a adăuga toate dependențele Spring MVC necesare la proiect.

Pași:

  • Faceți clic dreapta pe proiect
  • Configurați
  • Convertiți în proiectul Maven
Conversia Dynamic Web Project în Maven Project
Convertiți CrunchifySpringMVCTutorial în proiectul Maven

Pasul-4

Deschideți fișierul pom.xml și adăugați mai jos jar dependencies la proiect.

Dependențe Crunchify Spring MVC pom.xml

NOTE: Aici este fișierul meu pom.xml . Asigurați-vă că actualizați versiunea Java la 13 dacă nu v-ați mutat încă la JDK 13 . Vom continua să actualizăm acest tutorial la cea mai recentă versiune Spring MVC.

Prin urmare, fișierul pom.xml de mai jos poate avea o versiune diferită (cea mai recentă) a dependențelor Spring MVC față de imaginea de mai sus

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 >

Pasul-5

Creați un nou fișier Spring Configuration Bean : /WebContent/WEB-INF/crunchify-servlet.xml

Creați fișierul crunchify-servlet.xml - proiect 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 >

În crunchify-servlet.xml mai sus   fișier de configurare, am definit o etichetă <context:component-scan> . Acest lucru va permite lui Spring să încarce toate componentele din pachetul com.crunchify.controller și toate pachetele sale secundare.

Aceasta va încărca CrunchifyHelloWorld.class . De asemenea, am definit un bean viewResolver . Acest bean va rezolva vizualizarea și va adăuga șirul de prefix /WEB-INF/jsp/ și sufixul .jsp la vizualizarea din ModelAndView.

Rețineți că în clasa noastră CrunchifyHelloWorld , avem returnat un obiect ModelAndView cu numele vizualizării binevenit.

Acest lucru va fi rezolvat în calea /WEB-INF/jsp/welcome.jsp .

Pasul-6

Creați un fișier nou web.xml dacă nu este deja acolo. Hartă Spring MVC în fișierul /WebContent/WEB-INF/web.xml .

NOTE: dacă nu vedeți fișierul web.xml în „ dynamic web project ”, urmați acești pași.

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 >

Codul de mai sus din web.xml va mapa DispatcherServlet cu modelul URL /welcome.jsp . De asemenea, rețineți că am definit index.jsp ca fișier de bun venit.

Un lucru de remarcat aici este numele servlet-ului din eticheta <servlet-name> din web.xml . Odată ce DispatcherServlet este inițializat, acesta va căuta un nume de fișier [servlet-name]-servlet.xml în folderul WEB-INF al aplicației web. În acest exemplu, cadrul va căuta fișierul numit crunchify-servlet.xml .

Pasul-7

Creați clasa de controler.

  • Faceți clic dreapta pe Java Resources -> src
  • Faceți clic pe New -> Class
  • Pachet: com.crunchify.controller
  • Nume fișier: CrunchifyHelloWorld.java
Creați clasa Spring Controller 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 ) ;
}
}

Rețineți că am adnotat clasa CrunchifyHelloWorld cu @Controller și @RequestMapping("/welcome") . Când Spring scanează pachetul nostru, va recunoaște acest bean ca fiind un bean Controller pentru procesarea cererilor. Adnotarea @RequestMapping îi spune lui Spring că acest controler ar trebui să proceseze toate cererile care încep cu /welcome în calea URL. Acestea includ /welcome/* și /welcome.html .

Metoda helloWorld() returnează obiectul ModelAndView . Obiectul ModelAndView încearcă să se rezolve într-o vizualizare numită „bun venit”, iar modelul de date este transmis înapoi în browser, astfel încât să putem accesa datele din JSP. Numele vizualizării logice se va rezolva în /WEB-INF/jsp/welcome.jsp . Numele logic „binevenit” care este returnat în obiectul ModelAndView este mapat la calea /WEB-INF/jsp/welcome.jsp.

Obiectul ModelAndView conține, de asemenea, un mesaj cu cheia „mesaj” și valoare detaliată. Acestea sunt datele pe care le transmitem vederii noastre. În mod normal, acesta va fi un obiect de valoare sub formă de java bean care va conține datele care vor fi afișate în vizualizarea noastră. Aici pur și simplu trecem un șir.

Pasul-8

Vizualizarea – Creați un fișier nou /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 >

Creați un alt fișier /WebContent/WEB-INF/jsp/welcome.jsp .

NOTE: Nu uitați să creați folderul jsp și să puneți welcome.jsp în el

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

După toate, așa ar trebui să arate spațiul tău de lucru.

Cea mai simplă structură a proiectului Spring MVC Tutorial - Crunchify

Pasul-9

Faceți clic dreapta pe Project -> Run As -> Maven Build...

Maven Run-as - Maven Build în Eclipse IDE

Add Goals : clean install . Faceți clic pe Apply și Run .

Clean Instalați proiectul Maven Spring

Ar trebui să vedeți success message construirii:

Spring MVC Maven Clean Install Build Success Message

Unde sunt toate fișierele mele .jar?

Veți vedea toate fișierele .jar în folderul /target . Captură de ecran.

Pasul-10

  • Dacă don't see Tomcat Server în fila Servers , urmați pașii pentru a adăuga Apache Tomcat la Eclipse.
  • Implementați proiectul pe Apache Tomcat
    • Click dreapta
    • Adăugați și eliminați
    • Adăugați proiectul pe server (secțiunea din dreapta).
  • Faceți clic pe Start.
Porniți Apache Tomcat în Eclipse - Crunchify Tips

Asigurați-vă că vedeți mai jos jurnalele. Aceasta înseamnă că aplicația dvs. este implementată cu succes pe 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

Pasul-11. Terminat.

Vizitați: http://localhost:8080/CrunchifySpringMVCTutorial/ și ar trebui să fiți gata.

Ura.. Acum știi Hello World Spring MVC 5 Example . Anunțați-mă dacă întâmpinați vreo excepție în timp ce rulați acest lucru. Există mult mai multe exemple pe care le puteți găsi aici.

Do you want to include JS, CSS and images into JSP file? Urmați acest tutorial: Cel mai bun mod de a adăuga/integra JS, CSS și imagini în fișierul JSP folosind „mvc:resources mapping”.

A avea probleme? Vreo problemă?

Triaging Step-1 – Aveți o eroare HTTP Status 404?

Asigurați-vă că fișierul welcome.jsp se află în folderul jsp
De asemenea, urmați tutorialul de mai jos:

Pasul 2 de triaj – URL-ul nu funcționează? Eroare Tomcat?

Asigurați-vă că adăugați serverul Apache Tomcat la Targeted Runtime . Pe care este posibil să le fi selectat la Step-1 . Tomcat 7 sau 8 orice – serverul ar trebui să funcționeze.

Tutorial Spring MVC - Setare Eclipse Target Runtime

Pasul 3 de triaj – erori experte?

Asigurați-vă că actualizați toate dependențele Maven.

Dependențe de actualizare forțată - tutorial Spring MVC

Simțiți-vă liber să trimiteți un e-mail sau un comentariu mai jos dacă aveți probleme la rularea tutorialului de mai sus.