ภาพรวม: eXtensible Markup Language (XML) กำลังถูกใช้อย่างรวดเร็วในอุตสาหกรรม ภาษานี้ได้กลายเป็นมาตรฐานที่ใช้กันอย่างแพร่หลายในการอธิบายและแลกเปลี่ยนข้อมูลในรูปแบบที่ไม่ขึ้นกับแพลตฟอร์ม ภาษา และโปรโตคอล XML และข้อกำหนดเฉพาะเสริมสามารถใช้เพื่ออธิบายการแสดงเอกสารข้อมูล อธิบายข้อจำกัดของประเภทเอกสาร XML อธิบายการเชื่อมโยงระหว่างเอกสาร XML และทรัพยากร และอธิบายการแปลงและการจัดรูปแบบของเอกสาร XML โดยอัตโนมัติ
จะพัฒนาไลบรารีแท็กที่กำหนดเองได้อย่างไร
ฉันใช้การเขียนโปรแกรม JSP และ ASP มาเป็นเวลานาน ในบรรดาวิธีการเขียนโปรแกรมฝั่งเซิร์ฟเวอร์ทั้งสองวิธี ฉันรู้สึกว่า JSP มีประสิทธิภาพมากกว่ามาก ไม่ต้องพูดถึงสิ่งอื่นใด แท็กไลบรารีของ JSP คือเหตุผลที่ฉันเลือก JSP เป็นเครื่องมือพัฒนาแอปพลิเคชันเว็บฝั่งเซิร์ฟเวอร์ที่ต้องการ ทำไม เพราะ: ความรวดเร็วในการบำรุงรักษาและพัฒนา ภายในเพจเซิร์ฟเวอร์เดียว คุณสามารถผสมและจับคู่วิธีการและอ็อบเจ็กต์สคริปต์ต่างๆ ได้ เช่นเดียวกับ "คอนกรีต" การผสมผสานนี้ทำให้การเขียนสคริปต์ฝั่งเซิร์ฟเวอร์มีประสิทธิภาพ และช่วยให้โปรแกรมเมอร์ฝั่งเซิร์ฟเวอร์สามารถออกแบบเว็บเพจที่มีความยืดหยุ่นและไดนามิกมาก อย่างไรก็ตาม การผสมผสานแบบฟรีนี้ก็มีข้อเสียเช่นกัน ซึ่งเป็นเรื่องยากที่จะรักษา โดยเฉพาะอย่างยิ่งเมื่อโครงการมีขนาดใหญ่ขึ้น เนื่องจากผลิตภัณฑ์ขั้นสุดท้ายได้รับการดูแลโดยนักออกแบบเว็บไซต์แบบดั้งเดิม และที่แย่กว่านั้นคือ ความเร็วของการพัฒนาจะเพิ่มขึ้นเมื่อความซับซ้อนของโค้ดเพิ่มขึ้น มันจะช้าลงและไม่เอื้อต่อการพัฒนาสื่อและ เว็บแอปพลิเคชันขนาดใหญ่ เมื่อพัฒนาแล้ว ไซต์จะยังคงต้องหาโปรแกรมเมอร์ที่มีคุณสมบัติเหมาะสมเพื่อรักษาโค้ดที่ค่อนข้างซับซ้อนเหล่านี้
โชคดีที่ JSP มีทางออกที่ดี ไลบรารีแท็กมอบวิธีง่ายๆ ในการสร้างบล็อกโค้ดที่นำมาใช้ซ้ำได้ เมื่อออกแบบไลบรารีแท็กแล้ว จะสามารถใช้งานได้อีกครั้งในหลายโปรเจ็กต์ สิ่งที่สะดวกกว่าคือ คุณไม่จำเป็นต้องเรียนรู้ทักษะอื่นใดเพื่อสร้างไลบรารีแท็ก ซึ่งต่างจาก COM และ J2EE! ตราบใดที่คุณรู้วิธีเขียน JSP คุณสามารถสร้างไลบรารีแท็กได้ ไลบรารีแท็กยังสามารถปรับปรุงการบำรุงรักษาเว็บแอปพลิเคชันได้อีกด้วย นี่คืออินเทอร์เฟซ XML แบบธรรมดาด้วยแท็กที่กำหนดเองของเพจ JSP ด้วยวิธีนี้ นักออกแบบเว็บไซต์สามารถสร้างเว็บแอปพลิเคชัน JSP ได้โดยไม่ต้องมีความรู้เกี่ยวกับ JSP เลย การพัฒนาเว็บแบบเปิดนี้มีประสิทธิภาพมากสำหรับการดำเนินงานของทีม โปรแกรมเมอร์ JSP สามารถสร้างแท็กที่กำหนดเองและโมดูลโค้ดพื้นหลังได้ ในขณะที่นักออกแบบเว็บไซต์สามารถใช้แท็กที่กำหนดเองเพื่อสร้างแอปพลิเคชันเว็บและมุ่งเน้นไปที่การออกแบบเว็บ
1. คำจำกัดความของไลบรารีแท็ก ไลบรารีแท็ก JSP (หรือที่เรียกว่าไลบรารีแบบกำหนดเอง) ถือได้ว่าเป็นชุดของวิธีการสำหรับการสร้างสคริปต์ที่ใช้ XML ซึ่งได้รับการสนับสนุนโดย JavaBeans ตามแนวคิดแล้ว ไลบรารีแท็กเป็นโครงสร้างโค้ดที่เรียบง่ายและสามารถนำมาใช้ซ้ำได้
ตัวอย่างแท็กและเพจ HTML ที่ทำการแปลง XML/XSL
<%@ taglib uri=" http://www.jspinsider.com/jspkit/JAXP " prefix="JAXP"%>
ค:/xml/example.xml
c:/xml/example.xsl
ในตัวอย่างนี้ โดยใช้แท็กง่ายๆ เพื่อเข้าถึงโค้ดที่มีประสิทธิภาพยิ่งขึ้นในเบื้องหลัง XML จะถูกโหลดและผลลัพธ์จะถูกสร้างขึ้นผ่านไฟล์ XSL และส่งไปยังไคลเอนต์ ทั้งหมดนี้ทำได้โดยผ่านขั้นตอนนี้ โดยใช้การเรียกแท็กง่ายๆ
แท็กแบบกำหนดเองเปิดประตูสู่การสร้างโค้ดที่นำมาใช้ซ้ำได้อย่างง่ายดายในโครงการ JSP สิ่งที่คุณต้องมีคือไลบรารีแท็กและเอกสารประกอบ
2. ส่วนประกอบของแท็ก แม้ว่าไลบรารีแท็กจะใช้งานง่ายมาก แต่ก็ค่อนข้างซับซ้อนในการสร้างการออกแบบภายในเพื่อรองรับไลบรารีแท็ก อย่างน้อยก็ซับซ้อนกว่าการสร้าง JavaBean แบบธรรมดา ความซับซ้อนมาจากข้อเท็จจริงที่ว่าไลบรารีแท็กประกอบด้วยหลายส่วน อย่างไรก็ตาม คุณเพียงแค่ต้องรู้จัก Java และ JSP เท่านั้น
แท็กแบบง่ายประกอบด้วยองค์ประกอบต่อไปนี้:
⑴ JavaBeans: เพื่อให้ได้รับประโยชน์เชิงวัตถุโดยธรรมชาติของ Java ควรวางโค้ดที่นำมาใช้ซ้ำได้ในคอนเทนเนอร์โค้ดอิสระ JavaBeans เหล่านี้ไม่ได้เป็นส่วนหนึ่งของไลบรารีแท็ก แต่เป็นบล็อกพื้นฐานของโค้ดที่ฐานโค้ดของคุณใช้เพื่อทำงานที่เกี่ยวข้อง
⑵ การประมวลผลแท็ก: นี่คือแกนกลางที่แท้จริงของไลบรารีแท็ก ตัวจัดการแท็กจะอ้างอิงทรัพยากรใดๆ ที่ต้องการ (JavaBeans ของคุณ) และเข้าถึงข้อมูลทั้งหมดเกี่ยวกับเพจ JSP ของคุณ (วัตถุ pageContext) หน้า JSP จะส่งแอตทริบิวต์แท็กทั้งหมดที่ได้รับการตั้งค่าและเนื้อหาของแท็กบนหน้า JSP ไปยังตัวประมวลผลแท็ก หลังจากที่ตัวประมวลผลแท็กเสร็จสิ้นการประมวลผลแล้ว ตัวประมวลผลแท็กจะส่งเอาต์พุตกลับไปยังเพจ JSP ของคุณเพื่อประมวลผล
⑶ คำอธิบายไลบรารีแท็ก (ไฟล์ tld): นี่คือไฟล์ XML ธรรมดาที่บันทึกแอตทริบิวต์ ข้อมูล และตำแหน่งของตัวประมวลผลแท็ก คอนเทนเนอร์ JSP ใช้ไฟล์นี้เพื่อทราบว่าจะเรียกไลบรารีแท็กที่ไหนและอย่างไร
⑷ ไฟล์ web.xml ของเว็บไซต์: นี่คือไฟล์เริ่มต้นของเว็บไซต์ของคุณ ในไฟล์นี้ คุณกำหนดแท็กที่กำหนดเองที่ใช้ในเว็บไซต์ และไฟล์ tld ใดที่ใช้อธิบายแท็กที่กำหนดเองแต่ละแท็ก
⑸ ไฟล์การแจกจ่าย (ไฟล์ WAR หรือ JAR): หากคุณต้องการใช้แท็กที่กำหนดเองซ้ำ คุณต้องมีวิธีการถ่ายโอนจากโปรเจ็กต์หนึ่งไปยังอีกโปรเจ็กต์หนึ่ง การแพ็กเกจไลบรารีแท็กลงในไฟล์ JAR เป็นวิธีที่ง่ายและมีประสิทธิภาพ
⑹ สร้างการประกาศไลบรารีแท็กในไฟล์ JSP ของคุณ: มันง่ายมาก หากคุณต้องการใช้แท็กนี้ เพียงประกาศมันบนเพจ หลังจากนั้น คุณสามารถใช้มันได้ทุกที่ในหน้า JSP
ดูเหมือนจะมีงานที่ต้องทำมากมาย แต่จริงๆ แล้วไม่ได้ยากขนาดนั้น ประเด็นไม่ได้เกี่ยวกับการเขียนโค้ด แต่เกี่ยวกับการจัดระเบียบชิ้นส่วนอย่างถูกต้อง อย่างไรก็ตาม การแบ่งชั้นนี้มีความสำคัญเนื่องจากทำให้การใช้ฉลากมีความยืดหยุ่นและง่ายต่อการถ่ายโอน ที่สำคัญกว่านั้น เลเยอร์เหล่านี้มีอยู่เพื่อทำให้กระบวนการสร้างแท็กเป็นอัตโนมัติผ่าน JSP IDE (JSP Integrated Development Environment) คาดว่า JSP IDE ในอนาคตจะสามารถทำงานส่วนใหญ่ในการสร้างแท็กที่กำหนดเองได้โดยอัตโนมัติ ดังนั้นคุณเพียงแค่ต้องเขียนโค้ดและการประมวลผลแท็กเท่านั้น
หมายเหตุ: ตัวจัดการแท็กกำหนดแท็กที่กำหนดเองเพียงแท็กเดียวเท่านั้น ไลบรารีแท็กคือชุดของตัวประมวลผลแท็กหลายตัวที่จัดการงานเดียวกัน
3. สร้างแท็กของคุณเอง ต่อไปนี้จะสอนวิธีสร้างแท็กที่กำหนดเองทีละขั้นตอน ตัวอย่างเฉพาะคือการขยาย JSP เพื่อให้มีฟังก์ชันการเข้ารหัส HTML ของตัวเอง คุณลักษณะนี้จะแทนที่อักขระ < และ > ทั้งหมดด้วยโค้ด HTML สามารถขยายได้อย่างง่ายดายเพื่อประมวลผลการเข้ารหัสอื่น ๆ เพื่อให้ง่ายขึ้น ตัวอย่างนี้จะอธิบายเฉพาะองค์ประกอบพื้นฐานของการสร้างแท็กที่กำหนดเองเท่านั้น
⑴ สร้าง JavaBean
ส่วนของโค้ดที่นำมาใช้ซ้ำได้ควรวางไว้ใน JavaBean นี่เป็นสิ่งสำคัญเนื่องจากคุณมักจะใช้โค้ดนี้ในส่วนอื่นของโปรเจ็กต์ โค้ดใดๆ ที่วางอยู่ภายในตัวจัดการแท็กจะไม่สามารถนำมาใช้ซ้ำภายนอกแท็กได้ ดังนั้นจึงเป็นเรื่องสำคัญที่จะต้องแยกส่วนของโค้ดที่นำมาใช้ซ้ำออก ในตัวอย่างนี้ ตรรกะที่เข้ารหัสสำหรับ HTML เป็นเรื่องปกติ ดังนั้นจึงถูกวางไว้ใน JavaBean
⑵ การเข้ารหัส HTML JavaBean
/* HTML_Format.Java */
คลาสสาธารณะ HTML_Format ขยาย Object นำไปใช้ Java.io.Serializable {
/** สร้าง HTML_Format ใหม่ */
HTML_Format สาธารณะ () {}
/** แทนที่อักขระ < และ > ทั้งหมดในสตริงด้วยการเข้ารหัส HTML ตอบกลับ */
สตริงสาธารณะ HTML_Encode (สตริง as_data)
-
int li_len = as_data.length();
/*ความยาวของบัฟเฟอร์สตริงยาวกว่าสตริงเดิม*/
StringBuffer lsb_encode = 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());
-
}
⑶ สร้างตัวประมวลผลแท็ก ตัวประมวลผลแท็กใช้โค้ดต่อไปนี้:
ตัวประมวลผลแท็กการเข้ารหัส HTML
นำเข้า Java.io.IOException;
นำเข้า Javax.servlet.jsp.*;
นำเข้า Javax.servlet.jsp.tagext.*;
คลาสสาธารณะ HTML_FormatTag ขยาย BodyTagSupport
-
/* 1} ฟังก์ชั่นนี้จะถูกเรียกที่ส่วนท้ายของแท็ก*/
public int doEndTag() พ่น JspTagException
-
พยายาม
{ /* 2} รับข้อความในป้ายกำกับ */
BodyContent l_tagbody = getBodyContent();
สตริง 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;
-
}
การประมวลผลนี้ง่ายมาก ประกอบด้วย:
o อ่านข้อความระหว่างจุดเริ่มต้นและจุดสิ้นสุดของแท็ก o เรียกใช้ฟังก์ชันการเข้ารหัส html o ส่งผลลัพธ์กลับไปยังหน้า JSP
⑷ การสร้างตัวอธิบายแท็กจำเป็นต้องอธิบายแท็กที่กำหนดเอง เพื่อให้ระบบทราบวิธีการประมวลผล ส่วนต่อท้ายของไฟล์คำอธิบายนี้คือ .tld โดยปกติแล้วชื่อจะเหมือนกับตัวประมวลผลแท็ก และจัดเก็บไว้ในไดเร็กทอรี "/WEB-INF/"
ตัวอธิบายแท็กการเข้ารหัส 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>
<INFO>แท็กการเข้ารหัส HTML </INFO>
<แท็ก>
<NAME>HTMLEncode</NAME>
<TAGCLASS>HTML_FormatTag</TAGCLASS>
<INFO>เข้ารหัส HTML</INFO>
</TAG>
</TAGLIB>
⑸ อัปเดตไฟล์ Web XML เพื่อบอกให้คอนเทนเนอร์ JSP ใช้ไลบรารีแท็ก ในการดำเนินการนี้ คุณต้องแก้ไขไฟล์ web.xml โดยเฉพาะอย่างยิ่ง คุณต้องเพิ่มโปรเจ็กต์ taglib เพื่อลงทะเบียนไลบรารีแท็ก สิ่งสำคัญที่สุดคือ กำหนด URI ให้กับแท็ก URI คือข้อมูลอ้างอิงเฉพาะที่ใช้กับแท็กเฉพาะนี้บนเว็บไซต์เท่านั้น แนวทางปฏิบัติที่ดีคือการใช้ URL แบบเต็มหรือชื่อแพ็กเกจเพื่อให้แน่ใจว่าไม่ซ้ำกัน เนื่องจากแท็กสามารถใช้บนเว็บไซต์ต่างๆ ได้ ตัวอย่างนี้ทำให้ง่ายขึ้น
แก้ไขไฟล์ web.xml
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE เว็บแอป
สาธารณะ "-//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 ที่ไม่ซ้ำกัน และได้รับการกำหนดคำนำหน้าเนมสเปซ คำนำหน้าสามารถกำหนดเองได้ตราบใดที่ไม่ขัดแย้งกับเนมสเปซอื่น
ใช้แท็กการเข้ารหัส HTML บนเพจ JSP:
<%@ taglib uri="HTMLEncode" prefix="Examples" %>
<PRE>
<?XML:NAMESPACE PREFIX = ตัวอย่าง /><ตัวอย่าง:HTMLEncode>
<สวัสดี ตัวอย่างง่ายๆ>
</ตัวอย่าง:HTMLEncode>
</PRE>
เอาต์พุตโค้ดตัวอย่าง
<สวัสดี ตัวอย่างง่ายๆ>
ซึ่งแสดงเป็น:
<สวัสดี ตัวอย่างง่ายๆ>
ด้วยแท็กนี้ ฉันเข้ารหัสโค้ดทั้งหมดของหน้า สิ่งที่น่าสนใจคือแท็กที่กำหนดเองทั้งหมดได้รับการจัดการบนเซิร์ฟเวอร์ ซึ่งหมายความว่าคุณจะไม่เห็นแท็กที่กำหนดเองในหน้าผลลัพธ์
การสร้างฉลากไม่ใช่เรื่องยาก ส่วนที่ยากที่สุดคือการเรียนรู้ทุกรายละเอียดเกี่ยวกับการประมวลผลฉลาก นี่เป็นคุณสมบัติที่ทรงพลังมากและเราได้พูดถึงเพียงพื้นฐานเท่านั้น เนื่องจากกระบวนการนี้ต้องการหลายขั้นตอน โปรแกรมเมอร์ JSP ใหม่จะสับสนเมื่อสร้างแท็ก
จะใช้ JSP เพื่อพัฒนาแอปพลิเคชัน DOM ได้อย่างไร
DOM เป็นตัวย่อของ Document Object Model ซึ่งเป็น Document Object Model XML จัดระเบียบข้อมูลเป็นแผนภูมิ ดังนั้น DOM จึงเป็นคำอธิบายออบเจ็กต์ของแผนผังนี้ ในแง่ของคนธรรมดา มันคือการสร้างแบบจำลองต้นไม้สำหรับเอกสาร XML อย่างมีเหตุผลโดยการแยกวิเคราะห์เอกสาร XML และโหนดของต้นไม้นั้นเป็นวัตถุ เราสามารถเข้าถึงเนื้อหาของเอกสาร XML ได้โดยการเข้าถึงวัตถุเหล่านี้
ลองดูตัวอย่างง่ายๆ ด้านล่างเพื่อดูว่าเราดำเนินการเอกสาร XML ใน DOM อย่างไร นี่คือเอกสาร XML และวัตถุที่เราต้องการดำเนินการกับ:
<?xml version="1.0" encoding="UTF-8"?>
<ข้อความ>
<message>ลาก่อนการทำให้เป็นอนุกรม สวัสดี Java!</message>
</messages>
ต่อไป เราจำเป็นต้องแยกวิเคราะห์เนื้อหาของเอกสารนี้เป็นออบเจ็กต์ Java เพื่อใช้งานโดยโปรแกรม เมื่อใช้ JAXP เราสามารถทำได้โดยใช้โค้ดเพียงไม่กี่บรรทัด ขั้นแรก เราต้องสร้างโรงงาน parser เพื่อใช้โรงงานนี้เพื่อรับอ็อบเจ็กต์ parser เฉพาะ:
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
วัตถุประสงค์ของการใช้ DocumentBuilderFacotry ในที่นี้คือเพื่อสร้างโปรแกรมที่ไม่ขึ้นกับ parser เฉพาะ เมื่อเรียกใช้เมธอด newInstance() ของคลาส DocumentBuilderFactory แบบคงที่ โปรแกรมจะกำหนดว่า parser ใดที่จะใช้ตามตัวแปรระบบ และเนื่องจาก parser ทั้งหมดเป็นไปตามอินเทอร์เฟซที่กำหนดโดย JAXP โค้ดจึงเหมือนกันไม่ว่าจะใช้ parser ตัวใดก็ตาม ดังนั้นเมื่อสลับระหว่าง parsers ที่แตกต่างกัน คุณเพียงแค่ต้องเปลี่ยนค่าของตัวแปรระบบโดยไม่ต้องเปลี่ยนโค้ดใดๆ นี่คือประโยชน์ของโรงงาน
DocumentBuilder db = dbf.newDocumentBuilder();
หลังจากได้รับวัตถุโรงงานแล้ว ให้ใช้วิธีการคงที่ newDocumentBuilder() เพื่อขอรับวัตถุ DocumentBuilder ซึ่งแสดงถึงตัวแยกวิเคราะห์ DOM เฉพาะ แต่พาร์เซอร์ตัวใดของ Microsoft หรือ IBM นั้นไม่สำคัญต่อโปรแกรม
จากนั้นเราสามารถใช้ parser นี้เพื่อแยกวิเคราะห์เอกสาร XML:
เอกสาร doc = db.parse("c:/xml/message.xml");
วิธีการแยกวิเคราะห์ () ของ DocumentBuilder ยอมรับชื่อเอกสาร XML เป็นพารามิเตอร์อินพุตและส่งกลับวัตถุเอกสารนี้แสดงถึงแบบจำลองต้นไม้ของเอกสาร XML การดำเนินการในอนาคตทั้งหมดบนเอกสาร XML ไม่เกี่ยวข้องกับ parser และสามารถดำเนินการได้โดยตรงบนอ็อบเจ็กต์ Document นี้ วิธีการเฉพาะในการปฏิบัติงาน เอกสารถูกกำหนดโดย DOM
เริ่มต้นจากออบเจ็กต์ Document ที่ได้รับ เราสามารถเริ่มต้นการเดินทาง DOM ของเราได้ การใช้เมธอด getElementsByTagName() ของอ็อบเจ็กต์ Document เราจะได้รับอ็อบเจ็กต์ NodeList แสดงถึงองค์ประกอบแท็กในเอกสาร XML และอ็อบเจ็กต์ NodeList ดังที่คุณเห็นจากชื่อของมัน แสดงถึงอ็อบเจ็กต์ Node:
NodeList nl = doc.getElementsByTagName("ข้อความ");
สิ่งที่เราได้รับจากคำสั่งดังกล่าวคือรายการของวัตถุโหนดที่สอดคล้องกับแท็ก <message> ทั้งหมดในเอกสาร XML จากนั้นเราสามารถใช้ item() วิธีการของวัตถุ NodeList เพื่อรับแต่ละวัตถุ Node ในรายการ:
โหนด my_node = nl.item (0);
เมื่อวัตถุโหนดถูกสร้างขึ้น ข้อมูลที่จัดเก็บไว้ในเอกสาร XML จะถูกแยกและห่อหุ้มไว้ในโหนด ในตัวอย่างนี้ เพื่อแยกเนื้อหาภายในแท็ก Message เรามักจะใช้เมธอด getNodeValue() ของอ็อบเจ็กต์ Node:
ข้อความสตริง = my_node.getFirstChild().getNodeValue();
โปรดทราบว่าเมธอด getFirstChild() ยังใช้ที่นี่เพื่อรับออบเจ็กต์โหนดย่อยตัวแรกภายใต้ข้อความ แม้ว่าจะไม่มีแท็กย่อยหรือคุณลักษณะอื่นๆ ใต้แท็กข้อความยกเว้นข้อความ แต่เรายืนยันที่จะใช้เมธอด getFirseChild() ที่นี่ ซึ่งส่วนใหญ่เกี่ยวข้องกับคำจำกัดความของ DOM ของ W3C W3C ยังกำหนดส่วนของข้อความภายในแท็กเป็นโหนด ดังนั้นก่อนอื่นเราจะต้องได้รับโหนดที่เป็นตัวแทนของข้อความก่อนจึงจะสามารถใช้ getNodeValue() เพื่อรับเนื้อหาของข้อความได้ ขณะนี้ เนื่องจากเราสามารถแยกข้อมูลจากไฟล์ XML ได้ เราจึงสามารถใช้ข้อมูลนี้ในตำแหน่งที่เหมาะสมเพื่อสร้างแอปพลิเคชันได้
ตัวอย่าง DOM
เรามาคุยกันก่อนว่าตัวอย่างนี้จะทำอะไร เราได้บันทึกที่อยู่ URL บางส่วนไว้ในไฟล์ชื่อลิงก์ ที่อยู่ URL ที่เพิ่มเข้ามาจะถูกเขียนในไฟล์ XML นี้ มันเรียบง่ายมาก แต่ใช้งานได้จริง และเพียงพอที่จะอธิบายการใช้งาน DOM ส่วนใหญ่ได้
โปรแกรมแรกเรียกว่า xmldisplay.Java หน้าที่หลักของมันคือการอ่านเนื้อหาของแต่ละโหนดในไฟล์ XML นี้ จากนั้นจึงจัดรูปแบบเอาต์พุตบน System.out มาดูที่โปรแกรมนี้กันดีกว่า:
import Javax.xml.parsers *;
import org.w3c.dom.*;
นี่เป็นการแนะนำคลาสที่จำเป็น เนื่องจากมีการใช้ Parser XML ที่ Sun จัดเตรียมไว้ที่นี่ ดังนั้นจึงจำเป็นต้องแนะนำแพ็คเกจ Java.xml.parsers ซึ่งมี DOM parser และ SAX parsing การใช้งานเฉพาะของอุปกรณ์ แพ็คเกจ org.w3c.dom กำหนดอินเทอร์เฟซ DOM ที่พัฒนาโดย w3c
โรงงาน DocumentBuilderFactory = DocumentBuilderFactory.newInstance();
ตัวสร้าง DocumentBuilder=factory.newDocumentBuilder();
เอกสาร doc=builder.parse("links.xml");
doc.normalize();
นอกเหนือจากที่กล่าวมาข้างต้นแล้ว ยังมีเคล็ดลับเล็กๆ น้อยๆ อีกด้วย การเรียก Normalize() บนออบเจ็กต์ Document สามารถลบออบเจ็กต์ Text Node ที่ไม่จำเป็นซึ่งแมปในแผนผัง DOM ให้เป็นช่องว่างในเอกสาร XML ที่เป็นเนื้อหาที่จัดรูปแบบได้ มิฉะนั้นแผนผัง DOM ที่คุณได้รับอาจไม่ใช่สิ่งที่คุณจินตนาการ โดยเฉพาะอย่างยิ่งเมื่อส่งออก Normalize() นี้มีประโยชน์มากกว่า
ลิงก์ NodeList =doc.getElementsByTagName("link");
ดังที่กล่าวไว้ในตอนนี้ อักขระช่องว่างในเอกสาร XML จะถูกแมปเป็นออบเจ็กต์ในแผนผัง DOM ด้วย ดังนั้นการเรียกเมธอด getChildNodes ของเมธอด Node โดยตรงบางครั้งอาจมีปัญหาบางอย่าง และบางครั้งก็ไม่สามารถส่งคืนอ็อบเจ็กต์ NodeList ที่คาดไว้ได้ วิธีแก้ไขคือการใช้ getElementByTagName(String) ของ Element และ NodeLise ที่ส่งคืนคืออ็อบเจ็กต์ที่คาดหวัง จากนั้นคุณสามารถใช้เมธอด item() เพื่อแยกองค์ประกอบที่ต้องการได้
สำหรับ (int i=0;i<links.getLength();i++){
องค์ประกอบ link=(องค์ประกอบ) links.item(i);
System.out.print("เนื้อหา: ");
System.out.println(link.getElementsByTagName("ข้อความ").item(0).getFirstChild();
.getNodeValue());
...
ข้อมูลโค้ดข้างต้นทำให้เอาต์พุตที่จัดรูปแบบของเนื้อหาเอกสาร XML เสร็จสมบูรณ์ ตราบใดที่คุณใส่ใจกับรายละเอียดบางอย่าง เช่น การใช้เมธอด getFirstChile() และเมธอด getElementsByTagName() สิ่งเหล่านี้ก็ค่อนข้างง่าย
เนื้อหาต่อไปนี้เกี่ยวกับการเขียนแผนผัง DOM ใหม่ลงในเอกสาร XML หลังจากแก้ไขแล้ว โปรแกรมนี้เรียกว่า xmlwrite.Java ในเวอร์ชัน JAXP 1.0 ไม่มีคลาสและวิธีการโดยตรงที่สามารถจัดการการเขียนเอกสาร XML และคุณต้องใช้คลาสเสริมบางคลาสในแพ็คเกจอื่น ในเวอร์ชัน JAXP 1.1 มีการแนะนำการรองรับ XSLT สิ่งที่เรียกว่า XSLT คือการได้รับโครงสร้างเอกสารใหม่หลังจากการแปลงเอกสาร XML (การแปล) การใช้ฟังก์ชันที่เพิ่มเข้ามาใหม่นี้ ทำให้เราสามารถเขียนแผนผัง DOM ที่สร้างขึ้นใหม่หรือแก้ไขกลับไปยังไฟล์ XML ได้อย่างง่ายดาย มาดูการทำงานของโค้ดนี้กันดีกว่า ไฟล์ .xml:
นำเข้า Javax.xml.parsers.*;
นำเข้า Javax.xml.transform.*;
นำเข้า Javax.xml.transform.dom.DOMSource;
นำเข้า Javax.xml.transform.stream.StreamResult;
import org.w3c.dom.*;
หลายคลาสในแพ็คเกจ Java.xml.transform ที่เพิ่งเปิดตัวใช้เพื่อจัดการการแปลง XSLT
เราหวังว่าจะเพิ่มโหนดลิงก์ใหม่ให้กับไฟล์ XML ข้างต้น ดังนั้นก่อนอื่นเราจะต้องอ่านไฟล์ links.xml สร้างแผนผัง DOM จากนั้นแก้ไขแผนผัง DOM (เพิ่มโหนด) และสุดท้ายก็เพิ่ม DOM Write ที่แก้ไขแล้วกลับไปที่ ไฟล์ links.xml:
โรงงาน DocumentBuilderFactory = DocumentBuilderFactory.newInstance();
ตัวสร้าง DocumentBuilder=factory.newDocumentBuilder();
เอกสาร doc=builder.parse("links.xml");
doc.ทำให้เป็นมาตรฐาน();
//---รับตัวแปร----
String text="หน้าแรกของฮั่นจง";
สตริง url=" www.hzliu.com ";
ผู้เขียนสตริง = "Hzliu Liu";
String description="ไซต์จาก Hanzhong Liu ทำให้คุณประหลาดใจมาก!!!";
เพื่อให้เห็นประเด็นสำคัญได้ชัดเจนและทำให้ขั้นตอนง่ายขึ้น เราฮาร์ดโค้ดเนื้อหาที่จะเพิ่มลงในออบเจ็กต์ String หน่วยความจำ ในความเป็นจริง เรามักจะใช้อินเทอร์เฟซเพื่อแยกอินพุตของผู้ใช้หรือแยกเนื้อหาที่ต้องการออกจากฐานข้อมูลผ่าน JDBC
ข้อความ เช่น;
องค์ประกอบ link=doc.createElement("link");
ก่อนอื่น ควรชัดเจนว่าไม่ว่า Node ประเภทใด ไม่ว่าจะเป็นประเภทข้อความ ประเภท Attr หรือประเภทองค์ประกอบ ทั้งหมดถูกสร้างขึ้นผ่านอ็อบเจ็กต์ Document CreateXXX( ) วิธีการใน (XXX แสดงถึงประเภทเฉพาะที่จะสร้าง) ดังนั้น เราจำเป็นต้องเพิ่มรายการลิงก์ไปยังเอกสาร XML ขั้นแรกให้สร้างอ็อบเจ็กต์ลิงก์:
Element linktext=doc.createElement("text") ;
textseg=doc.createTextNode(ข้อความ);
linktext.appendChild(textseg);
link.appendChild (ข้อความลิงก์);
...
ขั้นตอนการสร้างโหนดอาจจะดูเหมือนกันเล็กน้อย แต่สิ่งที่ต้องสังเกตคือข้อความที่อยู่ใน Element (ใน DOM ข้อความเหล่านี้เป็นตัวแทนของ Node ด้วย ดังนั้นจึงต้องสร้างโหนดที่เกี่ยวข้องสำหรับโหนดเหล่านั้นด้วย) ใช้เมธอด setNodeValue() ของออบเจ็กต์ Element โดยตรงเพื่อตั้งค่าเนื้อหาของข้อความเหล่านี้ และคุณต้องใช้เมธอด setNodeValue() ของออบเจ็กต์ Text ที่สร้างขึ้นเพื่อตั้งค่าข้อความ เพื่อให้องค์ประกอบที่สร้างขึ้นและเนื้อหาข้อความสามารถ เพิ่มลงในแผนผัง DOM ลองดูโค้ดก่อนหน้าแล้วคุณจะเข้าใจสิ่งนี้ดีขึ้น:
doc.getDocumentElement().appendChild(ลิงก์);
สุดท้ายนี้ อย่าลืมเพิ่มโหนดที่สร้างขึ้นลงในแผนผัง DOM เมธอด getDocumentElement() ของคลาส Document ส่งคืนอ็อบเจ็กต์ Element ที่แสดงถึงโหนดรูทของเอกสาร ในเอกสาร XML โหนดรูทจะต้องไม่ซ้ำกัน
TransformerFactory tFactory = TransformerFactory.newInstance();
หม้อแปลงไฟฟ้า หม้อแปลงไฟฟ้า = tFactory.newTransformer();
แหล่งที่มาของ DOMSource = แหล่งที่มาของ DOMSource ใหม่ (doc);
ผลลัพธ์ StreamResult = StreamResult ใหม่ (Java.io.File ใหม่ ("links.xml"));
Transformer.transform(source, result)
จากนั้นใช้ XSLT เพื่อส่งออกแผนผัง DOM TransformerFactory ที่นี่ยังใช้รูปแบบโรงงาน ทำให้โค้ดเฉพาะไม่ขึ้นอยู่กับหม้อแปลงเฉพาะ วิธีการนำไปใช้นั้นเหมือนกับ DocumentBuilderFactory ดังนั้นฉันจะไม่ลงรายละเอียดที่นี่ วิธีการแปลงจากคลาส Transformer ยอมรับพารามิเตอร์สองตัว ได้แก่ แหล่งข้อมูล แหล่งที่มา และผลลัพธ์เป้าหมายเอาต์พุต DOMSource และ StreamResult ถูกใช้ที่นี่ตามลำดับ เพื่อให้เนื้อหาของ DOM สามารถส่งออกไปยังสตรีมเอาต์พุตได้ เมื่อสตรีมเอาต์พุตเป็นไฟล์ เนื้อหาของ DOM จะถูกเขียนลงในไฟล์
จะใช้ JSP เพื่อพัฒนาแอปพลิเคชัน SAX ได้อย่างไร
SAX เป็นตัวย่อของ Simple API สำหรับ XML ไม่ใช่มาตรฐานอย่างเป็นทางการที่เสนอโดย W3C อาจกล่าวได้ว่าเป็นมาตรฐาน "พื้นบ้าน" อันที่จริงแล้ว มันเป็นผลผลิตของการสนทนาในชุมชน ถึงกระนั้นก็ตาม SAX ก็ถูกใช้ใน XML ไม่น้อยไปกว่า DOM และตัวแยกวิเคราะห์ XML เกือบทั้งหมดก็รองรับ
เมื่อเปรียบเทียบกับ DOM แล้ว SAX เป็นวิธีการแบบน้ำหนักเบา เรารู้ว่าเมื่อประมวลผล DOM เราจำเป็นต้องอ่านเอกสาร XML ทั้งหมด จากนั้นสร้างแผนผัง DOM ในหน่วยความจำ และสร้างแต่ละ Node object บนแผนผัง DOM เมื่อเอกสารมีขนาดเล็ก ก็ไม่ก่อให้เกิดปัญหาใดๆ แต่เมื่อเอกสารมีขนาดใหญ่ขึ้น การประมวลผล DOM จะค่อนข้างใช้เวลานานและลำบาก โดยเฉพาะอย่างยิ่ง ความต้องการหน่วยความจำจะเพิ่มขึ้นแบบทวีคูณ ดังนั้นการใช้ DOM ในบางแอปพลิเคชันจึงไม่คุ้มค่า (เช่น ในแอปเพล็ต) ในเวลานี้ ทางเลือกอื่นที่ดีกว่าคือ SAX
SAX มีแนวคิดที่แตกต่างจาก DOM อย่างสิ้นเชิง ประการแรก ไม่เหมือนกับไดรเวอร์เอกสาร DOM ตรงที่ขับเคลื่อนด้วยเหตุการณ์ กล่าวคือ ไม่จำเป็นต้องอ่านเอกสารทั้งหมด และกระบวนการอ่านเอกสารก็เป็นกระบวนการแยกวิเคราะห์ SAX เช่นกัน สิ่งที่เรียกว่า event-driven หมายถึงโปรแกรมที่รันเมธอดตามกลไกการเรียกกลับ (หากคุณชัดเจนเกี่ยวกับโมเดลเหตุการณ์พร็อกซีใหม่ของ Java คุณจะเข้าใจกลไกนี้ได้อย่างง่ายดาย) XMLReader ยอมรับเอกสาร XML และแยกวิเคราะห์ในระหว่างกระบวนการอ่านเอกสาร XML กล่าวคือ กระบวนการอ่านเอกสาร กระบวนการแยกวิเคราะห์จะดำเนินการในเวลาเดียวกัน ซึ่งแตกต่างจาก DOM มาก ก่อนที่การแยกวิเคราะห์จะเริ่มต้น คุณต้องลงทะเบียน ContentHandler ด้วย XMLReader ซึ่งเทียบเท่ากับตัวฟังเหตุการณ์ มีการกำหนดวิธีการต่างๆ ใน ContentHandler เช่น startDocument() ซึ่งกำหนดสิ่งที่ควรจัดการเมื่อเอกสารเริ่มถูกพบในระหว่างการแยกวิเคราะห์ กระบวนการ เมื่อ XMLReader อ่านเนื้อหาที่เหมาะสม มันจะส่งเหตุการณ์ที่เกี่ยวข้อง มอบหมายพลังการประมวลผลของเหตุการณ์นี้ให้กับ ContentHandler และเรียกวิธีการที่เกี่ยวข้องเพื่อตอบสนอง
โดยทั่วไปอาจเข้าใจยากสักหน่อย แต่อย่ากังวล ตัวอย่างต่อไปนี้จะช่วยให้คุณเข้าใจกระบวนการแยกวิเคราะห์ SAX ดูไฟล์ XML แบบง่ายนี้:
<POEM>
<AUTHOR>อ็อกเดน แนช</AUTHOR>
<TITLE>หมัด</TITLE>
<LINE>อดัม</LINE>
</POEM>
เมื่อ XMLReader อ่านแท็ก <POEM> มันจะเรียกเมธอด ContentHandler.startElement() และส่งชื่อแท็ก POEM เป็นพารามิเตอร์ จำเป็นต้องดำเนินการที่สอดคล้องกันในเมธอด startElement() ที่คุณใช้เพื่อจัดการกับสิ่งที่ควรทำเมื่อ <POEM> ปรากฏขึ้น แต่ละเหตุการณ์จะถูกโยนออกไปทีละเหตุการณ์พร้อมกับกระบวนการแยกวิเคราะห์ (นั่นคือ กระบวนการอ่านเอกสาร) และวิธีการที่เกี่ยวข้องจะถูกเรียกตามลำดับ ในที่สุด เมื่อการแยกวิเคราะห์เสร็จสิ้นและเรียกใช้วิธีการ เอกสารก็จะถูกประมวลผล แค่นั้นแหละ. ตารางต่อไปนี้แสดงวิธีการที่ถูกเรียกตามลำดับเมื่อแยกวิเคราะห์ไฟล์ XML ด้านบน:
พบการเรียกกลับวิธีโครงการ
{document start} startDocument()
<POEM> startElement (null, "POEM", null, {แอตทริบิวต์})
"n" character("<POEM>n...", 6, 1)
<AUTHOR> startElement(null,"AUTHOR",null,{Attributes})
อักขระ "Ogden Nash"("<POEM>n...", 15, 10)
</AUTHOR> endElement(null,"ผู้เขียน",null)
"n" character("<POEM>n...", 34, 1)
<TITLE> startElement(null,"TITLE",null,{Attributes})
อักขระ "หมัด"("<POEM>n...", 42, 5)
</TITLE> endElement(null,"TITLE",null)
"n" character("<POEM>n...", 55, 1)
<LINE> startElement(null,"LINE",null,{Attributes})
"อดัม" character("<POEM>n...", 62, 4)
</LINE> endElement(null,"LINE",null)
"n" character("<POEM>n...", 67, 1)
</POEM> endElement(null,"POEM",null)
{End of document} endDocument()
ContentHandler จริงๆ แล้วเป็นอินเทอร์เฟซ เมื่อประมวลผลไฟล์ XML เฉพาะ คุณต้องสร้างคลาสที่ใช้ ContentHandler เพื่อจัดการเหตุการณ์เฉพาะ อาจกล่าวได้ว่านี่คือแกนหลักของการประมวลผล SAX เอกสาร ลองมาดูวิธีการบางอย่างที่กำหนดไว้ในนั้น:
อักขระที่เป็นโมฆะ (char [] ch, int start, int length): วิธีการนี้ใช้ในการประมวลผลสตริงที่อ่านในไฟล์ XML พารามิเตอร์ของมันคืออาร์เรย์อักขระและจุดเริ่มต้นของสตริงการอ่านในตำแหน่งเริ่มต้นและ length เราสามารถใช้ Constructor ของคลาส String เพื่อรับคลาส String ของสตริงนี้ได้อย่างง่ายดาย: String charEncontered=new String(ch,start,length)
void startDocument(): เมื่อคุณพบจุดเริ่มต้นของเอกสาร ให้เรียกเมธอดนี้เพื่อดำเนินการประมวลผลล่วงหน้า
void endDocument(): สอดคล้องกับวิธีการข้างต้น เมื่อเอกสารสิ้นสุดลง วิธีการนี้จะถูกเรียกให้ทำผลที่ตามมา
เป็นโมฆะ startElement (สตริง namespaceURI, สตริง localName, สตริง qName, แอตทริบิวต์ atts): วิธีการนี้จะถูกทริกเกอร์เมื่อมีการอ่านแท็กเริ่มต้น เนมสเปซไม่ได้รับการสนับสนุนในเวอร์ชัน SAX1.0 แต่การรองรับเนมสเปซมีให้ในเวอร์ชัน 2.0 ใหม่ เนมสเปซURI ในพารามิเตอร์ที่นี่คือเนมสเปซ localName คือชื่อป้ายกำกับ และ qName เป็นคำนำหน้าแก้ไขของป้ายกำกับ If ไม่มี เมื่อใช้เนมสเปซ พารามิเตอร์ทั้งสองจะเป็นโมฆะ และ atts คือรายการแอตทริบิวต์ที่มีอยู่ในแท็กนี้ คุณจะได้รับชื่อแอตทริบิวต์และค่าที่เกี่ยวข้องทั้งหมดผ่าน atts ควรสังเกตว่าคุณลักษณะที่สำคัญของ SAX คือการประมวลผลแบบสตรีมมิ่ง เมื่อพบแท็ก มันจะไม่บันทึกแท็กที่พบก่อนหน้านี้ กล่าวอีกนัยหนึ่ง ในเมธอด startElement() ข้อมูลทั้งหมดที่คุณทราบคือชื่อและคุณลักษณะ ของแท็ก ส่วนโครงสร้างที่ซ้อนกันของแท็ก ชื่อของแท็กด้านบน มีแอตทริบิวต์องค์ประกอบย่อย และข้อมูลที่เกี่ยวข้องกับโครงสร้างอื่น ๆ ไม่ทราบและต้องการความช่วยเหลือจากคุณ ทำให้การเขียนโปรแกรม SAX สะดวกน้อยกว่า DOM
void endElement(String namespaceURI, String localName, String qName): วิธีการนี้สอดคล้องกับวิธีการข้างต้น
เรายังคงใช้ตัวอย่างเอกสารที่เราใช้เมื่อพูดถึง DOM แต่ก่อนอื่น เรามาดูแอปพลิเคชันที่ง่ายกว่ากันก่อน เราหวังว่าจะนับจำนวนครั้งที่แต่ละแท็กปรากฏในไฟล์ XML ตัวอย่างนี้ง่ายมาก แต่ก็เพียงพอที่จะอธิบายแนวคิดพื้นฐานของการเขียนโปรแกรม SAX แน่นอนว่าคำสั่งการนำเข้ายังคงใช้อยู่ที่จุดเริ่มต้น:
import org.xml.sax.helpers.DefaultHandler;
นำเข้า Javax.xml.parsers.*;
นำเข้า org.xml.sax.*;
นำเข้า org.xml.sax.helpers.*;
นำเข้า Java.util.*;
import Java.io.*;
จากนั้น เราสร้างคลาสที่สืบทอดมาจาก DefaultHandler ตรรกะของโปรแกรมเฉพาะสามารถถูกละทิ้งไปในขณะนี้ สิ่งที่เราควรคำนึงถึงคือโครงสร้างของโปรแกรม:
คลาสสาธารณะ SAXCounter ขยาย DefaultHandler {
แท็ก Hashtable ส่วนตัว // Hashtable นี้ใช้เพื่อบันทึกจำนวนครั้งที่แท็กปรากฏขึ้น
//ทำงานก่อนประมวลผลเอกสาร
โมฆะสาธารณะ startDocument () พ่น SAXException {
tags = new Hashtable();//เตรียมใช้งาน Hashtable
-
//ประมวลผลแอตทริบิวต์ขององค์ประกอบเริ่มต้นแต่ละรายการ
โมฆะสาธารณะ startElement (สตริง namespaceURI, สตริงชื่อท้องถิ่น,
สตริง rawName, คุณสมบัติ atts)
พ่น SAXException
-
คีย์สตริง = localName;
...
มาดูกันว่าโปรแกรมนี้ทำอะไรได้บ้าง ในเมธอด main() สิ่งสำคัญที่คุณต้องทำคือสร้าง parser จากนั้นจึงแยกวิเคราะห์เอกสาร ในความเป็นจริง เมื่อสร้างวัตถุ SAXParser ที่นี่ เพื่อสร้างโค้ดโปรแกรมที่ไม่ขึ้นอยู่กับตัวแยกวิเคราะห์เฉพาะ เทคนิคการออกแบบเดียวกันกับใน DOM ถูกนำมาใช้: สร้างวัตถุ SAXParser เฉพาะผ่านคลาส SAXParserFactory ดังนั้นเมื่อแตกต่างกัน เมื่อแยกวิเคราะห์ สิ่งที่ต้องเปลี่ยนคือค่าของตัวแปรสภาพแวดล้อม ในขณะที่โค้ดโปรแกรมยังคงไม่เปลี่ยนแปลง นี่คือแนวคิดของรูปแบบ FactoryMethod ฉันจะไม่ลงรายละเอียดที่นี่ หากคุณยังไม่เข้าใจ คุณสามารถดูคำอธิบายใน DOM ด้านบนได้
แต่มีสิ่งหนึ่งที่ควรทราบที่นี่ ซึ่งเป็นความสัมพันธ์ระหว่างคลาส SAXParser และคลาส XMLReader คุณอาจสับสนเล็กน้อย ที่จริงแล้ว SAXParser เป็นคลาส wrapper สำหรับ XMLReader ใน JAXP และ XMLReader เป็นอินเทอร์เฟซที่กำหนดใน SAX2.0 สำหรับการแยกวิเคราะห์เอกสาร คุณยังสามารถเรียกเมธอด parser() ใน SAXParser หรือ XMLReader เพื่อแยกวิเคราะห์เอกสารได้ และเอฟเฟกต์ก็เหมือนกันทุกประการ อย่างไรก็ตาม วิธีการ parser() ใน SAXParser ยอมรับพารามิเตอร์มากขึ้นและสามารถแยกวิเคราะห์แหล่งข้อมูลเอกสาร XML ที่แตกต่างกันได้ ดังนั้นจึงสะดวกในการใช้งานมากกว่า XMLReader
ตัวอย่างนี้สัมผัสเฉพาะพื้นผิวของ SAX แต่ตัวอย่างต่อไปนี้เป็นขั้นสูงกว่า ฟังก์ชันที่เราต้องการนำไปใช้ด้านล่างนี้ได้ถูกนำไปใช้ในตัวอย่าง DOM แล้ว ซึ่งก็คือการอ่านเนื้อหาจากเอกสาร XML และจัดรูปแบบเอาต์พุต แม้ว่าตรรกะของโปรแกรมจะดูเรียบง่ายมาก แต่ SAX ก็ไม่ได้ดีไปกว่า DOM
ตามที่กล่าวไว้ก่อนหน้านี้ เมื่อพบแท็กเริ่มต้น ในเมธอด startElement() เราไม่สามารถรับตำแหน่งของแท็กในเอกสาร XML ได้ นี่เป็นปัญหาใหญ่เมื่อประมวลผลเอกสาร XML เนื่องจากความหมายของแท็กใน XML ส่วนหนึ่งถูกกำหนดโดยตำแหน่งของแท็ก และในบางโปรแกรมที่จำเป็นต้องตรวจสอบโครงสร้างของเอกสาร นี่ก็ยิ่งเป็นปัญหามากขึ้นไปอีก แน่นอนว่าไม่มีปัญหาใดที่ไม่สามารถแก้ไขได้ เราสามารถใช้ Stack เพื่อบันทึกโครงสร้างเอกสารได้
ลักษณะของสแต็กคือเข้าก่อนออกก่อน แนวคิดปัจจุบันของเราคือการใช้ push เพื่อเพิ่มชื่อของป้ายกำกับลงในสแต็กในเมธอด startElemnt() และแสดงออกมาในเมธอด endElement() เรารู้ว่าสำหรับ XML ที่มีโครงสร้างที่ดี โครงสร้างการซ้อนของแท็กเริ่มต้นแต่ละแท็กจะสอดคล้องกับแท็กปิดเสมอ และจะไม่มีการวางแนวที่ไม่ตรงระหว่างการซ้อนแท็ก ดังนั้นการโทรไปยังวิธีการเริ่มต้น () ทุกครั้งจะสอดคล้องกับวิธีการเรียกไปยัง endelement () อย่างหลีกเลี่ยงไม่ได้ดังนั้นการกดและป๊อปก็ปรากฏเป็นคู่ . ตำแหน่งในโครงสร้างเอกสาร
Public Class SaxReader ขยาย defaulthandler {
java.util.stack แท็ก = ใหม่ java.util.stack ();
...
แม้ว่าการวิเคราะห์สแต็กไม่ได้ใช้ที่นี่การวิเคราะห์สแต็กเป็นเรื่องง่ายมาก ถูกจัดเรียงจากล่างขึ้นบน คุณลักษณะของแต่ละองค์ประกอบ ในความเป็นจริงถ้าเราจัดเรียงองค์ประกอบของสแต็กทีละตัวจากล่างขึ้นบนเราจะได้รับเส้นทางที่ไม่ซ้ำกันจากโหนดรูท XML ไปยังโหนดปัจจุบัน .
จนถึงตอนนี้เราได้เชี่ยวชาญเครื่องมือสำคัญสองอย่างสำหรับการเขียนโปรแกรม XML: DOM และ SAX และยังรู้วิธีใช้ในโปรแกรม Java การเขียนโปรแกรม DOM นั้นค่อนข้างง่าย แต่ช้าและใช้หน่วยความจำจำนวนมากในขณะที่การเขียนโปรแกรม S AX นั้นซับซ้อนกว่า แต่เร็วและใช้หน่วยความจำน้อยลง ดังนั้นเราควรเลือกใช้วิธีการที่แตกต่างกันตามสภาพแวดล้อมที่แตกต่างกัน แอปพลิเคชั่น XML ส่วนใหญ่สามารถแก้ไขได้โดยใช้พวกเขา ควรสังเกตว่า DOM และ SAX เป็นภาษาที่ไม่ขึ้นกับภาษาและไม่ซ้ำกับ Java