บทความ
เริ่ม
เริ่มเรียนรู้
JavaRush /จาวาบล็อก /Random-TH /การสร้างเว็บแอปพลิเคชันอย่างง่ายโดยใช้ servlets และ jsp (...
Стас Пасинков
ระดับ
Киев

การสร้างเว็บแอปพลิเคชันอย่างง่ายโดยใช้ servlets และ jsp (ตอนที่ 1)

เผยแพร่ในกลุ่ม
ระดับความรู้ที่จำเป็นในการทำความเข้าใจบทความ:คุณมีความเข้าใจ Java Core ไม่มากก็น้อยอยู่แล้ว และต้องการดูเทคโนโลยี JavaEE และการเขียนโปรแกรมเว็บ จะเหมาะสมที่สุดหากคุณกำลังศึกษาภารกิจ Java Collections ซึ่งครอบคลุมหัวข้อที่ใกล้เคียงกับบทความ การสร้างเว็บแอปพลิเคชันอย่างง่ายโดยใช้เซิร์ฟเล็ตและ jsp (ตอนที่ 1) - 1เนื้อหานี้เป็นความต่อเนื่องเชิงตรรกะของบทความของฉันการสร้างโครงการเว็บอย่างง่ายใน IntelliJ Idea Enterprise ในนั้น ฉันสาธิตวิธีสร้างเทมเพลตโครงการเว็บที่ใช้งานได้ คราวนี้ ฉันจะแสดงวิธีสร้างเว็บแอปพลิเคชันที่เรียบง่ายแต่สวยงามโดยใช้เทคโนโลยี Java Servlet API และ JavaServer Pages API ใบสมัครของเราจะมีหน้าแรกพร้อมลิงก์สองลิงก์:
  • ไปยังหน้าการเพิ่มผู้ใช้
  • ไปยังหน้ามุมมองรายการผู้ใช้
ฉันจะยังคงใช้ IntelliJ Idea Enterprise Edition, Apache Maven (เพียงรวมการพึ่งพาบางส่วน) และ Apache Tomcat ในตอนท้าย เราจะ "ตกแต่ง" แอปพลิเคชันของเราโดยใช้เฟรม เวิร์ก W3.CSS เราจะถือว่าในขณะนี้คุณมีโปรเจ็กต์ว่างซึ่งเราจะพัฒนาที่นี่ ถ้าไม่ ให้อ่านบทความแรกและทำมัน มันจะใช้เวลาไม่กี่นาที :)

เล็กน้อยเกี่ยวกับโครงสร้างของแอปพลิเคชันในอนาคต

หน้าหลักของเรา ( / ) จะเป็นหน้า html แบบคงที่ที่ธรรมดาที่สุด โดยมีส่วนหัวและลิงก์/ปุ่มสองอัน:
  • เพิ่มผู้ใช้ใหม่ (จะถูกส่งไปที่/add );
  • ดูรายชื่อผู้ใช้ (ส่งไปที่/list )
Tomcat จะจับคำขอไปยังที่อยู่เหล่านี้และส่งไปยังหนึ่งในสองเซิร์ฟเล็ตที่เราจะสร้าง (เราจะอธิบายการแมปในไฟล์web.xml ) และในทางกลับกันเซิร์ฟเล็ตจะประมวลผลคำขอ เตรียมข้อมูล (หรือบันทึกหากมีการเพิ่มผู้ใช้) และถ่ายโอนการควบคุมไปยังไฟล์ jsp ที่เกี่ยวข้อง ซึ่งจะ "เรนเดอร์" ผลลัพธ์อยู่แล้ว เราจะจัดเก็บข้อมูลไว้ในรายการที่พบบ่อยที่สุด (รายการ)

มาสร้างโฮมเพจแบบคงที่กันดีกว่า

หากคุณมีindex.jsp อยู่ในโฟลเดอร์เว็บ ให้ลบออก แต่ในโฟลเดอร์นี้ เราจะสร้างไฟล์ html ธรรมดาที่เรียกว่าindex.html : 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>My super project!</title>
</head>
<body>
    <!-- header -->
    <div>
        <h1>Super app!<//h1>
    </div>

    <div>       <!-- content -->
        <div>    <!-- buttons holder -->
            <button onclick="location.href='/list'">List users<//button>
            <button onclick="location.href='/add'">Add user<//button>
        </div>
    </div>
</body>
</html>
ไม่มีอะไรซับซ้อนที่นี่ ในชื่อเรื่องเราระบุชื่อของหน้าของเรา ในเนื้อหาของหน้าเรามี div หลักสองส่วน: ส่วนหัว (ส่วนหัว) และเนื้อหา (เนื้อหา) ในเนื้อหาเรามีที่วางปุ่มของเรา และจริงๆ แล้วปุ่มสองปุ่มที่เมื่อคลิกจะถูกส่งไปยังที่อยู่ที่เหมาะสม คุณสามารถรันโปรเจ็กต์และดูว่าตอนนี้จะเป็นอย่างไร หากคุณคลิกที่ปุ่ม หน้าที่มีข้อผิดพลาด 404 จะเปิดขึ้นเนื่องจากเรายังไม่มี แต่นี่แสดงว่าปุ่มใช้งานได้ โปรดทราบว่านี่ไม่ใช่ตัวเลือกที่เป็นสากลที่สุด เพราะหากคุณปิดใช้งาน JavaScript โดยกะทันหัน ปุ่มเหล่านี้จะไม่มีประโยชน์ในเบราว์เซอร์ แต่เราจะถือว่าไม่มีใครปิดการใช้งาน JavaScript :) เห็นได้ชัดว่าสามารถใช้ลิงก์ธรรมดาได้ แต่ฉันชอบปุ่มมากกว่า คุณทำสิ่งที่คุณชอบที่สุด และอย่ามองว่าใน ตัวอย่าง ของฉันจะมี divมากมาย จากนั้นเราจะเติมสไตล์ให้และทุกอย่างจะดูสวยงามยิ่งขึ้น :)

สร้างไฟล์ jsp เพื่อเรนเดอร์ผลลัพธ์

ใน ไดเร็กทอรี เว็บ เดียวกัน เราจะสร้างโฟลเดอร์ที่เราจะใส่ไฟล์ jsp ของ เรา ฉันเรียกมันว่าวิว และขอย้ำอีกครั้งว่าคุณสามารถแสดงด้นสดได้ ในโฟลเดอร์นี้ เราจะสร้างไฟล์ jsp สองไฟล์:
  • add.jsp - หน้าสำหรับเพิ่มผู้ใช้
  • list.jsp - หน้าสำหรับแสดงรายการผู้ใช้
ให้พวกเขามีส่วนหัวของหน้าที่เหมาะสม บางอย่างเช่น "เพิ่มผู้ใช้ใหม่" และ "รายชื่อผู้ใช้" และเราจะปล่อยให้เป็นเช่นนั้นในตอนนี้

มาสร้างเซิร์ฟเล็ตสองอันกัน

Servlets จะยอมรับและดำเนินการตามคำขอที่ Tomcat จะส่งไปให้ ใน โฟลเดอร์ src/main/java เราจะสร้าง แพ็คเกจแอปซึ่งจะมีแหล่งที่มาของเรา ที่นั่นเราจะมีแพ็คเกจที่แตกต่างกันมากขึ้น ดังนั้นเพื่อไม่ให้แพ็คเกจเหล่านี้ถูกสร้างไว้ด้วยกัน เรามาสร้างคลาส ในแพ็คเกจ แอพกัน ดีกว่า (จากนั้นลบออก) ตอนนี้เรามาสร้างแพ็คเกจที่แตกต่างกันสามแพ็คเกจ ในแพ็คเกจ แอป :
Java-университет
  • เอนทิตี - นี่คือที่ที่เอนทิตีของเราจะโกหก (คลาสเองซึ่งจะอธิบายวัตถุผู้ใช้)
  • model - โมเดลของเราจะอยู่ที่นี่ (เพิ่มเติมเกี่ยวกับเรื่องนี้ในภายหลัง)
  • เซิร์ฟเล็ต - นี่คือเซิร์ฟเล็ตของเรา
หลังจากนี้ คุณสามารถลบคลาสนั้นออกจาก แพ็คเกจ แอป ได้อย่างปลอดภัย (ถ้าคุณเป็นผู้สร้างมันขึ้นมาแน่นอน) ใน แพ็คเกจ เซิร์ฟเล็ตเราจะสร้างคลาสขึ้นมา 2 คลาส:
  • AddServlet - จะประมวลผลคำขอที่ได้รับที่/add ;
  • ListServlet - จะประมวลผลคำขอที่ได้รับที่/ list

การเชื่อมต่อการพึ่งพาใน Maven

Tomcat เวอร์ชัน 9.* ใช้ข้อกำหนดเฉพาะของ Servlet เวอร์ชัน 4.0 และ JavaServer Pages เวอร์ชัน 2.3 สิ่งนี้เขียนไว้ในเอกสารอย่างเป็นทางการของ Tomcat 9 ในย่อหน้าแรกของบรรทัดที่สอง ซึ่งหมายความว่าหากคุณเช่นฉัน กำลังใช้ Tomcat เวอร์ชันนี้ โค้ดที่เราเขียนและส่งไปรันจะใช้เวอร์ชันที่ระบุทุกประการ แต่เราต้องการให้มีข้อกำหนดเหล่านี้ในโครงการของเรา เพื่อว่าอย่างน้อยโค้ดของเราที่ใช้จะคอมไพล์ได้สำเร็จ และสำหรับสิ่งนี้ เราจำเป็นต้องโหลดมันลงในโปรเจ็กต์ของเรา นี่คือจุดที่ Maven มาช่วยเหลือ

กฎทั่วไปคือ: หากคุณต้องการเชื่อมต่อบางสิ่งกับโปรเจ็กต์ของคุณโดยใช้ Maven:

  • ไปที่เว็บไซต์ที่เก็บ Maven
  • ค้นหาไลบรารีที่คุณต้องการและเวอร์ชันที่คุณต้องการ
  • คุณได้รับโค้ดอ้างอิงที่ต้องแทรกลงใน pom.xml ของคุณ
  • แทรก! :)
มาเริ่มกันเลย ก่อนอื่นมาเตรียมไฟล์ pomกัน ก่อน หลังจาก/versionแต่ก่อนหน้า/projectให้แทรกข้อมูลต่อไปนี้: 
<dependencies>

</dependencies>
ดังนั้นเราจึงระบุว่าภายในแท็กเหล่านี้ เราจะแสดงรายการการขึ้นต่อกันที่เราต้องการ ไปที่mvnrepository.comจะมีช่องค้นหาอยู่ด้านบน ขั้นแรก ให้ป้อน servlet ลงในการค้นหา ผลลัพธ์แรกซึ่งมีการใช้งานมากกว่าเจ็ดพันครั้งเหมาะกับเรา เราจำได้ว่าเราต้องการเวอร์ชัน 4.0 (สำหรับ Tomcat 9 สำหรับเวอร์ชันอื่น การใช้งานแบบเก่าอาจเหมาะสม) นี่เป็นเวอร์ชันล่าสุด ดังนั้นจึงไม่ค่อยมีการใช้งานมากนัก แต่เป็นเวอร์ชันที่เราต้องการ หน้าเว็บจะเปิดขึ้นซึ่งคุณสามารถรับรหัสสำหรับการพึ่งพานี้สำหรับผู้จัดการแพ็คเกจต่างๆ และคุณยังสามารถดาวน์โหลดได้อีกด้วย แต่เนื่องจากเราต้องการเชื่อมต่อโดยใช้ Maven เราจึงเลือกโค้ดบนแท็บ Maven เราคัดลอกและวางลงในไฟล์ pom ของเราภายในส่วนการอ้างอิง หากการแจ้งเตือนปรากฏขึ้นที่มุมขวาล่างของ IDEA และถามว่าเราต้องการเปิดใช้งานการนำเข้าอัตโนมัติหรือไม่ แสดงว่าเรายอมรับ หากคุณปฏิเสธโดยไม่ตั้งใจ ให้ไปที่ "การตั้งค่า" และเปิดใช้งานการนำเข้าอัตโนมัติด้วยตนเอง: การตั้งค่า (Ctrl + Alt + S) -> Build, Execution, Deployment -> Maven -> การนำเข้า สิ่งนี้จะเก็บไฟล์ pomและไฟล์การกำหนดค่า IDEA สำหรับสิ่งนี้ โครงการที่ซิงค์กัน ตอนนี้โดยใช้หลักการเดียวกัน เราจะค้นหาและเชื่อมต่อ JavaServer Pages เวอร์ชัน 2.3 (ป้อน jsp ในการค้นหา) และเนื่องจากเราได้ใช้ Maven แล้ว เราจึงบอกได้ทันทีว่าแหล่งที่มาของเราสอดคล้องกับไวยากรณ์ Java 8 และจำเป็นต้องคอมไพล์เป็นไบต์โค้ดในเวอร์ชันเดียวกัน หลังจากการดัดแปลงทั้งหมดนี้pom.xml ของเรา จะมีลักษณะดังนี้: 
<?xml version="1.0" encoding="UTF-8"?>
<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>ru.javarush.info.fatfaggy</groupId>
    <artifactId>my-super-project</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>1.8</maven.compile.source>
        <maven.compiler.target>1.8</maven.compile.target>
    </properties>

    <dependencies>
        <!-- Servlet API 4.0 for tomcat 9 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.0</version>
            <scope>provided</scope>
        </dependency>

        <!-- JavaServer Pages API 2.3 for tomcat 9 -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.1</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>

ทำให้เซิร์ฟเล็ตของเราเป็นเซิร์ฟเล็ตจริง

ณ จุดนี้ เซิร์ฟเล็ตที่เราสร้างขึ้นเป็นเพียงคลาสปกติเท่านั้น พวกเขาไม่มีฟังก์ชันการทำงานใดๆ แต่ตอนนี้เราได้เชื่อมต่อ Servlet API กับโปรเจ็กต์ของเราแล้ว และหากเป็นเช่นนั้น เราก็สามารถใช้คลาสจากที่นั่นได้ เพื่อให้เซิร์ฟเล็ตของเรา "ของจริง" เราเพียงแค่ต้องสืบทอดเซิร์ฟเล็ตเหล่านี้จากคลาส HttpServlet

การทำแผนที่หรือการแบ่งพาร์ติชัน

ตอนนี้ คงจะดีไม่น้อยหากบอก Tomcat ว่าคำขอจาก/addได้ รับการจัดการโดย เซิร์ฟเล็ตAddServlet ของเรา และดังนั้นคำขอจาก/listได้รับการจัดการโดย เซิร์ฟเล็ต ListServlet กระบวนการนี้เรียกว่าการทำแผนที่ ซึ่งทำได้ใน ไฟล์ web.xmlตามหลักการนี้:
  • ก่อนอื่นเราอธิบายเซิร์ฟเล็ต (เราตั้งชื่อและระบุเส้นทางไปยังคลาสเอง);
  • จากนั้นเราผูกเซิร์ฟเล็ตนี้กับที่อยู่เฉพาะ (เราระบุชื่อของเซิร์ฟเล็ตที่เราเพิ่งให้ไปและระบุที่อยู่ที่ควรส่งคำขอไปยังเซิร์ฟเล็ตนี้)
มาอธิบายเซิร์ฟเล็ตกันดีกว่า: 
<servlet>
    <servlet-name>add</servlet-name>
    <servlet-class>app.servlets.AddServlet</servlet-class>
</servlet>
ตอนนี้เราผูกไว้กับที่อยู่: 
<servlet-mapping>
    <servlet-name>add</servlet-name>
    <url-pattern>/add</url-pattern>
</servlet-mapping>
อย่างที่คุณเห็นชื่อเซิร์ฟเล็ตจะเหมือนกันในทั้งสองกรณี ด้วยเหตุนี้ Tomcat จึงรู้ว่าหากมีคำขอมาถึง/add address จะต้องส่งผ่านไปยังapp.servlets.AddServlet servlet เราทำเช่นเดียวกันกับเซิร์ฟเล็ตที่สอง ด้วยเหตุนี้web.xml ของเรา จึงมีเนื้อหาโดยประมาณดังนี้: 
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">

    <!-- add servlet -->
    <servlet>
        <servlet-name>add</servlet-name>
        <servlet-class>app.servlets.AddServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>add</servlet-name>
        <url-pattern>/add</url-pattern>
    </servlet-mapping>

    <!-- list servlet -->
    <servlet>
        <servlet-name>list</servlet-name>
        <servlet-class>app.servlets.ListServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>list</servlet-name>
        <url-pattern>/list</url-pattern>
    </servlet-mapping>
</web-app>
อย่างไรก็ตาม เราไม่ได้สร้างมาร์กอัปสำหรับหน้าหลักที่นี่ (ที่/ ) ความจริงก็คือในกรณีนี้เราไม่ต้องการมัน หน้าแรกของเราเป็นไฟล์ html ธรรมดา ที่แสดงปุ่มเพียงสองปุ่ม ไม่มีเนื้อหาแบบไดนามิก ดังนั้นจึงไม่มีเหตุผลสำหรับเราที่จะสร้างเซิร์ฟเล็ตแยกต่างหากสำหรับมัน โดยคำขอใดจากที่อยู่/ จะถูกส่งไป และซึ่งจะไม่ทำอะไรเลยนอกจากการถ่ายโอนการดำเนินการไปยังjsp บางตัว (ซึ่งจะต้องเป็นเช่นกัน สร้างขึ้น) ซึ่งจะวาดถ้าเรามีเพียงสองปุ่มเท่านั้น เราไม่ต้องการสิ่งนี้ เราพอใจกับทรัพยากรแบบคงที่ เมื่อ Tomcat ได้รับคำขอ มันจะตรวจสอบว่าไม่มีเซิร์ฟเล็ตเดียวที่สามารถประมวลผลคำขอตามที่อยู่ดังกล่าวได้ จากนั้นจะเห็นว่าตามที่อยู่นี้มี ไฟล์ htmlสำเร็จรูปจริง ๆซึ่งจะส่งได้สำเร็จ . เราสามารถเรียกใช้แอปพลิเคชันของเราได้อีกครั้ง (รีสตาร์ทเซิร์ฟเวอร์หรือปรับใช้ใหม่ตามที่คุณต้องการ) และตรวจสอบให้แน่ใจว่าหน้าหลักแสดงผลแล้ว ไม่มีอะไรเสียหาย เมื่อเราคลิกที่ปุ่ม การเปลี่ยนแปลงจะเกิดขึ้น แต่สำหรับตอนนี้มีข้อผิดพลาดเช่นกัน เขียนไว้. อย่างไรก็ตามหากก่อนหน้านี้เรามีข้อผิดพลาด 404 ตอนนี้เรามี 405 ซึ่งหมายความว่าการแมปใช้งานได้พบเซิร์ฟเล็ต แต่ไม่มีวิธีที่เหมาะสมในการประมวลผลคำขอ หากในขั้นตอนนี้ คุณยังคงได้รับข้อผิดพลาด 404 แม้ว่าทุกอย่างถูกต้องแล้ว บางทีคุณควรแก้ไขการกำหนดค่าการปรับใช้ตามแนวคิดนี้ ในการดำเนินการนี้ คุณต้องไปที่แก้ไขการกำหนดค่า (ที่ด้านบนใกล้กับปุ่มเริ่มต้น) ไปที่แท็บการปรับใช้ทางด้านขวาของหน้าต่าง และตรวจสอบให้แน่ใจว่าในบริบทของแอปพลิเคชันนั้น มีการระบุไว้อย่างง่าย /

การพูดนอกเรื่องโคลงสั้น ๆ: เกิดอะไรขึ้น "ภายใต้ประทุน"?

คุณคงสงสัยแล้วว่าแอปพลิเคชันของเราทำงานอย่างไรใน Tomcat? เกิดอะไรขึ้นที่นั่น? และ เมธอด main() อยู่ที่ไหน ? ทันทีที่คุณพิมพ์localhost:8080 ลงในเบราว์เซอร์ และไปที่ที่อยู่นี้ เบราว์เซอร์จะส่งคำขอไปยังที่อยู่นี้ผ่านโปรโตคอลhttp ฉันหวัง ว่าคุณจะทราบแล้วว่าคำขออาจมี "ประเภท" ที่แตกต่างกัน โดยคำขอที่ได้รับความนิยมมากที่สุดคือGETและPOST ทุกคำขอต้องมีคำตอบ คำขอ GET คาด หวังว่าจะได้รับ โค้ด htmlสำเร็จรูปในการตอบสนองซึ่งจะถูกส่งกลับไปยังเบราว์เซอร์ และเบราว์เซอร์จะแทนที่โค้ดนี้อย่างสวยงามด้วยตัวอักษร ปุ่ม และแบบฟอร์มทุกประเภท คำขอ POSTนั้นน่าสนใจกว่าเล็กน้อย เนื่องจากมีข้อมูลบางอย่างอยู่ด้วย ตัวอย่างเช่น ในแบบฟอร์มการลงทะเบียนผู้ใช้หรือการอนุญาต คุณป้อนข้อมูลของคุณและคลิก "ส่ง" ในขณะนี้คำขอ POST ถูกส่งไปยังเซิร์ฟเวอร์ โดยมีข้อมูลส่วนบุคคลของคุณอยู่ข้างใน เซิร์ฟเวอร์ยอมรับข้อมูลนี้ ประมวลผล และส่งคืนการตอบกลับบางประเภท (เช่นหน้า htmlที่มีโปรไฟล์ของคุณ) ความแตกต่างพื้นฐานระหว่างคำขอเหล่านี้คือคำขอ GETมีจุดประสงค์เพื่อรับข้อมูลจากเซิร์ฟเวอร์เท่านั้น ในขณะที่คำขอ POSTจะมีข้อมูลบางอย่างติดตัวไปด้วย และข้อมูลบนเซิร์ฟเวอร์อาจมีการเปลี่ยนแปลง (เช่น เมื่อคุณอัปโหลดภาพถ่ายของคุณไปยังเซิร์ฟเวอร์ จะบินไปในคำขอ POST และเซิร์ฟเวอร์จะเพิ่มลงในฐานข้อมูล กล่าวคือ มีการเปลี่ยนแปลงบางอย่างเกิดขึ้น ทีนี้กลับไปที่ Tomcat อีกครั้ง เมื่อได้รับคำขอจากไคลเอ็นต์ก็จะดูที่อยู่ค้นหาข้อมูลเพื่อ ดูว่ามีเซิร์ฟเล็ตที่เหมาะสมหรือไม่ซึ่งจะประมวลผลคำขอไปยังที่อยู่ดังกล่าว (หรือทรัพยากรสำเร็จรูปที่สามารถส่งคืนได้ทันที) หากไม่พบสิ่งใดที่จะส่งคืนจะไม่ตอบกลับด้วยหน้า html แต่ ด้วยการตอบสนอง 404 หากพบเซิร์ฟเล็ตที่เหมาะสมซึ่ง "อยู่" บนที่อยู่นี้ก็จะดูว่าได้รับคำขอประเภทใด (GET, POST หรืออย่างอื่น) แล้วถามเซิร์ฟเล็ตว่ามีวิธีการที่ สามารถจัดการคำขอประเภทนี้ได้ หาก servlet แจ้งว่าไม่สามารถประมวลผลประเภทนี้ได้ Tomcat จะตอบกลับไคลเอนต์ด้วยรหัส 405 นี่คือสิ่งที่เกิดขึ้นกับเรา แต่ถ้าพบเซิร์ฟเล็ตที่เหมาะสมและมีวิธีการที่เหมาะสม Tomcat จะสร้างอ็อบเจ็กต์ของเซิร์ฟเล็ตนี้ รันในเธรดใหม่ ( thread ) ซึ่งช่วยให้เซิร์ฟเล็ตทำงานในเธรดแยกกัน และ Tomcat ยังคงทำงานต่อไป การรับและส่งคำขอด้วยตนเอง นอกจากนี้ Tomcat ยังสร้างวัตถุเพิ่มเติมอีกสองวัตถุ: ประเภทหนึ่งHttpServletRequest (ฉันจะเรียกมันว่าคำขอสั้น ๆ ในอนาคต) และประเภทที่สองHttpServletResponse(ผมจะเรียกมันว่าคำตอบ) ในออบเจ็กต์แรก จะวางข้อมูลทั้งหมดที่ได้รับในคำขอจากไคลเอ็นต์ เพื่อให้สามารถดึงข้อมูลทั้งหมดออกจากออบเจ็กต์นี้ได้ หลังจากทั้งหมดนี้ มันจะส่งผ่านวัตถุทั้งสองนี้ไปยังวิธีการที่เหมาะสมของเซิร์ฟเล็ตที่ทำงานในเธรดที่แยกจากกัน ทันทีที่เซิร์ฟเล็ตทำงานเสร็จและพร้อมที่จะส่งไปยังไคลเอนต์ ก็ชูธงไปที่ Tomcat โดยพูดว่า “เสร็จแล้ว ทุกอย่างพร้อมแล้ว” Tomcat ยอมรับการตอบกลับและส่งไปยังไคลเอนต์ สิ่งนี้ทำให้ Tomcat สามารถรับคำขอและส่งคำตอบได้โดยไม่หยุดชะงัก ในขณะที่งานทั้งหมดเสร็จสิ้นโดยเซิร์ฟเล็ตที่ทำงานในเธรดที่แยกจากกัน ดังนั้น เมื่อเราเขียนโค้ดเซิร์ฟเล็ต เราจะกำหนดงานที่จะดำเนินการ และใช่ คุณสามารถนึกถึง เมธอด main()ได้ว่าอยู่ใน Tomcat นั่นเอง (ใช่ มันเขียนด้วยภาษา Java) และเมื่อเรา "เริ่ม" Tomcat ไฟล์main().

เราจับวิธีการ GET ด้วยเซิร์ฟเล็ตและส่งการตอบกลับง่ายๆ

ในขณะนี้ servlet ของเราไม่มีวิธีการที่เหมาะสม (GET) ดังนั้น Tomcat จึงส่งคืนข้อผิดพลาด 405 มาให้เรา มาสร้างมันกันเถอะ! คลาสHttpServletซึ่งเราสืบทอดเซิร์ฟเล็ตของเรามากำหนดวิธีการที่แตกต่างกัน เพื่อที่จะตั้งโค้ดสำหรับวิธีการต่างๆ เราก็เพียงแค่แทนที่มัน ในกรณีนี้ เราจำเป็นต้องแทนที่เมธอดdoGet()ในเซิร์ฟเล็ตทั้งสอง 
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

}
อย่างที่คุณเห็น เมธอดนี้ยอมรับสองอ็อบเจ็กต์: req (คำขอ) และresp (ตอบกลับ) สิ่งเหล่านี้คือออบเจ็กต์เดียวกับที่ Tomcat จะสร้างและเติมให้เราเมื่อเรียกวิธีการที่เหมาะสมในเซิร์ฟเล็ตนี้ ก่อนอื่น เรามาตอบคำถามที่ง่ายที่สุดกันดีกว่า เมื่อต้องการทำเช่นนี้ ให้ใช้ อ็อบเจ็กต์ respและรับ อ็อบเจ็กต์ PrintWriterซึ่งสามารถใช้เพื่อเขียนคำตอบได้ เมื่อใช้มันเราจะพิมพ์สตริงง่ายๆ 
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    PrintWriter writer = resp.getWriter();
    writer.println("Method GET from AddServlet");
}
เราจะทำสิ่งที่คล้ายกันใน เซิร์ฟเล็ต ListServletหลังจากนั้นเราจะเริ่มเซิร์ฟเวอร์ของเราอีกครั้ง อย่างที่คุณเห็นทุกอย่างได้ผล! เมื่อคุณคลิกที่ปุ่ม หน้าต่างๆ จะเปิดขึ้นพร้อมข้อความที่เรา "บันทึก" ด้วย PrintWriter เพียงแต่ว่าjsp ของเรา ที่เราเตรียมไว้สำหรับสร้างเพจที่มีคำตอบนั้นไม่ได้ถูกนำมาใช้ในทางใดทางหนึ่ง นี่เป็นเพราะว่าการประหารชีวิตไปไม่ถึงพวกเขา ตอนนี้เซิร์ฟเวอร์เล็ตเองสร้างการตอบกลับและทำงานให้เสร็จสิ้น โดยส่งสัญญาณให้ Tomcat ทราบว่ามีการตอบกลับพร้อมสำหรับไคลเอนต์แล้ว Tomcat เพียงรับคำตอบนี้และส่งกลับไปยังไคลเอนต์ เราถ่ายโอนการควบคุมจากเซิร์ฟเล็ตไปยังjsp มาเปลี่ยนโค้ดวิธีการของเราด้วยวิธีนี้:
  • เราได้รับจากออบเจ็กต์คำขอซึ่งเป็นออบเจ็กต์ตัวจัดการคำขอโดยที่เราส่ง ที่อยู่ jspของเพจที่เราต้องการถ่ายโอนการควบคุม
  • เมื่อใช้ออบเจ็กต์ที่ได้รับ เราจะถ่ายโอนการควบคุมไปยัง เพจ jsp ที่ระบุ และอย่าลืมแนบออบเจ็กต์คำขอและการตอบสนองที่เราได้รับจาก Tomcat ไว้ที่นั่น
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    RequestDispatcher requestDispatcher = req.getRequestDispatcher("views/add.jsp");
    requestDispatcher.forward(req, resp);
}
ในเนื้อหาของหน้า jsp (ภายในแท็ก body) เราสามารถเขียนบางอย่างเพื่อให้เรามองเห็นได้ชัดเจนว่าหน้าใดกำลังแสดงอยู่ หลังจากนั้นเราจะรีสตาร์ทเซิร์ฟเวอร์และตรวจสอบ กดปุ่มบนเพจหลัก เพจถูกเปิด ซึ่งหมายความว่าคำร้องขอจะถูกส่งไปยังเซิร์ฟเล็ต หลังจากนั้นการควบคุมจะถูกถ่ายโอนไปยังเพจ jsp ซึ่งถูกเรนเดอร์แล้ว นั่นคือทั้งหมดที่ ในส่วนถัดไปของบทความ เราจะพูดถึงฟังก์ชันการทำงานของแอปพลิเคชันของเรา

มีอะไรให้อ่านอีก:

การสร้างโครงการเว็บอย่างง่ายใน IntelliJ Idea Enterprise ทีละขั้นตอนพร้อมรูปภาพ


แชทของฉัน
ความคิดเห็น
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION