บทความ
เริ่ม
เริ่มเรียนรู้
CodeGym /จาวาบล็อก /สุ่ม /การสร้างเว็บแอปพลิเคชันอย่างง่ายโดยใช้เซิร์ฟเล็ตและ JSP (...
John Squirrels
ระดับ
San Francisco

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

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

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

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

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

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

สร้างสองเซิร์ฟเล็ต

Servlets จะรับและดำเนินการตามคำขอที่Tomcatส่งมา ใน โฟลเดอร์ src/main/javaให้สร้างapp package ซึ่งเราจะใส่ซอร์สโค้ดของเรา แพ็คเกจอื่น ๆ ก็จะไปที่นั่นด้วย ดังนั้น เพื่อป้องกันไม่ให้สร้างแพ็คเกจเหล่านี้ภายในกันและกัน เราจะสร้างบางคลาสใน แพ็คเกจ แอพ (เราจะลบออกในภายหลัง) ตอนนี้สร้างแพ็คเกจที่แตกต่างกันสามแพ็คเกจใน แพ็คเกจ แอพ :
  • เอนทิตี — เอนทิตีของเรา (คลาสที่อธิบายออบเจกต์ผู้ใช้) ไปที่นี่
  • โมเดล — นี่คือที่มาของโมเดลของเรา (เราจะพูดถึงเรื่องนี้ในภายหลัง);
  • เซิร์ฟเล็ต — และนี่คือที่มาของเซิร์ฟเล็ตของเรา
เมื่อคุณทำเสร็จแล้ว คุณสามารถลบคลาสนั้นออกจาก แพ็คเกจ แอปได้ อย่างสบายๆ (แน่นอนว่าถ้าคุณสร้างมันขึ้นมา) ใน แพ็คเกจ servletsให้สร้างสองคลาส:
  • AddServlet — ประมวลผลคำขอที่ส่งไปยัง / เพิ่ม ;
  • 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) -> สร้าง ดำเนินการ ปรับใช้ -> Maven -> นำเข้าและไฟล์การกำหนดค่า IDEA สำหรับโครงการนี้ที่ซิงค์กัน ตามหลักการเดียวกัน เราจะค้นหาและเชื่อมต่อJavaServer Pages 2.3 (ค้นหา "JSP") และเนื่องจากเราได้เริ่มใช้ Maven แล้ว เรามาบอกว่าไฟล์ต้นฉบับของเราใช้ไวยากรณ์ Java 8 และเราต้องคอมไพล์ให้เป็น bytecode สำหรับเวอร์ชันนั้น หลังจากทำตามขั้นตอนทั้งหมดแล้ว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>cc.codegym.info.fatfaggy</groupId>
    <artifactId>my-super-project</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compile.source>1.8</maven.compile.source>
        <maven.compile.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ว่าคำขอสำหรับที่อยู่ / เพิ่มได้รับการประมวลผลโดยAddServlet ของเรา และคำขอสำหรับที่อยู่ / รายการจะได้รับการจัดการโดย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>
อย่างที่คุณเห็น servlet-name เหมือนกันในทั้งสองกรณี เป็นผลให้Tomcatรู้ว่าหากได้รับคำขอ /add จะต้องส่งไปยัง app.servlets.AddServlet เราทำสิ่งเดียวกันกับเซิร์ฟเล็ตที่สอง สุดท้ายนี้ 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 หมายความว่าการแมปทำงานและพบเซิร์ฟเล็ต แต่ไม่มีวิธีการที่เหมาะสมในการจัดการกับคำขอ

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

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

ใช้เซิร์ฟเล็ตเพื่อจับเมธอด GET และส่งการตอบกลับที่ง่ายมาก

ในขณะนี้ เซิร์ฟเล็ตของเราไม่มีเมธอดที่เหมาะสม (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("GET method from AddServlet");
}
เราจะทำสิ่งที่คล้ายกันใน ListServlet จากนั้นเราจะรีสตาร์ทเซิร์ฟเวอร์ของเรา อย่างที่คุณเห็นทุกอย่างใช้งานได้! เมื่อคุณคลิกที่ปุ่ม คุณจะได้หน้าที่มีข้อความที่เรา "เขียน" ด้วย PrintWriter แต่ไฟล์ JSP ที่เราเตรียมไว้เพื่อสร้างเพจที่มีการตอบกลับไม่ได้ถูกใช้ นั่นเป็นเพียงเพราะพวกเขาไม่เคยถูกประหารชีวิต เซิร์ฟเล็ตของเราสร้างการตอบสนองเองและทำงานจนเสร็จสิ้น โดยส่งสัญญาณไปยัง Tomcat ว่าพร้อมที่จะตอบสนองต่อไคลเอนต์ Tomcat เพียงแค่ตอบรับและส่งกลับไปยังลูกค้า ส่งต่อการควบคุมจากเซิร์ฟเล็ตไปยังไฟล์ JSP เราจะเปลี่ยนรหัสวิธีการของเราดังนี้:
  • เราได้รับอ็อบเจกต์ dispatcher ของออบเจกต์จากอ็อบเจกต์ที่ร้องขอ และส่งไปยังแอดเดรสของหน้า 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);
}
ในแท็ก body ของหน้า JSP คุณสามารถเพิ่มบางอย่างเพื่อให้เราเห็นได้ชัดว่าหน้าใดกำลังแสดงอยู่ เมื่อคุณทำเสร็จแล้ว ให้รีสตาร์ทเซิร์ฟเวอร์และตรวจสอบ เราคลิกปุ่มบนหน้าหลักและหน้าเปิดขึ้น ซึ่งหมายความว่าคำขอจะถูกส่งไปยังเซิร์ฟเล็ต จากนั้นการควบคุมจะถูกส่งผ่านไปยังหน้า JSP ซึ่งขณะนี้กำลังแสดงผล นั่นคือทั้งหมดที่สำหรับตอนนี้. ในส่วนถัดไปของบทความนี้ เราจะดำเนินการเกี่ยวกับฟังก์ชันการทำงานของแอปพลิเคชันของเรา

อ่านเพิ่มเติม:
ความคิดเห็น
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION