วงจรชีวิตของเซิร์ฟเล็ตใน Java: วิธีการ สถาปัตยกรรม การเปรียบเทียบ & การตั้งค่า

บทนำ

Servlets ให้วิธีการที่ไม่เพียงแต่อิงส่วนประกอบและไม่ขึ้นกับแพลตฟอร์ม แต่ยังสนับสนุนอย่างมากสำหรับการสร้างแอปพลิเคชันบนเว็บอีกด้วย Servlets สามารถเข้าถึง java APIs และ JDBC API เพื่อเข้าถึงฐานข้อมูล ในกรณีของ Java Servlets แม้ว่าจะไม่มีข้อจำกัดในแง่ของประสิทธิภาพของโปรแกรม CGI (Common Gateway Interface) แต่ก็ยังมีข้อเสียอยู่บ้าง

Servlet คืออะไร?

Servlet เป็นเทคโนโลยีที่มีประโยชน์อย่างมากสำหรับการสร้างหน้าเว็บแบบไดนามิก มันทำหน้าที่เป็นชั้นกลางระหว่างเว็บเบราว์เซอร์และไคลเอนต์ HTTP หรือเซิร์ฟเวอร์ ด้วยความช่วยเหลือของเซิร์ฟเล็ต ในตอนแรก เรารวบรวมอินพุตจากผู้ใช้ และจากนั้นสร้างหน้าเว็บแบบไดนามิก Servlet ขยายขีดความสามารถของเซิร์ฟเวอร์และแอปพลิเคชันโฮสต์ Servlets ขยายขีดความสามารถของเซิร์ฟเวอร์และตอบสนองต่อคำขอทุกประเภทสำหรับผู้ใช้

แหล่งที่มา

CGI เทียบกับ Servlets

ก่อนเซิร์ฟเล็ต CGI ถูกใช้อย่างกว้างๆ CGI เป็นวิธีการส่งคำขอที่ได้รับจากผู้ใช้ไปยังโปรแกรมแอปพลิเคชัน แม้ว่า CGI จะเป็นวิธีการสำหรับเว็บเซิร์ฟเวอร์ แต่ก็ยังได้รับการตอบกลับจากเบราว์เซอร์ (ไคลเอนต์) เมื่อผู้ใช้ร้องขอหน้าเว็บไปยังเบราว์เซอร์ เซิร์ฟเวอร์จะส่งกลับไปยังพวกเขา

เมื่อลูกค้าต้องการกรอกแบบฟอร์มบนหน้าเว็บและลองส่งอีกครั้ง แบบฟอร์มจะถูกประมวลผลโดยโปรแกรมแอปพลิเคชัน เซิร์ฟเวอร์ส่งข้อมูลไปยังโปรแกรมเว็บแอปพลิเคชันขนาดเล็ก โปรแกรมนี้ประมวลผลข้อมูลก่อนแล้วจึงส่งกลับผ่านข้อความยืนยัน

วิธีวงจรชีวิตของ Servlet โดยสังเขป

ส่วนใหญ่มีวิธีวงจรชีวิตของเซิร์ฟเล็ตสามวิธี ซึ่งเราสามารถอธิบายได้ดังนี้:

1. ในนั้น()
2. บริการ()
3. ทำลาย()

แหล่งที่มา

สถาปัตยกรรมเซิร์ฟเล็ต

• ประการแรก จะอ่านข้อมูลที่ลูกค้าส่งมา จากนั้นจะแทรกแบบฟอร์ม HTML ในหน้าเว็บแล้วส่งคำขอที่ส่งโดยลูกค้า
• หลังจากนั้น เซิร์ฟเล็ตจะประมวลผลข้อมูลและเชื่อมต่อกับระบบจัดการฐานข้อมูล โดยเรียกใช้ RMI โดยเรียกใช้บริการเว็บ
• หลังจากประมวลผลแล้ว สามารถส่งเอกสารในรูปแบบข้อความและ gif ได้

• ในที่สุดก็ส่ง HTTP ไปยังไคลเอนต์

แหล่งที่มา

ตอนนี้เราจะพูดถึงวิธีการเหล่านี้ในรายละเอียด

1. init()

เมธอด init() ถูกเรียกเพียงครั้งเดียวหลังจากสร้างอินสแตนซ์เซิร์ฟเล็ต ในตอนแรก มันจะเริ่มต้นเซิร์ฟเล็ต Servlet.init() ระบุว่าอินสแตนซ์ของเซิร์ฟเล็ตถูกสร้างขึ้นสำเร็จแล้ว

ไวยากรณ์ของวิธีการ init() ถูกกำหนดเป็น:

init โมฆะสาธารณะ (การกำหนดค่า ServletConfig) พ่น ServletException {

//รหัสเริ่มต้น

}

2. บริการ()

เมื่อใดก็ตามที่เซิร์ฟเล็ตได้รับการร้องขอ เว็บคอนเทนเนอร์จะเรียกใช้เมธอด service()

• เพื่อรวบรวมข้อมูลที่ร้องขอ b
• y ไคลเอนต์ ใช้ วัตถุ คำขอบริการ
• ในการสร้างเนื้อหาเอาต์พุต จะใช้อ็อบเจ็กต์ ServletResponse

ลายเซ็นของบริการ () วิธีการได้รับเป็น:

บริการโมฆะสาธารณะ (คำขอ ServletRequest การตอบสนอง ServletREsponse)

พ่น ServletEXception , IOException {

//ขอรหัสการจัดการ

}

เมธอด service() ใช้ doGet, doPost, doPut, doDelete และวิธีอื่นๆ อีกมากมาย

3. ทำลาย()

ผู้ใช้เรียกเมธอด destroy() อย่างน้อยหนึ่งครั้งใน วงจรชีวิตของ เซิร์ฟเล็ต มันถูกใช้เพื่อยุติการเชื่อมต่อฐานข้อมูล เพื่อปล่อยหน่วยความจำและทรัพยากรที่จัดสรร นอกจากนี้ยังช่วยในการทำความสะอาดและการรวบรวมขยะเกี่ยวข้องกับสิ่งนี้

ลายเซ็นของเมธอด destroy() คือ

โมฆะสาธารณะ ทำลาย(){

// รหัสสรุป

}

อ่านเพิ่มเติม: Servlet กับ JSP

การตั้งค่าสภาพแวดล้อมของ Servlet

ในการสร้างแอปพลิเคชัน Servlet ขั้นแรกเราต้องทำตามขั้นตอนบางอย่างเช่นการติดตั้ง Tomcat Server ซึ่งจะอธิบายไว้ด้านล่าง-

1. การสร้างโครงสร้างไดเร็กทอรี

แหล่งที่มา

อันดับแรก เราต้องสร้างโครงสร้างไดเร็กทอรีด้านบนภายในไดเร็กทอรีชื่อ Apache – Tomcat\webapps เราจำเป็นต้องเก็บ HTML, ไฟล์สแตติก, รูปภาพทั้งหมดไว้ในเว็บแอปพลิเคชันเพื่อสร้างโฟลเดอร์ เซิร์ฟเล็ตต้องเก็บไว้ในโฟลเดอร์คลาส สุดท้าย ไฟล์ web.xml ควรอยู่ใต้โฟลเดอร์ WEB-INF

2. การสร้างเซิร์ฟเล็ต

มีสามวิธีที่แตกต่างกันโดยที่เราสามารถสร้างเซิร์ฟเล็ตได้

1. โดยการใช้อินเทอร์เฟซ Servlet
2. โดยการขยายคลาส GenericServlet
3. จำเป็นต้องขยายคลาสเซิร์ฟเล็ต HTTP

เซิร์ฟเล็ตสามารถสร้างขึ้นได้เป็นหลักถ้าเราสามารถขยายคลาสนามธรรม httpServlet

3. รวบรวมเซิร์ฟเล็ต

สำหรับการคอมไพล์เซิร์ฟเล็ต จำเป็นต้องมีไฟล์ JAR –

1. โดยการตั้งค่า classpath
2. โดยวาง jar ในโฟลเดอร์ JRE/lib/ext

4. สร้าง Deployment Descriptor

DD สามารถกำหนดเป็นไฟล์ XML ที่ใช้โดยเซิร์ฟเวอร์บนเว็บ ดังนั้น

พวกเขาสามารถเรียกใช้ servlets ได้อย่างง่ายดาย DD ใช้เพื่อวัตถุประสงค์สำคัญหลายประการ

1. โดยการจับคู่ URL กับคลาส Servlet
2. โดยการเริ่มต้นพารามิเตอร์
3. โดยกำหนดหน้าข้อผิดพลาด
4. โดยบทบาทความปลอดภัย
5. โดยการประกาศแท็กไลบรารี

5. เริ่มเซิร์ฟเวอร์

ในการเริ่มเซิร์ฟเวอร์ Apache Tomcat เราต้องดับเบิลคลิกที่ไฟล์ startup.bat ภายใต้ไดเร็กทอรี apache-tomcat/bin และไฟล์นั้นจะเริ่มทำงาน

6. การเริ่มเซิร์ฟเวอร์ Tomcat เป็นครั้งแรก

ในการเริ่ม Tomcat Server เป็นครั้งแรก เราต้องตั้งค่า JAVA_HOME ในตัวแปร Environment ขั้นตอนต่อไปนี้กล่าวถึงด้านล่าง คลิกขวาที่ My Computer และเราต้องไป ที่ Properties

แหล่งที่มา

2. ต่อไป เราจะไปที่ แท็บ ขั้นสูง และเราต้องคลิกที่ ปุ่มตัวแปรสภาพ แวดล้อม

แหล่งที่มา

3. ดังนั้น เราจะคลิก ที่ปุ่มใหม่ และป้อน JAVA_HOME ในช่องข้อความชื่อตัวแปรและเส้นทางของ JDK ภายในช่องข้อความค่าตัวแปร จากนั้น เราต้องบันทึกโดยคลิก ตกลง

แหล่งที่มา

7. การรันแอพพลิเคชั่น Servlet

เมื่อเรารันปุ่มเซิร์ฟเล็ต มันจะมีลักษณะดังนี้ –

หลังจากเปิดบราวเซอร์แล้ว ให้พิมพ์ http:localhost:8080/First/hello

ชำระเงิน: เงินเดือนนักพัฒนา Java ในอินเดีย

Servlet ขออินเทอร์เฟซ

ServletRequest มุ่งหวังที่จะจัดหาข้อมูลที่แท้จริงเกี่ยวกับเซิร์ฟเล็ตให้กับลูกค้า

รวมถึงประเภทเนื้อหา ความยาว ค่าพารามิเตอร์ และอื่นๆ อีกมากมาย

วิธีการ

1. getAttribute(สตริง)

ส่งกลับค่าของแอตทริบิวต์ตามที่ร้องขอถ้าแอตทริบิวต์ไม่มีอยู่

แล้วคืนค่า NULL

2. getAttributeNames()

ส่งกลับชื่อของแอตทริบิวต์ปัจจุบันที่ร้องขอโดยไคลเอนต์

3.getCharacterEncoding()

ส่งกลับชุดอักขระบางชุด

4.getContentLength()

ส่งกลับ ขนาดเอนทิตีข้อมูลที่ ร้องขอ

5. getContentType()

ในตอนแรกจะขอข้อมูลประจำตัวของวัตถุ หากไม่พบ จะส่งกลับค่า NULL

6. getInputStream()

ส่งกลับกระแสข้อมูลไบนารีที่ลูกค้าได้รับจากนั้นส่งคืนสตริง

7.getParameter(สตริง)

ส่งกลับสตริงของพารามิเตอร์

8. getParameterNames()

ส่งคืนชื่อพารามิเตอร์

9. getParameterValues ​​(สตริง)

ส่งกลับค่าของพารามิเตอร์ มีอยู่ในรูปของสตริงเสมอ

10. getProtocol()

ส่งคืนโปรโตคอลและเวอร์ชันในรูปแบบ <protocol>/<เวอร์ชันหลัก>.<เวอร์ชันรอง>

11.getReader()

ส่งคืนโปรแกรมอ่านบัฟเฟอร์เพื่ออ่านข้อความในเนื้อหาของคำขอ

12. getRealPath (สตริง)

หลีกเลี่ยงเส้นทางเสมือนและส่งคืนเส้นทางจริง

13. getRemoteAddr()

มันส่งคืนที่อยู่ IP

14. getRemoteHost()

ส่งคืนชื่อโฮสต์ที่มีโครงสร้างโดยสมบูรณ์ของเอเจนต์

15. getScheme()

ส่งคืน URL ที่ใช้ในคำขอ

16. getServerName()

ส่งคืนชื่อโฮสต์ของเซิร์ฟเวอร์

17. getServerPort()

ส่งคืนหมายเลขพอร์ต

18. setAttribute (สตริง วัตถุ)

วิธีนี้จะรวบรวมแอตทริบิวต์สำหรับคำขอประเภทใดก็ได้

การตอบสนองของเซิร์ฟเล็ต

ServletResponse เรียกใช้อ็อบเจ็กต์ และบันทึกการตอบสนองของผู้ใช้ต่างๆ คอนเทนเนอร์เว็บรับผิดชอบกิจกรรมเหล่านี้ทั้งหมด ขั้นตอนในการสร้างสิ่งนี้มีความสำคัญมาก ขั้นตอนคือการสร้างวัตถุ

ตอนนี้ให้เราพูดถึงรายละเอียดเกี่ยวกับ ServletConfig และ ServletContext ด้านล่าง

ServletConfig

1. เว็บคอนเทนเนอร์สร้างอ็อบเจ็กต์ config ตามพารามิเตอร์การเริ่มต้น

2. ต้องมีหนึ่ง ServletConfig ต่อ Servlet

วิธีการ

1. เท่ากับ (วัตถุ)

ตรวจสอบว่าวัตถุปัจจุบันมีค่าเท่ากับวัตถุที่กำหนดหรือไม่

2. GetHashCode()

ทำงานเป็นฟังก์ชันแฮชเริ่มต้น

3. GetType()

ส่งกลับประเภทของอินสแตนซ์ปัจจุบัน

4. MemberwiseClone()

ถ้าเราเรียกใช้วัตถุนี้ สามารถสร้างสำเนาตื้นได้ มันหมายถึงวัตถุปัจจุบันโดยค่าเริ่ม ต้น

5. ToString()

ส่งกลับสตริงซึ่งแสดงถึงวัตถุปัจจุบัน

ServletContext

ให้เราพูดถึง ServletContext ด้านล่าง:

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

เซิร์ฟเล็ตสองประเภทสามารถกำหนดได้ดังนี้:

1. เซิร์ฟเล็ตทั่วไป

เราอ้างถึงเซิร์ฟเล็ต Generic ว่าไม่ขึ้นกับโปรโตคอล และจำเป็นต้องเรียกใช้โดยการแทนที่ เราสามารถเรียกใช้เซิร์ฟเล็ตทั่วไปได้สามวิธี -

• ไฟล์ HTML

เราสามารถสร้างไฟล์ HTML ที่ไม่ซับซ้อนซึ่งสามารถดูเหมือน WebContent/index.html

• ไฟล์คลาส Java

เซิร์ฟเล็ตทั่วไปสามารถสร้างได้โดยการขยายคลาส GenericServlet หากเราสามารถสร้างไฟล์คลาสใหม่อย่างง่าย เราก็สามารถเปลี่ยนชื่อเป็นไฟล์ทั่วไปได้ เส้นทางของไฟล์มีลักษณะดังนี้:/ javaResouces/src/default package/generic.java

• ไฟล์ XML

เราพบไฟล์นี้ในพาธ WebContent/WEB-INF/web.xml เราสามารถแมปเซิร์ฟเล็ตด้วย URL เฉพาะ

2. เซิร์ฟเล็ต HTTP

เซิร์ฟเล็ตประเภทนี้เป็นเพียงส่วนขยายของคลาสเซิร์ฟเล็ตเท่านั้น แม้ว่าจะขึ้นกับ HTTP แต่ก็ตั้งกฎบางอย่างที่ช่วยให้เว็บเบราว์เซอร์และเซิร์ฟเวอร์สื่อสารกันได้ และเซิร์ฟเล็ต HTTP ยังสามารถแทนที่เมธอด doGet() หรือ doPost() นอกจากนี้ยังสามารถแทนที่ทั้งสองวิธี

ข้อดีของเซิร์ฟเล็ต

ตอนนี้ให้เราดูข้อดีของเซิร์ฟเล็ต –

1. ผลงานมีความโดดเด่น
2. Servlets สามารถดำเนินการได้ภายในพื้นที่ที่อยู่ของเซิร์ฟเวอร์ ด้วยเหตุนี้ เราจึงสามารถพูดได้ว่าไม่จำเป็นต้องสร้างพื้นที่ที่อยู่แยกต่างหากเพื่อจัดการกับคำขอของลูกค้า
3. พวกมันไม่ขึ้นกับแพลตฟอร์มและอิงตามส่วนประกอบเป็นหลัก
4. เซิร์ฟเล็ตมีความปลอดภัยเนื่องจากตัวจัดการความปลอดภัยกำหนดข้อจำกัดบางอย่างเพื่อปกป้องทรัพยากรและข้อมูล
5. ขณะทำงาน ผู้ใช้ไม่จำเป็นต้องกังวลเกี่ยวกับการเพิ่มหน่วยความจำเป็นเทคนิคการจัดสรรขยะ
6. เซิร์ฟเล็ตมีฟังก์ชันเต็มรูปแบบเนื่องจากไลบรารีทั้งหมดพร้อมใช้งาน สามารถสื่อสารกับแอปเพล็ตและกลไกอื่นๆ ได้อย่างง่ายดาย

แหล่งที่มา

ข้อเสียของเซิร์ฟเล็ต

ข้อจำกัดของเซิร์ฟเล็ตถูกกล่าวถึงเป็น –

1. สามารถโหลดได้ครั้งละหนึ่งเซิร์ฟเล็ตใน JVM ดังนั้นเราจึงสามารถพูดได้ว่าจำนวนคำขอมีความสำคัญ
2. เมื่อมีคำขอจะมีเธรดเท่านั้น ไม่ควรมีกระบวนการที่นั่น
3. การออกแบบเซิร์ฟเล็ตนั้นมีค่าใช้จ่ายสูง และบางครั้งก็ค่อนข้างมีปัญหา
4. เราต้องการการตั้งค่าอื่นๆ ในเบราว์เซอร์ เช่น JRE (Java Runtime Environment) บนเซิร์ฟเวอร์เพื่อเรียกใช้เซิร์ฟเล็ต

อ่านเพิ่มเติม: แนวคิดและหัวข้อโปรเจ็กต์ Java

เรียนรู้ หลักสูตรซอฟต์แวร์ออนไลน์ จากมหาวิทยาลัยชั้นนำของโลก รับโปรแกรม PG สำหรับผู้บริหาร โปรแกรมประกาศนียบัตรขั้นสูง หรือโปรแกรมปริญญาโท เพื่อติดตามอาชีพของคุณอย่างรวดเร็ว

บทสรุป

ในยุคปัจจุบันของโลกดิจิทัล เทคโนโลยีและอินเทอร์เน็ตได้กลายเป็นแรงผลักดันของทุกสิ่ง อินเทอร์เน็ตไม่สงบ ทุก ๆ วินาที การถ่ายโอนข้อมูลจำนวนมากนั้นยุ่งมาก

แต่เนื่องจากการถ่ายโอนข้อมูลจำนวนมาก อินเทอร์เน็ตจึงช้าลง เนื่องจากเราต้องการความเร็วด้วย ดังนั้น ไซต์ไดนามิกจึงถูกสร้างขึ้นโดยนักพัฒนาซอฟต์แวร์ ไซต์เหล่านี้มีการเปลี่ยนแปลงและอัปเดตทุกขณะ หากต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับ Servlets ใน Java และการพัฒนา โปรดดู โปรแกรม Executive PG ของ upGrad ในการพัฒนาซอฟต์แวร์แบบฟูลสแตก และเริ่มต้นการเดินทางของคุณ

แรงจูงใจหลักของบทความนี้คือการให้ผู้อ่านมีแนวคิดพื้นฐานของเซิร์ฟเล็ต เพื่อให้พวกเขาได้รับแนวคิดพื้นฐานเกี่ยวกับเซิร์ฟเล็ต

ลงจอดบนงานในฝันของคุณ

สมัครเลยตอนนี้สำหรับโปรแกรม Executive PG ในการพัฒนา Full Stack