เนื้อหา:
- การแนะนำ
- การสร้างโครงการ
- การเชื่อมต่อสปริง MVC
- การสร้างเพจและตัวควบคุม
- การกำหนดค่า
- แบบอย่าง
- โมเดล-มุมมอง-คอนโทรลเลอร์
การแนะนำ
ฉันเริ่มทำความคุ้นเคยกับเทคโนโลยีและเฟรมเวิร์กที่ใหม่สำหรับฉันโดยศึกษาตัวอย่างต่างๆ ที่มีการนำไปใช้ เพราะโดยปกติแล้วฉันจะเข้าใจบางสิ่งได้ดีที่สุดเมื่อฉันเห็นมันใช้งานจริงโดยใช้ตัวอย่างของแอปพลิเคชันที่ครบครัน โดยทั่วไปตัวอย่างดังกล่าวคือ แอปพลิเค ชัน CRUD ( C reate, Read , U pdate, D elete) อินเทอร์เน็ตเต็มไปด้วยตัวอย่างของระดับความซับซ้อนที่แตกต่างกัน ปัญหาคือพวกเขามักจะไม่อธิบายรายละเอียดว่าทำอย่างไร อะไร และทำไมจึงทำที่นั่น เหตุใดจึงเพิ่มการพึ่งพาดังกล่าว เหตุใดจึงต้องมีคลาสดังกล่าว ฯลฯ ในกรณีส่วนใหญ่ พวกเขาจะใช้แอปพลิเคชันที่เสร็จสมบูรณ์แล้วพร้อมกับไฟล์ POM สุดท้าย พร้อมด้วยคลาสเวอร์ชันสุดท้าย และเพียงแค่ดำเนินการผ่านแต่ละแอปพลิเคชัน โดยไม่เน้นไปที่สิ่งเล็กๆ น้อยๆ ที่อาจดูเหมือนชัดเจนสำหรับผู้มีประสบการณ์ ฉันได้ดูตัวอย่างดังกล่าวมามากมายและมักจะชัดเจนว่าทุกอย่างทำงานอย่างไร แต่วิธีที่พวกเขามาถึงสิ่งนี้ยังไม่ชัดเจนนัก ดังนั้นฉันจึงตัดสินใจว่าตัวอย่างดังกล่าวจะมีประโยชน์ไม่ใช่จากตำแหน่งของนักพัฒนาที่มีประสบการณ์ แต่จากตำแหน่งของผู้เริ่มต้นที่ไม่เคยจัดการกับ Spring, Hibernate และเรื่องอื่น ๆ
การสร้างโครงการ
ดังนั้น เนื่องจากฉันเป็นมือใหม่ เราจะไม่ใช้ต้นแบบที่ไม่ชัดเจนใดๆ Spring Initializr ยังคงฟังดูน่ากลัวเกินไป ดังนั้นเราจะสร้างโครงการ Maven ที่เรียบง่ายที่สุด ฉันไม่มีชื่อโดเมน ดังนั้นใน groupid ฉันจะเขียนเฉยๆtestgroup
และใน artifactid ฉันจะเขียนชื่อ เช่นfilmography
(นี่จะเป็นรายชื่อภาพยนตร์) เราสร้างโปรเจ็กต์และเลือกEnable auto-import
ว่าไอเดียจะแนะนำเมื่อใด ด้วยเหตุนี้ ทุกครั้งที่เราทำการเปลี่ยนแปลงใดๆ กับไฟล์ POM (Project Object Model ไฟล์นี้จะอธิบายโครงสร้างทั้งหมดของโปรเจ็กต์ Maven) ทุกอย่างจะถูกนำไปใช้กับโปรเจ็กต์โดยอัตโนมัติทันที ไลบรารีจะถูกพรากไปจากพื้นที่เก็บข้อมูลในเครื่องของเราหากเรามีอยู่แล้ว หรือหากเราใช้การพึ่งพาใหม่บางอย่างที่เราไม่เคยจัดการมาก่อน Maven จะดาวน์โหลดไลบรารีเหล่านั้นผ่านทางอินเทอร์เน็ตจากพื้นที่เก็บข้อมูลส่วนกลาง Maven ยังมีฟังก์ชันในการดาวน์โหลดซอร์สและเอกสารประกอบ (ดาวน์โหลดซอร์สและ/หรือเอกสารประกอบ) นอกจากนี้ยังสะดวกมาก หากคลาสหรือวิธีการบางอย่างไม่ชัดเจน คุณสามารถไปที่ซอร์สโค้ดและดูว่ามันทำงานอย่างไรภายในนั้น มาเพิ่มรายละเอียดสองสามอย่างกัน นี่จะเป็นเว็บแอปพลิเคชันและเราจะใช้Tomcat ในการปรับใช้แอปพลิเคชันกับ Tomcat คุณจะต้องถ่ายโอนแอปพลิเคชันไปที่นั่นในรูปแบบของไฟล์เก็บถาวรสงคราม (ทรัพยากรแอปพลิเคชันเว็บ ซึ่งเป็นรูปแบบพิเศษสำหรับแอปพลิเคชันเว็บ) เมื่อต้องการทำเช่นนี้ ให้เพิ่มบรรทัดต่อไปนี้ลงในไฟล์ POM เพื่อให้แอปพลิเคชันถูกคอมไพล์ลงในไฟล์เก็บถาวร war:
<packaging>war</packaging>
คุณจะต้องมีไดเร็กทอรีพิเศษสำหรับแหล่งที่มาของเว็บ ในกรณีของเราจะมี หน้า jspและแหล่งข้อมูลบนเว็บบางส่วน มาสร้างmain
ไดเร็กทอรีwebapp
กัน ควรเรียกสิ่งนั้นทุกประการและอยู่ในmain
ลักษณะเดียวกับjava
เนื่องจากresources
นี่คือโครงสร้างไดเร็กทอรี Maven มาตรฐาน เมื่อเราติดตั้งแพ็คเกจแล้วwar
และพิจารณาว่านี่คือโครงการเว็บ ไดเร็กทอรีwebapp
จะถูกทำเครื่องหมายเป็นแหล่งแอปพลิเคชันเว็บโดยอัตโนมัติ (จะมีจุดสีน้ำเงินอยู่) และทุกสิ่งที่เกี่ยวข้องกับเว็บจะถูกค้นหาในโฟลเดอร์นี้ และครู่หนึ่ง ตามค่าเริ่มต้น Maven จะใช้ภาษาเวอร์ชัน 1.5 แต่ฉันต้องการใช้เช่นเวอร์ชัน 1.8 - Java 8 (คุณสามารถใช้ 10 หรือ 11 ได้ แต่ยังไม่มีแผนที่จะใช้คุณสมบัติใด ๆ จากที่นั่น ดังนั้นปล่อยให้เป็น 8 ). วิธีแก้ไขนี้ทำได้ง่ายมาก โดยเราเขียน "Maven java 8" ใน Google และดูว่าต้องเพิ่มอะไรบ้างในไฟล์ POM เพื่อให้ Maven รวบรวมคลาสของเราสำหรับเวอร์ชันที่ต้องการ ด้วยเหตุนี้เราจึงมีดังต่อไปนี้: 
การเชื่อมต่อสปริง MVC
คุณต้องเริ่มต้นที่ไหนสักแห่ง ตามแผนเราจะเชื่อมต่อฐานข้อมูลและใช้ Hibernate แต่ทั้งหมดนี้ฟังดูน่ากลัวเกินไปเล็กน้อยในตอนนี้ เราต้องทำอะไรที่ง่ายกว่านี้ก่อน Spring MVC นี่ดีกว่าแล้ว เราคุ้นเคยกับรูปแบบ MVC มาเป็นเวลานาน มันถูกใช้ในครึ่งหนึ่งของงานใหญ่ของหลักสูตร จากนี้เราจะเริ่มเต้นรำกัน ในการสร้างเว็บแอปพลิเคชันด้วย Spring MVC เราจำเป็นต้องมี Servlet-API เช่น สิ่งนั้นด้วยความช่วยเหลือซึ่งการโต้ตอบระหว่างคำขอและการตอบสนองจะเกิดขึ้น ลองเชื่อมต่อสิ่งนี้กัน เราไปที่ Google ค้นหาการขึ้นต่อกันที่จำเป็นในพื้นที่เก็บข้อมูล Mavenและเพิ่มลงในไฟล์pom.xml
. 
เราจำเป็นต้องมีข้อจำกัดความรับผิดชอบเล็กน้อย โดยปกติจะแนะนำให้ยังคงเพิ่มการขึ้นต่อกันสำหรับแต่ละไลบรารีที่ใช้ แม้ว่าจะรวมเข้ากับไลบรารีที่เพิ่มไว้แล้วก็ตาม เนื่องจาก ซึ่งสามารถช่วยหลีกเลี่ยงปัญหาและข้อบกพร่องบางประการได้ ตัวอย่างง่ายๆ สมมติว่าเราได้เพิ่มการขึ้นต่อกันที่ใช้ API บางตัว และในขณะเดียวกัน ก็จะดึงการใช้งานบางประเภทสำหรับ API นี้ขึ้นมา จากนั้นเราได้เพิ่มการขึ้นต่อกันอื่นที่ใช้ API เดียวกันและดึงการใช้งานบางส่วนสำหรับสิ่งนี้ด้วย แต่คราวนี้แตกต่างออกไป ดังนั้น เราจะมีการใช้งาน API เดียวกันที่แตกต่างกัน 2 แบบ และหากเราต้องการใช้วิธีการบางอย่างของ API นี้ที่ไหนสักแห่งปัญหาก็จะเกิดขึ้นเนื่องจากระบบจะไม่รู้ว่าจะใช้วิธีใดมันจะเลือกแบบสุ่มบางทีอาจไม่ใช่แบบที่เราคาดไว้ และหากคุณระบุการขึ้นต่อกันอย่างชัดเจนสำหรับการใช้งานอย่างใดอย่างหนึ่ง ระบบจะให้ความสำคัญกับสิ่งดังกล่าว อย่างไรก็ตาม นี่ไม่ใช่คำแนะนำที่เข้มงวด แต่จะนำไปใช้กับโครงการขนาดใหญ่ที่ใช้ห้องสมุดต่างๆ มากมายจากบริษัทต่างๆ เราจะไม่ทำอย่างนั้นที่นี่ เพื่อไม่ให้โหลดไฟล์ POM มากเกินไป คาดว่าจะไม่มีปัญหาใดๆ แต่ถึงกระนั้นก็ยังคุ้มค่าที่จะคำนึงถึงเรื่องนี้ |
provided
ขึ้นอยู่กับ หมายถึง อะไรjavax.servlet-api
? ขอบเขตคือขอบเขตของการขึ้นต่อกันprovided
ซึ่งหมายความว่าการขึ้นต่อกันจะพร้อมใช้งานในขั้นตอนการคอมไพล์และทดสอบแอปพลิเคชัน แต่จะไม่ถูกเก็บถาวร ความจริงก็คือในการปรับใช้แอปพลิเคชันเราจะใช้คอนเทนเนอร์เซิร์ฟเล็ต Tomcat และมีไลบรารีดังกล่าวอยู่ภายในอยู่แล้ว ดังนั้นจึงไม่จำเป็นต้องถ่ายโอนไปที่นั่นและสร้างภาระให้กับไฟล์เก็บถาวรด้วยโหลดที่ไม่จำเป็น เมื่อมองไปข้างหน้า ด้วยเหตุผลเดียวกัน เราจะดำเนินการโดยไม่มีวิธีปกติmain
เนื่องจากมีอยู่แล้วใน Tomcat
การสร้างเพจและตัวควบคุม
มาลองทำอาหารง่ายๆ กันดีกว่า ขั้นแรก เรามาสร้างwebapp
ไดเร็กทอรีเพิ่มเติม ตัวอย่างเช่นpages
ซึ่งจะจัดเก็บมุมมองของเรา เช่น jsp และสร้างเพจสองสามเพจ เราจะต้องมีหน้าเว็บที่จะแสดงรายการภาพยนตร์ในอนาคตfilms.jsp
และบางทีเราอาจสร้างหน้าแยกต่างหากสำหรับการแก้ไขก็ได้editPage.jsp
. เราจะไม่กรอกข้อมูลที่จริงจังในตอนนี้ เพียงเพื่อการทดสอบ เราจะสร้างลิงก์ในหน้าหนึ่งไปยังอีกหน้าหนึ่ง 
controller
และสร้างคลาสขึ้นมาFilmController
(โดยทั่วไปไม่จำเป็นต้องทำแพ็คเกจทุกอย่างในแพ็คเกจที่แตกต่างกัน แอปพลิเคชั่นนี้จะเล็กและเรียบง่ายมาก แต่ในโปรเจ็กต์ปกติอาจมีคอนโทรลเลอร์ คลาสการกำหนดค่า โมเดลได้มากมาย ฯลฯ ดังนั้นแม้จะเริ่มต้นด้วยโปรเจ็กต์เล็กๆ ก็ควรทำความคุ้นเคยกับการทำทุกอย่างอย่างเป็นระเบียบและมีโครงสร้างทันทีเพื่อไม่ให้เกิดความยุ่งเหยิง) ในชั้นเรียนนี้ เราจะสร้างวิธีการที่จะคืนมุมมองของเราเพื่อตอบสนองต่อคำขอ
package testgroup.filmography.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class FilmController {
@RequestMapping(value = "/", method = RequestMethod.GET)
public ModelAndView allFilms() {
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("films");
return modelAndView;
}
@RequestMapping(value = "/edit", method = RequestMethod.GET)
public ModelAndView editPage() {
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("editPage");
return modelAndView;
}
}
ประเด็นคืออะไร? Spring MVC มีสิ่งที่เรียกว่าDispatcherServlet
. นี่เป็นเหมือนตัวควบคุมหลัก คำขอที่เข้ามาทั้งหมดจะผ่านไปและส่งต่อไปยังตัวควบคุมเฉพาะ คำอธิบายประกอบ@Controller
เพียงบอก Spring MVC ว่าคลาสนี้เป็นตัวควบคุม (โดยทั่วไปแล้วมีเหตุผล) ผู้มอบหมายงานจะตรวจสอบคำอธิบายประกอบ@RequestMapping
เพื่อเรียกใช้วิธีการที่เหมาะสม คำอธิบายประกอบ@RequestMapping
ช่วยให้คุณสามารถระบุที่อยู่สำหรับวิธีการควบคุมได้ โดยที่ที่อยู่เหล่านั้นจะมีอยู่ในไคลเอนต์ (เบราว์เซอร์) นอกจากนี้ยังสามารถนำไปใช้กับคลาสคอนโทรลเลอร์เพื่อตั้งค่าที่อยู่รูทสำหรับวิธีการทั้งหมด allFilms()
พารามิเตอร์สำหรับวิธีการvalue
ถูกตั้งค่าเป็น " /
" ดังนั้นจะถูกเรียกทันทีเมื่อมีการป้อนhttp://host:port/ ในเบราว์เซอร์ (เช่น โดยค่าเริ่มต้นคือhttp://localhost:8080/หรือhttp //127.0 .0.1:8080/ ) พารามิเตอร์method
ระบุประเภทของคำขอที่รองรับ (GET, POST, PUT ฯลฯ) เนื่องจากที่นี่เรารับเฉพาะข้อมูล จึงใช้ GET ต่อมาเมื่อวิธีการเพิ่มและแก้ไขปรากฏขึ้น ก็จะมีคำขอ POST อยู่แล้ว (อย่างไรก็ตาม แทนที่จะใช้คำอธิบายประกอบ@RequestMapping
ที่ระบุวิธีการ คุณสามารถใช้คำอธิบาย@GetMapping
ประกอบ@PostMapping
ฯลฯ@GetMapping
เทียบเท่ากัน@RequestMapping(method = RequestMethod.GET
)) ในวิธีการของเรา เราสร้างวัตถุModelAndView
และตั้งชื่อมุมมองที่ต้องการส่งคืน
การกำหนดค่า
มาดูการตั้งค่ากันต่อconfig
มาสร้าง คลาสในแพ็คเกจกันดีWebConfig
กว่า จะมีเพียงวิธีเดียวเท่านั้นที่ส่งคืนอ็อบเจ็กต์ประเภทViewResolver
นี่คืออินเทอร์เฟซที่จำเป็นในการค้นหาการแสดงตามชื่อ
package testgroup.filmography.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "testgroup.filmography")
public class WebConfig {
@Bean
ViewResolver viewResolver() {
InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
viewResolver.setPrefix("/pages/");
viewResolver.setSuffix(".jsp");
return viewResolver;
}
}
@Configuration
บอกกับ Spring ว่าคลาสนี้เป็นคลาสการกำหนดค่าและมีคำจำกัดความและการขึ้นต่อกันbean
ของส่วนประกอบต่างๆ Beansเป็นวัตถุที่ Spring จัดการ @Bean
คำอธิบายประกอบใช้เพื่อ กำหนด bean @EnableWebMvc
อนุญาตให้คุณนำเข้าการกำหนดค่า Spring MVC จากไฟล์WebMvcConfigurationSupport
. ตัวอย่างเช่น คุณยังสามารถใช้อินเทอร์เฟซWebMvcConfigurer
ที่มีวิธีการมากมาย และปรับแต่งทุกอย่างตามที่คุณต้องการ แต่เรายังไม่จำเป็นที่จะต้องพูดถึงเรื่องนั้น การตั้งค่ามาตรฐานก็เพียงพอแล้ว @ComponentScan
บอกให้ Spring ทราบว่าจะหาส่วนประกอบที่ควรจัดการได้จากที่ไหน เช่น คลาสที่มีเครื่องหมายประกอบ@Component
หรืออนุพันธ์ของมัน เช่น@Controller
, @Repository
, @Service
. คำอธิบายประกอบเหล่านี้จะกำหนดคลาส bean โดยอัตโนมัติ ในวิธีการนี้viewResolver()
เราสร้างการใช้งานและกำหนดว่าจะค้นหาการนำเสนอในwebapp
. ดังนั้นเมื่ออยู่ในเมธอดคอนโทรลเลอร์เราตั้งชื่อ " films
" มุมมองจะพบเป็น " /pages/films.jsp
" ดังนั้นเราจึงมีคลาสการกำหนดค่า แต่สำหรับตอนนี้มันเป็นเพียงคลาสที่แยกจากกันบางประเภทเท่านั้น มันไม่ส่งผลกระทบต่อแอปพลิเคชันของเราแต่อย่างใด . เราจำเป็นต้องลงทะเบียนการกำหนดค่านี้ในบริบทของ Spring เพื่อสิ่งนี้คุณต้องมีชั้นAbstractAnnotationConfigDispatcherServletInitializer
เรียน ในแพ็คเกจconfig
เราสร้างตัวตายตัวแทน พูดว่าAppInitializerและนำเมธอดของมันไปใช้
package testgroup.filmography.config;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
public class AppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
@Override
protected Class<?>[] getRootConfigClasses() {
return new Class[0];
}
@Override
protected Class<?>[] getServletConfigClasses() {
return new Class[]{WebConfig.class};
}
@Override
protected String[] getServletMappings() {
return new String[]{"/"};
}
}
วิธีสุดท้ายจะลงทะเบียนที่อยู่และมีอีก 2 วิธีในการลงทะเบียนคลาสการกำหนดค่า การกำหนดค่าเว็บ โดยที่ViewResolver
's และสิ่งที่คล้ายคลึงกันถูกกำหนดไว้ในgetServletConfigClasses()
. เป็นการดีกว่าที่จะอ่านเกี่ยวกับทั้งหมดนี้ในเอกสารประกอบและคำแนะนำต่างๆ แต่ในกรณีของเรายังไม่จำเป็นที่จะต้องเจาะลึกเรื่องนี้WebConfig
โดยหลักการแล้วของเราสามารถRootClasses
กำหนดได้ทั้งสองอย่าง คุณสามารถกำหนดทั้งสองอย่างพร้อมกันได้ แต่ก็ยังใช้งานได้ . อีกหนึ่งสิ่ง. อาจมีปัญหาในการเข้ารหัสเมื่อเมื่อส่งค่าด้วยอักขระภาษารัสเซียจากแบบฟอร์มผลลัพธ์จะเป็นการเขียนลวก ๆ เพื่อแก้ไขปัญหานี้ เราจะเพิ่มตัวกรองที่จะประมวลผลคำขอล่วงหน้า ไปที่ คลาส AppInitializerและแทนที่เมธอดgetServletFilters
ซึ่งเราระบุการเข้ารหัสที่ต้องการ แน่นอนว่าควรจะเหมือนกับที่อื่นๆ เช่นเดียวกับในหน้าและในฐานข้อมูล:
protected Filter[] getServletFilters() {
CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
characterEncodingFilter.setEncoding("UTF-8");
characterEncodingFilter.setForceEncoding(true);
return new Filter[] {characterEncodingFilter};
}
ดูเหมือนว่าทุกอย่างจะได้รับการตั้งค่าแล้ว คุณสามารถลองเรียกใช้และดูว่าเกิดอะไรขึ้น เรียกใช้ -> เรียกใช้ -> แก้ไขการกำหนดค่า -> เพิ่มการกำหนดค่าใหม่ -> เซิร์ฟเวอร์ Tomcat -> Local ถัดไป คุณต้องเลือกสิ่งประดิษฐ์ที่จะปรับใช้ แนวคิดนี้จะให้คำแนะนำคำเตือน: ไม่มีสิ่งประดิษฐ์ที่ทำเครื่องหมายไว้สำหรับการปรับใช้ คลิก ปุ่ม แก้ไขและเลือก...: war exploded หรือคุณสามารถไปที่Deployment -> add -> Artifact -> ...: war exploded 
/
" 
/filmography
" จากนั้นคุณจะต้องเพิ่มสิ่งนี้ลงในที่อยู่ทั้งหมด เช่น จะไม่มี" http://localhost:8080/edit"แต่จะเป็น"http://localhost:8080/filmography/edit" ) คลิกเรียกใช้และรอจนกว่าจะเริ่มต้น นี่คือสิ่งที่ฉันได้รับ: 
webapp
ไดเร็กทอรีพิเศษขึ้นWEB-INF
มา สิ่งที่อยู่ข้างในจะถูกซ่อนไม่ให้เปิดเผยต่อสาธารณะและสามารถเข้าถึงได้ผ่านตัวควบคุมเท่านั้น เราวางไดเร็กทอรีด้วยมุมมองของเรา ( pages
) WEB-INF
และViewResolver
เพิ่มลงในคำนำหน้าตามลำดับ:
viewResolver.setPrefix("/WEB-INF/pages/");
ตอนนี้เราได้หน้าเว็บของเราที่http://localhost:8080แต่ถ้าเราลองไปที่http://localhost:8080/WEB-INF/pages/films.jsp โดยตรง เราก็ได้รับข้อผิดพลาด 404 เยี่ยมเลย เรามี เว็บแอปพลิเคชันที่ง่ายที่สุด Hello World อย่างที่พวกเขาพูด โครงสร้างโครงการในปัจจุบันมีลักษณะดังนี้:

แบบอย่าง
เรามีมุมมองและตัวควบคุมอยู่แล้ว แต่ใน MVC ยังมีตัวอักษรตัวที่ 3 ดังนั้นเพื่อให้ภาพสมบูรณ์เราจะเพิ่มแบบจำลองด้วย ในแพ็คเกจmodel
เรามาสร้างคลาสFilm
กัน โดยมีฟิลด์ต่อไปนี้: int id
, String title
(ชื่อเรื่อง), int year
(ปีที่ออกฉาย), String genre
(ประเภท) และboolean watched
(เช่น คุณเคยดูภาพยนตร์เรื่องนี้แล้วหรือไม่)
package testgroup.filmography.model;
public class Film {
private int id;
private String title;
private int year;
private String genre;
private boolean watched;
// + Getters and setters
}
ไม่มีอะไรพิเศษ เป็นแค่คลาสธรรมดา สนามส่วนตัว ผู้ได้รับและผู้ตั้งค่า อ็อบเจ็กต์ของคลาสดังกล่าวเรียกอีกอย่างว่าPOJO
(Plain Old Java Object) ก็คือ "วัตถุ Java อย่างง่าย" ตอนนี้เรามาลองสร้างวัตถุดังกล่าวและแสดงบนหน้ากัน สำหรับตอนนี้ เราจะไม่กังวลมากเกินไปเกี่ยวกับวิธีสร้างและเริ่มต้นใช้งาน หากต้องการทดลองใช้ ให้สร้างมันขึ้นมาโดยตรงในคอนโทรลเลอร์อย่างโง่เขลา เช่นนี้
public class FilmController {
private static Film film;
static {
film = new Film();
film.setTitle("Inception");
film.setYear(2010);
film.setGenre("sci-fi");
film.setWatched(true);
}
และเพิ่มวัตถุนี้ให้กับเราModelAndView
โดยใช้วิธีการaddObject
:
@RequestMapping(method = RequestMethod.GET)
public ModelAndView allFilms() {
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("films");
modelAndView.addObject("film", film);
return modelAndView;
}
ตอนนี้เราสามารถแสดงวัตถุนี้บนหน้าของเราได้แล้ว แทนที่จะfilms.jsp
เป็น Hello World เราจะเขียน${film}
และวัตถุที่สอดคล้องกับชื่อแอตทริบิวต์ " film
" จะถูกแทนที่ที่นี่ ลองรันดูสิว่าเกิดอะไรขึ้น (เพื่อผลลัพธ์ที่ชัดเจนของอ็อบเจ็กต์ คลาสFilm
จึงถูกนิยามใหม่toString()
):

โมเดล-มุมมอง-คอนโทรลเลอร์
ในขั้นตอนนี้ ดูเหมือนว่าเราจะมีแอปพลิเคชัน Spring MVC ที่ครบถ้วนแล้ว ก่อนที่จะดำเนินการต่อ เป็นการดีที่จะดูทุกอย่างอีกครั้งและพิจารณาว่ามันทำงานอย่างไร บนอินเทอร์เน็ตคุณจะพบรูปภาพและไดอะแกรมมากมายเกี่ยวกับสิ่งนี้ ฉันชอบอันนี้:
Dispatcher Servlet
จากนั้นจะค้นหาคอนโทรลเลอร์ที่เหมาะสมเพื่อประมวลผลคำขอนี้โดยใช้HandlerMapping
(นี่คืออินเทอร์เฟซสำหรับการเลือกคอนโทรลเลอร์ ตรวจสอบว่าคอนโทรลเลอร์ใดที่มีอยู่มีวิธียอมรับที่อยู่ดังกล่าว) เรียกวิธีการที่เหมาะสมและController
ส่งคืนข้อมูลเกี่ยวกับมุมมอง จากนั้นผู้มอบหมายงานจะค้นหามุมมองที่ต้องการตามชื่อโดยใช้ViewResolver
'a หลังจากนั้นข้อมูลโมเดลจะถูกถ่ายโอนไปยังมุมมองนี้ และเราจะได้เพจของเราเป็นเอาต์พุต บางอย่างเช่นนี้ ดำเนินการต่อ... ขอแนะนำ Maven, Spring, MySQL, Hibernate และแอปพลิเคชัน CRUD แรก (ตอนที่ 1) ขอแนะนำ Maven, Spring, MySQL, Hibernate และแอปพลิเคชัน CRUD แรก (ตอนที่ 2) ขอแนะนำ Maven, Spring, MySQL, Hibernate และ แอปพลิเคชัน CRUD แรก (ตอนที่ 3) ข้อมูลเบื้องต้นเกี่ยวกับ Maven, Spring, MySQL, Hibernate และแอปพลิเคชัน CRUD แรก (ตอนที่ 4)
GO TO FULL VERSION