ข้อมูลเบื้องต้นเกี่ยวกับ Maven, Spring, MySQL, Hibernate และแอปพลิเคชัน CRUD แรก (ตอนที่ 1)

สวัสดีตอนบ่าย. ในบทความนี้ ฉันอยากจะแบ่งปันประสบการณ์ครั้งแรกของฉันกับสิ่งต่างๆ เช่น Maven, Spring, Hibernate, MySQL และ Tomcat ในกระบวนการสร้างแอปพลิเคชัน CRUD แบบง่ายๆ นี่เป็นส่วนแรกของ 4 บทความนี้มีไว้สำหรับผู้ที่ผ่านด่าน 30-40 ไปแล้วที่นี่ แต่ยังไม่ได้เสี่ยงเกินกว่า Java บริสุทธิ์และเพิ่งเริ่มต้น (หรือกำลังจะเริ่มต้น) เพื่อเข้าสู่โลกที่เปิดกว้างด้วย เทคโนโลยี กรอบงาน และคำอื่นๆ ที่ไม่คุ้นเคยทั้งหมดนี้

เนื้อหา:

• การแนะนำ
• การสร้างโครงการ
• การเชื่อมต่อสปริง MVC
• การสร้างเพจและตัวควบคุม
• การกำหนดค่า
• แบบอย่าง
• โมเดล-มุมมอง-คอนโทรลเลอร์

การแนะนำ

ฉันเริ่มทำความคุ้นเคยกับเทคโนโลยีและเฟรมเวิร์กที่ใหม่สำหรับฉันโดยศึกษาตัวอย่างต่างๆ ที่มีการนำไปใช้ เพราะโดยปกติแล้วฉันจะเข้าใจบางสิ่งได้ดีที่สุดเมื่อฉันเห็นมันใช้งานจริงโดยใช้ตัวอย่างของแอปพลิเคชันที่ครบครัน โดยทั่วไปตัวอย่างดังกล่าวคือ แอปพลิเค ชัน CRUD ( C reate, Read , U pdate, D elete) อินเทอร์เน็ตเต็มไปด้วยตัวอย่างของระดับความซับซ้อนที่แตกต่างกัน ปัญหาคือพวกเขามักจะไม่อธิบายรายละเอียดว่าทำอย่างไร อะไร และทำไมจึงทำที่นั่น เหตุใดจึงเพิ่มการพึ่งพาดังกล่าว เหตุใดจึงต้องมีคลาสดังกล่าว ฯลฯ ในกรณีส่วนใหญ่ พวกเขาจะใช้แอปพลิเคชันที่เสร็จสมบูรณ์แล้วพร้อมกับไฟล์ POM สุดท้าย พร้อมด้วยคลาสเวอร์ชันสุดท้าย และเพียงแค่ดำเนินการผ่านแต่ละแอปพลิเคชัน โดยไม่เน้นไปที่สิ่งเล็กๆ น้อยๆ ที่อาจดูเหมือนชัดเจนสำหรับผู้มีประสบการณ์ ฉันได้ดูตัวอย่างดังกล่าวมามากมายและมักจะชัดเจนว่าทุกอย่างทำงานอย่างไร แต่วิธีที่พวกเขามาถึงสิ่งนี้ยังไม่ชัดเจนนัก ดังนั้นฉันจึงตัดสินใจว่าตัวอย่างดังกล่าวจะมีประโยชน์ไม่ใช่จากตำแหน่งของนักพัฒนาที่มีประสบการณ์ แต่จากตำแหน่งของผู้เริ่มต้นที่ไม่เคยจัดการกับ Spring, Hibernate และเรื่องอื่น ๆ ฉันจะพยายามอธิบายรายละเอียดให้มากที่สุดเท่าที่จะเป็นไปได้ (เท่าที่ความเข้าใจของฉันอนุญาต) เส้นทางทั้งหมดของฉันในการสร้างแอปพลิเคชัน CRUD โดยเริ่มจากบางสิ่งในระดับ Hello World ที่ง่ายที่สุด ก่อนอื่น ฉันทำสิ่งนี้เพื่อตัวเอง เพราะเมื่อคุณพยายามอธิบาย บอก อธิบายบางสิ่ง คุณจะซึมซับและจัดระเบียบในหัวได้ดีขึ้นมาก แต่ถ้าสิ่งนี้มีประโยชน์กับใครบางคนและช่วยให้พวกเขาคิดอะไรบางอย่างได้ฉันก็จะดีใจมาก ในตัวอย่าง นี้เรามาลองสร้างแอปพลิเคชัน CRUD แบบง่ายโดยใช้Maven , Tomcat , Spring , HibernateและMySQL ขั้นตอนเบื้องต้น เช่น การติดตั้งMaven , MySQLโดยใช้แนวคิดเวอร์ชันUltimate เป็นต้น ฉันคิดว่าไม่จำเป็นต้องอธิบายรายละเอียดก็ไม่น่าจะมีปัญหากับเรื่องนี้ เป็นที่น่าสังเกตว่าในตัวอย่างนี้ การกำหนดค่าจะถูกกำหนดค่าโดยใช้คลาส Java (เรียกว่า JavaConfig) โดยไม่ใช้ xml

การสร้างโครงการ

ดังนั้น เนื่องจากฉันเป็นมือใหม่ เราจะไม่ใช้ต้นแบบที่ไม่ชัดเจนใดๆ 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. ในส่วนไลบรารีภายนอก คุณจะเห็นว่าไม่เพียง โหลด spring-webmvc เท่านั้น แต่ยังมีสิ่งอื่นๆ อีกมากมายด้วย เหล่านั้น. เราไม่จำเป็นต้องรวมการพึ่งพาเพิ่มเติมสำหรับspring core , context , beansฯลฯ ที่เราต้องการ ทุกสิ่งที่เราต้องการก็ถูกดึงขึ้นมาพร้อมกับspring- webmvc อีกหนึ่งบันทึก 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 และคุณต้องไปที่Deploymentและตั้ง ค่า ฟิลด์บริบท Applecation (ซึ่งจะเป็นส่วนหนึ่งของที่อยู่ URL ที่แอปพลิเคชันจะพร้อมใช้งานในเบราว์เซอร์) เป็น " /" จากนั้นแอปพลิเคชันของเราจะพร้อมใช้งานทันทีที่http://localhost:8080/ (แต่คุณสามารถระบุบางสิ่งที่นั่นได้ เช่น " /filmography" จากนั้นคุณจะต้องเพิ่มสิ่งนี้ลงในที่อยู่ทั้งหมด เช่น จะไม่มี" http://localhost:8080/edit"แต่จะเป็น"http://localhost:8080/filmography/edit" ) คลิกเรียกใช้และรอจนกว่าจะเริ่มต้น นี่คือสิ่งที่ฉันได้รับ: ดูเหมือนทุกอย่างจะเรียบร้อยดี แต่มีข้อแม้อยู่ประการหนึ่ง ความจริงก็คือว่าขณะนี้เพจของเราสามารถเข้าถึงได้แบบสาธารณะและสามารถเข้าถึงได้โดยตรงโดยการเขียนเส้นทางในแถบที่อยู่ เราเข้าสู่http://localhost:8080/pages/films.jspและตอนนี้เราได้รับเพจของเราโดยที่ผู้ควบคุมไม่ทราบ อย่างไรก็ตาม สิ่งนี้ยังไม่ถูกต้องนัก ดังนั้นเราจะสร้าง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)