รู้เบื้องต้นเกี่ยวกับไลบรารีแท็ก JSP

ฉันเขียนโปรแกรมด้วย JSP และ ASP มาเป็นเวลานาน ในบรรดาโซลูชันการเขียนโปรแกรมฝั่งเซิร์ฟเวอร์ทั้งสองนี้ ฉันรู้สึกว่า JSP มีประสิทธิภาพมากกว่า ASP มาก เหตุใดฉันจึงควรเลือก JSP เป็นเครื่องมือพัฒนาแอปพลิเคชันเว็บฝั่งเซิร์ฟเวอร์ที่ฉันต้องการ แน่นอนว่า JSP มีคุณสมบัติและฟังก์ชันที่น่าสนใจมากมาย แต่ไลบรารีแท็กของ JSP เป็นหนึ่งในเหตุผลที่สำคัญที่สุดสำหรับฉันในการตัดสินใจครั้งนี้
ทำไมคุณพูดแบบนี้? เหตุผลมีสองเท่า: การบำรุงรักษาและความเร็วของการพัฒนา ภาษาสคริปต์ฝั่งเซิร์ฟเวอร์เป็นจุดหลอมรวมของการพัฒนาอินเทอร์เน็ต บนเพจเซิร์ฟเวอร์ คุณสามารถผสมวิธีสคริปต์และอ็อบเจ็กต์ต่างๆ ได้อย่างง่ายดาย หน้าประเภทนี้เป็นเพียงคอนกรีตสำหรับการสร้างเว็บ มันเป็นส่วนผสมของ "สิ่ง" ที่ทำให้สคริปต์ฝั่งเซิร์ฟเวอร์มีความสามารถในการประมวลผลข้อมูลที่ทรงพลัง ช่วยให้โปรแกรมเมอร์ฝั่งเซิร์ฟเวอร์สามารถพัฒนาเว็บเพจแบบไดนามิกและยืดหยุ่นได้ แต่ในทางกลับกัน การผสมสคริปต์ฟรีก็มีข้อเสียเช่นกัน ซึ่งก็คือการบำรุงรักษานั้นยุ่งยากมาก โดยเฉพาะอย่างยิ่งเมื่อขนาดของโปรเจ็กต์ยังคงเติบโตอย่างต่อเนื่อง ที่แย่กว่านั้นคือเมื่อความซับซ้อนของโค้ดเพิ่มขึ้น ความเร็วของการพัฒนาจะช้าลง ซึ่งไม่เอื้อต่อการพัฒนาเว็บแอปพลิเคชันขนาดกลางและขนาดใหญ่จำนวนมาก เว็บแอปพลิเคชันฝั่งเซิร์ฟเวอร์ขนาดกลางหรือใหญ่ เปิดตัวช้ามากและต้นทุนสูงอย่างควบคุมไม่ได้ นอกจากนี้ เมื่อพัฒนาแล้ว ไซต์ยังจำเป็นต้องค้นหาโปรแกรมเมอร์ที่มีคุณสมบัติเหมาะสมเพื่อรักษาโค้ดที่ค่อนข้างซับซ้อนเหล่านี้ ด้วยเหตุนี้ โปรแกรมเมอร์เหล่านี้จึงกลายเป็นนักออกแบบเว็บไซต์ทั่วไป และแอปพลิเคชันฝั่งเซิร์ฟเวอร์มีบทบาทสำคัญในทั้งการออกแบบกราฟิกขั้นสุดท้ายและการใช้งาน . มันอ่อนแอลง.
เพื่อที่จะเอาชนะปัญหานี้ ASP ได้แนะนำเทคโนโลยีอ็อบเจ็กต์ COM ในขณะที่ JSP ได้จัดเตรียม J2EE ไว้เป็นมาตรการตอบโต้ โซลูชันเหล่านี้สร้างขึ้นบนกลไกของฐานโค้ดแบบรวมศูนย์และนำกลับมาใช้ใหม่ได้ อย่างไรก็ตาม มันใช้งานยากเกินไปและใช้เวลาเรียนรู้นานมาก นอกจากนี้ โซลูชันเหล่านี้ไม่ได้ลดความอยากในการสร้างโค้ดที่ยุ่งวุ่นวาย และด้วยเหตุนี้ เราจึงต้องจัดทีมพัฒนาขนาดใหญ่ที่มีโครงสร้างดีเพื่อใช้เทคโนโลยีเหล่านี้ สำหรับโปรเจ็กต์ขนาดกลาง วิธีการดังกล่าวมักจะถูกใช้น้อยกว่า แต่จริงๆ แล้ว โปรเจ็กต์เว็บแอปพลิเคชันขนาดกลางเป็นวิธีที่พบได้บ่อยที่สุด เป็นผลให้หลายโครงการถูกบังคับให้ใช้สภาพแวดล้อมการพัฒนาและการบำรุงรักษาที่ไม่ตรงกับความต้องการของพวกเขา
โชคดีที่ JSP ให้วิธีที่ดีกว่าในการแก้ปัญหานี้ ไลบรารีแท็กมอบวิธีง่ายๆ ในการสร้างบล็อกโค้ดที่นำมาใช้ซ้ำได้ เมื่อออกแบบไลบรารีแท็กแล้ว จะสามารถใช้งานได้อีกครั้งในหลายโปรเจ็กต์ สิ่งที่สะดวกกว่านั้นคือ ไม่เหมือนกับ COM และ J2EE ตราบใดที่คุณรู้วิธีเขียน JSP คุณไม่จำเป็นต้องเรียนรู้ทักษะอื่นใดเพื่อสร้างไลบรารีแท็ก! สุดท้ายนี้ ไลบรารีแท็กยังช่วยปรับปรุงความสามารถในการบำรุงรักษาเว็บแอปพลิเคชันอีกด้วย การปรับปรุงความสามารถในการบำรุงรักษานี้สะท้อนให้เห็นในการใช้งานอินเทอร์เฟซที่ปรับแต่งได้แบบ XML บนเพจ JSP อย่างง่ายดาย ด้วยเหตุนี้ นักออกแบบเว็บไซต์จึงสามารถสร้างเว็บแอปพลิเคชัน JSP ได้โดยไม่ต้องรู้ว่า JSP คืออะไร ด้วยวิธีนี้การพัฒนาเว็บจึงกลายเป็นงานพัฒนาทีมที่มีประสิทธิภาพมาก โปรแกรมเมอร์ JSP สามารถสร้างแท็กที่กำหนดเองและโมดูลโค้ดส่วนหลังได้ ในขณะที่นักออกแบบเว็บไซต์สามารถใช้แท็กที่กำหนดเองและมุ่งเน้นไปที่การออกแบบเว็บทั้งหมดได้ ไลบรารีแท็กแก้ปัญหาความสับสนของโค้ดและทำได้อย่างหมดจดและสวยงาม (อันที่จริง XML เป็นสาระสำคัญในการแก้ปัญหาเหล่านี้ แต่ไลบรารีแท็กยังคงมีบทบาทสำคัญ)

ไลบรารีแท็กคืออะไร?
ไลบรารีแท็ก JSP (หรือที่เรียกว่าไลบรารีแท็กที่กำหนดเอง) สามารถใช้เป็นวิธีการสร้างสคริปต์ที่ใช้ XML ผ่าน JavaBeans ตามแนวคิดแล้ว แท็กเป็นโครงสร้างโค้ดที่เรียบง่ายและสามารถนำมาใช้ซ้ำได้ ตัวอย่างเช่น ใน JSPKit รุ่นล่าสุดของเรา (ภายใน JSP Insider) เอกสาร XML สามารถเข้าถึงได้ง่ายโดยใช้แท็ก XML โปรดดูรายการ A ด้านล่าง
รายการ A: ตัวอย่างแท็กที่ทำการแปลง XML/XSL และหน้า HTML ที่มีอยู่
<%@ taglib uri=" http://www.jspinsider.com/jspkit/JAXP " คำนำหน้า = "JAXP"%>
<JAXP:TransformerTag>
<JAXP:XMLFile>c:/xml/example.xml</JAXP:XMLFile>
<JAXP:XSLFile>c:/xml/example.xsl</JAXP:XSLFile>
</JAXP:TransformerTag>

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

คุณสมบัติที่สำคัญของไลบรารีแท็ก

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

2. ไลบรารีแท็ก JSP แบบขยายสามารถมีคุณสมบัติและฟังก์ชันใดๆ ในข้อกำหนด JSP (JSP 1.2) คุณสามารถขยายและเพิ่มฟังก์ชันของ JSP ได้โดยไม่มีขีดจำกัดโดยไม่ต้องรอให้ JSP เวอร์ชันถัดไปปรากฏขึ้น ตัวอย่างเช่น คุณไม่พอใจกับการโทรแบบรวม JSP คุณสามารถสร้างแท็กรวมของคุณเองที่บังคับใช้ข้อกำหนดของคุณเองได้

3. ดูแลรักษาง่าย

ไลบรารีแท็กทำให้เว็บแอปพลิเคชัน JSP ดูแลรักษาง่ายมากด้วยเหตุผลดังต่อไปนี้:
(1) การติดฉลากนั้นง่ายและสะดวกสำหรับทุกคนที่ใช้และเข้าใจ
(2) รหัสลอจิกของโปรแกรมทั้งหมดรวมอยู่ในตัวประมวลผลแท็กและ JavaBeans ซึ่งหมายความว่าเมื่อคุณอัปเกรดโค้ด คุณไม่จำเป็นต้องแก้ไขทุกหน้าที่ใช้โค้ด คุณจะต้องแก้ไขไฟล์โค้ดแบบรวมศูนย์เท่านั้น
(3) หากคุณต้องการเพิ่มฟังก์ชันใหม่ คุณไม่จำเป็นต้องแก้ไขเพจที่มีอยู่ คุณสามารถเพิ่มแอตทริบิวต์เพิ่มเติมให้กับแท็กเพื่อแนะนำลักษณะการทำงานใหม่ ในขณะที่แอตทริบิวต์เก่าอื่นๆ ยังคงไม่เปลี่ยนแปลง เพื่อให้ยังคงสามารถใช้เพจเก่าทั้งหมดได้ . ใช้งานได้ปกติ. ตัวอย่างเช่น คุณมีป้ายกำกับที่ทำให้ข้อความทั้งหมดเป็นสีน้ำเงิน:
<BlueText>ข้อความของฉัน</BlueText>
แต่ภายหลังในโครงการ คุณต้องการให้สีน้ำเงินเข้มขึ้น คุณสามารถเก็บป้ายกำกับเดิมไว้ได้ และเพิ่มแอตทริบิวต์ใหม่ลงไป: เฉดสี ดังที่แสดงด้านล่าง:
<BlueText shade="teal">ข้อความของฉัน</BlueText>
แท็กเก่าทั้งหมดยังคงสามารถสร้างข้อความสีน้ำเงินได้ แต่ตอนนี้คุณสามารถใช้แท็กเดียวกันเพื่อสร้างข้อความสีน้ำเงินเข้มได้
(4) ป้ายกำกับปรับปรุงการนำโค้ดกลับมาใช้ซ้ำได้ Code ที่ทดสอบและใช้งานหลายครั้งจะมี Bug น้อยลงอย่างแน่นอน ดังนั้น เพจ JSP ที่ใช้แท็กแบบกำหนดเองจึงมีข้อบกพร่องน้อยกว่าและสะดวกกว่ามากในการบำรุงรักษา

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

โครงสร้างแท็ก

แม้ว่าไลบรารีแท็กจะใช้งานง่ายมาก แต่กลไกการใช้งานภายในของการสร้างไลบรารีแท็กยังคงค่อนข้างซับซ้อน อย่างน้อยก็ซับซ้อนกว่าการสร้าง JavaBean แบบธรรมดา ความซับซ้อนมาจากข้อเท็จจริงที่ว่าไลบรารีแท็กประกอบด้วยหลายส่วน อย่างไรก็ตาม คุณเพียงแค่ต้องเชี่ยวชาญความรู้เกี่ยวกับ Java และ JSP เท่านั้น
แท็กแบบง่ายประกอบด้วยองค์ประกอบต่อไปนี้:
1. JavaBean: เพื่อให้ได้รับประโยชน์จาก Java และลักษณะเชิงวัตถุโดยธรรมชาติ ควรวางโค้ดที่นำมาใช้ซ้ำได้ในคอนเทนเนอร์โค้ดแยกต่างหาก ซึ่งก็คือ JavaBean JavaBeans เหล่านี้ไม่ใช่ส่วนสำคัญของไลบรารีแท็ก แต่เป็นโมดูลโค้ดพื้นฐานที่ไลบรารีแท็กใช้เพื่อทำงานที่ได้รับมอบหมาย
2. ตัวประมวลผลแท็ก: ตัวประมวลผลแท็กคือหัวใจที่แท้จริงของไลบรารีแท็ก ตัวจัดการแท็กอ้างอิงทรัพยากรภายนอกที่ต้องการ (JavaBeans) และรับผิดชอบในการเข้าถึงข้อมูลเพจ JSP (ออบเจ็กต์ PageContext) หน้า JSP จะส่งผ่านแอตทริบิวต์ของแท็กที่ตั้งค่าไว้บนหน้าและเนื้อหาในส่วนเนื้อหาของแท็กไปยังตัวประมวลผลแท็ก เมื่อตัวประมวลผลแท็กเสร็จสิ้น ระบบจะส่งผลเอาต์พุตที่ประมวลผลกลับไปที่หน้า JSP เพื่อดำเนินการต่อไป
3. ตัวอธิบายไลบรารีแท็ก (ไฟล์ TLD): นี่คือไฟล์ XML ธรรมดาที่บันทึกแอตทริบิวต์ ข้อมูล และตำแหน่งของตัวประมวลผลแท็ก คอนเทนเนอร์ JSP ใช้ไฟล์นี้เพื่อทราบว่าจะเรียกไลบรารีแท็กที่ไหนและอย่างไร
4. ไฟล์ web.xml ของเว็บไซต์: นี่คือไฟล์เริ่มต้นของเว็บไซต์ ในไฟล์นี้ จำเป็นต้องกำหนดแท็กที่กำหนดเองที่ใช้ในเว็บไซต์ รวมถึงไฟล์ tld ที่ใช้อธิบายแท็กที่กำหนดเองแต่ละแท็ก
5. เผยแพร่ไฟล์ (ไฟล์ WAR หรือ JAR): หากคุณต้องการใช้แท็กแบบกำหนดเองซ้ำ คุณต้องมีวิธีย้ายแท็กจากโปรเจ็กต์หนึ่งไปยังอีกโปรเจ็กต์หนึ่ง การแพ็กเกจไลบรารีแท็กลงในไฟล์ JAR เป็นวิธีที่ง่ายและมีประสิทธิภาพ
6. การประกาศไลบรารีแท็กบนเพจ JSP: หากคุณต้องการใช้แท็กที่กำหนดเองในหน้า JSP คุณต้องใช้ตัวระบุไลบรารีแท็กเพื่อประกาศบนเพจ

ดูเหมือนว่าจะมีงานอีกมากที่ต้องทำและแน่นอนว่ามันจะยุ่งยากเล็กน้อยเมื่อคุณเริ่มใช้งานครั้งแรก แต่ก็ไม่ได้ยากมาก ประเด็นไม่ได้เกี่ยวกับการเขียนโค้ด แต่เกี่ยวกับการจัดระเบียบชิ้นส่วนอย่างถูกต้อง โครงสร้างแบบลำดับชั้นนี้มีความสำคัญเนื่องจากทำให้การใช้แท็กมีความยืดหยุ่นและง่ายต่อการถ่ายโอน ที่สำคัญกว่านั้น ระดับเหล่านี้ช่วยให้กระบวนการทั้งหมดในการสร้างไลบรารีแท็กเป็นอัตโนมัติผ่าน JSP IDE (สภาพแวดล้อมการพัฒนาแบบรวม JSP) JSP IDE สามารถทำงานส่วนใหญ่ในการสร้างแท็กที่กำหนดเองได้โดยอัตโนมัติ และคุณเพียงต้องรับผิดชอบในการตั้งค่าโค้ดและตัวประมวลผลแท็กด้วยตัวเองเท่านั้น

(หมายเหตุ: ตัวประมวลผลแท็กกำหนดแท็กที่กำหนดเองเพียงแท็กเดียวเท่านั้น ไลบรารีแท็กคือชุดของตัวประมวลผลแท็กหลายตัวที่จัดการงานเดียวกัน)

สร้างแท็กแรกของคุณ

ต่อไปนี้จะสอนคุณทีละขั้นตอนถึงวิธีสร้างแท็กที่กำหนดเอง ซึ่งเป็นตัวอย่างเฉพาะ กำลังขยาย JSP เพื่อให้มีฟังก์ชันการเข้ารหัส HTML ของตัวเอง คุณลักษณะนี้จะแทนที่อักขระ < และ > ทั้งหมดด้วยโค้ด HTML สามารถขยายได้อย่างง่ายดายเพื่อประมวลผลการเข้ารหัสอื่น ๆ เพื่อให้ง่ายขึ้น ตัวอย่างนี้จะอธิบายเฉพาะองค์ประกอบพื้นฐานของการสร้างแท็กที่กำหนดเองเท่านั้น

ส่วนที่นำมาใช้ซ้ำได้ของโค้ด

ที่สร้าง JavaBean

นี่เป็นสิ่งสำคัญมาก วิธีนี้ทำให้คุณสามารถใช้โค้ดซ้ำในโครงการอื่นได้ เนื่องจากโค้ดใดๆ ที่วางอยู่ภายในตัวจัดการแท็กจะไม่สามารถนำมาใช้ซ้ำภายนอกแท็กได้ จึงเป็นสิ่งสำคัญที่จะต้องแยกส่วนของโค้ดที่นำมาใช้ซ้ำออก ในตัวอย่างนี้ ตรรกะที่เข้ารหัสสำหรับ HTML เป็นเรื่องปกติ ดังนั้นจึงถูกวางไว้ใน JavaBean โปรดดูรายการ B
รายการ B: JavaBeans ที่เข้ารหัส HTML
/* HTML_Format.java */
คลาสสาธารณะ HTML_Format ขยาย Object นำไปใช้ java.io.Serializable {

/** สร้าง HTML_Format ใหม่ */
public HTML_Format() {}

/** แทนที่อักขระ < และ > ทั้งหมดในสตริงด้วยการเข้ารหัส HTML ตอบกลับ */
สตริงสาธารณะ HTML_Encode (สตริง as_data)
-
int li_len = as_data.length();

/*ความยาวของบัฟเฟอร์สตริงยาวกว่าสตริงเดิม*/
StringBuffer lsb_encode = new StringBuffer(li_len + (li_len/10));

/* วนซ้ำเพื่อแทนที่อักขระ < และ > ทั้งหมด*/
สำหรับ (int li_count = 0; li_count < li_len; li_count++)
{ สตริง ls_next = String.valueOf(as_data.charAt(li_count));
ถ้า (ls_next.equals("<")) ls_next = "<";
ถ้า (ls_next.equals(">")) ls_next = ">";
lsb_encode.ผนวก( ls_next );
}

ส่งคืน( lsb_encode.toString() );
-
-

รหัสสำหรับการสร้างตัวประมวลผลแท็กแสดงอยู่ในรายการ C:
รายการ C: ตัวประมวลผลแท็กการเข้ารหัส HTML
นำเข้า java.io.IOException;
นำเข้า javax.servlet.jsp.*;
นำเข้า javax.servlet.jsp.tagext.*;

คลาสสาธารณะ HTML_FormatTag ขยาย BodyTagSupport
-
/* 1) ฟังก์ชั่นนี้จะถูกเรียกที่ส่วนท้ายของแท็ก*/
public int doEndTag() พ่น JspTagException
-
พยายาม
{ /* 2) รับข้อความในป้ายกำกับ */
BodyContent l_tagbody = getBodyContent();
String ls_output = "";

/* 3) หากเนื้อหาของแท็กมีข้อความ ให้ประมวลผล */
ถ้า(l_tagbody != null)
{ HTML_Format l_format = HTML_Format ใหม่ ();
/* 3a) แปลงเนื้อหาของแท็กให้เป็นสตริง */
สตริง ls_html_text = l_tagbody.getString();
ls_output = l_format.HTML_Encode(ls_html_text);
-
/* 4) เขียนผลลัพธ์กลับไปยังสตรีมข้อมูล */
pageContext.getOut().write(ls_output.trim());
-
จับ (IOException จ)
{ โยน JspTagException ใหม่ ("ข้อผิดพลาดของแท็ก:" + e.toString());
}

/* ให้ JSP ประมวลผลเนื้อหาของหน้าต่อไปนี้ต่อไป*/
กลับ EVAL_PAGE;
-
}

การประมวลผลนี้ง่ายมาก ประกอบด้วย:
1. อ่านข้อความระหว่างแท็กเปิดและแท็กปิด
2. เรียกใช้ฟังก์ชันการเข้ารหัส html
3. ส่งผลลัพธ์กลับไปที่หน้า JSP

สร้างคำอธิบายแท็ก

เราจำเป็นต้องอธิบายแท็กที่กำหนดเอง เพื่อให้ระบบรู้ว่าต้องทำอย่างไร ส่วนต่อท้ายของไฟล์คำอธิบายนี้คือ .tld โดยปกติแล้วไฟล์ TLD จะตั้งชื่อตามตัวประมวลผลแท็ก และจัดเก็บไว้ในไดเร็กทอรี "/WEB-INF/" ดูรายการ D.
รายการ D: ตัวอธิบายแท็กการเข้ารหัส HTML ＜?xml version="1.0" encoding="UTF-8" ?＞

＜!DOCTYPE taglib
สาธารณะ "-//Sun Microsystems, Inc.//ไลบรารีแท็ก DTD JSP 1.1//EN"
" http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd ">
<TAGLIB>
＜เวอร์ชัน TLIBVERSION>1.0＜/เวอร์ชัน TLIBVERSION">
<JSPVERSION>1.1＜/JSPVERSION>
＜SHORTNAME><HTML_FormatTag<//SHORTNAME>
＜URI>＜/URI>
<ข้อมูล>แท็กการเข้ารหัส HTML </ข้อมูล>

＜TAG>
<NAME>HTMLEncode</NAME>
＜TAGCLASS><HTML_FormatTag</TAGCLASS>
<ข้อมูล>เข้ารหัส HTML</ข้อมูล>
＜/TAG><

/ ＜/TAGLIB>

อัปเดตไฟล์ Web XML

เพื่อบอกคอนเทนเนอร์ JSP ถึงวิธีใช้ไลบรารีแท็ก ในการดำเนินการนี้ คุณต้องแก้ไขไฟล์ web.xml โดยเฉพาะอย่างยิ่ง คุณต้องเพิ่มโปรเจ็กต์ taglib เพื่อลงทะเบียนไลบรารีแท็กและกำหนด URI ให้กับแท็ก URI เป็นดัชนีเดียวบนเว็บไซต์ที่ใช้กับแท็กนี้โดยเฉพาะ เนื่องจากแท็กอาจถูกใช้บนเว็บไซต์ต่างๆ ในอนาคต วิธีที่ดีที่สุดคือใช้ URL ที่สมบูรณ์และ/หรือชื่อแพ็คเกจเพื่อให้แน่ใจว่าไม่ซ้ำกัน ตัวอย่างนี้ทำให้ง่ายขึ้น ดูรายการ E สำหรับโค้ดตัวอย่าง
รายการ E: แก้ไขไฟล์ web.xml <?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE web-app
สาธารณะ "-//Sun Microsystems, Inc.//เว็บแอปพลิเคชัน DTD 2.2//EN"
" http://java.sun.com/j2ee/dtds/web-app_2.2.dtd "> ＜เว็บแอ

ป

＜TAGLIB>

<TAGLIB-URI>
HTMLเข้ารหัส
＜/TAGLIB-URI>
＜TAGLIB-สถานที่>
/WEB-INF/HTML_FormatTag.tld
＜/TAGLIB-สถานที่>
＜/TAGLIB><

＜/WEB-APP>

ใช้แท็กใหม่

หลังจากตั้งค่าแท็กที่กำหนดเองแล้ว คุณสามารถใช้แท็กเหล่านั้นบนหน้า JSP ของคุณได้ ในการดำเนินการนี้ เพียงใช้คำสั่งคำสั่ง taglib เพื่อประกาศแท็กที่คุณต้องการใช้บนเพจ แท็กได้รับการจัดทำดัชนีโดย URI ที่ไม่ซ้ำกัน ซึ่งจากนั้นจะกำหนดคำนำหน้าเนมสเปซ คำนำหน้านี้ไม่มีความหมายพิเศษ ตราบใดที่ไม่ขัดแย้งกับเนมสเปซอื่นๆ ก็สามารถกำหนดเองได้ โปรดดูรายการ F และ G ด้านล่าง

<%@ taglib uri="HTMLEncode" prefix="Examples" %>

บนเพจ JSP

＜ก่อน>
＜?XML:NAMESPACE PREFIX = ตัวอย่าง /></ตัวอย่าง:HTMLEncode>
＜สวัสดี ตัวอย่างง่ายๆ＞
＜/ตัวอย่าง:HTMLEncode><
＜/PRE>

</ รายการ G: ผลลัพธ์ของโค้ดตัวอย่าง ＜สวัสดี ตัวอย่างแบบง่าย>
ซึ่งแสดงเป็น:
<สวัสดี ตัวอย่างง่ายๆ>

ด้วยแท็กนี้ ฉันเข้ารหัสโค้ดทั้งหมดของหน้า แท็กที่กำหนดเองทั้งหมดได้รับการประมวลผลบนเซิร์ฟเวอร์ ซึ่งหมายความว่าคุณจะไม่เห็นแท็กที่กำหนดเองในหน้าผลลัพธ์

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

บทสรุป

ไลบรารีแท็กเป็นหนึ่งในคุณสมบัติที่สำคัญที่สุดของ JSP และยังอยู่ระหว่างการพัฒนาอย่างต่อเนื่อง นี่เป็นสิ่งใหม่จริง ๆ ดังนั้นจึงยังไม่ได้รับการยอมรับอย่างกว้างขวาง แต่ไลบรารีแท็กที่กำหนดเองได้ขจัดความลึกลับออกไป และนักพัฒนาจำนวนมากขึ้นเรื่อย ๆ ก็เริ่มให้ความสนใจและใช้งานมัน ในช่วงปลายปี 2001 คาดว่าไลบรารีแท็กจะเป็นคุณลักษณะทั่วไปในโปรเจ็กต์ JSP จำนวนมาก

ประโยชน์ของไลบรารีแท็กจะกล่าวถึงสั้นๆ ในบทความนี้เท่านั้น จริงๆ แล้วไลบรารีแท็กมีคุณสมบัติที่มีประสิทธิภาพอื่นๆ มากมาย ไลบรารีแท็กผลักดันการพัฒนา JSP สู่โลกใหม่ที่ไม่เคยมีมาก่อน นี่เป็นเทคโนโลยีใหม่ที่น่าตื่นเต้นสำหรับนักพัฒนา JSP เพราะพวกเขาได้รับเครื่องมือที่สามารถแปลง JSP ให้เป็นแอปพลิเคชันต่างๆ และสร้างเว็บแอปพลิเคชันประเภทใดก็ได้ ไลบรารีแท็กเปลี่ยน JSP ให้เป็นความสามารถในการพัฒนาแบบไดนามิกที่สมบูรณ์ที่สุด และสภาพแวดล้อมการเขียนโปรแกรมเว็บที่มีประสิทธิภาพ ความสามารถของมันถูกจำกัดด้วยจินตนาการและความคิดสร้างสรรค์ของเราเท่านั้น