Ikhtisar: eXtensible Markup Language (XML) dengan cepat digunakan di industri. Ini telah menjadi standar yang banyak digunakan untuk mendeskripsikan dan bertukar data dalam format yang tidak bergantung pada platform, bahasa, dan protokol. XML dan spesifikasi tambahannya dapat digunakan untuk mendeskripsikan representasi data dokumen, menjelaskan batasan jenis dokumen XML, menjelaskan hubungan antara dokumen XML dan sumber daya, dan menjelaskan konversi otomatis dan pemformatan dokumen XML.
Bagaimana cara mengembangkan perpustakaan tag khusus?
Saya sudah lama menggunakan pemrograman JSP dan ASP. Di antara dua metode pemrograman sisi server, saya semakin merasa bahwa JSP jauh lebih kuat. Belum lagi, perpustakaan tag JSP adalah alasan mengapa saya memilih JSP sebagai alat pengembangan aplikasi web sisi server pilihan. Mengapa? Karena: kecepatan pemeliharaan dan pengembangan. Dalam satu halaman server, Anda dapat mencampur dan mencocokkan berbagai metode dan objek skrip. Seperti "beton", campuran ini membuat skrip sisi server kuat dan memungkinkan pemrogram sisi server merancang halaman Web yang sangat fleksibel dan dinamis. Namun, campuran gratis ini juga memiliki kelemahan, yaitu sulit untuk dipelihara. terutama ketika proyek menjadi lebih besar, karena produk akhir dikelola oleh perancang web tradisional, dan lebih buruk lagi, kecepatan pengembangan meningkat seiring dengan meningkatnya kompleksitas kode. Ini akan menjadi lebih lambat dan tidak kondusif untuk pengembangan media dan aplikasi web berskala besar. Setelah dikembangkan, situs masih perlu mencari pemrogram yang memenuhi syarat untuk memelihara kode yang agak rumit ini.
Untungnya, JSP memberikan solusi yang baik. Pustaka tag menyediakan cara mudah untuk membuat blok kode yang dapat digunakan kembali. Setelah perpustakaan tag dirancang, perpustakaan tersebut dapat digunakan kembali di banyak proyek. Yang lebih nyaman lagi adalah, tidak seperti COM dan J2EE, Anda tidak perlu mempelajari keterampilan lain untuk membuat perpustakaan tag! Selama Anda tahu cara menulis JSP, Anda bisa membuat perpustakaan tag. Pustaka tag juga dapat meningkatkan pemeliharaan aplikasi web. Ini adalah antarmuka XML sederhana berkat tag khusus halaman JSP. Dengan cara ini, desainer Web bahkan dapat membangun aplikasi Web JSP tanpa mengetahui pengetahuan JSP apa pun. Pengembangan web terbuka ini sangat efektif untuk operasional tim. Pemrogram JSP dapat membuat tag khusus dan modul kode latar belakang, sementara desainer Web dapat menggunakan tag khusus untuk membangun aplikasi Web dan fokus pada desain Web.
1. Definisi perpustakaan tag Perpustakaan tag JSP (juga disebut perpustakaan khusus) dapat dianggap sebagai sekumpulan metode untuk menghasilkan skrip berbasis XML, yang didukung oleh JavaBeans. Secara konseptual, pustaka tag adalah konstruksi kode yang sangat sederhana dan dapat digunakan kembali.
Contoh tag dan laman HTML yang melakukan konversi XML/XSL
<%@ taglib uri=" http://www.jspinsider.com/jspkit/JAXP " prefix="JAXP"%>
c:/xml/example.xml
c:/xml/example.xsl
Dalam contoh ini, dengan menggunakan tag sederhana untuk mengakses kode yang lebih kuat di belakang layar, XML dimuat dan hasilnya dihasilkan melalui file XSL dan dikirim ke klien, semua melalui Ini selesai menggunakan panggilan tag sederhana.
Tag khusus membuka pintu untuk membuat kode yang mudah digunakan kembali dalam proyek JSP. Yang Anda butuhkan hanyalah perpustakaan tag dan dokumentasinya.
2. Komponen Tag Meskipun pustaka tag sangat mudah digunakan, namun cukup rumit untuk membuat desain internal untuk mendukung pustaka tag, setidaknya lebih rumit daripada membuat JavaBean sederhana. Kompleksitasnya berasal dari fakta bahwa perpustakaan tag terdiri dari beberapa bagian. Namun, Anda hanya perlu mengetahui Java dan JSP.
Tag sederhana terdiri dari elemen-elemen berikut:
⑴ JavaBeans: Untuk mendapatkan manfaat berorientasi objek yang melekat pada Java, kode yang dapat digunakan kembali harus ditempatkan dalam wadah kode independen. JavaBeans ini bukan bagian dari perpustakaan tag. Namun ini adalah blok kode dasar yang digunakan basis kode Anda untuk melakukan tugas terkait.
⑵ Pemrosesan tag: Ini adalah inti sebenarnya dari perpustakaan tag. Penangan tag akan mereferensikan sumber daya apa pun yang diperlukan (JavaBeans Anda) dan mengakses semua informasi tentang halaman JSP Anda (objek pageContext). Halaman JSP juga akan mengirimkan semua atribut tag yang telah ditetapkan dan isi badan tag pada halaman JSP ke pemroses tag. Setelah pemroses tag selesai memproses, ia akan mengirimkan hasilnya kembali ke halaman JSP Anda untuk diproses.
⑶ Deskripsi perpustakaan tag (file tld): Ini adalah file XML sederhana yang mencatat atribut, informasi, dan lokasi pemroses tag. Kontainer JSP menggunakan file ini untuk mengetahui di mana dan bagaimana memanggil perpustakaan tag.
⑷ File web.xml situs web: Ini adalah file inisialisasi situs web Anda. Dalam file ini, Anda menentukan tag khusus yang digunakan di situs web, dan file tld mana yang digunakan untuk menjelaskan setiap tag khusus.
⑸ File distribusi (file WAR atau JAR): Jika Anda ingin menggunakan kembali tag khusus, Anda memerlukan cara untuk mentransfernya dari satu proyek ke proyek lainnya. Mengemas perpustakaan tag ke dalam file JAR adalah cara yang sederhana dan efektif.
⑹ Buat deklarasi perpustakaan tag di file JSP Anda: Caranya sangat sederhana. Jika Anda ingin menggunakan tag ini, cukup deklarasikan di halaman. Setelah itu, Anda dapat menggunakannya di mana saja di halaman JSP.
Sepertinya banyak pekerjaan yang harus dilakukan, tapi sebenarnya tidak terlalu sulit. Intinya bukan tentang pengkodean, tetapi tentang mengatur bagian-bagiannya dengan benar. Namun, pelapisan ini penting karena membuat penggunaan label menjadi fleksibel dan mudah dipindahkan. Lebih penting lagi, lapisan ini ada untuk mengotomatiskan proses pembuatan tag melalui JSP IDE (JSP Integrated Development Environment). Diharapkan IDE JSP di masa mendatang dapat secara otomatis menyelesaikan sebagian besar pekerjaan pembuatan tag khusus, sehingga Anda hanya perlu menulis kode dan memproses tag.
Catatan: Penangan tag hanya mendefinisikan satu tag khusus; pustaka tag adalah kumpulan beberapa pemroses tag yang menangani tugas yang sama.
3. Buat tag Anda sendiri. Berikut ini akan mengajari Anda langkah demi langkah cara membuat tag khusus. Contoh spesifiknya adalah memperluas JSP sehingga memiliki fungsi pengkodean HTML sendiri. Fitur ini menggantikan semua karakter < dan > dengan kode HTML. Itu dapat dengan mudah diperluas untuk melakukan pemrosesan pengkodean lainnya. Untuk mempermudah, contoh ini hanya menjelaskan elemen dasar pembuatan tag khusus.
⑴ Buat JavaBean
Setiap bagian kode Anda yang dapat digunakan kembali harus ditempatkan di JavaBean. Ini penting karena Anda akan sering menggunakan kode ini di tempat lain dalam proyek. Kode apa pun yang ditempatkan di dalam pengendali tag tidak dapat digunakan kembali di luar tag, jadi penting untuk mengisolasi bagian kode yang dapat digunakan kembali. Dalam contoh ini, logika yang dikodekan untuk HTML adalah umum dan oleh karena itu ditempatkan di JavaBean.
⑵ Pengkodean HTML JavaBean
/* HTML_Format.Java */
public class HTML_Format extends Obyek mengimplementasikan Java.io.Serializable {
/** Buat HTML_Format baru */
HTML_Format publik() {}
/** Ganti semua karakter < dan > dalam string dengan pengkodean HTML respons */
String publik HTML_Encode(String as_data)
{
int li_len = as_data.panjang();
/*Panjang buffer string lebih panjang dari string aslinya*/
StringBuffer lsb_encode = StringBuffer baru(li_len + (li_len/10));
/* Perulangan untuk mengganti semua karakter < dan >*/
untuk(int li_count = 0; li_count < li_len; li_count++)
{ String ls_next = String.valueOf(as_data.charAt(li_count));
if (ls_next.equals("<")) ls_next = "<";
if (ls_next.equals(">")) ls_next = ">";
lsb_encode.append(ls_next);
}
return(lsb_encode.toString());
}
}
⑶ Buat pemroses tag. Pemroses tag menggunakan kode berikut:
Pemroses tag pengkodean HTML
impor Java.io.IOException;
import Javax.servlet.jsp.*;
import Javax.servlet.jsp.tagext.*;
HTML_FormatTag kelas publik memperluas BodyTagSupport
{
/* 1} Fungsi ini akan dipanggil di akhir tag*/
public int doEndTag() menampilkan JspTagException
{
mencoba
{ /* 2} Dapatkan teks di label */
BodyContent l_tagbody = getBodyContent();
Tali ls_output = "";
/* 3} Jika badan tag berisi teks, proseslah */
jika(l_tagbody != nol)
{ HTML_Format l_format = HTML_Format baru();
/* 3a} Mengubah isi isi tag menjadi string */
String ls_html_text = l_tagbody.getString();
ls_output = l_format.HTML_Encode(ls_html_text);
}
/* 4}Tulis kembali hasilnya ke aliran data*/
pageContext.getOut().write(ls_output.trim());
}
menangkap (IOException e)
{ throw new JspTagException("Kesalahan Tag:" + e.toString());
}
/* Biarkan JSP terus memproses konten halaman berikut*/
kembalikan EVAL_PAGE;
}
}
Pemrosesan ini sangat sederhana, meliputi:
o Membaca teks antara awal dan akhir tag o Memanggil fungsi pengkodean html o Mengembalikan hasilnya ke halaman JSP.
⑷ Membuat deskriptor tag perlu mendeskripsikan tag khusus agar sistem mengetahui cara memprosesnya. Akhiran file deskripsi ini adalah .tld, biasanya namanya sama dengan tag processor, dan disimpan di direktori "/WEB-INF/".
Deskriptor tag pengkodean HTML
PUBLIK "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
" http://Java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd ">
⑸ Perbarui file XML Web agar sekarang memberi tahu penampung JSP untuk menggunakan perpustakaan tag. Untuk melakukan ini, Anda perlu memodifikasi file web.xml. Secara khusus, Anda perlu menambahkan proyek taglib untuk mendaftarkan perpustakaan tag. Yang terpenting, tetapkan URI ke tag. URI adalah referensi unik yang hanya berlaku untuk tag tertentu di situs web. Sebaiknya gunakan URL lengkap atau nama paket untuk memastikan keunikan karena tag dapat digunakan di situs web berbeda. Contoh ini disederhanakan.
Ubah file web.xml
PUBLIK "-//Sun Microsystems, Inc.//Aplikasi Web DTD 2.2//EN"
" http://Java.sun.com/j2ee/dtds/web-app_2.2.dtd ">
Kode HTML
/WEB-INF/HTML_FormatTag.tld
⑹ Tag khusus yang menggunakan tag baru telah disiapkan dan dapat digunakan pada halaman JSP. Untuk melakukan hal ini, cukup deklarasikan tag pada halaman menggunakan direktif taglib. Tag direferensikan oleh URI uniknya dan diberi awalan namespace. Awalannya bisa sembarangan asalkan tidak bertentangan dengan namespace lain.
Gunakan tag pengkodean HTML pada halaman JSP:
<%@ taglib uri="HTMLEncode" prefix="Examples" %>
Contoh keluaran kode
yang ditampilkan sebagai:
Dengan tag ini, saya mengkodekan semua kode halaman. Hal yang menarik adalah semua tag khusus ditangani di server. Ini berarti Anda tidak akan melihat tag khusus di halaman keluaran.
Membuat label tidaklah sulit. Bagian tersulitnya adalah mempelajari seluruh seluk beluk pemrosesan label. Ini adalah fitur yang sangat kuat, dan kami hanya menyentuh dasar-dasarnya. Karena proses ini memerlukan beberapa langkah, programmer JSP baru akan bingung saat membuat tag.
Bagaimana cara menggunakan JSP untuk mengembangkan aplikasi DOM?
DOM adalah singkatan dari Document Object Model yang merupakan model objek dokumen. XML mengatur data ke dalam sebuah pohon, jadi DOM adalah deskripsi objek dari pohon ini. Dalam istilah awam, secara logis membangun model pohon untuk dokumen XML dengan mengurai dokumen XML, dan simpul pohon adalah objek. Kita dapat mengakses konten dokumen XML dengan mengakses objek tersebut.
Mari kita lihat contoh sederhana di bawah ini untuk melihat bagaimana kita mengoperasikan dokumen XML di DOM. Ini adalah dokumen XML dan objek yang ingin kita operasikan:
Selanjutnya, kita perlu menguraikan konten dokumen ini ke dalam objek Java untuk digunakan oleh program. Dengan menggunakan JAXP, kita dapat melakukan ini hanya dengan beberapa baris kode. Pertama, kita perlu membuat pabrik parser untuk menggunakan pabrik ini guna mendapatkan objek parser tertentu:
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
Tujuan penggunaan DocumentBuilderFacotry di sini adalah untuk membuat program yang independen terhadap parser tertentu. Ketika metode statis newInstance() dari kelas DocumentBuilderFactory dipanggil, ia menentukan parser mana yang akan digunakan berdasarkan variabel sistem. Dan karena semua parser mematuhi antarmuka yang ditentukan oleh JAXP, kodenya tetap sama, apa pun parser yang digunakan. Jadi ketika berpindah antar parser yang berbeda, Anda hanya perlu mengubah nilai variabel sistem tanpa mengubah kode apa pun. Inilah keuntungan dari pabrik.
DocumentBuilder db = dbf.newDocumentBuilder();
Setelah mendapatkan objek pabrik, gunakan metode statis metode newDocumentBuilder() untuk mendapatkan objek DocumentBuilder, yang mewakili parser DOM tertentu. Namun parser yang mana, milik Microsoft atau IBM, tidak penting bagi program ini.
Lalu, kita bisa menggunakan parser ini untuk mengurai dokumen XML:
Dokumen doc = db.parse("c:/xml/message.xml");
Metode parse() dari DocumentBuilder menerima nama dokumen XML sebagai parameter masukan dan mengembalikan objek Dokumen. Objek Dokumen ini mewakili model pohon dari dokumen XML. Semua operasi masa depan pada dokumen XML tidak ada hubungannya dengan parser dan dapat dioperasikan langsung pada objek Dokumen ini. Metode spesifik pengoperasian Dokumen ditentukan oleh DOM.
Mulai dari objek Dokumen yang diperoleh, kita bisa memulai perjalanan DOM kita. Dengan menggunakan metode getElementsByTagName() pada objek Dokumen, kita bisa mendapatkan objek NodeList. Objek Node mewakili elemen tag dalam dokumen XML, dan objek NodeList, seperti yang Anda lihat dari namanya, mewakili objek Daftar Node.
NodeList nl = doc.getElementsByTagName("pesan");
Apa yang kita dapatkan melalui pernyataan tersebut adalah daftar objek Node yang sesuai dengan semua tag
Node my_node = nl.item(0);
Ketika objek Node dibuat, data yang disimpan dalam dokumen XML diekstraksi dan dienkapsulasi dalam Node.js. Dalam contoh ini, untuk mengekstrak konten dalam tag Pesan, kita biasanya menggunakan metode getNodeValue() dari objek Node:
Pesan string = my_node.getFirstChild().getNodeValue();
Harap dicatat bahwa metode getFirstChild() juga digunakan di sini untuk mendapatkan objek Node anak pertama di bawah pesan. Meskipun tidak ada sub-tag atau atribut lain di bawah tag pesan kecuali teks, kami bersikeras menggunakan metode getFirseChild() di sini, yang terutama terkait dengan definisi DOM W3C. W3C juga mendefinisikan bagian teks dalam tag sebagai Node, jadi kita harus terlebih dahulu mendapatkan Node yang mewakili teks sebelum kita dapat menggunakan getNodeValue() untuk mendapatkan konten teks. Sekarang, karena kita sudah bisa mengekstrak data dari file XML, kita bisa menggunakan data ini di tempat yang tepat untuk membangun aplikasi.
Contoh DOM
Pertama mari kita bicara tentang apa yang akan dilakukan contoh ini. Kami telah menyimpan beberapa alamat URL dalam sebuah file bernama link. Alamat URL yang ditambahkan ditulis dalam file XML ini. Ini sangat sederhana, namun sangat praktis, dan cukup untuk menggambarkan sebagian besar penggunaan DOM.
Program pertama disebut xmldisplay.Java. Fungsi utamanya adalah membaca konten setiap node dalam file XML ini, lalu memformat outputnya di System.out. Mari kita lihat program ini:
import Javax.xml.parsers. *;
import org.w3c.dom.*;
Ini untuk memperkenalkan kelas-kelas yang diperlukan, karena parser XML yang disediakan oleh Sun digunakan di sini, sehingga paket Java.xml.parsers perlu diperkenalkan, yang berisi parser DOM dan parsing SAX. Implementasi spesifik perangkat. Paket org.w3c.dom mendefinisikan antarmuka DOM yang dikembangkan oleh w3c.
Pabrik DocumentBuilderFactory = DocumentBuilderFactory.newInstance();
Pembuat DocumentBuilder=pabrik.newDocumentBuilder();
Dokumen doc=builder.parse("links.xml");
doc.normalize();
Selain yang di atas, ada juga sedikit trik. Memanggil normalize() pada objek Dokumen dapat menghapus objek Node Teks yang tidak perlu yang dipetakan di pohon DOM sebagai kosong di dokumen XML sebagai konten yang diformat. Jika tidak, pohon DOM yang Anda dapatkan mungkin tidak seperti yang Anda bayangkan. Terutama saat mengeluarkan, normalize() ini lebih berguna.
NodeList links =doc.getElementsByTagName("link");
Seperti disebutkan tadi, karakter spasi dalam dokumen XML juga akan dipetakan sebagai objek di pohon DOM. Oleh karena itu, memanggil metode getChildNodes dari metode Node secara langsung terkadang mengalami beberapa masalah, dan terkadang tidak dapat mengembalikan objek NodeList yang diharapkan. Solusinya adalah dengan menggunakan getElementByTagName(String) Elemen, dan NodeLise yang dikembalikan adalah objek yang diharapkan. Kemudian, Anda dapat menggunakan metode item() untuk mengekstrak elemen yang diinginkan.
untuk (int i=0;i
System.out.print("Isi: ");
System.out.println(link.getElementsByTagName("teks").item(0).getFirstChild();
.getNodeValue());
...
Cuplikan kode di atas melengkapi keluaran konten dokumen XML yang diformat. Selama Anda memperhatikan beberapa detail, seperti penggunaan metode getFirstChile() dan metode getElementsByTagName(), ini relatif mudah.
Konten berikut adalah tentang menulis ulang pohon DOM ke dalam dokumen XML setelah memodifikasinya. Program ini disebut xmlwrite.Java. Dalam versi JAXP 1.0, tidak ada kelas dan metode langsung yang dapat menangani penulisan dokumen XML, dan Anda perlu menggunakan beberapa kelas tambahan di paket lain. Dalam versi JAXP 1.1, dukungan untuk XSLT diperkenalkan. Yang disebut XSLT adalah untuk mendapatkan struktur dokumen baru setelah mengubah dokumen XML (Terjemahan). Dengan menggunakan fungsi yang baru ditambahkan ini, kita dapat dengan mudah menulis kembali pohon DOM yang baru dibuat atau dimodifikasi ke file XML. Mari kita lihat implementasi kodenya. Fungsi utama kode ini adalah untuk menghubungkan Tambahkan simpul tautan baru ke File .xml:
import Javax.xml.parsers.*;
import Javax.xml.transform.*;
impor Javax.xml.transform.dom.DOMSource;
impor Javax.xml.transform.stream.StreamResult;
import org.w3c.dom.*;
Beberapa kelas dalam paket Java.xml.transform yang baru diperkenalkan digunakan untuk menangani transformasi XSLT.
Kami berharap dapat menambahkan node tautan baru ke file XML di atas, jadi kami harus terlebih dahulu membaca file links.xml, membuat pohon DOM, kemudian memodifikasi pohon DOM (menambahkan node), dan terakhir menambahkan DOM Write yang telah dimodifikasi kembali ke file links.xml:
Pabrik DocumentBuilderFactory = DocumentBuilderFactory.newInstance();
Pembuat DocumentBuilder=pabrik.newDocumentBuilder();
Dokumen doc=builder.parse("links.xml");
doc.normalisasi();
//---Dapatkan variabel----
String text="Beranda Hanzhong";
String url=" www.hzliu.com ";
Penulis string="Hzliu Liu";
String Description="Sebuah situs dari Hanzhong Liu, memberi Anda banyak kejutan!!!";
Untuk melihat poin-poin penting dengan jelas dan menyederhanakan prosedur, kami melakukan hard-code pada konten yang akan ditambahkan ke dalam objek String memori operasi, kita sering menggunakan antarmuka untuk mengekstrak input pengguna, atau mengekstrak konten yang diinginkan dari database melalui JDBC.
Teks teksseg;
Elemen link=doc.createElement("link");
Apa pun tipe Nodenya, apakah itu tipe Teks, tipe Attr, atau tipe Elemen, semuanya dibuat melalui objek Dokumen CreateXXX( ) metode dalam (XXX mewakili tipe spesifik yang akan dibuat), oleh karena itu, kita perlu menambahkan item tautan ke dokumen XML, pertama-tama buat objek tautan:
Elemen linktext=doc.createElement("text") ;
textseg=doc.createTextNode(teks);
linktext.appendChild(textseg);
link.appendChild(teks tautan);
...
Proses pembuatan node mungkin sedikit seragam, namun yang perlu diperhatikan adalah teks yang terdapat dalam Elemen (di DOM, teks ini juga mewakili sebuah Node, jadi node yang sesuai juga harus dibuat untuknya). Langsung gunakan metode setNodeValue() dari objek Elemen untuk menyetel konten teks ini, dan Anda perlu menggunakan metode setNodeValue() dari objek Teks yang dibuat untuk menyetel teks, sehingga Elemen yang dibuat dan konten teksnya dapat ditambahkan ke pohon DOM. Lihatlah kode sebelumnya dan Anda akan memahaminya dengan lebih baik:
doc.getDocumentElement().appendChild(tautan);
Terakhir, jangan lupa menambahkan node yang dibuat ke pohon DOM. Metode getDocumentElement() kelas Dokumen mengembalikan objek Elemen yang mewakili simpul akar dokumen. Dalam dokumen XML, simpul akar harus unik.
TransformerFactory tFactory =TransformerFactory.newInstance();
Trafo trafo = tFactory.newTransformer();
Sumber DOMSource = DOMSource baru(doc);
Hasil StreamResult = StreamResult baru(Java.io.File baru("links.xml"));
transformator.transform(sumber, hasil);
Kemudian gunakan XSLT untuk menampilkan pohon DOM. TransformerFactory di sini juga menerapkan pola pabrik, menjadikan kode spesifik tidak tergantung pada trafo spesifik. Cara implementasinya sama dengan DocumentBuilderFactory, jadi saya tidak akan membahas detailnya di sini. Metode transfrom kelas Transformer menerima dua parameter, sumber data Sumber dan hasil target keluaran. DOMSource dan StreamResult digunakan di sini masing-masing, sehingga konten DOM dapat di-output ke aliran output. Ketika aliran output berupa file, konten DOM ditulis ke file.
Bagaimana cara menggunakan JSP untuk mengembangkan aplikasi SAX?
SAX adalah singkatan dari Simple API untuk XML. Ini bukan standar resmi yang diusulkan oleh W3C. Ini dapat dikatakan sebagai standar de facto "rakyat". Faktanya, ini adalah hasil diskusi komunitas. Meski begitu, SAX digunakan dalam XML tidak kalah dengan DOM, dan hampir semua parser XML mendukungnya.
Dibandingkan dengan DOM, SAX adalah metode yang ringan. Kita tahu bahwa saat memproses DOM, kita perlu membaca seluruh dokumen XML, kemudian membuat pohon DOM di memori dan menghasilkan setiap objek Node di pohon DOM. Jika dokumen berukuran kecil, hal ini tidak menimbulkan masalah, namun jika dokumen menjadi lebih besar, pemrosesan DOM menjadi cukup memakan waktu dan tenaga. Secara khusus, kebutuhan memorinya juga akan meningkat secara eksponensial, sehingga penggunaan DOM di beberapa aplikasi tidak hemat biaya (seperti di applet). Saat ini, solusi alternatif yang lebih baik adalah SAX.
SAX secara konseptual sangat berbeda dari DOM. Pertama-tama, tidak seperti driver dokumen DOM, driver ini digerakkan oleh peristiwa, artinya, tidak perlu membaca seluruh dokumen, dan proses membaca dokumen juga merupakan proses penguraian SAX. Yang disebut event-driven mengacu pada metode program yang berjalan berdasarkan mekanisme panggilan balik. (Jika Anda paham tentang model peristiwa proksi Java yang baru, Anda akan dengan mudah memahami mekanisme ini.) XMLReader menerima dokumen XML dan menguraikannya selama proses membaca dokumen XML, yaitu proses membaca dokumen. Proses parsing dilakukan dalam waktu yang bersamaan, hal ini sangat berbeda dengan DOM. Sebelum penguraian dimulai, Anda perlu mendaftarkan ContentHandler dengan XMLReader, yang setara dengan pendengar peristiwa. Banyak metode yang didefinisikan dalam ContentHandler, seperti startDocument(), yang mengkustomisasi apa yang harus ditangani ketika dokumen mulai ditemukan selama penguraian. proses. penting. Saat XMLReader membaca konten yang sesuai, XMLReader akan menampilkan peristiwa terkait, mendelegasikan kekuatan pemrosesan peristiwa ini ke ContentHandler, dan memanggil metode terkait untuk merespons.
Mungkin agak sulit untuk memahaminya secara umum, namun jangan khawatir, contoh berikut akan membantu Anda memahami proses parsing SAX. Lihatlah file XML sederhana ini:
Ketika XMLReader membaca tag
Menemukan panggilan balik metode proyek
{document start} startDocument()
"n" karakter("
Karakter "Ogden Nash"("
endElement(null,"AUTHOR",null)
"n" karakter("
"n" karakter("
Karakter "Adam"("
"n" karakter("
{End of document} endDocument()
ContentHandler sebenarnya adalah sebuah antarmuka. Saat memproses file XML tertentu, Anda perlu membuat kelas yang mengimplementasikan ContentHandler untuk menangani peristiwa tertentu. Dapat dikatakan bahwa ini sebenarnya adalah SAX yang memproses XML dokumen tersebut. Mari kita lihat beberapa metode yang didefinisikan di dalamnya:
void character(char[] ch, int start, int length): Metode ini digunakan untuk memproses string yang dibaca dalam file XML. Parameternya adalah array karakter dan titik awal dari string yang dibaca dalam array ini panjangnya, kita dapat dengan mudah menggunakan konstruktor kelas String untuk mendapatkan kelas String dari string ini: String charEncontered=new String(ch,start,length).
void startDocument(): Saat Anda menemukan bagian awal dokumen, panggil metode ini untuk melakukan beberapa pekerjaan prapemrosesan.
void endDocument(): Sesuai dengan metode di atas, ketika dokumen berakhir, metode ini dipanggil untuk melakukan beberapa pekerjaan setelahnya.
void startElement(String namespaceURI, String localName, String qName, Attributes atts): Metode ini akan dipicu ketika tag awal dibaca. Namespace tidak didukung dalam versi SAX1.0, namun dukungan untuk namespace disediakan dalam versi 2.0 yang baru. NamespaceURI dalam parameter di sini adalah namespace, localName adalah nama label, dan qName adalah awalan label If yang dimodifikasi tidak ada Saat menggunakan namespace, tidak ada parameter yang nol. Dan atts adalah daftar atribut yang terdapat dalam tag ini. Melalui atts, Anda bisa mendapatkan semua nama atribut dan nilai terkait. Perlu dicatat bahwa fitur penting SAX adalah pemrosesan streamingnya. Saat menemukan tag, ia tidak akan mencatat tag yang ditemukan sebelumnya. Dengan kata lain, dalam metode startElement(), semua informasi yang Anda ketahui hanyalah nama dan atribut Adapun struktur bersarang dari tag, nama tag atas, apakah terdapat atribut sub-elemen, dan informasi terkait struktur lainnya, tidak diketahui dan memerlukan bantuan program Anda untuk menyelesaikannya. Hal ini membuat SAX kurang nyaman untuk pemrograman dibandingkan DOM.
void endElement(String namespaceURI, String localName, String qName): Metode ini sesuai dengan metode di atas.
Kita masih menggunakan contoh dokumen yang kita gunakan saat membicarakan DOM, tapi pertama-tama, mari kita lihat aplikasi yang lebih sederhana. Kita berharap dapat menghitung berapa kali setiap tag muncul dalam file XML. Contoh ini sangat sederhana, namun cukup untuk menggambarkan ide dasar pemrograman SAX. Tentu saja, pernyataan import masih digunakan di awal:
import org.xml.sax.helpers.DefaultHandler;
import Javax.xml.parsers.*;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import Java.util.*;
import Java.io.*;
Kemudian, kita membuat kelas yang mewarisi dari DefaultHandler. Logika program spesifik dapat dikesampingkan untuk sementara waktu. Yang harus kita perhatikan adalah struktur program:
public class SAXCounter extends DefaultHandler {
private Hashtable tag; // Hashtable ini digunakan untuk mencatat berapa kali tag muncul
//Bekerja sebelum memproses dokumen
public void startDocument() melempar SAXException {
tag = new Hashtable();//Inisialisasi Hashtable
}
//Memproses setiap atribut elemen awal
public void startElement(String namespaceURI, String localName,
String rawName, Atribut atts)
melempar SAXException
{
Kunci string = Nama lokal;
...
Mari kita lihat apa yang dilakukan program ini. Dalam metode main(), hal utama yang Anda lakukan adalah membuat parser dan kemudian mengurai dokumen. Faktanya, saat membuat objek SAXParser di sini, untuk membuat kode program tidak bergantung pada parser tertentu, teknik desain yang sama seperti di DOM digunakan: buat objek SAXParser tertentu melalui kelas SAXParserFactory, sehingga ketika berbeda Saat parsing , yang perlu diubah hanyalah nilai variabel lingkungan, sedangkan kode program tidak boleh diubah. Ini adalah ide pola FactoryMethod. Disini saya tidak akan panjang lebar, jika masih belum paham bisa simak penjelasannya di DOM diatas.
Namun ada satu hal yang perlu diperhatikan disini, yaitu hubungan antara kelas SAXParser dan kelas XMLReader. Anda mungkin sedikit bingung. Faktanya, SAXParser adalah kelas pembungkus untuk XMLReader di JAXP, dan XMLReader adalah antarmuka yang ditentukan dalam SAX2.0 untuk mem-parsing dokumen. Anda juga dapat memanggil metode parser() di SAXParser atau XMLReader untuk mengurai dokumen, dan efeknya persis sama. Namun, metode parser() di SAXParser menerima lebih banyak parameter dan dapat mengurai sumber data dokumen XML yang berbeda, sehingga lebih nyaman digunakan daripada XMLReader.
Contoh ini hanya menyentuh permukaan SAX, namun contoh berikut ini lebih maju. Fungsi yang ingin kita terapkan di bawah ini sudah diimplementasikan pada contoh DOM, yaitu membaca konten dari dokumen XML dan memformat outputnya. Walaupun logika programnya masih terlihat sangat sederhana, SAX tidak lebih baik dari DOM saja.
Seperti disebutkan sebelumnya, ketika menemukan tag awal, dalam metode startElement(), kita tidak bisa mendapatkan posisi tag dalam dokumen XML. Ini merupakan masalah besar saat memproses dokumen XML, karena semantik tag dalam XML sebagian ditentukan oleh lokasinya. Dan dalam beberapa program yang perlu memverifikasi struktur dokumen, hal ini menjadi masalah yang lebih besar. Tentu saja, tidak ada masalah yang tidak dapat diselesaikan. Kita dapat menggunakan tumpukan untuk mencatat struktur dokumen.
Karakteristik tumpukan adalah masuk pertama, keluar pertama. Ide kami saat ini adalah menggunakan push untuk menambahkan nama label ke tumpukan dalam metode startElemnt(), dan memunculkannya dalam metode endElement(). Kita tahu bahwa untuk XML yang terstruktur dengan baik, struktur sarangnya sudah lengkap. Setiap tag awal selalu berhubungan dengan tag akhir, dan tidak akan ada ketidakselarasan antara sarang tag. Oleh karena itu, setiap panggilan ke metode startElement() pasti akan berhubungan dengan panggilan ke metode endElement(), jadi push dan pop juga muncul berpasangan. Kita hanya perlu menganalisis struktur tumpukan untuk mengetahui dengan mudah di mana label saat ini berada Posisi dalam struktur dokumen.
Saxreader kelas publik memperluas defaulthandler {
Java.util.stack tags = java.util.stack () baru;
...
Analisis tumpukan tidak digunakan di sini, analisis tumpukan sebenarnya adalah tugas yang sangat mudah diatur dari bawah ke atas. Atribut dari setiap elemen. Bahkan, jika kita mengatur elemen tumpukan satu per satu dari bawah ke atas, kita akan mendapatkan jalur unik dari node root XML ke node saat ini. .
Sejauh ini, kami telah menguasai dua alat utama untuk pemrograman XML: DOM dan SAX, dan juga tahu cara menggunakannya dalam program Java. Pemrograman DOM relatif sederhana, tetapi lambat dan memakan banyak memori, sementara pemrograman S AX lebih kompleks, tetapi cepat dan mengambil lebih sedikit memori. Oleh karena itu, kita harus memilih untuk menggunakan metode yang berbeda sesuai dengan lingkungan yang berbeda. Sebagian besar aplikasi XML pada dasarnya dapat diselesaikan menggunakannya. Perlu dicatat bahwa Dom dan Sax sebenarnya tidak tergantung pada bahasa dan tidak unik untuk Java.