Parser

Parser'lar bir XML document'inden bilgileri elde etmek için kullanılan programlar veya api'lerdir. İki tür parser vardır. DOM Parser'lar ve SAX Parser'lar.

Bir XML document'i element'lerin hiyerarşik bir şekilde sıralanmasında oluşur. Bir element'in içinde başka element'ler, yazılar olabilir. Bu bilginin tamamı DOM Parser'lar ile hafızaya taşınır. XML document'inin bir eşi hafızada oluşturulur. DOM Parser'ları XML document'ini element'leri, attributeler'i, yazıları vs.. okur ve hafızada DOM nesnesi oluşturur. Bu nesneye erişmek içinde DOM standartı kullanılır. DOM nesnesi ile bir element'in adına, değerine ,attribute'lerine erişilebilir.

SAX Parser'ları ise olay temellidir. XML document'ini baştan sona tararlar ve bu işlem yapılırken her değişiklikte sizin bir methodunuzu çağırırlar. Document başladı, element başladı, element bitti, karakterler okundu gibi. Eğer XML document'in bir bilgi elde etmek istiyorsanız SAX parser kullanılır. Örneğin id attribute'si 12 olan person element'in tel attributesi'nin değeri alınmak istenebilir. Sadece bu bilgiyi elde etmek için tüm XML document'ini hafızaya yüklemeye gerek yoktur. SAX Parser person element'ine rastlandığında sana haber verir ve person element'inin attribute'lerini sana gönderir. Sen de bu gönderdiklerine göre aradığın person element'inin bu olup olmadığını (id'si 12 olmalı) anlarsın. Eğer değilse SAX Parser diğer element'lerden devam edecektir.

SAX Parser Örneği

Xalan API'si SAX Parser api'lerini içinde barındırır. Aşağıdaki örnekte xalan API'sini kullanıyoruz.

Bu örneğimizde text.xml dosyasının element'lerini ,attribute'lerini ve onların değerlerini ekrana bastırıyoruz. XML dosyası şu şekildedir:

  1 <?xml version="1.0" encoding="ISO-8859-9">
  2 <test>
  3 	<person id="12">
  4 		<name>Ali</name>
  5 		<tel id="home">02129456789</tel>
  6 	</person>
  7 	<person id="asd">
  8 		<name>Veli</name>
  9 		<tel id="home">02124365</tel>
 10 	</person>
 11 	<person id="fasf">
 12 		<name>Yusuf</name>
 13 		<tel id="home">1212162840</tel>
 14 	</person>
 15 </test>

Bu dosyanın içeriğini ekrana basan java programı:

  1 import java.io.*;
  2 import java.net.*;
  3 import javax.xml.parsers.*;
  4 import org.xml.sax.*;
  5 import org.xml.sax.helpers.*;
  6 public class SAXTest{
  7   private String theFile;
  8   public SAXTest(String file){
  9     theFile=file;
 10   }
 11   public void print(){
 12     DefaultHandler handler=new DefaultHandler(){
 13       public void startElement(String uri,String lname,String qname,Attributes attributes){
 14         System.out.println("element name: "+qname);
 15         for(int i=0;i<attributes.getLength();i++){
 16           String name=attributes.getQName(i);
 17           String value=attributes.getValue(i);
 18           System.out.println(" attribute name= "+name+" value= "+value);
 19         }
 20       }
 21       public void characters(char[] ch, int start, int finish){
 22         String s=new String(ch,start,finish);
 23         System.out.println("element value: "+s);
 24       }
 25     };
 26     try{
 27       SAXParser parser=getParser();
 28       parser.parse(theFile,handler);
 29     }catch(Exception e){e.printStackTrace();}
 30   }
 31   public SAXParser getParser() throws Exception{
 32     SAXParserFactory factory=SAXParserFactory.newInstance();
 33     return factory.newSAXParser();
 34   }
 35   static public void main(String[] args) {
 36     String file="test.xml";
 37     SAXTest test=new SAXTest(file);
 38     test.print();
 39   }
 40 }

Önce bir SAXParser nesnesini veren bir fonksiyon yarattık.

public SAXParser getParser() throws Exception{
	SAXParserFactory factory=SAXParserFactory.newInstance();
  return factory.newSAXParser();
}

Bir XML Document'ini parse etmek için bir Handler vermemiz gereklidir. Bu handler nesnesi document'le ile ilgili tüm olaylarda çağrılacaktır. Biz startElement ve characters method'larını dolduruyoruz. startElement bir element'te rastalndığında , characters method'u ise text'ler rastlandığında çağrılacaktır. Biz handler'i şu şekilde yarrattık

DefaultHandler handler=new DefaultHandler(){
	public void startElement(String uri,String lname,String qname,Attributes attributes){
		//element'e rastlandı
	}
	public void characters(char[] ch, int start, int finish){
		//karaktere rastlandı
	}
};

daha sonra parse etme işlemini yapıyoruz.

SAXParser parser=getParser();
parser.parse(theFile,handler);

getParser method'u bize SAXParser'ı vermektedir. Tüm bu işlemler print methodunun içinde yapılmıştır. print methodu çağrıldığında verilen XML'deki element'ler ve element'leri değerleri basılacaktır.

startEement methodu'na element'in attribute'leri gönderilir. Biz bir döngü açıp tüm attribute'leri bastırıyoruz. characters methodunda ise bize char[] dizisi, ilk index ve son index verilir. Bizde element'in değerini

String s=new String(ch,start,finish);

ile s string'ine çeviririz.

DOM Parser Örneği

Yukarıdakinin bir benzerini bu sefer DOM PArser kullanarak yapalım. Burada Tüm XML document'i Document class'ın bir nesnesine dönüştürülmelidir. document nesnesi oluşturulduktan sonra XML dosyası ile ilgili tüm bilgiler alınabilir.

  1 import org.w3c.dom.*;
  2 import javax.xml.parsers.*;
  3 import java.io.*;
  4 public class DOMTest {
  5   public void print(String file) throws Exception{
  6     Document doc=getDocument(file);
  7     Element root=doc.getDocumentElement();
  8     printNode(root);
  9   }
 10   public void printNode(Node node){
 11     System.out.println("name: "+node.getNodeName()+" value: "+node.getNodeValue());
 12     printAttribute(node);
 13     NodeList list=node.getChildNodes();
 14     for(int i=0;i<list.getLength();i++){
 15       Node aNode=list.item(i);
 16       printNode(aNode);
 17     }
 18   }
 19   public void printAttribute(Node node){
 20     NamedNodeMap map=node.getAttributes();
 21     if(map!=null){
 22       for(int i=0;i<map.getLength();i++){
 23         Node aNode=map.item(i);
 24         String name=aNode.getNodeName();
 25         String value=aNode.getNodeValue();
 26         System.out.println("Attribute: "+name+" : "+value);
 27       }
 28     }
 29   }
 30   public DocumentBuilder getBuilder() throws Exception{
 31     DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
 32     return factory.newDocumentBuilder();
 33   }
 34   public Document getDocument(String file) throws Exception{
 35     DocumentBuilder builder=getBuilder();
 36     return builder.parse(new File(file));
 37   }
 38   static public void main(String[] args) {
 39     try{
 40       DOMTest test=new DOMTest();
 41       test.print("test.xml");
 42     }catch(Exception e){e.printStackTrace();}
 43   }
 44 }

Önce DocumentBuilder nesnesini yaratmamız gerekir. Ardından Document nesnesini oluşturmak için DocumentBuilder nesnesinin parse methodu kullanılır.

public DocumentBuilder getBuilder() throws Exception{
  DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
  return factory.newDocumentBuilder();
}
public Document getDocument(String file) throws Exception{
  DocumentBuilder builder=getBuilder();
  return builder.parse(new File(file));
}

getBuilde method'u bize DocumentBuilder verir. getDocument methodu ise verilen bir file için Document nesnesini bize döndürür.

Artık Document nesnesini elde ettiğimize göre tüm bilgiyi basabiliriz. Önce

Element root=doc.getDocumentElement();

ile root element'i alınır. printNode bir Node'u ekrana basmak içindir. Node'un önce attribue'leri print edilir. Sonra tüm çocuklar elde edilir ve hepsi print edilir. printNode method'u recursive bir şekilde tüm node'lar bitene kadar devam edecektir.

Dosya Listesi