java에서 XML 문서를 생성하고 해석하는 네 가지 방법 설명 (소개 + 장단점 비교 + 예시)

모두가 알다시피 현재 XML을 해석하는 방법은 점점 많아지고 있지만, 주류적인 방법도 네 가지가 있다. 즉, DOM, SAX, JDOM과 DOM4J
다음은 우선 이 네 가지 방법의jar 패키지 다운로드 주소를 제시합니다.
DOM: 지금 Java JDK에서 다 가지고 있어요. xml-apis에서.가방 안
SAX: http://sourceforge.net/projects/sax/
JDOM: http://jdom.org/downloads/index.html
DOM4J: http://sourceforge.net/projects/dom4j/
1. 소개 및 장단점 분석
1. DOM(Document Object Model)
DOM은 XML 문서의 공식 W3C 표준을 플랫폼 및 언어와 무관한 방식으로 나타냅니다.DOM은 계층 구조로 구성된 노드 또는 정보 단편의 집합입니다.이 차원 구조는 개발자가 트리에서 특정한 정보를 찾을 수 있도록 한다.이 구조를 분석하려면 일반적으로 전체 문서를 불러오고 차원 구조를 구성한 후에야 모든 작업을 할 수 있다.정보 계층을 기반으로 하기 때문에 DOM은 트리 또는 객체 기반으로 간주됩니다.
[장점]
① 애플리케이션이 데이터와 구조를 변경할 수 있도록 합니다.
② 접근은 양방향이며 트리에서 위아래로 탐색하여 임의의 부분의 데이터를 얻고 조작할 수 있다.
[단점]
① 일반적으로 전체 XML 문서를 로드하여 계층 구조를 구성하고 리소스를 많이 소모합니다. 
2. SAX(Simple API for XML)
SAX 처리의 장점은 스트리밍의 장점과 매우 유사하다.분석은 모든 데이터가 처리되기를 기다리는 것이 아니라 바로 시작할 수 있다.그리고 응용 프로그램은 데이터를 읽을 때만 데이터를 검사하기 때문에 메모리에 데이터를 저장할 필요가 없다.이것은 대형 문서에 있어서 커다란 장점이다.사실상 응용 프로그램은 전체 문서를 해석할 필요가 없다.그것은 어떤 조건이 충족될 때 해석을 멈출 수 있다.일반적으로 SAX는 대체자 DOM보다 훨씬 빠릅니다.
DOM 을 선택하시겠습니까? SAX 를 선택하시겠습니까?XML 문서를 처리하기 위해 스스로 코드를 작성해야 하는 개발자에게 DOM인지 SAX 해석 모델을 선택하는 것은 매우 중요한 설계 결정이다.DOM은 트리 구조를 만드는 방식으로 XML 문서에 액세스하고 SAX는 이벤트 모델을 사용합니다.
DOM 해석기는 XML 문서를 내용을 포함하는 트리로 바꾸어 트리를 훑어볼 수 있습니다.DOM 해석 모델의 장점은 프로그래밍이 쉽다는 것이다. 개발자는 트리를 만드는 명령을 호출한 다음navigation API를 이용하여 필요한 트리 노드에 접근하여 임무를 완성할 수 있다.트리의 요소를 쉽게 추가하고 수정할 수 있습니다.그러나 DOM 해석기를 사용할 때 전체 XML 문서를 처리해야 하기 때문에 성능과 메모리에 대한 요구가 비교적 높다. 특히 큰 XML 파일을 만났을 때.DOM 해상도는 XML 문서가 자주 바뀌어야 하는 서비스에 자주 사용됩니다.
SAX 해상도는 이벤트 기반 모델을 사용합니다. XML 문서를 해석할 때 일련의 이벤트를 촉발할 수 있으며, 주어진 tag를 발견할 때 리셋 방법을 활성화하여 이 방법이 만든 탭을 찾았다는 것을 알려 줍니다.SAX는 일반적으로 메모리에 대한 요구가 비교적 낮을 것이다. 왜냐하면 개발자가 처리할 태그를 스스로 결정하기 때문이다.특히 개발자가 문서에 포함된 일부 데이터만 처리할 수 있을 때 SAX의 이러한 확장 능력은 더욱 잘 나타난다.그러나 SAX 해상도를 사용할 때 인코딩 작업이 어렵고 같은 문서의 여러 데이터를 동시에 접근하기 어렵다.
[강점]
① 모든 데이터가 처리될 때까지 기다릴 필요 없이 분석은 바로 시작됩니다.
② 데이터를 읽을 때만 데이터를 확인하므로 메모리에 저장할 필요가 없습니다.
③ 전체 문서를 분석할 필요 없이 조건이 충족될 때 해석을 중지할 수 있습니다.
④ 시스템 메모리보다 큰 문서를 분석할 수 있는 효율성과 성능이 높습니다.
[단점]
① 응용 프로그램이 TAG의 처리 논리(예를 들어 부/자 관계 유지 등)를 스스로 책임져야 하기 때문에 문서가 복잡할수록 프로그램은 복잡해진다.
② XPath가 지원되지 않는 한 단방향 탐색으로 문서 계층을 지정할 수 없으며 동일한 문서의 다른 섹션 데이터에 동시에 액세스하기 어렵습니다.
 3. JDOM(Java-based Document Object Model)
JDOM의 목적은 XML과의 상호작용을 간소화하고 DOM을 사용하는 것보다 빠른 Java 특정 문서 모델이 되는 것이다.첫 번째 Java 특정 모델이기 때문에 JDOM은 줄곧 대대적으로 보급되고 추진되었다.Java Specification Request JSR-102를 통해 Java Standard Extension으로 최종 사용하는 것을 고려하고 있습니다.2000년 초부터 JDOM 개발을 시작했습니다.
JDOM과 DOM은 크게 다릅니다.우선 JDOM은 인터페이스를 사용하지 않고 특정 클래스만 사용합니다.이것은 어떤 면에서는 API를 간소화하지만 유연성도 제한한다.둘째, API는 Collections 클래스를 대량으로 사용하여 이미 이런 클래스에 익숙한 자바 개발자들의 사용을 간소화시켰다.
JDOM 문서는 "자바/XML 문제를 80% 이상 해결하는 데 20% 이상의 노력을 기울인다"(학습 곡선에 따라 20%로 가정) 는 목적을 설명합니다.JDOM은 대부분의 Java/XML 응용 프로그램에 당연히 유용하며, 대부분의 개발자들은 API가 DOM보다 훨씬 이해하기 쉽다는 것을 발견한다.JDOM은 또한 사용자가 XML에서 무의미한 일을 하지 않도록 프로그램 행위에 대한 상당히 광범위한 검사를 포함한다.그러나 XML은 기본을 뛰어넘는 작업을 하기 위해 충분히 이해해야 합니다. (심지어 어떤 경우의 오류도 이해해야 합니다.)이것은 아마도 DOM이나 JDOM 인터페이스를 배우는 것보다 더 의미 있는 작업일 것이다.
JDOM 자체에는 해상도가 없습니다.일반적으로 SAX2 해상도를 사용하여 입력 XML 문서를 해석하고 검증합니다(이전에 구성된 DOM을 입력으로 표시할 수도 있지만).여기에는 JDOM 표현을 SAX2 이벤트 흐름, DOM 모델 또는 XML 텍스트 문서로 내보내기 위한 변환기가 포함되어 있습니다.JDOM은 Apache 라이센스 변형 아래에 게시된 오픈 소스 코드입니다.
[장점]
① 인터페이스 대신 특정 클래스를 사용하여 DOM의 API를 단순화합니다.
② Java 컬렉션 클래스를 대량으로 사용하여 Java 개발자를 편리하게 합니다.
[단점]
① 좋은 융통성이 없다.
② 성능이 떨어진다.
4. DOM4J(Document Object Model for Java)
DOM4J는 완전히 독립된 개발 결과를 대표하지만, 처음에는 JDOM의 스마트 지점이었다.이것은 통합된 XPath 지원, XML Schema 지원, 큰 문서나 유동화된 문서에 대한 이벤트 기반 처리를 포함한 기본 XML 문서 표현을 뛰어넘는 많은 기능을 통합시켰다.또한 DOM4J API와 표준 DOM 인터페이스를 통해 병렬 액세스 기능을 제공하는 문서 표현 구축 옵션도 제공합니다.2000 하반기부터 그것은 줄곧 개발 중이다.
이러한 모든 기능을 지원하기 위해 DOM4J는 인터페이스와 추상적인 기본 클래스를 사용합니다.DOM4J는 API의 Collections 클래스를 대량으로 사용하지만, 많은 경우에 더 좋은 성능이나 직접적인 인코딩 방법을 허용하는 대체 방법을 제공한다.직접적인 장점은 DOM4J가 더 복잡한 API의 대가를 치렀지만 JDOM보다 훨씬 큰 유연성을 제공했다는 것이다.
유연성, XPath 통합 및 대용량 문서 처리 목표를 추가할 때 DOM4J의 목표는 JDOM과 같습니다. Java 개발자를 위한 용이성과 직관적인 조작입니다.또한 JDOM보다 더 완전한 해결 방안이 되어 본질적으로 모든 Java/XML 문제를 처리하는 목표를 실현하는 데 주력한다.이 목표를 달성할 때 JDOM보다 부정확한 응용 프로그램의 행위를 방지하는 것을 강조합니다.
DOM4J는 매우 우수한 Java XML API로 성능이 우수하고 기능이 강하며 사용하기 쉬운 특징을 가지며 오픈 소스 코드의 소프트웨어이기도 하다.이제 점점 더 많은 자바 소프트웨어들이 DOM4J를 사용하여 XML을 읽고 쓰는 것을 볼 수 있다. 특히 태양의 JAXM마저도 DOM4J를 사용하고 있다.
[장점]
① 자바 집합 클래스를 대량으로 사용하여 자바 개발자를 편리하게 하고 성능을 향상시키는 대체 방법을 제공한다.  
② XPath를 지원합니다.
③ 성능이 좋습니다.
[단점]
① 인터페이스가 많이 사용되어 API가 복잡합니다.
비교
1. DOM4J의 성능이 가장 좋고 Sun의 JAXM까지 DOM4J를 사용하고 있다.현재 많은 개원 프로젝트에서 DOM4J를 대량으로 사용하고 있는데, 예를 들어 유명한 Hibernate도 DOM4J로 XML 프로필을 읽는다.이식성을 고려하지 않으면 DOM4J를 사용합니다.
 2. JDOM과 DOM은 성능 테스트에서 좋지 않으며 10M 문서를 테스트할 때 메모리가 넘치지만 이식할 수 있습니다.작은 문서에서도 DOM과 JDOM을 사용할 필요가 있습니다.JDOM 개발자들은 정식 버전이 나오기 전에 성능 문제에 집중하기를 기대한다고 설명했지만 성능 관점에서 볼 때 추천할 만한 점이 없다.또한 DOM은 여전히 매우 좋은 선택입니다.DOM은 다양한 프로그래밍 언어에 광범위하게 적용됩니다.이것은 여전히 XML과 관련된 많은 다른 표준의 기초이다. 왜냐하면 이것은 정식으로 W3C의 추천을 받기 때문에 (예를 들어 비표준적인 Java 모델을 바탕으로 하는 것과) 일부 유형의 항목에서도 그것을 필요로 할 수 있다. (예를 들어 JavaScript에서 DOM을 사용하는 것)
3. SAX는 특정한 해석 방식인 이벤트 구동에 의존하는 것이 좋습니다.SAX가 다가오는 XML 흐름을 감지하지만 메모리에 불러오지 않았습니다. (물론 XML 흐름이 읽히면 일부 문서가 메모리에 잠시 숨겨져 있습니다.)
내 견해: 만약 XML 문서가 비교적 크고 이식성 문제를 고려하지 않는다면 DOM4J를 사용하는 것을 권장한다.XML 문서가 작으면 JDOM을 사용하는 것이 좋습니다.데이터를 저장하지 않고 신속하게 처리해야 하는 경우 SAX를 고려합니다.그러나 어쨌든 그 말: 자신에게 맞는 것이 가장 좋다. 시간이 허락된다면 이 네 가지 방법을 모두 한 번 시도해 보고 자신에게 맞는 것을 선택하면 된다.
예제
편폭을 절약하기 위해 이 네 가지 XML 문서를 만드는 방법과 차이점은 당분간 제시하지 않고 XML 문서를 해석하는 코드만 제시합니다. 완전한 프로젝트가 필요하다면 (XML 문서 구축 + XML 분석 + 테스트 비교)
다음은 XML 컨텐트의 예입니다.

<?xml version="1.0" encoding="UTF-8"?>
<users>
  <user id="0">
    <name>Alexia</name>
    <age>23</age>
    <sex>Female</sex>
  </user>
  <user id="1">
    <name>Edward</name>
    <age>24</age>
    <sex>Male</sex>
  </user>
  <user id="2">
    <name>wjm</name>
    <age>23</age>
    <sex>Female</sex>
  </user>
  <user id="3">
    <name>wh</name>
    <age>24</age>
    <sex>Male</sex>
  </user>
</users>

먼저 XML 문서 확인을 위한 인터페이스를 정의합니다.

/**
 * @author Alexia
 *
 *  XML 
 */
public interface XmlDocument {
  
  /**
   *  XML 
   * 
   * @param fileName
   *       
   */
  public void parserXml(String fileName);
}

1. DOM 예

package com.xml;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

/**
 * @author Alexia
 * 
 * DOM  XML 
 */
public class DomDemo implements XmlDocument {
  private Document document;

  public void parserXml(String fileName) {
    try {
      DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
      DocumentBuilder db = dbf.newDocumentBuilder();
      Document document = db.parse(fileName);
      NodeList users = document.getChildNodes();
      
      for (int i = 0; i < users.getLength(); i++) {
        Node user = users.item(i);
        NodeList userInfo = user.getChildNodes();
        
        for (int j = 0; j < userInfo.getLength(); j++) {
          Node node = userInfo.item(j);
          NodeList userMeta = node.getChildNodes();
          
          for (int k = 0; k < userMeta.getLength(); k++) {
            if(userMeta.item(k).getNodeName() != "#text")
              System.out.println(userMeta.item(k).getNodeName()
                  + ":" + userMeta.item(k).getTextContent());
          }
          
          System.out.println();
        }
      }
      
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (ParserConfigurationException e) {
      e.printStackTrace();
    } catch (SAXException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

2. SAX 예

package com.xml;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.StringWriter;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;
import org.xml.sax.helpers.DefaultHandler;

/**
 * @author Alexia
 * 
 * SAX  XML 
 */
public class SaxDemo implements XmlDocument {

  public void parserXml(String fileName) {
    SAXParserFactory saxfac = SAXParserFactory.newInstance();

    try {
      SAXParser saxparser = saxfac.newSAXParser();
      InputStream is = new FileInputStream(fileName);
      saxparser.parse(is, new MySAXHandler());
    } catch (ParserConfigurationException e) {
      e.printStackTrace();
    } catch (SAXException e) {
      e.printStackTrace();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

class MySAXHandler extends DefaultHandler {
  boolean hasAttribute = false;
  Attributes attributes = null;

  public void startDocument() throws SAXException {
    // System.out.println(" ");
  }

  public void endDocument() throws SAXException {
    // System.out.println(" ");
  }

  public void startElement(String uri, String localName, String qName,
      Attributes attributes) throws SAXException {
    if (qName.equals("users")) {
      return;
    }
    if (qName.equals("user")) {
      return;
    }
    if (attributes.getLength() > 0) {
      this.attributes = attributes;
      this.hasAttribute = true;
    }
  }

  public void endElement(String uri, String localName, String qName)
      throws SAXException {
    if (hasAttribute && (attributes != null)) {
      for (int i = 0; i < attributes.getLength(); i++) {
        System.out.print(attributes.getQName(0) + ":"
            + attributes.getValue(0));
      }
    }
  }

  public void characters(char[] ch, int start, int length)
      throws SAXException {
    System.out.print(new String(ch, start, length));
  }
}

3. JDOM 예

package com.xml;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.List;

import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.XMLOutputter;

/**
 * @author Alexia
 * 
 * JDOM  XML 
 * 
 */
public class JDomDemo implements XmlDocument {

  public void parserXml(String fileName) {
    SAXBuilder builder = new SAXBuilder();

    try {
      Document document = builder.build(fileName);
      Element users = document.getRootElement();
      List userList = users.getChildren("user");

      for (int i = 0; i < userList.size(); i++) {
        Element user = (Element) userList.get(i);
        List userInfo = user.getChildren();

        for (int j = 0; j < userInfo.size(); j++) {
          System.out.println(((Element) userInfo.get(j)).getName()
              + ":" + ((Element) userInfo.get(j)).getValue());

        }
        System.out.println();
      }
    } catch (JDOMException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }

  }
}

4. DOM4J 예

package com.xml;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Iterator;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

/**
 * @author Alexia
 * 
 * Dom4j  XML 
 */
public class Dom4jDemo implements XmlDocument {

  public void parserXml(String fileName) {
    File inputXml = new File(fileName);
    SAXReader saxReader = new SAXReader();

    try {
      Document document = saxReader.read(inputXml);
      Element users = document.getRootElement();
      for (Iterator i = users.elementIterator(); i.hasNext();) {
        Element user = (Element) i.next();
        for (Iterator j = user.elementIterator(); j.hasNext();) {
          Element node = (Element) j.next();
          System.out.println(node.getName() + ":" + node.getText());
        }
        System.out.println();
      }
    } catch (DocumentException e) {
      System.out.println(e.getMessage());
    }
  }

}

이상은 본문의 전체 내용입니다. 여러분의 학습에 도움이 되고 저희를 많이 응원해 주십시오.