Tanım: Bir XML belgesindeki bilgiyi okuyarak , programlama dilleri tarafından kullanılabilmesini, erişilebilmesini sağlayan her türlü yazılım veya API'si

Tanım: Bir XML belgesindeki bilgiyi okuyan, doğrulayan ve başka tiplere çevrilmesini sağlayan her türlü yazılım veya API

Java'da temel olarak iki parser türü vardır :

• DOM Parser (XML'li DOM nesnesine yükler ve bu nesne üzerinden bilgilere erişilir)
• SAX Parser (XML'i baştan sona kadar tarar ve her yeni nesneye rastlandığında (element, attribute ve text vb..) olay bildirimi gerçekleştirir)
   

Tanım: Bir XML belgesini olay temelli (event) olarak okuyan parser türü. Tüm belge baştan sona taranır ve her yeni nesneye rastlandığında (element, attribute ve text vb..) olay bildirimi gerçekleşir ve tarama kaldığı yerden devam eder

Tanım: Bir XML'i DOM (Document Object Model : bir XML veya HTML belgesinin, programlama dillerinden ve platformdan bağımsız olarak erişilebilmesi için kullanılan , elementlerin ağaç şeklinde oluşturulduğu nesne yapısı) nesnesine yükleyen ve DOM nesnesi üzerinden erişim sağlayan parser türü

XML belgesi aşağıdaki gibidir :

<!--?xml version="1.0" encoding="ISO-8859-9"-->
<test>
	<person id="12">
		<name>Ali</name>
		<tel id="home">02129456789</tel>
	</person>
	<person id="asd">
		<name>Veli</name>
		<tel id="home">02124365</tel>
	</person>
	<person id="fasf">
		<name>Yusuf</name>
		<tel id="home">1212162840</tel>
	</person>
</test>

Bu dosyanın tüm içeriğini ekrana basan örnek aşağıdaki gibidir :

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.helpers.DefaultHandler;
public class SAXTest {
	private String theFile;
	public SAXTest(String file) {
		theFile = file;
	}
	public void print() {
		DefaultHandler handler = new DefaultHandler() {
			@Override
			public void startElement(String uri, String lname, String qname, Attributes attributes) {
				System.out.println("element name: " + qname);
				for (int i = 0; i < attributes.getLength(); i++) {
					String name = attributes.getQName(i);
					String value = attributes.getValue(i);
					System.out.println(" attribute name= " + name + " value= " + value);
				}
			}
			@Override
			public void characters(char[] ch, int start, int finish) {
				String s = new String(ch, start, finish);
				System.out.println("element value: " + s);
			}
		};
		try {
			SAXParser parser = getParser();
			parser.parse(theFile, handler);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	public SAXParser getParser() throws Exception {
		SAXParserFactory factory = SAXParserFactory.newInstance();
		return factory.newSAXParser();
	}
	static public void main(String[] args) {
		String file = "test.xml";
		SAXTest test = new SAXTest(file);
		test.print();
	}
}

Ö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

XML belgesi aşağıdaki gibidir :

<?xml version="1.0" encoding="ISO-8859-9">
<test>
	<person id="12">
		<name>Ali</name>
		<tel id="home">02129456789</tel>
	</person>
	<person id="asd">
		<name>Veli</name>
		<tel id="home">02124365</tel>
	</person>
	<person id="fasf">
		<name>Yusuf</name>
		<tel id="home">1212162840</tel>
	</person>
</test>

DOM Parser kodu aşağıdaki gibidir :

import org.w3c.dom.*;
import javax.xml.parsers.*;
import org.w3c.dom.NodeList;
import java.io.*;
public class DOMTest {
	public void print(String file) throws Exception {
		Document doc = getDocument(file);
		Element root = doc.getDocumentElement();
		printNode(root);
	}
	public void printNode(Node node) {
		System.out.println("name: " + node.getNodeName() + " value: " + node.getNodeValue());
		printAttribute(node);
		NodeList list = node.getChildNodes();
		for (int i = 0; i < list.getLength(); i++) {
			aNode = list.item(i);
			printNode(aNode);
		}
	}
	public void printAttribute(Node node){
		NamedNodeMap map=node.getAttributes();
		if(map!=null){
		for(int i=0;iNode aNode=map.item(i);
		String name=aNode.getNodeName();
		String value=aNode.getNodeValue();
		System.out.println("Attribute: "+name+" : "+value);
	}
	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));
	}
	static public void main(String[] args) {
		try {
			DOMTest test = new DOMTest();
			test.print("test.xml");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

Ö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.

Aşağıda DocumentBuilder ile Java'da bir XML String'ten Document nesnesi oluşturulmaktadır :

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); 
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse( new InputSource(new StringReader(xmlString))) ;

xmlString ile belirtilen XML şeklindeki bir String'tir

Bir XML dökümanının hiyerarşik yapısını biçimlendirip output'a veya bir dosyaya yazabilirsiniz. Bunun için TransformerFactory sınıfında OutputProperty değerleri kullanılır. Aşağıda bu işi yapan basit bir örnek görülmektedir :

public class XmlOutputPropertyTest {
	public static void main(String[] args) 
			throws UnsupportedEncodingException, 
			TransformerFactoryConfigurationError, TransformerException {
		
	String xml="<test><message id=\"123\"><b>World</b></message><detail>Detay bilgisi burada</detail></test>";
		
        Transformer transformer = TransformerFactory.newInstance().newTransformer();
        
        transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes"); // xml declarasyonu istemiyoruz
        
        transformer.setOutputProperty(OutputKeys.INDENT, "yes");
        
        transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
        
        transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
        
        StringReader reader=new StringReader(xml);
        StreamSource source =new StreamSource(reader);
        
        StreamResult result= new StreamResult(new OutputStreamWriter(System.out, "UTF-8"));
        
        transformer.transform(source  , result);
		
	}
}

Bu uygulama çalıştığında standart output (çıktı) ekranında XML biçimli bir şekilde gözükecektir :

<test>
  <message id="123">
    <b>World</b>
  </message>
  <detail>Detay bilgisi burada</detail>
</test>

XML'i biçimlenmesi aşağıdaki kod bölümü sağlamaktadır :

transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes"); // xml declarasyonu istemiyoruz
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");

Eğer bu satırları yorum haline getirip tekrar çalıştırırsak çıktı aşağıdaki gibi olacaktır :

<?xml version="1.0" encoding="UTF-8"?>
<test>
<message id="123"><b>World</b></message>
<detail>Detay bilgisi burada</detail>
</test>

Bu örnekte bir XML'den Java nesnesini yüklüyoruz. Bunun için Java Architecture for XML Binding (JAXB) kütüphanesini kullanıyoruz. XML'imiz aşağıdaki gibi olsun :

<commands>
	<command key="EN">
		 <p name="Go" required="true" type="integer"/>
		 <p name="Come" required="true" type="string"/>
	</command>	
	<command key="TR">
		 <p name="Gel" required="true" type="string"/>
		 <p name="Git" required="true" type="float"/>
	</command>	
</commands>

Görüldüğü gibi commands kök (root) elementidir. İçerisinde iki tane komut vardır. Komutlarında parametreleri vardır ve p etiketi ile verilmiştir. Java sınıfları aşağıdaki gibidir. Paramtre sınıfı :

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;

import org.apache.commons.lang3.builder.ToStringBuilder;

@XmlAccessorType(XmlAccessType.PROPERTY)
public class Parameter {
	
	private String name;
	private String type;
	private boolean required;
	
	public Parameter() {}
	public Parameter(String name, String type, boolean required) {
		super();
		this.name = name;
		this.type = type;
		this.required = required;
	}
	

	@XmlAttribute  
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@XmlAttribute  
	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

	@XmlAttribute(name = "required")
	public boolean isRequired() {
		return required;
	}
	
	public void setRequired(boolean required) {
		this.required = required;
	}
	
	@Override
	public String toString() {		
		return ToStringBuilder.reflectionToString(this);						
	}
}

Komut için sınıf :

import java.util.List;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;

import org.apache.commons.lang3.builder.ToStringBuilder;

@XmlAccessorType(XmlAccessType.PROPERTY)
public class Command {

	private String key;
	private List<Parameter> parameters;
	
	public Command() {
	}
	
	public Command(String key, List<Parameter> parameters) {
		super();
		this.key = key;
		this.parameters = parameters;
	}

	@XmlAttribute
	public String getKey() {
		return key;
	}

	public void setKey(String key) {
		this.key = key;
	}

	@XmlElement(name = "p")
	public List<Parameter>  getParameters() {		
		return parameters;		
	}
	
	public void setParameters(List<Parameter> parameters) {
		this.parameters = parameters;
	}
	
	@Override
	public String toString() {		
		return ToStringBuilder.reflectionToString(this);						
	}
}

En son da ana sınıfı tanımlayalım :

import java.io.File;
import java.util.Collections;
import java.util.List;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

import org.apache.commons.lang3.builder.ToStringBuilder;

@XmlRootElement (name = "commands")
@XmlAccessorType(XmlAccessType.PROPERTY)
public class Commands {

	private List<Command> commands;
	
	public Commands() {
	}
	 
	public Commands(List<Command> commands) {
		super();
		this.commands = commands;
	}
	
       @XmlElement(name = "command")
	public List<Command> getCommands() {
		return commands;
	}

	public void setCommands(List<Command> commands) {
		this.commands = commands;
	}

	@Override
	public String toString() {
		return ToStringBuilder.reflectionToString(this);						
	}	
}

Bu sınıflar yaratıldığı için artık XML'den sınıfı yüklüyebiliriz :

public static void main(String[] args) 
		throws JAXBException {
	
	JAXBContext jaxbContext = JAXBContext.newInstance(Commands.class);  
	
	Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();  
		
	Commands commands= (Commands) jaxbUnmarshaller.unmarshal(
			new File("D:\\commands.xml"));  
	
	System.out.println(commands);
}

Burada bir klasör içindeki XML yüklenmektedir. Commands'ı ekrana bastırdığınızda XML'den bilgilerin yüklendiğini ekranda göreceksiniz.