반응형
출처: http://kr.blog.yahoo.com/kwon37xi/folder/3381246.html

Java와 XML 데이터 바인딩이란 XML 파일을 자바 객체로 바꾸는 것이다.(DOM 객체로 만든다는 의미가 아니다)


예를들어 다음과 같은 XML이 있을 때
<AddressBook>
   <Person>
      <Name>홍길동</Name>
      <Address>서울</Address>
      <Phone>02-123-4567</Phone>
   </Person>
</AddressBook>
  • 위와 같은 상황에서 AddressBook, Person, Name, Address, Phone이라는 클래스를 생성해주고
  • XML 데이터를 입력하면 최상위 요소인 AddressBook의 객체가 생성되는 것이다.
  • AddressBook의 객체를 ab라고 할 때 ab.getPerson()하면 Person의 객체를 얻게 된다.
  • Person객체를 person이라 할 때 person.getName()Name객체를 리턴하거나 혹은 직접적으로 문자열 "홍길동"을 리턴하는 식이다.

클래스 생성

클래서 생성은 XML의 제약 집합(DTD, XML Schemas)로부터 자바 클래스를(가능하다면 인터페이스를) 생성하는 과정이다. XML 제약집합을 자바 클래스 정의와 동일하게 간주하면 된다.

언마샬링(Unmarshalling)

언마샬링은 XML 문서를 자바 클래스의 인스턴스로 변환하는 것을 의미한다.

단순히 XML 문서를 얻고 그 문서를 데이터 바인딩 프레임워크가 제공하는 도구나 클래스 인스턴스에 전달한 후, XML문서에 해당하는 자바 객체를 구하면 된다. 이때 생성된 자바 객체는 일반적으로 문서를 나타내는 최상의 부모 클래스의 인스턴스이다.

마샬링(Marshalling)

마샬링은 자바 객체와 이 객체에 종속적인 객체를 XML 형태로 변환하는 과정이다.

Castor

  • http://castor.exolab.org
  • 오픈 소스 XML 데이타 바인딩 프레임워크
  • Xerces 와 castor-버전-xml.jar 가 필요하다.

바잉딩 클래스 생성하기

  • XML Schemas 를 작성한다.
  • 다음을 실행하면 스키마에 따라 -package에 지정된 패키지로 클래스들이 생성된다.

    java org.exolab.castor.builder.SourceGenerator -i catalog.xsd -package javaxml2.castor
    

Unmarshall

File catalogFile = new File("catalog.xml");
InputSource is = new InputSource(new FileInputStream(catalogFile));

// Root 요소 클래스와 InputSource를 인자로 넘겨서 Unmarshalling을 수행한다.
Catalog catalog = (Catalog)Unmarshaller.unmarshal(Catalog.class, is);
  • InputSource 대신 Reader를 사용해도 되지만 문자 인코딩 문제가 발생할 수 있으므로 InputSource가 나은 것 같다.

Marshalling


// 변경된 카탈로그를 다시 파일에 저장한다.
FileWriter writer = new FileWriter(catalogFile);

Marshaller marshal = new Marshaller(writer);
marshal.setEncoding("euc-kr");
marshal.marshal(catalog);
  • 저기서 XML의 문자 인코딩을 지정했는데, 이것은 Writer의 인코딩과 일치해야 한다. 여기서는 운영체제 문자 인코딩이 EUC-KR 이다.
  • 다음 과 같이 Marshaller의 객체를 생성하지 않고 static 메소드로 해도 된다. 하지만 이럴 경우 운영체제의 문자 인코딩이 UTF-8이 아니라면 문자 인코딩 문제가 발생할 수 있다. 이 경우에 Writer의 인코딩을 UTF-8로 맞춰야 한다.

    Marshaller.marshal(catalog, writer);
  • 반응형
    출처: http://kr.blog.yahoo.com/kwon37xi/folder/3381246.html


    • JAXP는 새로운 기능을 제공하는 것이 아니라 기존의 SAX, DOM 파서들을 래핑해서 벤더 중립적으로 SAX와 DOM 기능을 사용할 수 있게 해준다.
    • JAXP는 XML 분석 기능을 제공하지 않는다. 즉, SAX, DOM 혹은 그 이외의 XML 파싱 API 없이 JAXP만 가지고는 XML을 분석할 수 없다.
    • SAX, DOM 그리고 JDOM은 XML을 분석하는데 사용된다. 반면 JAXP는 이러한 API와 분석된 문서의 결과를 얻는 방법을 제공한다. JAXP 자체는 문서를 분석하는 새로운 방법을 제공하는 것은 아니다.
    • 결론 : JAXP는 새로운 작업을 수행하기 위한 API가 아니라 기존에 존재하는 API를 추상화시켜 특정 벤더에 종속적인 코드를 전혀 쓰지않고 하나의 단일된 형태로 사용할 수 있게 만든 중간계층이다.

    JAXP 1.0 with SAX

    • SAX 1.0만 지원한다.
    • SAX 처리 파서와 함께 JAXP를 사용하려면 org.xml.sax.HandlerBase 클래스를 확장하고 애플리케이션에서 처리하려는 콜백들을 구현하면 된다. HandlerBase는 SAX 2.0의 DefaultHandler와 같은 역할을 한다.
    • JAXP는 자바 시스템 Property를 통해서 벤더 클래스의 파서를 지정할 수 있다.

    SAX 사용순서

    • SAXParserFactory 클래스의 객체를 생성한다.
    • SAXParserFactory는 SAX 파서의 인스턴스를 생성하고, 파서의 옵션을 설정하는 역할을 한다.
    • SAXParserFactory에서 설정한 옵션들은 그것을 통해 얻은 모든 파서의 인스턴스에 적용된다.
      • SAXParserFactory.setNamespaceAware(boolean) : 네임스페이스 인식 여부
      • SAXParserFactory.setValidating(boolean) : 유효성 검사 여부
    • 일단 SAXParserFactory를 설정하고 나면, SAXParserFactory.newSAXParser() 메소드를 사용하여 파서에 해당하는 SAXParser 클래스(JAXP에 포함된 클래스임)의 인스턴스를 구할 수 있다.
    • SAXParser.parse()로 XML 파싱을 수행한다.
      // JAXP import
      import javax.xml.parsers.*;
      
      // SAX import
      import org.xml.sax.*;
      
      // SAXParserFactory를 얻는다.
      SAXParserFactory factory = SAXParserFactory.newInstance();
      
      // 유효성 검사를 수행하고, 네임스페이스를 인식하지 않도록 설정
      factory.setValidating(true);
      factory.setNamespaceAware(false);
      
      // SAXParser를 얻어 파싱을 한다.
      SAXParser parser = factory.newSAXParser();
      parser.parse(new File(xmlFileName), new MyHandlerBase());
      // MyHandlerBase는 org.xml.sax.HandlerBase 를 상속한 클래스이다.
      

    발생 가능한 예외

    • FactoryConfigurationError : 일반적으로 파서가 사용하는 JAXP 구현 클래스나 시스템 Property를 불러올 수 없을 경우에 발생한다.
    • ParserConfigurationException : 파서에서 사용할 수 없는 특징을 설정할 때 발생한다.

    SAXParser 클래스

    • SAXParser.isValidating() : 유효성 검사 수행 여부
    • SAXParser.isNamespaceAware() : 네임스페이스 인식 여부
    • SAXParser 클래스는 위 두 특징을 변경할 수 있는 메소드는 제공하지 않는다. SAXParserFactory에서 변경해야 한다.
    • SAXParser.getParser() : 내부적으로 실제 사용하는 파서의 객체(org.xml.sax.Parser의 인스턴스)

    JAXP 1.0 with DOM

    • SAX와 거의 동일하다.
    • 파싱 후 Document 객체를 리턴한다.

    DOM 사용 순서

    • DocumentBuilderFactory 클래스의 인스턴스를 얻는다.
    • factory 객체에서 설정할 사항들을 설정하고,
    • DocumentBuilder를 DocumentBuilderFactory로 부터 얻는다.
    • DocumentBuilder로 파싱을 수행해서 Document 객체를 얻는다.
      // DocumentBuilderFactory를 얻는다.
      DocumentBuilderFactory factory =
        DocumentBuilderFactory.newInstance();
      
      // 여러가지 설정...
      
      // DocumentBuilder 얻기
      DocumentBuilder builder = factory.newDocumentBuilder();
      
      // XML 파싱 수행
      Document doc = builder.parse(new File(xmlFileName));
      

    발생 가능한 예외

    SAX와 동일하다.

    DocumentBuilder 클래스

    • SAX 이벤트를 처리하지 않으므로 HandlerBase 인스턴스가 필요없다.
    • DocumentBuilder.parse()는 곧바로 Document 객체를 리턴한다.
    • SAX의 ErrorHandler를 위한 DocumentBuilder.setErrorHandler()
    • SAX의 EntityResolver를 위한 DocumentBuilder.setEntityResolver()

    네임스페이스?

    JAXP 1.0은 네임스페이스를 처리하지 않는다. "지원"만 할 뿐이다.

    JAXP 1.1은 네임스페이스를 처리할 수 있다.

    파서의 변경

    • JAXP가 사용하는 파서를 변경한다는 것은 실제로 파서를 생성하는 Factory를 변경한다는 의미이다.
    • SAXParserFacotry 변경 : javax.xml.parsers.SAXParserFactory 시스템 프라퍼티로 설정
    • DocumentBuilderFactory 변경 : javax.xml.parsers.DocumentBuilderFactory 시스템 프라퍼티로 설정

    JAXP 1.1

    • XSLT 프로세서는 javax.xml.transform.TransformerFactory 시스템 프라퍼티로 설정할 수 있다.

    1.1에서 바뀐점

    • SAX 2.0과 DOM Level 2를 지원한다.
    • 네임스페이스를 처리한다.
    • SAX 2.0으로 넘어가면서 Parser 인터페이스는 디프리케이티드 되었다. 대신 org.xml.sax.XMLReader를 사용한다.
    • SAXParser.getXMLReader()가 추가되었다.
    • SAXParser에 SAX 2의 DefaultHandler를 인자로 받는 parse() 메소드를 추가했다.
    • SAXParserFactory.setFeature(), SAXParserFactory.getFeature()가 추가되었다.
    • SAXParser.setProperty(), SAXParser.getProperty()가 추가되었다.

    TrAX API : XSL을 위한 API

    • XML 문서 변환을 벤더에 중립적으로 처리할 수 있다.
    • 다음과 같은 순서로 XSL 변환을 처리한다.
      1. TransformerFactory를 얻는다.
      2. Transformer를 얻는다.
      3. 변환을 수행한다.

    Factory

    • javax.xml.transform.TransformerFactory 팩토리 객체를 생성한다.
    • 팩토리 객체에 다양한 옵션을 설정한다. 이 옵션들은 이 팩토리에서 생성되는 모든 Tansformer 인스턴스에 영향을 주게 된다.
      • 속성 설정(각 XSL 프로세서에 종속적임). TransformerFactory.setAttribute(), TransformerFactory.getAttribute()
      • ErrorListener 설정 : 분석도중에 발생하는 문제를 프로그램에서 처리시킨다. javax.xml.transform.ErrorListener 인터페이스 구현. TransformerFactory.setErrorListener()로 설정.
      • URIResolver 설정 : xsl:import 혹은 xsl:include 등에서 가져올 XML 데이터를 Source 객체로 제공해준다. 특정 URI를 만났을 때 Transformer가 여러 곳에 있는 특정 문서를 검색할 수 있게 해준다. javax.xml.transform.URIResolver 인터페이스 구현. TransformerFactory.setURIResolver()로 설정.
    • TansformerFactory.newTransformer()는 변환에 사용되는 스타일시트를 입력으로 받아들인다.

      // TransformerFactory를 얻는다.
      TransformerFactory factory = TransformerFactory.newInstance();
      
      // TransformerFactory를 구성한다.
      factory.setErrorResolver(myErrorResolver);
      factory.setURIResolver(myURIResolver);
      
      // 명시된 옵션들을 가지는 작업에 사용할 Transformer를 얻는다.
      Transformer transformer =
         factory.newTransformer(new StreamSource("foundation.xsl"));
      

    XML 변환

    • 스타일시트의 위치는 반드시 그것의 위치를 나타내는 javax.xml.transform.Source의 인스턴스를 사용해 명시한다.
    • Source 인터페이스 : 스타이시트, XML 혹은 다른 정보들의 집할일 수 있는 입력의 위치
      • StreamSource : InputStream, Reader, 시스템 아이디로 입력 받음
      • DOMSource : DOM 트리에서 데이터 읽기. org.w3c.dom.Node를 인자로 받음. 이미 DOM파싱이 된 문서를 사용할 때는 DOMSource를 써야 성능이 더 좋다.
      • SAXSource : SAX 생성기로 부터 데이타 읽기. InputSource혹은 XMLReader를 입력으로 받는다. SAX 컨텐트 핸들러가 이미 사용중이고, 콜백이 설정되고 변환에 앞서 특정 작업을 처리해야 할 경우라면 SAXSource를 사용하는 것이 좋다.
    • 변환 결과는 javax.xml.transform.Result의 인스턴스로 받는다.
    • Result 인터페이스 : 변환된 문서를 출력할 목표 지정
      • StreamResult
      • DOMResult
      • SAXResult : SAX의 ContentHandler를 인스턴스로 넘겨 받는다.
        // 명시된 옵션들을 가지는 작업에 사용할 Transformer를 얻는다.
        Transformer transformer =
            factory.newTransformer(new StreamSource("foundation.xsl"));
        
        // 변환을 수행하고 결과 출력
        transformer.transform(new StreamSource("asimov.xml"),
                              new StreamResult("results.xml"));
        

    SourceLocator

    • SourceLocator 인터페이스는 동작이 발생한 위치에 대한 정보를 제공한다.
    • DOMLocator 인터페이스는 처리중인 DOM 노드를 반환하는 getOriginatingNode()라는 메소드가 추가되어 있다.

    OutputKeys

    • javax.xml.transform.OutputKeys 클래스는 TrAX의 변환을 위한 출력 Property를 위해 몇몇 상수를 정의하고 있다.

    Templates

    • 여러번 재활용되고 다중 쓰레드에서 사용할 Transformer를 생성한다.
    • Templates 인터페이스는 출력 Property의 집합을 여러 개의 변환작업에 똑같이 적용하고 싶거나, 변환 지시어들의 집합을 연속적으로 사용하고 싶을 때 사용한다.
      TransformerFactory factory = TransformerFactory.newInstance();
      
      // Templates 객체를 얻는다.
      Template template =
          factory.newTemplates(new StreamSource("html.xsl"));
      
      // Transformer의 인스턴스를 얻는다.
      Transformer transformer = template.newTransformer();
      
      // 변환
      transformer.transform(new DOMSource(orderForm), new StreamResult(res.getOutputStream()));
      
    • 하나의 스타일시트를 두 번이상 사용하면 Templates 객체를 사용하는 것이 좋다.
    • XSL 스타일시트를 자바 객체로 변환하는 과정을 반복하지 않으므로 더 성능이 좋다.
    • 다중 쓰레드 환경에서는 Templates 꼭 사용해야 한다.

    JAXP 설정

    $JRE_HOME/lib/ext 디렉토리에 jaxp.properties 파일을 만들고 원하는 팩토리를 설정해 둘 수 있다.
    반응형
    출처: http://kr.blog.yahoo.com/kwon37xi/folder/3381246.html


    TEXT 클래스

    • org.jdom.Text
    • Element 클래스는 getText() 메소드로 텍스트를 얻을 수 있지만, 내부적으로는 Text 클래스의 인스턴스를 만들어서 요소의 텍스트를 저장한다.
    • 이렇게 한 이유는 트리모델에서 탐색을 용이하게 하기 위해서이다.

    EntityRef 클래스

    • org.jdom.EntityRef
    • XML 엔티티 참조를 나타낸다.
    • 만약 엔티티가 XML DTD나 스키마를 참조한다면, 이 클래스로 이름, 공개ID, 시스템ID를 설정하거나 반환할 수 있다.
    • JDOM 컨텐트 트리의 어디에나 위치할 수 있다.
    • 거의 사용되지 않는다.
    • EntityRef를 사용하기 위해서는 엔티티 확장을 하지 않게 해야한다.

      SAXBuilder builder = new SAXBuilder();
      
      // 엔티티 참조를 확장하지 않는다.(기본값은 true)
      builder.setExpandEntities(false);
      
      // EntityRef 객체를 포함하는 트리 생성
      Document doc = builder.build(inputStream);
      
    • 엔티티 확장을 true로 하면 엔티티를 만날 때는 실제 엔티티의 값으로 바뀐 것을 읽게 된다.
    • 엔티티 참조 생성

      EntityRef ref = new EntityRef("TrueNorthGuitarsTagline");
      ref.setSystemID("tngTagline.xml");
      
      // 트리에 넣는다.
      tagLineElement.addContent(ref);
      

    Namespace 클래스

    • org.jdom.Namespace
    • 요소를 생성하거나 요소를 검색하는데 새로운 네임스페이스가 필요하다면, Namespace 클래스의 정적 메소드인 getNamespace()를 사용해야 한다.

      // 접두어가 있는 네임스페이스를 생성한다.
      Namespace schemaNamespace =
          Namespace.getNamespace("xsd", "http://www.w3.org/XMLSchema/2001");
      
      // 접두어가 없는 네임스페이스를 생성한다.
      Namespace javaxml2Namespace =
          Namespace.getNamespace("http://www.oreilly.com/javaxml2");
      
    • 네임스페이스 적용

      // 네임스페이스가 있는 요소 생성
      Element schema = new Element("schema", schemaNamespace);
      
      // 특정한 네임스페이스에 속한 자식 요소들을 찾는다.
      List chapterElements = contentElement.getChildren("chapter", javaxml2Namespace);
      
      // 요소에 새로운 네임스페이스를 선언한다.
      catalogElement.addNamespaceDeclaration(
          Namespace.getNamespace("tng", "http://www.truenorthguitars.com");
      
    • 접두어와 상관없이 Namespace의 URI가 동일하면 Namespace객체는 동일하다. - 이것은 표준 규약을 따르는 것이다.

    JDOM Factory

    • org.jdom.JDOMFactory 인터페이스는 JDOM에 있는 모든 타입의 객체를 생성하기 위한 여러 메소드를 정의하고 있다.
    • 보통 JDOM은 org.jdom.DefaultJDOMFactory 클래스를 사용해서 JDOM 트리를 구성한다. DefaultJDOMFactory 클래스를 상속하여 자신만의 팩토리 클래스를 작성할 수 있다.

      class CustomJDOMFactory extends org.jdom.DeafultJDOMFactory {
          ....
      }
      
    • 사용자 정의 Factory 사용해서 JDOM 트리 구성하기 : setFactory(factory)

      SAXBuilder builder = new SAXBuilder();
      
      JDOMFactory factory = new CustomJDOMFactory();
      
      // 사용자 정의 팩토리를 사용하도록 설정
      builder.setFactory(factory);
      
    • JDOMFactory를 사용할 때는 필요한 메소드가 정확히 구현되었는지 확실히 확인해야 한다.
    반응형
    출처: http://kr.blog.yahoo.com/kwon37xi/folder/3381246.html

    JDOM은 XML 문서를 트리 구조로 구성한다는 점에서 DOM과 유사하다. 그러나 JDOM은 오직 Java만 지원한다.
    JDOM은 DOM이 아니며 내부적으로 DOM을 확장하지도 않았다.

    기본적으로 알아야 할 것

    JDOM에는 DOM의 Node와 같은 트리 구조를 위한 상위 인터페이스가 존재하지 않는다. 요소(Element)와 속성(Attribute) 등 모든 것이 콘크리트 클래스(concrete class; 일반적인 인터페이스와 abstract 클래스를 제외한 클래스를 뜻한다. 또한 직접적으로 객체를 생성할 수 있는 클래스를 콘크리트 클래스라고 한다)로 이루어져 있다.

    • Element 클래스에 getText()가 있어 요소의 컨텐트를 구할 수 있다.
    • NodeListNamedNodeMap 같은 리스트 클래스가 없이 Java 컬렉션 API(java.util.List 등)을 사용한다.
    • Element.getAttributes() 로 속성의 List를 얻을 수 있다.

    JDOM Document 생성하기

    XML 원시 데이타가 없는 상태에서 JDOM Document 객체를 생성하려면 우선 JDOM의 Element 클래스를 사용해 XML 문서의 루트 요소를 생성하고, Element 클래스를 Document 클래스 생성자에 인자로 전달하여 Document 인스턴스를 생성하면 된다.
    Element rootElement = new Element("root"); // "root"는 Root 요소
    Document document = new Document(rootElement); // 새로운 Document 생성
    

    입력과 출력

    JDOM은 파서가 아니다. JDOM은 XML 원본을 읽기 위해 다른 파서에 의존한다. 또한 JDOM은 SAX 이벤트, DOM 트리, JDBC의 ResultSet 등을 입력 받는다.
    • 입력 스트림, 파일, 디스크상의 문서를 사용하거나 또는 기존의 XML을 DOM 트리로 생성할 필요가 없는 경우에는 SAXBuilder를 사용하는 것이 좋다.

      SAXBuilder builder = new SAXBuilder();
      Document doc = builder.build(new FileInputStream("contents.xml"));
      
    • DOM 빌더는 이미 DOM 트리 구조로 되어 있는 것을 JDOM 으로 바꿀 때만 사용한다. 성능이 SAXBuilder에 비해 떨어지므로 DOM 트리가 아닌 스트림에서 XML 데이터를 읽어 파싱할 때는 SAXBuilder를 사용한다.

      DOMBuilder builder = new DOMBuilder();
      
      // myDomDocumentObject는 DOM의 Document 객체이다.
      Document doc = builder.build(myDomDocumentObject);
      
      위는 org.w3c.dom.Documentorg.jdom.Document로 전환한다.
    • JDOM의 구조를 DOM 트리로 바꾸려면 DOMOutputter 클래스를 사용한다.

      DOMOutputter outputter = new DOMOutputter();
      org.w3c.dom.Document domDoc = outputter.output(myJDOMDocumentObject);
      
    • JDOM의 구조를 이용해 SAX 이벤트를 처리하려면

      SAXOutputter outputter = new SAXOutputter();
      outputter.setContentHandler(myContentHandler);
      outputter.setErrorHandler(myErrorHandler);
      outputter.output(myJDOMDocumentObject);
      
      SAXOutputter는 XML 문서가 아닌 JDOM Document를 분석하여 SAX 이벤트를 발생시키는 SAXReader라고 생각하면 된다.
    • XMLOutputter는 XML 문서를 Stream이나 Writer, 파일 또는 변환하려는 다른 구조 등으로 출력한다.

      XMLOutputter outputter = new XMLOutputter(org.jdom.output.Format.getPrettyFormat());
      outputter.output(jdomDocumentObject, new FileOutputStream("result.xml"));
      
      org.jdom.output.Format 객체를 이용해 출력 형식을 결성할 수 있으며 Format.getPrettyFormat()은 잘 정렬된 기본적인 XML 출력 형식을 지정한다.
    • XMLOutputter는 책에서 설명한 JDOM 버전과 현재 1.0 버전의 사용법이 다르다. 여기서 설명한 것은 1.0 기준이다.

    요소, 속성 등을 추가하기

    • Element의 내용은 Element.setText(String)으로 추가한다.

      // <ClassName>org.jdom.Element</ClassName>
      Element element = new Element("ClassName");
      element.setText("org.jdom.Element");
      
    • Element나 그 외의 JDOM에 적합한 모든 구성 요소는 요소의 addContent() 메소드에 의해 추가될 수 있다. 추가 될 수 있는 타입으로는 Element, Attribute, Entity, Comment, ProcessingInstruction 등이 있다.

    자식 노드 얻기

    • Element.getChild("요소이름")로 요소에서 "요소이름"의 자식 요소 첫번째를 얻을 수 있다. 자식 요소가 없으면 null을 리턴한다.
    • Element.getChildren()은 현재 요소의 자식 요소 List를 리턴한다.
    • Element.getChildren("요소이름")은 현재 요소의 "요소이름"이라는 자식 요소 List를 리턴한다.
    • Element.getTextTrim()은 요소의 텍스트에서 앞뒤 공백을 제거하고 리턴한다.
    • Element.getTextNormalize()은 요소의 텍스트에서 앞뒤 공백을 제거하고 중간에 나온 공백은 공백이 여러개라도 한개로 만들어 리턴한다.

    속성

    • 속성 값 설정 첫번째 방식

      Attribute attribute =
        new Attribute("value", propertyValue); // 속성이름 value, 속성값 propertyValue
      element.setAttribute(attribute);
      
    • 속성 값 설정 두번째 방식

      element.setAttribute("value", propertyValue);
      
    • 속성 값 가져오기

      String text = element.getAttribut    eVal     ue("value"); // 속성 value의 값 가져오기
      
    • 속성 리스트 가져오기

      List attrs = element.getAttributes(); // 요소에 속한 속성(Attribute 객체)의 List
      

    getContent()

    Document나 Element 클래스에서 getContent()를 사용하면 컨텐트의 타입(요소, 처리지시어, 주석, 엔티티, 텍스트 등)과 상관없이 해당하는 모든 컨텐트를 리턴한다.
    • 주석을 XML문서의 맨 앞에 추가하려면 다음과 같이 해야한다. 그냥 doc.addContent(comment)를 하면 XML 문서의 맨 마지막에 주석이 추가되어 버린다.

      // doc 은 JDOM의 Document 객체이다.
      Comment comment = new Comment("이러쿵 저러쿵..");
      doc.getContent().add(0, comment);
      

    XPath

    XPath xpath = XPath.newInstance("/collection/dvd"); // XPath 문자열
    List list = xpath.selectNodes(doc); // Document 객체
    

    얻어진 list의 각 요소들을 Element, Attribute, String 등으로 캐스팅하여 사용하면 된다.

    Element e = (Element)xpath.selectSingleNode(doc); 이처럼 XPath.selectSingleNode()를 사용하면 XPath결과 중에서 한 개의 값만을 가져올 수 있다.

    XSLT

    • JDOM의 XSLTranformer는 파라미터를 받지 않는 문제가 있다. 이때 JAXP를 사용해야 한다.
    • 트랜스폼 결과는 Document로 리턴된다.

      StringWriter writer = new StringWriter();
      
      XSLTransformer transformer = new XSLTransformer("list.xsl");
      Document resultDoc= transformer.transform(doc); // Document 객체
      
      XMLOutputter out = new XMLOutputter(Format.getPrettyFormat());
      out.output(resultDoc, stringWriter); // 문자열 Writer에 결과를 저장.
      
      out.println(stringWriter.toString()); // 문자열로 출력
      

    반응형
    출처: http://kr.blog.yahoo.com/kwon37xi/folder/3381246.html

    • DOM은 XML을 생성하고 변경할 수 있다.

    XML DOM 트리의 생성과 변경

    • 새로운 XML을 생성하기 위해서는 org.w3c.dom.DOMImplementation을 구현한 클래스를 사용해야한다.
    • Xerces의 DOMImplementation구현 : org.apache.xerces.dom.DOMImplementationImpl
    • 생성 예

      DOMImplementation domImpl = new DOMImplementationImpl();
      Document doc = domImpl.createDocument(null, "rootElement", null);
      
    • Document 객체 생성시 파서의 Document 구현 클래스를 사용하면 DocType 이 생성되지 않는다. DOMImplementation 을 사용해서 새로운 XML DOM 트리를 생성해야 한다.
    • DOMImplementation.createDocument(1,2,3);
      • 첫번째 인자 : 문서의 루트 요소를 위한 네임스페이스
      • 두번째 인자 : 루토 요소
      • 세번째 인자 : DocType 클래스의 인스턴스.
    • DocType이 필요할 경우 DOMImplementation.createDocType() 사용.
    • 변경 예

      Element root = doc.getDocumentEelment();
      root.setAttribute("id", id); // id 속성의 추가
      
      Element nameElement = doc.createElement("name");
      Text nameText = doc.createTextNode("내용");
      nameElement.appendChild(nameText); //name 요소에 텍스트 값 추가
      root.appendChild(nameElement); // rootElement 요소에 name 요소 추가
      
    • 모든 노드의 생성은 Document 객체의 create* 메소드를 통해서 이뤄진다.
    • "appendChild()"는 자식 노드를 추가한다.

    네임스페이스

    • DOM Level 2는 네임스페이스를 지원한다.
    • 네임스페이스를 위해 Node 인터페이스는 "getPrefix()"와 "getNamespaceURI()" 메소드를 제공한다.
    • Document.createElementNS() 네임스페이스를 지원하는 요소 추가.
    • 네임스페이스를 인식하는 각 메소드의 첫번째 인자는 "네임스페이스 URI"이고, 두번째 인자는 요소와 속성등의 QName이다. QName은 "ora:copyright" 와 같은 형태를 띈다.
    • "ora:copyright" 요소에서 getPrefix() : "ora" 리턴
    • 네임스페이스에 속하지 않는 요소에서 getPrefix() : null 리턴
    • 네임스페이스를 지정했을 때는 루트 요소에 xmlns 속성을 지정해야 한다.

    DOM Level 2 - 순회(Traverse)

    • DOM 트리를 순회하는 기능을 제공한다.
    • "org.w3c.dom.traversal.DocumentTraversal" 인터페이스를 이용한다.
    • 일반적인 파서의 Document 구현 클래스는 DocumentTraversal 도 함께 구현한다.
    • NodeIterator

      NodeList descriptionElements =
      	root.getElementsByTagNameNS(docNS, "description");
      Element description = (Element)descriptionElements.item(0);
      
      // NodeIterator를 구한다.
      NodeIterator i = ((DocumentTraversal)doc)
      	.createNodeIterator(description, NodeFilter.SHOW_ALL,
      	new FormattingNodeFilter(), true);
      
      Node n;
      
      while ((n = i.nextNode()) != null) {
      	System.out.println("Search phrase found: '" + n.getNod eVal  ue() + "'");
      }
      
    • createNodeIterator(1, 2, 3, 4)
      • 첫번째 인자 : 순회할 노드 요소
      • 두번째 인자 : 상수 필터
        1. NodeFilter.SHOW_ALL : 모든 노드를 포함하여 순회
        2. NodeFilter.SHOW_ELEMENT : 요소만 순회
        3. NodeFilter.SHOW_TEXT : 텍스트 노드만 순회
      • 세번째 인자 : NodeFilter 구현 객체
      • 네번째 인자 : 엔티티 참조의 실제값을 분석할 것인가?
      • 두번째와 세번째 인자가 함께 나올 경우 두번째 인자 필터를 우선적용하고 그 결과를 다시 세번째 인자로 필터링한다.
    • NodeFilter
      • public short acceptNode(Node n); 을 이용해서 순회할 노드인지 여부를 결정한다.
        • 리턴값 NodeFilter.FILTER_SKIP : 필터로 들어온 노드는 건너 뛰고 그 자식노드를 계속 탐색
        • 리턴값 NodeFilter.FILTER_REJECT : 필터로 들어온 노드와 그 자식 모두 건너 뜀
        • 리턴값 NodeFilter.FILTER_ACCEPT : 필터로 들어온 노드 사용
      • 노드 필터 예

        class FormattingNodeFilter implements NodeFilter {
        	public short acceptNode(Node n) {
        		if (n.getNodeType() == Node.TEXT_NODE) {
        			Node parent = n.getParentNode();
        
        			if ((parent.getNodeName().equalsIgnoreCase("b")) ||
        				(parent.getNodeName().equalsIgnoreCase("i"))) {
        				return FILTER_ACCEPT;
        			}
        		}
        
        		return FILTER_SKIP;
        	}
        }
        
    • TreeWalker
      트리 뷰를 얻는다. 필터를 이용해 특정한 요소 등만 가진 트리를 생성해낸다.

    범위(Range)

    알 수 없는 DOM 구조에 새로운 컨텐트를 추가하거나 또는 컨텐트를 삭제, 복사, 추출해야 할 경우에 범위 모듈을 사용한다.

    Wrong document Exception

    잘못된 문서 예외(Wrong document Exception)은 서로 다른 문서의 노드들을 함께 사용하려 할 때 발생한다.

    다른 문서의 노드를 현재 문서에 append하려면 importNode를 사용한다.
    Element otherDocElement = otherDoc.getDocumentElement();
    Element thisDocElement = thisDoc.getDocumentElement();
    
    // 대상 문서에 노드 임포트
    Element readyToUseElement =
        (Element)thisDoc.importNode(otherDocElement);
    
    // 아무문제없이 노드 추가
    thisDocElement.appendChild(readyToUseElement);
    



    반응형
    출처: http://kr.blog.yahoo.com/kwon37xi/folder/3381246.html
    DOM(Document Object Model)은 모든 프로그래밍 언어와 개발 도구에서 사용하는 문서의 컨텐트 모델을 표현하기 위해 설계되었다. 각 언어별로 바인딩이 존재한다.
    이 점은 장점이 될 수도 있지만, JAVA 고유의 편리한 기능을 사용할 수 없어, 단점으로 작용하기도 한다. JAVA 고유의 기능을 사용한 JDOM이 DOM보다 훨씬 편리하다.
    • DOM은 모든 면에서 트리 모델이다.
    • DOM은 XML문서 전체를 메모리에 저장하여 표현한다.
    • 각 트리는 org.w3c.dom.Node 인턴페이스를 기반으로 한다. 요소, 속성, 텍스트, PI, 주석 등 모든 것이 Node로 표현된다.
    • 요소의 텍스트도 하나의 트리로 간주된다. 그러므로 Element 노드의 텍스트를 구할 때 "getText()"와 같은 방식으로 구할 수 없고, 요소의 Text 자식 노드들을 구한뒤, 거기서 값을 가져와야한다.

    SAX의 장/단점

    • SAX는 순차적이라 XML문서의 요소를 무작위로 접근할 수 없다.
    • 형제 요소를 처리하기 어렵다.
    • 메모리를 훨씬 적게 사용한다.

    XML 파싱 : Xerces 기준

    • DOM에서는 문서를 완전히 분석하여 트리 구조가 생성되어야 XML 문서의 데이터를 사용할 수 있다.
    • DOM에서 문서를 분석한 결과는 org.dom.w3c.dom.Document 객체로 표현된다.
    • 다음과 같이 XML 문서를 파싱한다.

      import org.apache.xerces.parsers.DOMParser; // 파서 import
      import org.w3c.dom.*; // DOM 인터페에스 import
      ...
      
      DOMParser parser = new DOMParser();
      
      // Document 객체인 DOM 트리 구성
      parser.parse("document.xml");
      Document doc = parser.getDocument(); // DOM Document 객체 얻기
      

    • import org.apache.xerces.parsers.DOMParser
      • void parse(org.xml.sax.InputSource inputSource)
      • void parse(java.lang.String systemId)

    Node

    • DOM의 장점중의 하나는 XML을 표현하는(Document 객체를 포함한) 모든 DOM 객체가 DOM의 Node인터페이스를 상속한다는 점이다.
    • Node.getNodeType() : 현재 노드의 타입(요소, 속성, PI 등등..)을 가리킨다.
    • Document.getDocumentElement() : 최상위 요소(Root Element) 노드
    • Node.getNodeName() : 노드의 이름. Text 노드(요소의 값)의 경우 이 노드 이름은 의미가 없다.
    • Node.getNodeValue() : 노드의 값. Element 노드의 경우 이 값은 의미가 없으며 자식 노드를 구해 그 중 Text노드의 값을 가져와야만 한다.
    • Node.getChildNodes() : NodeList 인스턴스 반환. 자식 노드 목록.
    • NamedNodeMap Node.getAttributes() : Element 노드의 경우에만 유효. 속성 목록을 반환한다.
    • NodeList.item(int) : 자식 Node들을 순서대로 반환받는다.

    DOCTYPE, PI 등의 처리

    최상위 엘리먼트보다 상위에 오는 DOCTYPE과 PI(처리 지시어; Processing Instruction)등을 처리하려면 Document 노드 단에서 자식 노드들을 얻어야만 한다.

    NodeList 사용시 주의점!

    이것은 Java와 XML 책에는 없는 내용이다. 내 경험상의 주의점이다.
    

    다음과 같은 XML이 있을 때
    <root>
      <child1>hello</child1>
      <child2>hi~</chil2>
    </root>
    
    위 XML을 파싱하여 "root" 엘리먼트 Node 객체에서 getChildNodes()를 했을 경우에 주의할 점이 있다.
    이 상황에서 "child1" 노드 객체를 가져올 때
    DOMParser parser = new DOMParser();
    
    parser.parse("test.xml");
    
    Document doc = parser.getDocument();
    
    Element root = doc.getDocumentElement();
    
    NodeList children = root.getChildNodes(); // root 의 자식 노드 얻기 -- !! 요주의 부분!!
    
    Node child1Node = children.item(0); // child1 요소 얻기 
    
    Node textNode = child1Node.getChildNodes().item(0); // child1의 텍스트 얻기
    
    System.out.println("child1 : " + textNode.getNodeValue());
    
    위와 같이 하면 제대로 값을 가져올 수 있을까?

    답은 "가져올 수도 있고 못 가져올 수도 있으나, 십중팔구는 NullPointerException이 발생한다는 것이다."
    NullPointerException이 발생한다면 그것은 textNode가 null이기 때문이다.
    위와 같이 NodeList.item(int) 메소드를 사용할 경우에 root 요소와 child1 요소 사이의 공백이 Text 노드로서 읽힐 수도 있다. 이 경우 NodeList.item(0)가 리턴하는 노드는 child1 요소가 아니라 root요소의 Text 노드가 되는 것이다.
    만약 root 요소와 child1요소 사이에 아무런 공백도 없거나 DTD 등으로 공백을 무시하도록 했다면 안 그럴 수도 있다.

    그러므로 child1 요소를 명백하게 가져오려고 할 경우에는 root.getChildNodes()를 사용해서는 안된다. root 노드를 Element 객체로 캐스팅하고 Element.getElementsByTagName(String)으로 명백하게 가져와야 한다.
    Element root = doc.getDocumentElement();
    
    // 이 부분이 바뀌었다!!
    NodeList children = root.getElementsByTagName("child1"); // root 의 자식 노드 얻기
    
    Node child1Node = children.item(0); // child1 요소 얻기
    
    Node textNode = child1Node.getChildNodes().item(0); // child1의 텍스트 얻기
    
    System.out.println("child1 : " + textNode.getNodeValue());
    

    위와 같이 하면 children 객체에는 요소 이름이 "child1"인 요소만 남게 된다.

    반응형
    출처: http://kr.blog.yahoo.com/kwon37xi/folder/3381246.html

    Property

    파서에 추가되는 인터페이스로서 파서에 특정 인터페이스를 추가하여 분석 기능을 추가한다(수행 동작이 인터페이스를 구현한 객체에 구현되어 있다). Property는 Feature와 마찬가지로 URI를 사용하여 구별하는데, http://xml.org/sax/properites/를 접두어로 가지며 lexical-hander 같은 구분자가 뒤에 따라온다.

    • XMLReader.setProperty(String propertyID, Object value)
    • XMLReader.setFeature(String featureID, boolean value)
    • Object XMLReader.getProperty(String propertyID)
    • boolean XMLReader.getFeature(String featureID)

    Feature

    파서가 수행해야 하는 동작을 나타내기 위한 플래그로서 파서가 수행 가능한 동작의 실행 여부를 표시한다(수행하는 동작은 이미 파서에 구현되어 있다). Feature는 URI를 사용하여 구분하는데 http://xml.org/sax/features/를 접두어로 가지며 뒤에 validation과 같은 구분자가 따른다. 즉, 유효성 검사와 관련된 Feature는 http://xml.org/sax/features/validation이라는 URI로 표시된다.

    EntityResolver

    • org.xml.sax.EntityResolver
    • 엔티티를 분석하는 이벤트 핸들러

    public InputSource resolveEntity(String publicID, String systemID)

    • XMLReader가 엔티티 참조를 만날 때마다 그 엔티티에 해당하는 공개ID와 시스템ID를 resolveEntity메소드에 넘겨준다.
    • resolveEntity() 메소드에 어떤 코드를 추가하더라도, 항상 기본적으로는 null 을 반환하도록 해야 한다.

    DTDHandler

    • org.xml.sax.DTDHandler
    • DTDHandler 인터페이스는 XMLReader가 분석하지 못한 엔티티나 표기(Notation) 선언을 만나게 되면 이를 알려준다. 물론 이 두 가지 이벤트는 XML문서가 아니라 DTD에서 발생한다.
    • 유효성 검사를 하면서 동시에 이 핸들러를 사용하는 것은 피하는 것이 좋다.
    • DTDHandler를 등록했다고 해도 유효성 검사 Feature(http://xml.org/sax/features/validation)를 선언하지 않으면 유효성 검사를 하지 않는다.

    public void notationDecl(String name, String publicID, String systemID)

    표기 선언(Notation)을 만나면 호출된다.

    public void unparsedEntityDecl(String name, String publicId, String systemId, String notationName)

    분석되지 않은 엔티티 선언을 만나면 호출된다.

    org.xml.sax.helpers.DefaultHandler 클래스

    • 여러 핸들러(ContentHandler, ErrorHandler, EntityResolver, DTDHandler)를 모두 구현했다. 구현한 메소드는 아무런 작동도 하지 않는다.
    • 이것을 상속하여 클래스를 작성하면 불필요한 메소드를 뺀 핸들러 클래스를 만들 수 있다.
    • EntityResolver는 다른 핸들러 클래스와 별도로 분리하는 것이 좋다.

    XMLFilter

    • 하나의 SAX Reader가 모든 것을 처리하도록 하는 대신 Reader가 특정 처리를 하고 다른 Reader에게 넘겨주는 작업을 반복적으로 수행하는 파이프라인.
    • org.xml.sax.helpers.XMLFilterImpl클래스를 상속하여 구현하고, 자기 부모로 XMLReader를 지정하면 된다.
    • 핸들러는 최종 필터에 등록해야 한다.
    • XMLFilterImpl 클래스는 기본적으로 5개의 인터페이스에 정의된 모든 메소드는 관련된 이벤트를 처리하지 않고 단순히 넘어가도록 구현돼 있다. XMLFilterImpl 클래스를 상속한 클래스는 필터가 처리하는 메소드만 오버라이딩하여 구현하면 된다.

    XMLWriter

    org.xml.sax.ext.LexicalHandler

    • 주석, 엔티티선언, DTD 선언 그리고 CDATA 영역과 같은 구문과 관련된 이벤트를 처리하는 메소드를 제공한다. ContentHandler는 이 구문 관련 이벤트를 기본적으로 무시한다.
    • 이것을 사용하기 위해서는 Property에 이 핸들러를 구현한 객체를 등록해야만 한다.

      reader.setProperty("http://xml.org/sax/properties/lexical-handler", lexicalHandler);
      

    public void startDTD(String name, String publicID, String systemID)

    DTD 참조 또는 선언의 시작

    public void endDTD()

    DTD 참조 또는 선언의 끝

    public void startEntity(String name)

    엔티티 참조 시작

    public void endEntity(String name)

    엔티티 참조 끝

    public void startCDATA()

    CDATA 영역 시작

    public void endCDATA()

    CDATA 영역 끝

    public void comment(char[] ch, int start, int length)

    • 주석
    • <!-- 와 --> 주석 구분자를 제외한 텍스트만을 받는다.

    org.xml.sax.ext.DeclHandler

    • DeclHandler 핸들러는 요소 선언이나 속성 선언과 같은 DTD에서 발생하는 특정 이벤트를 처리하는 메소드를 정의 하며 아주 특별한 경우에만 사용된다.
    • 이것을 사용하기 위해서는 Property로 이 핸들러를 구현한 객체를 등록해야 한다.

      reader.setProperty("http://xml.org/sax/properties/declaration-handler", declHandler);
      

    public void attributeDecl(java.lang.String eName, java.lang.String aName, java.lang.String type, java.lang.String mode, java.lang.String value)

    속성의 선언을 처리한다. <!ATTLIST>

    public void elementDecl(java.lang.String name, java.lang.String model)

    요소의 선언을 처리한다. <!ELEMENT>

    public void externalEntityDecl(java.lang.String name, java.lang.String publicId, java.lang.String systemId)

    외부 자원을 참조하는 엔티티 선언을 처리한다. <!ENTITY>

    public void internalEntityDecl(java.lang.String name, java.lang.String value)

    내부에서 선언된 엔티티 선언을 처리한다.

    반응형
    출처: http://kr.blog.yahoo.com/kwon37xi/folder/3381246.html
    Java와 XML 2판의 내용정리이다.
    책을 보지 않으면 이 내용을 이해할 수 없을 수 있다.

    SAX 파서는 XML 문서를 순차적으로 분서하는데 문서를 분석하는 동안 시작 태그나 속성, 종료 태그, 텍스트 데이터 등을 만나면 각 구성 요소를 처리하는 메소드를 호출한다.
    이때 메소드를 호출하는 구성요소를 만나는 것이 이벤트가 된다. 즉, SAX 파서가 시작태그를 만나는 것이 하나의 이벤트이고 속성을 만나는 것이 또 다른 이벤트가 된다. 그리고 각 구성요소를 처리하는 메소드를 호출하는 것은 이벤트를 처리한다라고 표현하며, 호출되는 메소드를 콜백(callback) 메소드라고 부른다.

    SAX Parser

    http://xml.apache.org 에서 Xerces 파서를 구할 수 있다.

    SAX 클래스는 org.xml.sax 구조로 패키징되어 있다. 최소한 org.xml.sax.XMLReader 클래스가 있어야 한다.

    SAX 공식 홈 : http://wwww.saxproject.org

    SAXReader

    SAX 사용의 시작은 org.xml.sax.XMLReader 의 객체를 얻는 것이다.
    // 파서 클래스 지정. 여기서는 아파치 Xerces
    private String parserClass="org.apache.xerces.parsers.SAXParser";
    
    // 파싱에 사용할 XMLReader 객체 생성
    XMLReader reader = XMLReaderFactory.createXMLReader(parserClass);
    

    • XMLReader 의 객체는 재사용이 가능하지만 한 번에 한개의 XML 파일만을 파싱해야한다.

    XML 문서 파싱

    XMLReader 객체의 parse(InputSource) 혹은 parse(String URI)로 파싱한다. InputSource 사용권장.

    InputSource is = new InputSource(new FileInputStream(new File(xmlURI)));
    
    // 필수적으로 SystemID를 설정해야 한다.
    // SystemID는 XML 문서의 URI이다.(파일의 경우 파일의 경로)
    is.setSystemId(xmlURI);
    
    // 파싱
    reader.parse(inputSource);
    
    • 항상 시스템 ID를 설정해야만 한다!!
    • SystemID는 XML문서의 URI이다. 파일의 경우는 파일의 경로를 의미한다.

    Handler 등록

    핸들러는 SAX 파서가 문서를 순차적으로 분석하는 동안 발생한 이벤트에 대해 호출할 메소드를을 가진 클래스 객체이다.

    • XMLReader.setContentHandler()
    • XMLReader.setErrorHandler()
    • XMLReader.setDTDHandler()
    • XMLReader.setEntityHandler()


    • 모든 핸들러는 throws SAXException 을 해야 한다.

    Content Handler

    • 요소 등 XML의 내용을 만났을때 호출되는 콜백 메소드를 가지는 클래스.
    • ContentHandler 인터페이스 구현

    public void setDocumentLocator(Locator locator)

    • 분석중인 문서의 위치 정보를 가진 Locator의 객체 생성. Locator 객체의 getLineNumber(), getColumnNumber() 메소드들로 이벤트가 발생한 위치를 알아낼 수 있다.
    • 이벤트의 위치는 실제 처리중인 분석과정에만 유효. Locator는 ContentHandler를 구현한 클래스 범위 내에서만 사용되어야 한다! Locator를 ContentHandler 의 인스턴스 멤버로 등록한다.

    public void startDocument() throws SAXException

    • 문서 시작시 호출되는 콜백 메소드.
    • 모든 핸들러를 포함하여 가장 처음에 호출.(setDocumentLocator() 제외)

    public void endDocument() throws SAXException

    • 문서 분석이 끝날 때 호출되는 콜백 메소드
    • 모든 핸들러를 포함하여 가장 나중에 호출.

    public void processingInstruction(String target, String data)

    • 처리지시어(<? --- ?>)를 처리한다.
    • XML 데이터를 사용하는 실제 애플리케이션은 이 메소드로 처리 지시어를 받아 변수 값을 설정하거나 특정한 처리 과정을 수행하는 메소드를 실행한다.
    • <?xml version="1.0"?> 이 부분은 전달되지 않는다.

    네임스페이스 매핑

    • 네임스페이스를 선언하는 xmlns 를 만나면 발생
    • public void startPrefixMapping(String prefix, String uri)
    • public void endPrefixMapping(String prefix)
    • 프로그래밍 패턴

      private Map namespaceMappings = new HashMap();
      
      public void startPrefixMapping(String prefix, String uri) {
      	// 시각적인 이벤트는 발생하지 않는다.
      	namespaceMappings.put(uri, prefix);
      }
      
      public void endPrefixMapping(String prefix) {
      	// 시각적인 이벤트는 발생하지 않는다.
      	for (Iterator i = namespaceMappings.keySet().iterator(); i.hasNext(); ) {
      		String uri = (String)i.next();
      		String thisPrefix = (String)namespaceMappings.get(uri);
      		if (prefix.equals(thisPrefix)) {
      			namespaceMappings.remove(uri);
      			break;
      		}
      	}
      }
      

    public void startElement(String namespaceURI, String localName, String qName, Attributes atts)

    • 요소가 시작될 때 호출
    • qName 은 네임스페이스 접두어가 있다면 그것을 이름에 포함한다.
    • atts 는 요소의 속성들을 배열로 가지고 있다.

    public void endElement(String namespaceURI, String localName, String qName, Attributes atts)

    • 요소가 닫힐 때 호출

    public void characters(char[] ch, int start, int length)

    • 요소의 텍스트 데이터
    • ch 배열의 start 인덱스부터 length 길이 만큼 만이 데이터이다!!

    public void ignorableWhitespace(char[] ch, int start, int length)

    • 무시 가능한 공백문자가 올 경우 호출
    • DTD나 스키마가 없으면 호출되지 않는다. DTD나 스키마에서 무시가능한 공백문자를 지정하기 때문이다.

    public void skippedEntity(String name)

    • 파서가 엔티티를 처리하지 않을 때 호출
    • 실제 이 메소드가 호출되는 경우는 거의 없다.(Xerces는 절대 호출하지 않는다.)
    • 이 콜백을 수행하면 엔티티 참조의 앞의 앰퍼샌드와 뒤의 세미콜론을 포함하지 않는 엔티티 참조를 매개변수로 전달한다.

    ErrorHandler

    • 파싱중 오류가 발생하면 호출되는 핸들러
    • ErrorHandler 인터페이스 구현

    public void warning(SAXParseException ex)

    • 경고

    public void error(SAXParseException ex)

    • 치명적이지 않은 오류

    public void fatalError(SAXParseException ex)

    • 치명적 오류
    • 파싱을 중지하는게 낫다.

    반응형

    중앙대학교 컴퓨터공학과 자바 동호회 JSTORM   http://www.jstorm.pe.kr  최진호님이 작성하신 문서입니다.

    JDOM을 이용한 Java/XML 프로그래밍 자료입니다.
    반응형

    본 문서는 http://cafe.naver.com/specialj.cafe?iframe_url=/ArticleRead.nhn%3Farticleid=1336 을 참조 

    DOM 문서 객체 모델 [-, document object model]
    본문
    브라우저를 통한 확장성 생성 언어(XML) 문서의 상호 연동을 위한 객체 기반의 문서 모델. 플랫폼과 언어 면에서 중립적인 인터페이스로서 프로그램과 스크립트에 의한 문서의 내용˙구조˙종류의 동적인 접근과 변경이 가능하며, 스크립트나 프로그램 언어에 웹 페이지를 연결해 준다. 웹 페이지를 조작˙생성하기 위해 사용되는 속성, 방법 및 이벤트가 객체를 구성하는데, 이러한 객체들은 대부분의 웹 브라우저에서 스크립트 언어를 통해 접근할 수 있다.

     

     

     

    JDOM [Java Document Object Model]
    본문
    자바에 최적화확장성 생성 언어(XML) 데이터 가공을 위해 만든 개방 소스 라이브러리. 자바 기반의 개발 도구로, 좀 더 직관적인 방법으로 XML을 조작할 수 있는 개방 소스 응용 프로그램 인터페이스(API)이며, SAX(Simple API for XML)와 문서 객체 모델(DOM)과도 상호 연동되고, SAX와 DOM의 장점만을 골라 만든 클래스인터페이스를 제공한다. JDOM은 W3C DOM과 유사하지만 DOM을 기반으로 설계되거나 DOM을 모델로 하지 않은 대안적인 문서 객체 모델로, 차이점은 DOM은 언어 중립적으로 설계되었고, 초기에 HTML 페이지의 자바 스크립트 가공에 주로 이용되었던 반면, JDOM은 자바 전용으로 설계되어 메소드 오버로딩(method overloading), 컬렉션(collection), 리플렉션(reflection), 친숙한 프로그램밍 환경 등 자바의 기본 기능들을 활용한다는 데 있다.

     

    SAX

    [simple API for XML, simple application program interface for Extensible Markup Language]

    본문
    확장성 생성 언어(XML)로 된 웹 파일을 해석할 수 있게 해 주는 응용 프로그램 인터페이스(API). XML을 해석하기 위해 문서 객체 모델(DOM) 대신 사용할 수 있는 대안으로 DOM보다 간단하고 대량의 파일용으로 적절하나 데이터 내용 운용면에서는 능력이 떨어진다. 또한 이벤트형 인터페이스이벤트를 제어하고 상황을 처리하여 XML 파서(parser)와 함께 사용된다.

     

    JAX [Java API for XML]
    본문
    확장성 생성 언어(XML) 데이터 처리를 위한 자바 응용 프로그램 인터페이스. XML 파서(paser)를 얻기 위한 표준 인터페이스 JAXP(Java API for XML Procession), 메세징 프로토콜의 기초를 제공하는 JAXM(Java API for XML Messaging), 단순 객체 접근 프로토콜(SOAP) 스팩(제품 명세)에 따른 메시지를 만들고 소비하도록 하는 SAAJ(SOAP with Attachments API for Java), XML을 기반으로 한 자바 원격 프로시져 호출 응용 프로그램 인터페이스(API)인 JAX/RPC(Java API for XML-based RPC), XML 레지스터가 저장한 퍼블리싱된 웹 서비스 정보를 액세스하는 방법을 제공하는 JAXR(Java API for XML Registries)로 구성된다.

     

    자바 XML팩 [Java XML Pack]
    본문
    선 마이크로시스템스사가 2001년 12월에 발표한 자바 언어(환경)를 확장성 생성 언어(XML)나 웹 서비스에 대응시키는 응용 프로그램 인터페이스(API)를 정리한 패키지. 자바 개발자에게 프로그램의 XML 대응이나 웹 서비스의 구축에 필요한 기술 제공을 목적으로 한다. JAXP(Java API for XML Processing), JAXM(Java API for XML Messaging), JAXB(Java API for XML Data Binding) 등 몇 개의 XML 관련 패키지를 통합한 것이다. 향후 자바 XML 팩에는 문서 처리, 데이터 처리 등 다른 XML 기술도 수록될 예정이다.

     

     

     

    그외에 웹로직으로 알려진 BEA Systems의 스택스(StAX: Streaming API for Java)가 있다.


    + Recent posts