ฉันจะตอบคำถามทั่วไปเกี่ยวกับคำถามนี้:
ตอบคำถาม
ทำไมเราต้องมีโปรแกรมแยกวิเคราะห์ XML?
เราต้องการตัวแยกวิเคราะห์ XML เพราะเราไม่ต้องการทำทุกอย่างในแอปพลิเคชันของเราและเราต้องการโปรแกรมหรือไลบรารี "ผู้ช่วยเหลือ" บางอย่างที่จะทำสิ่งที่ต่ำมาก แต่จำเป็นสำหรับเรามาก สิ่งที่จำเป็นในระดับต่ำ แต่จำเป็นเหล่านี้รวมถึงการตรวจสอบรูปแบบที่ดีตรวจสอบเอกสารกับ DTD หรือสคีมา (เพียงเพื่อตรวจสอบตัวแยกวิเคราะห์) การแก้ไขการอ้างอิงอักขระการทำความเข้าใจส่วน CDATA และอื่น ๆ ตัวแยกวิเคราะห์ XML เป็นเพียงโปรแกรม "ตัวช่วย" ดังกล่าวและพวกเขาจะทำงานเหล่านี้ทั้งหมด ด้วยตัวแยกวิเคราะห์ XML เราได้รับการปกป้องจากความซับซ้อนเหล่านี้จำนวนมากและเราสามารถตั้งสมาธิกับตัวเองในการเขียนโปรแกรมระดับสูงผ่าน API ที่ใช้งานโดยตัวแยกวิเคราะห์ซึ่งทำให้ประสิทธิภาพการเขียนโปรแกรมดีขึ้น
อันไหนดีกว่า SAX หรือ DOM
ตัวแยกวิเคราะห์ SAX และ DOM มีข้อดีและข้อเสีย ตัวเลือกใดดีกว่าควรขึ้นอยู่กับคุณสมบัติของใบสมัครของคุณ (โปรดดูคำถามด้านล่าง)
เครื่องมือแยกวิเคราะห์ตัวใดที่สามารถรับความเร็วได้ดีกว่าตัวแยกวิเคราะห์ DOM หรือ SAX
ตัวแยกวิเคราะห์ SAX สามารถรับความเร็วที่ดีขึ้นได้
ข้อแตกต่างระหว่าง API แบบอิงทรีและ API แบบอิงเหตุการณ์คืออะไร
Tree-based API นั้นมีศูนย์กลางอยู่ที่โครงสร้างของต้นไม้ดังนั้นจึงมีส่วนต่อประสานกับส่วนประกอบของแผนผัง (ซึ่งเป็นเอกสาร DOM) เช่นส่วนต่อประสานเอกสาร, ส่วนต่อประสานโหนด, ส่วนต่อประสาน NodeList, ส่วนต่อประสานองค์ประกอบ, ส่วนต่อประสาน Attr เป็นต้น อย่างไรก็ตามโดยคมชัด API ตามเหตุการณ์จะมีส่วนต่อประสานบนตัวจัดการ มีอินเตอร์เฟสตัวจัดการสี่อินเตอร์เฟส, ContentHandler อินเตอร์เฟส, อินเตอร์เฟส DTDHandler, อินเตอร์เฟส EntityResolver และอินเตอร์เฟส ErrorHandler
อะไรคือความแตกต่างระหว่าง DOM Parser และ SAX Parser
ตัวแยกวิเคราะห์ DOM และตัวแยกวิเคราะห์ SAX ทำงานได้หลายวิธี:
ตัวแยกวิเคราะห์ DOM สร้างโครงสร้างแบบต้นไม้ในหน่วยความจำจากเอกสารอินพุตแล้วรอการร้องขอจากไคลเอนต์ แต่ตัวแยกวิเคราะห์ SAX ไม่ได้สร้างโครงสร้างภายในใด ๆ แต่จะเกิดขึ้นของส่วนประกอบของเอกสารอินพุตเป็นเหตุการณ์และบอกลูกค้าว่ามันอ่านอะไรเมื่ออ่านผ่านเอกสารอินพุต
ตัวแยกวิเคราะห์ DOM ให้บริการแอปพลิเคชันไคลเอนต์พร้อมเอกสารทั้งหมดเสมอไม่ว่าลูกค้าจะต้องการจำนวนเท่าใด แต่ตัวแยกวิเคราะห์ SAX ให้บริการแอปพลิเคชันไคลเอนต์เสมอกับชิ้นส่วนของเอกสารในเวลาที่กำหนด
- ด้วย DOM parser การเรียกใช้เมธอดในแอปพลิเคชันไคลเอนต์จะต้องชัดเจนและก่อให้เกิดสายโซ่ แต่ด้วย SAX วิธีการบางอย่าง (โดยปกติจะอยู่เหนือ cient) จะถูกเรียกใช้โดยอัตโนมัติ (โดยนัย) ในวิธีที่เรียกว่า "การโทรกลับ" เมื่อมีเหตุการณ์บางอย่างเกิดขึ้น วิธีการเหล่านี้ไม่จำเป็นต้องเรียกลูกค้าอย่างชัดเจนถึงแม้ว่าเราจะสามารถเรียกพวกเขาอย่างชัดเจน
เราจะตัดสินใจได้อย่างไรว่าโปรแกรมแยกวิเคราะห์ตัวใดดี
ตัวแยกวิเคราะห์ที่ดีควรเป็นไปอย่างรวดเร็ว (ประหยัดเวลา) มีประสิทธิภาพของพื้นที่มีฟังก์ชันการใช้งานที่หลากหลายและใช้งานง่าย แต่ในความเป็นจริงไม่มีตัวแยกวิเคราะห์หลักใดที่มีคุณสมบัติเหล่านี้ทั้งหมดในเวลาเดียวกัน ตัวอย่างเช่น DOM Parser อุดมไปด้วยฟังก์ชันการทำงาน (เพราะมันสร้างต้นไม้ DOM ในหน่วยความจำและช่วยให้คุณสามารถเข้าถึงส่วนใด ๆ ของเอกสารซ้ำ ๆ และช่วยให้คุณสามารถปรับเปลี่ยนต้นไม้ DOM) แต่มันเป็นพื้นที่ที่ไม่มีประสิทธิภาพเมื่อเอกสารมีขนาดใหญ่ และใช้เวลานานหน่อยในการเรียนรู้วิธีทำงานกับมัน อย่างไรก็ตาม SAX Parser มีพื้นที่ว่างที่มีประสิทธิภาพมากขึ้นในกรณีของเอกสารอินพุตขนาดใหญ่ (เพราะไม่มีโครงสร้างภายใน) ยิ่งไปกว่านั้นทำงานได้เร็วกว่าและเรียนรู้ได้ง่ายกว่า DOM Parser เนื่องจาก API นั้นง่ายมาก แต่จากมุมมองการทำงาน มันให้ฟังก์ชั่นน้อยลงซึ่งหมายความว่าผู้ใช้เองจะต้องดูแลมากขึ้นเช่นการสร้างโครงสร้างข้อมูลของตัวเอง โดยวิธีการแยกวิเคราะห์ที่ดีคืออะไร? ฉันคิดว่าคำตอบนั้นขึ้นอยู่กับลักษณะของการสมัครของคุณ
แอปพลิเคชันในโลกแห่งความจริงอะไรบ้างที่ใช้ SAX parser มีข้อดีกว่าการใช้ DOM parser และในทางกลับกัน แอปพลิเคชันทั่วไปสำหรับ DOM parser และ SAX parser คืออะไร
ในกรณีต่อไปนี้การใช้ตัวแยกวิเคราะห์ SAX มีข้อดีกว่าการใช้ตัวแยกวิเคราะห์ DOM
- เอกสารที่ป้อนมีขนาดใหญ่เกินไปสำหรับหน่วยความจำที่มีอยู่ (จริง ๆ แล้วในกรณีนี้ SAX เป็นตัวเลือกเดียวของคุณ)
- คุณสามารถประมวลผลเอกสารเป็นชิ้นเล็ก ๆ ที่ต่อเนื่องกันได้ คุณไม่จำเป็นต้องใช้เอกสารทั้งหมดก่อนจึงจะสามารถทำงานที่เป็นประโยชน์ได้
- คุณเพียงแค่ต้องการใช้ parser เพื่อดึงข้อมูลที่น่าสนใจและการคำนวณทั้งหมดของคุณจะขึ้นอยู่กับโครงสร้างข้อมูลที่สร้างขึ้นด้วยตัวเอง ที่จริงแล้วในแอปพลิเคชั่นส่วนใหญ่ของเราเราสร้างโครงสร้างข้อมูลของเราเองซึ่งโดยปกติแล้วจะไม่ซับซ้อนเท่ากับทรี DOM จากความหมายนี้ฉันคิดว่าโอกาสในการใช้ DOM parser น้อยกว่าการใช้ SAX parser
ในกรณีต่อไปนี้การใช้ตัวแยกวิเคราะห์ DOM มีข้อดีกว่าการใช้ตัวแยกวิเคราะห์ SAX
- แอปพลิเคชันของคุณจำเป็นต้องเข้าถึงส่วนต่าง ๆ ของเอกสารในเวลาเดียวกัน
- แอปพลิเคชันของคุณอาจใช้โครงสร้างข้อมูลภายในซึ่งมีความซับซ้อนเกือบเท่ากับเอกสาร
- แอปพลิเคชันของคุณต้องแก้ไขเอกสารซ้ำ ๆ
- แอปพลิเคชันของคุณต้องเก็บเอกสารไว้เป็นระยะเวลานานโดยใช้วิธีการโทรหลายวิธี
ตัวอย่าง (ใช้ parser DOM หรือ SAX parser หรือไม่):
สมมติว่าผู้สอนมีเอกสาร XML ที่มีข้อมูลส่วนบุคคลทั้งหมดของนักเรียนรวมถึงคะแนนที่นักเรียนทำในชั้นเรียนและตอนนี้เขากำลังกำหนดเกรดสุดท้ายสำหรับนักเรียนโดยใช้แอปพลิเคชัน สิ่งที่เขาต้องการผลิตคือรายการที่มี SSN และผลการเรียน นอกจากนี้เราคิดว่าในใบสมัครของเขาผู้สอนไม่ใช้โครงสร้างข้อมูลเช่นอาร์เรย์เพื่อจัดเก็บข้อมูลส่วนบุคคลของนักเรียนและคะแนน หากผู้สอนตัดสินใจที่จะให้ A แก่ผู้ที่ได้รับค่าเฉลี่ยของชั้นเรียนหรือสูงกว่าและให้ B แก่ผู้อื่นดังนั้นเขาควรใช้โปรแกรมแยกวิเคราะห์ DOM ในใบสมัครของเขา เหตุผลก็คือเขาไม่มีทางที่จะรู้ว่าค่าเฉลี่ยของระดับชั้นก่อนที่เอกสารทั้งหมดจะได้รับการประมวลผล สิ่งที่เขาอาจต้องทำในใบสมัครของเขาคือสิ่งแรกที่ต้องพิจารณานักเรียนทุกคน ทำคะแนนและคำนวณค่าเฉลี่ยแล้วดูเอกสารอีกครั้งและกำหนดเกรดสุดท้ายให้นักเรียนแต่ละคนโดยเปรียบเทียบคะแนนที่เขาได้รับกับค่าเฉลี่ยของชั้นเรียน อย่างไรก็ตามหากผู้สอนใช้นโยบายการให้เกรดเช่นว่านักเรียนที่ได้ 90 คะแนนขึ้นไปจะได้รับมอบหมาย A และคนอื่น ๆ จะได้รับมอบหมายจาก B ดังนั้นเขาน่าจะใช้ SAX parser ดีกว่า เหตุผลคือเพื่อให้นักเรียนแต่ละคนได้เกรดสุดท้ายเขาไม่จำเป็นต้องรอให้เอกสารทั้งหมดถูกประมวลผล เขาสามารถกำหนดเกรดให้กับนักเรียนได้ทันทีที่ตัวแยกวิเคราะห์ SAX อ่านเกรดของนักเรียนคนนี้ ในการวิเคราะห์ข้างต้นเราคิดว่าผู้สอนไม่ได้สร้างโครงสร้างข้อมูลของตนเอง ถ้าเขาสร้างโครงสร้างข้อมูลของตัวเองเช่นอาร์เรย์ของสตริงเพื่อเก็บ SSN และอาร์เรย์ของจำนวนเต็มเพื่อเก็บคะแนน ในกรณีนี้, ฉันคิดว่า SAX เป็นตัวเลือกที่ดีกว่าก่อนหน้านี้สามารถประหยัดทั้งหน่วยความจำและเวลาได้ดี แต่ยังทำงานให้เสร็จ อีกหนึ่งข้อพิจารณาในตัวอย่างนี้ จะทำอย่างไรถ้าสิ่งที่ผู้สอนต้องการทำคือไม่พิมพ์รายการ แต่เพื่อบันทึกเอกสารต้นฉบับกลับมาพร้อมกับเกรดของนักเรียนแต่ละคนที่อัพเดต ในกรณีนี้ตัวแยกวิเคราะห์ DOM ควรเป็นตัวเลือกที่ดีกว่าไม่ว่าจะใช้นโยบายการให้คะแนนแบบใด เขาไม่จำเป็นต้องสร้างโครงสร้างข้อมูลใด ๆ ของเขาเอง สิ่งที่เขาต้องทำคือการแก้ไขทรี DOM แรก (เช่นตั้งค่าเป็นโหนด 'เกรด') จากนั้นบันทึกทรีที่ถูกปรับเปลี่ยนทั้งหมด หากเขาเลือกที่จะใช้ตัวแยกวิเคราะห์ SAX แทนที่จะเป็นตัวแยกวิเคราะห์ DOM ในกรณีนี้เขาต้องสร้างโครงสร้างข้อมูลที่ซับซ้อนเกือบเท่ากับทรี DOM ก่อนที่เขาจะสามารถทำงานให้เสร็จได้ แต่ทำงานให้เสร็จลุล่วง อีกหนึ่งข้อพิจารณาในตัวอย่างนี้ จะทำอย่างไรถ้าสิ่งที่ผู้สอนต้องการทำคือไม่พิมพ์รายการ แต่เพื่อบันทึกเอกสารต้นฉบับกลับมาพร้อมกับเกรดของนักเรียนแต่ละคนที่อัพเดต ในกรณีนี้ตัวแยกวิเคราะห์ DOM ควรเป็นตัวเลือกที่ดีกว่าไม่ว่าจะใช้นโยบายการให้คะแนนแบบใด เขาไม่จำเป็นต้องสร้างโครงสร้างข้อมูลใด ๆ ของเขาเอง สิ่งที่เขาต้องทำคือการแก้ไขทรี DOM แรก (เช่นตั้งค่าเป็นโหนด 'เกรด') จากนั้นบันทึกทรีที่ถูกปรับเปลี่ยนทั้งหมด หากเขาเลือกที่จะใช้ตัวแยกวิเคราะห์ SAX แทนที่จะเป็นตัวแยกวิเคราะห์ DOM ในกรณีนี้เขาต้องสร้างโครงสร้างข้อมูลที่ซับซ้อนเกือบเท่ากับทรี DOM ก่อนที่เขาจะสามารถทำงานให้เสร็จได้ แต่ทำงานให้เสร็จลุล่วง อีกหนึ่งข้อพิจารณาในตัวอย่างนี้ จะทำอย่างไรถ้าสิ่งที่ผู้สอนต้องการทำคือไม่พิมพ์รายการ แต่เพื่อบันทึกเอกสารต้นฉบับกลับมาพร้อมกับเกรดของนักเรียนแต่ละคนที่อัพเดต ในกรณีนี้ตัวแยกวิเคราะห์ DOM ควรเป็นตัวเลือกที่ดีกว่าไม่ว่าจะใช้นโยบายการให้คะแนนแบบใด เขาไม่จำเป็นต้องสร้างโครงสร้างข้อมูลใด ๆ ของเขาเอง สิ่งที่เขาต้องทำคือการแก้ไขทรี DOM แรก (เช่นตั้งค่าเป็นโหนด 'เกรด') จากนั้นบันทึกทรีที่ถูกปรับเปลี่ยนทั้งหมด หากเขาเลือกที่จะใช้ตัวแยกวิเคราะห์ SAX แทนที่จะเป็นตัวแยกวิเคราะห์ DOM ในกรณีนี้เขาต้องสร้างโครงสร้างข้อมูลซึ่งมีความซับซ้อนเหมือนต้นไม้ DOM ก่อนที่เขาจะสามารถทำงานให้เสร็จได้ แต่เพื่อบันทึกเอกสารต้นฉบับกลับมาพร้อมกับเกรดของนักเรียนแต่ละคนที่อัพเดตแล้ว? ในกรณีนี้ตัวแยกวิเคราะห์ DOM ควรเป็นตัวเลือกที่ดีกว่าไม่ว่าจะใช้นโยบายการให้คะแนนแบบใดก็ตาม เขาไม่จำเป็นต้องสร้างโครงสร้างข้อมูลใด ๆ ของเขาเอง สิ่งที่เขาต้องทำคือการแก้ไขทรี DOM แรก (เช่นตั้งค่าเป็นโหนด 'เกรด') จากนั้นบันทึกทรีที่ถูกปรับเปลี่ยนทั้งหมด หากเขาเลือกที่จะใช้ตัวแยกวิเคราะห์ SAX แทนที่จะเป็นตัวแยกวิเคราะห์ DOM ในกรณีนี้เขาต้องสร้างโครงสร้างข้อมูลซึ่งมีความซับซ้อนเหมือนต้นไม้ DOM ก่อนที่เขาจะสามารถทำงานให้เสร็จได้ แต่เพื่อบันทึกเอกสารต้นฉบับกลับมาพร้อมกับเกรดของนักเรียนแต่ละคนที่อัพเดตแล้ว? ในกรณีนี้ตัวแยกวิเคราะห์ DOM ควรเป็นตัวเลือกที่ดีกว่าไม่ว่าจะใช้นโยบายการให้คะแนนแบบใดก็ตาม เขาไม่จำเป็นต้องสร้างโครงสร้างข้อมูลใด ๆ ของเขาเอง สิ่งที่เขาต้องทำคือการแก้ไขทรี DOM แรก (เช่นตั้งค่าเป็นโหนด 'เกรด') จากนั้นบันทึกทรีที่ถูกปรับเปลี่ยนทั้งหมด หากเขาเลือกที่จะใช้ตัวแยกวิเคราะห์ SAX แทนที่จะเป็นตัวแยกวิเคราะห์ DOM ในกรณีนี้เขาต้องสร้างโครงสร้างข้อมูลซึ่งมีความซับซ้อนเหมือนต้นไม้ DOM ก่อนที่เขาจะสามารถทำงานให้เสร็จได้ โหนด) จากนั้นให้บันทึกแผนผังที่ถูกแก้ไขทั้งหมด หากเขาเลือกที่จะใช้ตัวแยกวิเคราะห์ SAX แทนที่จะเป็นตัวแยกวิเคราะห์ DOM ในกรณีนี้เขาต้องสร้างโครงสร้างข้อมูลซึ่งมีความซับซ้อนเหมือนต้นไม้ DOM ก่อนที่เขาจะสามารถทำงานให้เสร็จได้ โหนด) จากนั้นให้บันทึกแผนผังที่ถูกแก้ไขทั้งหมด หากเขาเลือกที่จะใช้ตัวแยกวิเคราะห์ SAX แทนที่จะเป็นตัวแยกวิเคราะห์ DOM ในกรณีนี้เขาต้องสร้างโครงสร้างข้อมูลซึ่งมีความซับซ้อนเหมือนต้นไม้ DOM ก่อนที่เขาจะสามารถทำงานให้เสร็จได้
ตัวอย่าง
คำแถลงปัญหา : เขียนโปรแกรม Java เพื่อดึงข้อมูลทั้งหมดเกี่ยวกับวงกลมซึ่งเป็นองค์ประกอบในเอกสาร XML ที่กำหนด เราสมมติว่าองค์ประกอบวงกลมแต่ละวงมีองค์ประกอบย่อยสามองค์ประกอบ (เช่น x, y และรัศมี) รวมถึงแอตทริบิวต์สี ตัวอย่างเอกสารได้รับด้านล่าง:
<?xml version="1.0"?>
<!DOCTYPE shapes [
<!ELEMENT shapes (circle)*>
<!ELEMENT circle (x,y,radius)>
<!ELEMENT x (#PCDATA)>
<!ELEMENT y (#PCDATA)>
<!ELEMENT radius (#PCDATA)>
<!ATTLIST circle color CDATA #IMPLIED>
]>
<shapes>
<circle color="BLUE">
<x>20</x>
<y>20</y>
<radius>20</radius>
</circle>
<circle color="RED" >
<x>40</x>
<y>40</y>
<radius>20</radius>
</circle>
</shapes>
โปรแกรมกับ DOMparser
import java.io.*;
import org.w3c.dom.*;
import org.apache.xerces.parsers.DOMParser;
public class shapes_DOM {
static int numberOfCircles = 0; // total number of circles seen
static int x[] = new int[1000]; // X-coordinates of the centers
static int y[] = new int[1000]; // Y-coordinates of the centers
static int r[] = new int[1000]; // radius of the circle
static String color[] = new String[1000]; // colors of the circles
public static void main(String[] args) {
try{
// create a DOMParser
DOMParser parser=new DOMParser();
parser.parse(args[0]);
// get the DOM Document object
Document doc=parser.getDocument();
// get all the circle nodes
NodeList nodelist = doc.getElementsByTagName("circle");
numberOfCircles = nodelist.getLength();
// retrieve all info about the circles
for(int i=0; i<nodelist.getLength(); i++) {
// get one circle node
Node node = nodelist.item(i);
// get the color attribute
NamedNodeMap attrs = node.getAttributes();
if(attrs.getLength() > 0)
color[i]=(String)attrs.getNamedItem("color").getNodeValue();
// get the child nodes of a circle node
NodeList childnodelist = node.getChildNodes();
// get the x and y value
for(int j=0; j<childnodelist.getLength(); j++) {
Node childnode = childnodelist.item(j);
Node textnode = childnode.getFirstChild();//the only text node
String childnodename=childnode.getNodeName();
if(childnodename.equals("x"))
x[i]= Integer.parseInt(textnode.getNodeValue().trim());
else if(childnodename.equals("y"))
y[i]= Integer.parseInt(textnode.getNodeValue().trim());
else if(childnodename.equals("radius"))
r[i]= Integer.parseInt(textnode.getNodeValue().trim());
}
}
// print the result
System.out.println("circles="+numberOfCircles);
for(int i=0;i<numberOfCircles;i++) {
String line="";
line=line+"(x="+x[i]+",y="+y[i]+",r="+r[i]+",color="+color[i]+")";
System.out.println(line);
}
} catch (Exception e) {e.printStackTrace(System.err);}
}
}
โปรแกรมกับ SAXparser
import java.io.*;
import org.xml.sax.*;
import org.xml.sax.helpers.DefaultHandler;
import org.apache.xerces.parsers.SAXParser;
public class shapes_SAX extends DefaultHandler {
static int numberOfCircles = 0; // total number of circles seen
static int x[] = new int[1000]; // X-coordinates of the centers
static int y[] = new int[1000]; // Y-coordinates of the centers
static int r[] = new int[1000]; // radius of the circle
static String color[] = new String[1000]; // colors of the circles
static int flagX=0; //to remember what element has occurred
static int flagY=0; //to remember what element has occurred
static int flagR=0; //to remember what element has occurred
// main method
public static void main(String[] args) {
try{
shapes_SAX SAXHandler = new shapes_SAX (); // an instance of this class
SAXParser parser=new SAXParser(); // create a SAXParser object
parser.setContentHandler(SAXHandler); // register with the ContentHandler
parser.parse(args[0]);
} catch (Exception e) {e.printStackTrace(System.err);} // catch exeptions
}
// override the startElement() method
public void startElement(String uri, String localName,
String rawName, Attributes attributes) {
if(rawName.equals("circle")) // if a circle element is seen
color[numberOfCircles]=attributes.getValue("color"); // get the color attribute
else if(rawName.equals("x")) // if a x element is seen set the flag as 1
flagX=1;
else if(rawName.equals("y")) // if a y element is seen set the flag as 2
flagY=1;
else if(rawName.equals("radius")) // if a radius element is seen set the flag as 3
flagR=1;
}
// override the endElement() method
public void endElement(String uri, String localName, String rawName) {
// in this example we do not need to do anything else here
if(rawName.equals("circle")) // if a circle element is ended
numberOfCircles += 1; // increment the counter
}
// override the characters() method
public void characters(char characters[], int start, int length) {
String characterData =
(new String(characters,start,length)).trim(); // get the text
if(flagX==1) { // indicate this text is for <x> element
x[numberOfCircles] = Integer.parseInt(characterData);
flagX=0;
}
else if(flagY==1) { // indicate this text is for <y> element
y[numberOfCircles] = Integer.parseInt(characterData);
flagY=0;
}
else if(flagR==1) { // indicate this text is for <radius> element
r[numberOfCircles] = Integer.parseInt(characterData);
flagR=0;
}
}
// override the endDocument() method
public void endDocument() {
// when the end of document is seen, just print the circle info
System.out.println("circles="+numberOfCircles);
for(int i=0;i<numberOfCircles;i++) {
String line="";
line=line+"(x="+x[i]+",y="+y[i]+",r="+r[i]+",color="+color[i]+")";
System.out.println(line);
}
}
}
