달력

3

« 2024/3 »

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
2010. 10. 1. 16:58

PMD report 파일의 한글 문제 그거/Java2010. 10. 1. 16:58


한글이 포함된 rule 파일을 사용하여 PMD로 java source를 체크한 결과물인 xml 파일을 열어보면

한글들이 &u 어쩌구 저쩌구 하면서 unicode 형식으로 나온다.

이 xml 파일을 읽어서 따로 결과물을 만들고자 할 경우

unicode로 표현된 한글들 때문에 SAXException이 발생하는데  아래와 같이 수정하면 해결할 수 있다.

1. net.sourceforge.pmd.util.StringUtil.java 소스를 열어서.
2. 85 라인의 아래 부분을 수정한다.
      buf.append("&u").append(Integer.toHexString(c)).append(';');
      =>
      buf.append("&#x").append(Integer.toHexString(c)).append(';');
3. StringUtil.java 를 컴파일해서 pmd-4.2.5.jar 파일을 repackaging 한다.
4. PMD를 다시 실행한다.
   결과 xml 파일을 보면 &#x 어쩌구로 변경됐다.
5. xml 파일을 읽어서 결과를 만든다.

출처
http://sayjava.egloos.com/5302833
:
Posted by 뽀기
2010. 1. 29. 19:09

XML 특수 문자 파싱 오류 확인 그거/Java2010. 1. 29. 19:09


<?xml version=\"1.0\" encoding=\"euc-kr\"?><root><data>한&#123;글1234 &#xF;5678&#15; &#16; English日本0A</data></root>

이런 XML을 파싱을 하다 보면...

[Fatal Error] :4:13: Character reference "&#15" is an invalid XML character.
org.xml.sax.SAXParseException: Character reference "&#15" is an invalid XML character.
 at org.apache.xerces.parsers.DOMParser.parse(Unknown Source)
 at cis.jcaps.app.XMLParserTest.handle(XMLParserTest.java:75)
 at cis.jcaps.app.XMLParserTest.doIt(XMLParserTest.java:53)
 at cis.jcaps.app.XMLParserTest.main(XMLParserTest.java:177)

이런 에러가 납니다.

바로 &#15; 요놈!. 특수문자가 변환된 놈 때문이지요..

이걸 HTML 파일로 저장해서 보면..



이렇게 보입니다.. 꼭 벌레같다는..

암튼. 저 데이터를 XML로 변환을 하면.. &#15; 가 되지요.

이  &#15; 를 다시 원래 벌레로 만들려면 XML 파서가 바로 위 같은 에러를 뱉어냅니다.

이 문제를 해결하기 위해서..

final Pattern nonValidPattern = Pattern.compile("&#(x?)([0-9a-fA-F]+);");

 public String stripNonValidXMLCharacters(String str) {
  StringBuffer out = new StringBuffer();
  Matcher matcher = nonValidPattern.matcher(str);
  int value = 0;
  boolean isHex = false;
  boolean valid = false;
  while (matcher.find())
  {
   isHex = matcher.group(1) != null;
   value = Integer.parseInt(matcher.group(2), isHex ? 16 : 10);
   valid = false;
   if ((value == 0x9) ||
     (value == 0xA) ||
     (value == 0xD) ||
     ((value >= 0x20) && (value <= 0xD7FF)) ||
     ((value >= 0xE000) && (value <= 0xFFFD)) ||
     ((value >= 0x10000) && (value <= 0x10FFFF)))
    valid = true;
   if (!valid)
    matcher.appendReplacement(out, "");
  }
  matcher.appendTail(out);
  return out.toString();
 }

이 method를 사용하면 됩니다.

"&#(x?)([0-9a-fA-F]+);"

바로 이 패턴을 이용하여, &#xx; 이런식의 문자열을 지워버리는거죠.

&#로 시작하고,
&#뒤에 x가 0번 혹은 1번만 나오고.
&#뒤에 뒤에 숫자, 또는 영문자 a~f 까지만 허용되는 문자열이 1번 이상 나오고,
마지막은 ; 로 끝나는 문자열을 찾는거죠.

해당 문자열을 찾은 후에

   if ((value == 0x9) ||
     (value == 0xA) ||
     (value == 0xD) ||
     ((value >= 0x20) && (value <= 0xD7FF)) ||
     ((value >= 0xE000) && (value <= 0xFFFD)) ||
     ((value >= 0x10000) && (value <= 0x10FFFF)))
    valid = true;


이 루틴을 이용해서, XML 파싱에 허용되는 문자들만 거르게 되는겁니다!! 냐하하하.

:
Posted by 뽀기

'즐겨찾기 > 공부' 카테고리의 다른 글

자바스크립트 매뉴얼(한글)  (0) 2007.04.19
DOM 이해하기 (한글)  (0) 2007.04.19
:
Posted by 뽀기
2007. 4. 19. 11:37

DOM 이해하기 (한글) 즐겨찾기/공부2007. 4. 19. 11:37

DOM 이해하기 Tutorial

https://www.ibm.com/developerworks/kr/library/tutorial/x-udom/index.html


from : IBM developerWorks
:
Posted by 뽀기
2007. 3. 20. 10:36

DOM(Document Object Model) 그거/Tech2007. 3. 20. 10:36

DOM

DOM(Document Object Model)

  • W3C's definition

    "The Document Object Model is a platform- and language-neutral interface that will allow programs and scripts to dynamically access and update the content, structure and style of documents.

  • DOM 의 역할
    • dynamic access and update
      • XML/HTML 문서의 접근 및 수정 => 내용/구조/스타일 정보의 검색 및 수정
      • 대상 문서 : XML1.0 또는 HTML4.0, 기타 웹문서
      • 컨텐츠의 조작 : 문서 요소에서 text 등 컨텐츠의 검색/질의, 추가/수정/삭제
      • 구조의 탐색 및 조작 : 각 요소와 속성에 대한 검색/질의, 추가/수정/삭제
    • interface
      • 응용 프로그램 인터페이스 (API) - 각종 메소드 및 속성을 정의
      • 플랫폼 및 언어 중립적(스크립트 포함) : Java, JavaScript, ASP, ...
  • DOM level
    • DOM level 1 : 1998.10 W3C 표준안
    • DOM level 2 : 2000.11 W3C 표준안
    • DOM level 3 : 2001.8 W3C Working Draft

DOM and XML Parser

  • Parser 의 역할
    • XML 문서를 읽고 해석 : well-formed, valid 검사
    • 응용프로그램 개발시 파서 사용 이유
      • 파서가 메모리에 DOM 트리를 생성 : XML 문서트리와 일치
      • 세부적인 XML 문법으로부터 프로그램 격리

  • [참고] SAX 기반 Parser

DOM 구조적 모델

  • DOM 트리에서 노드/객체의 종류
    • Document : 문서 객체, 최상위 노드
    • Element, Attribute : 문서의 구조를 구성하고 있는 요소
    • Text : 컨텐츠의 내용, 항상 단말 노드
    • Collection : 일종의 노드 집합
  • DOM 트리의 예

    <parent>
        <child  id="123">text here</child>
     </parent>

     

  • 인터페이스(API)의 예
    • 객체의 속성과 메소드를 사용하기 위한 사양
    • DOM 인터페이스 예
      - 문서.childNodes[1].nodeName
      - 문서.firstChild.firstCild.firstCild.nodeName
      - 문서.firstChild.firstCild.firstCild.nodeValue
  • DOM Core Interface (Object Hierachy) 교재 p.414 (표9-3)

DOM 주요 API

  • DOM 인터페이스의 공통 속성
    • type, name, value
    • 예) Node 객체의 경우 nodeType, nodeName, nodeValue 속성
      • nodeType은 위 그림과 같이 여러 가지가 있다 (p.418 표 9-6, 9-7)
  • 주요 객체/속성/메소드 - 진행하면서 지속적으로 참조

    객체(Object)

    속성(Properties)

    메소드(methods) 

    Node 객체

    nodeName, nodeType, nodeValue, childNodes, parentNode, childNode, firstChild, lastChild, previousSibling, nextSibling, attributes, ownerDocument, ..., 
    (
    text, xml) [표9-8]

    [표9-10] 노드 정보 구하기
    getNodeName, ..., getAttributes, ...
    [표 9-11] 문서 조작
    appendChild, insertBefore,
    removeChild, replaceChild, cloneNode
    [표 9-12] 트리 순회 관련
    getParentNode, getChildNode, ...
    hasChildNodes, ...

    Document 객체

    doctype,
    documentElement, implementation, ...

    (async, readyState)
    * W3C 표준이 아니라  MS에서 제공하는 인터페이스

    [표9-13] 문서관련 정보
    egtDoctype, getImplementation, ...
    [표 9-14] 트리 순회 관련
    getDocumentElement, getElemenmtByID,
    getElementByTagName, ...
    [표 9-15] 문서 작성
    createElement, createAttribute, createTextNode, createCDATASection, createComment, createEntityReference, ...

    DOMImplementation 객체


    [표 9-16] hasFeature, createDocument, ...

    DocumentFragment 객체

    * Node 객체와 동일

    * Node 객체와 동일

    NodeList 객체

    length

    [표 9-17] getLength, item

    Element 객체

    tagName

    [표 9-18] Element의 속성에 접근
    getAttribute, setAttribute, getAttributeNode, setAttributeNode, removeAttribute, ...,
    [표 9-18]Element 객체에 접근
    getTagName, hasAttribute, ...

    NamedNodeMap 객체

    length

    [표 9-19] getNamedItem, setNamedItem, removeNamedItem, item, getLength

    Attribute 객체

    name, value

    [표 9-20] getName, getValue, setValue, ...

    CharacterData 객체

    data, length

    [표 9-21] appendData, deleteData, insertData, replaceData, substringData, ...

DOM 프로그래밍 시작 - Document 객체

  • 문서 객체 새로 만들기 : DOMDocument 객체를 생성
    • Msxml.DOMDocument 객체를 새로 만들기
    • 또는 HTML에서 <xml> 태그 이용

    JavaScript (JScript)

    <Script language="Javascript">
       
    var xdoc1,xdoc2
       
    xdoc1 = new ActiveXObject("Msxml.DOMDocument");
       
    xdoc2 = new ActiveXObject("Msxml.DOMDocument");
        ...
    xdoc1.load("ex08.xml");  xdoc2.load("ex09.xml");
    </script>
    VBScript 의 경우 <Script language="VbScript">
      Dim xdoc1,xdoc2
      Set xdoc1 = CreateObject("Msxml.DOMDocument")
      Set xdoc2 = CreateObject("Msxml.DOMDocument")
      ...
    xdoc1.load("ex08.xml"); xdoc2.load("ex09.xml");
    </Script>

    HTML에서 <xml>  태그 이용

    - MSXML 파서 설치안한 경우

    <HTML> <HEAD>
        <Script language="Javascript">
            xdoc.load("ex08.xml");    </script>
    </HEAD>
    <BODY>
        <xml id="xdoc1"></xml>
        <xml id="xdoc2" src="ex09.xml"></xml>
    </BODY> </HTML>

    Java의 경우

    import java.xml.parsers.*;
    ...
    class xxxxxx
    {
      public static void main(String[] args) throws Exception
      {
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        DocumentBuilder  db = dbf.newDocumentBuilder();
        Document  xdoc1 = db.parse(new FileInputStream(arg[0]));
    ...

  • 기존의 XML 문서 읽기
    • DOMDocument 객체 읽기 - async 속성, load 메소드, xml 속성 : MSXML에서 제공
    MSXML 파서 설치한 경우   MSXML 파서 설치안한 경우  
    <HTML>
    <HEAD>
    <Script language="Javascript">
    function xload0()
    {
       
    var xdoc = new
            ActiveXObject("Msxml.DOMDocument");
        xdoc.
    async = false;    xdoc.load("ex08.xml");
       
    alert(xdoc.xml);
    }
    </script>
    </HEAD>
    <BODY>
    <input type="button" value="XML 로드0"
        onClick="xload0()">
    </BODY>
    </HTML>  
    <HTML>
    <HEAD>
    <Script language="Javascript">
    function xload1()
    {
        xdoc.async = false;
        xdoc.load("ex08.xml");

         alert(xdoc.xml);
    }
    </script>
    </HEAD>
    <BODY>
    <input type="button" value="XML 로드1"
        onClick="xload1()">
    <xml id="xdoc"></xml>
    </BODY>
    </HTML>
    VBScript 의 경우
    <Script language="VbScript">
      Dim xdoc
      Set xdoc = CreateObject("Msxml.DOMDocument")
      xdoc.
    async = False;
      xdoc.
    load("ex08.xml");  MsgBox  xdoc.xml
    </Script>
  • 신규 XML 문서의 작성
    • loadXML 메소드  
     xdoc.async = false;
     xdoc.
    loadXML( "<book><title>XML 입문</title><author>일지매</author></book>");
     alert(xdoc.xml);  
     xdoc.async = false;
     xdoc.
    loadXML( "<book> <title> XML 입문 </title> <author> 일지매 </author> </book>");
     alert(xdoc.xml);  
  • 공백의 처리 : preserveWhiteSpace 속성
     xdoc.async = false;
     xdoc.preserveWhiteSpace = true;
     xdoc.loadXML( "<book> <title> XML 입문 </title> <author> 일지매 </author> </book>");
     alert(xdoc.xml);  
     xdoc.async = false;
     xdoc.preserveWhiteSpace = true;
     xdoc.load("ex08.xml");
     alert(xdoc.xml);  
  • XML 문서의 저장 : save 메소드
  • 에러 처리 : parseError 객체
    • parseError.errorCode, parseError.line, parseError.linepos, parseError.reason
     xdoc.async = false;
     xdoc.loadXML( "<book> <title> XML 입문 </title> <author> 일지매 </authors> </book>");
     alert(xdoc.xml);  
     xdoc.async = false;
     xdoc.loadXML( "<book> <title> XML 입문 </title> <author> 일지매 </authors> </book>");
     if (xdoc.parseError)
        alert("에러 위치 : " + xdoc.parseError.line + "번째 라인 " + xdoc.parseError.linepos 
                  + "번째 문자 에러 이유 : " + xdoc.parseError.reason);
     else
    alert(xdoc.xml);  
  • 루트 노드 찾기 (루트 에리먼트)
    • documentElement 속성
     xdoc.async = false;
     xdoc.load("ex08.xml");
     var xroot = xdoc.
    documentElement;
     alert(xroot.nodeName);  
     xdoc.async = false;
     xdoc.loadXML( "<book> <title> XML 입문 </title> <author> 일지매 </author> </book>");

     var xroot = xdoc.
    documentElement;
     alert(xroot.nodeName);  

Node 객체의 정보구하기 - Node 객체

  • 속성 : nodeName, nodeType, nodeValue, attributes, text 속성
  • nodeType
    • 1 (element), 2 (attribute), 3 (text) , 4 (CDATA), 5 (Entity Reference)...
  •  xdoc.load("ex08.xml");
     var xroot = xdoc.documentElement;
     alert('nodeName: '+xroot.nodeName+' nodeType: '+xroot.nodeType+
           ' nodeValue: '+xroot.nodeValue+' attributes: '+xroot.attributes.length);
     alert('xroot.text : ' + xroot.text);
     

실습 프로그램

  • 파일 LOAD 및 DOM 명령 실행 (교재 s20-03.htm 과 s20-05.htm 혼합)

    XML 파일 경로를 직접 입력하거나  '찾아보기'로 선택, 'LOAD'로 파일을 메모리에 로드
    경로 :  =>

    또는 미리 작성되어 있는 파일 사용하기  

    사용하고자 하는 DOM 구문을 아래에 입력하고 '확인' 버튼을 클릭  (예 : xdoc.text, xdoc.documentElement.firstChild.nodeName, ...) 구문 :    

     <SCRIPT language="Javascript">
            var xdoc, rootNode;
            function
    FileLoad(filename)
            {
                    xdoc = new ActiveXObject("Msxml.DOMDocument");
                    xdoc.async = false;
                    if (filename) xdoc.load(
    filename);
                    else xdoc.load(
    "file://"+path.value);
                    if (xdoc.parseError.errorCode != 0)
                        alert("파일을 메모리로 로드하는데 실패하였습니다 : " + xdoc.parseError.reason);
     
                    rootNode = xdoc.documentElement;
                    alert("[파일로드 성공] 루트 엘리먼트 : " + rootNode.nodeName);
            }
            function Execute()
            {
                    var selectionString;
                    try {
                            selectionString = eval(syntax.value);
                    } catch(e) {
                            selectionString = null;
                    }
                    alert(selectionString);
            }
    </SCRIPT>  
     ...
    <BODY>
     ... 경로 : <input  type="file"  size="40"  id="
    path">
         <input  type="button"  value="LOAD"  onclick="
    FileLoad()">
     ... 미리 작성되어 있는 파일
         <input  type="button"  value="서점 책 list"  onclick="
    FileLoad("ex08.xml")">
     ... 구문 : <input  size="50"  id="
    syntax"  value="xdoc.">&nbsp;
         <input  type="button" onclick="
    Execute()" value=확인>
     ...
    </BODY>

'그거 > Tech' 카테고리의 다른 글

JSTL(JavaServer Pages Standard Tag Library)  (0) 2007.03.29
Velocity  (0) 2007.03.29
패턴과 프레임워크  (0) 2007.03.14
Crossing borders: JavaScript의 특징 (한글)  (0) 2007.03.13
JSON vs. XML  (0) 2007.03.13
:
Posted by 뽀기
2007. 3. 13. 15:22

JSON vs. XML 그거/Tech2007. 3. 13. 15:22

Ajax를 이용한 웹 애플리케이션이 늘어나면서부터 서버와의 통신에 있어 어떠한 데이터 교환 형식을 이용할지에 대한 관심이 부쩍 늘어난 것 같다. 이러한 관심의 예로 JSON(Javascript Object Notation)을 기존 XML을 대체할 데이터 교환 규약으로 보고 있는 사람들이 많으며 26일 InfoQ에서도 이러한 JSON과 XML에 대한 논쟁?을 기사로 올렸다. XML은 지난 몇년에 걸쳐 업계의 노력으로 이제는 완전히 시장이 포화상태에 있다. 반면 JSON은 그동안 사람들에게 많이는 알려지지 않았지만, 그 고유의 단순함 내지는 경량모델로 최근에 개발자들 사이에서 인기를 얻고있는 데이터 교환이다. 뭐 사실 구글에서 조금만 검색해도 JSON에 대한 이런 이야기는 많이 찾아볼 수 있다. -_-;

JSON은 Head Rush Ajax라는 책에서 처음 접했는데, 처음보는 것이고 또 아직은 XML이 더 눈에 익숙하고 더 연마해야 하는지라 자세히 살펴보지는 않았는데, JSON에 관한 ppt를 보니 사람들이 왜 JSON에 열광하는지 조금 이해가 갔다. 사실 XML은 그 규약 자체도 상당히 엄격한(XML의 well-formedness를 준수하는 데만도 10가지 규칙을 내세운다.)데다 네임스페이스나 그런것도 복잡하고...

아무튼 JSON을 지지하는 측에서 JSON이 데이터 교환에 있어서의 장점은 이렇단다. (대충 직역)
1. 사람과 동시에 기계도 읽을 수 있는 형식이다.
2. 유니코드를 지원하는데, 따라서 거의 모든 인간 언어가 소통 가능하다.
3. 자기문서화적이다(? 원문 - self-documenting). 즉, 특정 값 뿐만 아니라 구조와 필드명까지 서술한다.
4. 엄격한 문법과 필수적인 알고리즘을 허용하는 파싱 요구조건이 단순하며, 효율적이고, 일관성있다.
5. 대부분의 일반 컴퓨터 과학에서 제시하는 자료구조인 레코드, 리스트, 트리를 표현할 수 있는 능력을 지녔다.

반면에 JSON 사용에 대해 반박하는 일반적인 논쟁거리는 다음과 같다.
1. JSON은 네임스페이스를 갖지 않는다. 따라서 모든 객체 자체가 네임스페이스이며 키 집합은 다른 객체에 독립적이며 심지어 배타적으로 중첩된다. 또한 JSON은 애매모호함을 피하기 위해 다른 언어에서 하는 것과 같이 컨텍스트를 이용한다.
2. JSON은 검증기가 없다. 궁극적으로 모든 애플리케이션이 입력에 대한 검증을 책임져야 한다. 이는 위임될 수 없으나 YAML 검증기는 사용할 수 있다.
3. JSON은 확장될 수 없다. 사실 그럴필요가 없다. JSON은 유연하며 어떠한 비순환 데이터 구조를 표현할 수 있다. 새로운 필드가 기존 구조를 폐기시키지 않고도 추가될 수 있다.
4. JSON은 XML이 아니다. Douglas는 JSON이 XML에 비해 훨씬 더 심플하다고 주장한다.

읽고나서 보니 Douglas 이 사람 JSON을 발명한 아키텍트네.. -_-;;
아무튼 JSON이 XML에 비해 데이터 교환에 있어서는 상당히 간단한 것임에는 틀림없고, 어디에 어떻게 사용되는 지는 그 상황이 어떠한 상황이냐에 달린 것 같다.(어중간한 으로 마무리.. -_-v)

그나저나 JSON은 뭐라고 발음한다냐? '제이손'? '제이에스-온'? '제이에스오엔'?, '자바스크립트 오브젝트 노테이션~ 헉헉'?

출처 : decoder.egloos.com

:
Posted by 뽀기
2007. 2. 22. 17:17

10. XML 문서의 변환과 응용 그거/Tech2007. 2. 22. 17:17

# XML 문서의 변환과 응용

# 문서 변환 방법

1. TrAX(Transformation API for XML)
  XSLT stylesheet를 이용해 문서 변환을 수행

# 데이터의 변환

1. XML의 입력
  TrAX : 여러 형태의 XML 데이터 입력을 처리할 수 있도록 고안됨

  Source interface 구현

  StreamSource source = new StreamSource("events.xml");

2. 변환 결과의 출력
  문서 변환의 결과는 문서 입력의 형식에 따라 여러 가지 형식을 가질 수 있으며,
  이러한 변환 결과의 출력을 위해 Result interface를 이용

  StreamResult result = new StreamResult("transform.html");

3. TransformerFactory
  문서의 변환을 위한 Transformer 객체를 생성하기 전에 TrasnformerFactory class를 이용한다.

  TransformerFactory transFactory = TransformerFactory.newInstance();

4. stylesheet의 선택
  Transformer 객체는 하나의 특정 stylesheet에 기반을 두고 있기 때문에,
  Transformer 객체를 생성하기 전에 문서 변환에 이용할 stylesheet를 지정해야 한다.

  StreamSource style = new StreamSource("style.xml");

  하지만, XML 문서내에 여러 종류의 stylesheet를 이용할 경우 문제가 되기 때문에 다음과 같이 수정한다.

  Source style = transFactory.getAssociatedStylesheet(source, null, null, null);

  getAssociatedStylesheet(StreamSource, media attribute, title attribute, charset attribute)
    : XML 문서 내 XSLT 처리 지시문의 media, title, charset attribute를 기반으로 stylesheet 문서를 선택할 수 있도록 한다.

5. Transformer 객체의 생성과 문서 변환
  TransformerFactory에서 Transformer 객체를 생성할 때는 문서 변환에 필요한 모든 규칙들을 포함하고 있는 stylesheet 문서를 Transformer 객체에 전달해야 한다.
  stylesheet를 지정하지 않을 경우 출력 결과는 입력 XML 문서와 동일한 문서가 된다.

  Transformer trans = transFactory.newTransformer(style);
  trans.transform(source, result);

# template과 parameter
  Templates 객체를 이용하여 여러 파일에 대해 문서 변환 수행시 Transformer를 미리 compile 시켜 두고 사용하면 처리 시간과 성능을 향상시킬 수 있다.

1. template 생성
  TrAX에서 template의 생성은 TransformerFactory와 Transformer 객체의 생성 과정 중간 단계에서 이루어진다.

  Templates template = transFactory.newTemplates(style);
  Transformer trans = template.newTransformer();

  template은 동일한 stylesheet를 이용해서 여러 번 문서 변환을 수행할 때 더 효과적이다.

2. parameter의 이용
  문서 변환 과정을 수행할 때 전달 가능한 값으로, 변환 결과에 영향을 미치게 된다.

  trans.setParameter("optionalChoice", "yes");

3. 다중 파일의 변환
  template과 parameter를 이용해서 여러 XML 파일을 효과적으로 변환하거나 하나의 XML 파일에 대해 여러 번 문서 변환을 수행할 수 있다.

  String outputFileName_opt = "transform_opt.html";
  String outputFileName_mand = "transform_mand.html";

  StreamResult result_opt = new StreamResult(outputFileName_opt);
  StreamResult result_mand = new StreamResult(outputFileName_mand);

  ...

  trans.setParameter("optionalChoice", "yes");
  trans.transform(source, result_opt);

  trans.setParameter("optionalChoice", "no");
  trans.transform(source, result_mand);

# 문서 변환과 SAX
  TrAX에서 SAX를 이용할 경우 추가적으로 고려해야 할 사항들
  - TrAX를 사용하기 전에 SAXSources와 SAXResults를 이용한다.
  - 문서 변환을 수행할 ContentsHandler를 작성하고, 이를 통해 입력 XML 문서를 파싱한다.
  - 문서 변환에 XMLFilters 객체를 사용할 수도 있다.

1. SAX 입력
  SAX 이벤트에 대한 소스를 생성하고 이를 문서 변환을 위한 입력으로 이용하기 위해 SAXSource 객체를 지정한다.

  XMLReader reader = XMLReaderFactory.createXMLReader();
  SAXSource source = new SAXSource(reader, new InputSource("inputFile.xml"));

  StreamResult result = new StreamResult("outputFile.xml");

  TransformerFactory transFactory = TransformerFactory.newInstance();
  Source style = transFactory.getAssociatedStylesheet(source, null, null, null);
  Transformer trans = transFactory.newTransformer(style);

  trans.transfor(source, result);

  입력 문서의 유효성 검증은 다음과 같이 가능하다.

  String featureId = "http://www.xml.org/sax/features/validation";
  reader.setFeature(featureId, true);

2. Transformer를 ContentsHandler로 이용
  Transformer를 Contentshandler로 명시적으로 선언

  StreamResult result = new StreamResult("outputFile.xml");

  TransformerFactory transFactory = TransformerFactory.newInstance();
  SAXTransformerFactory saxTransFactory = (SAXTransformerFactory)transFactory;

  TransformerHander trans = saxTransFactory.newTransformerHandler(style);
  trans.setResult(result);

  XMLReader reader = XMLReaderFactory.createXMLReader();

  reader.setContentHandler(trans);

3. SAX 출력
  문서 변환의 결과로 출력되는 SAX 스트림이 의미를 가지도록 하기 위해서는 이 SAX 스트림을 ContentsHandler에 전달해야 한다.

4. 연속된 문서 변환
 
  한 문서 변환 과정의 결과가 다른 문서 변환 과정의 입력으로 처리 되는 식의 연속된 처리 과정

  StreamSource style1 = new StreamSource("votes1.xsl");
  StreamSource style2 = new StreamSource("votes2.xsl");

  StreamResult result = new StreamResult("output.xml");

  TransformerFactory transFactory = TransformerFactory.newInstance();

  SAXTransformerFactory saxTransFactory = (SAXTransformerFactory)transFactory;

  TransformerHandler trans1 = saxTransFactory.newTransformerHandler(style1);
  TransformerHandler trans2 = saxTransFactory.newTransformerHandler(style2);

  trans1.setResult(new SAXResult(trans2));  // trans1에 대한 출력을 SAXResult로 trans2에 전달
  trans2.setResult(result);                 // trans2에 대한 출력을 result로 출력

  XMLReader reader = XMLReaderFactory.createXMLReader();
  reader.setContentHandler(trans1);
  reader.parse("xmlfile.xml");

5. SAX와 XMLFilter
  XMLFilter를 이용하여 연속된 문서 변환을 수행할 수도 있다.

  XMLFilter trans1 = saxTransFactory.newXMLFilter(style1);
  XMLFilter trans2 = saxTransFactory.newXMLFilter(style2)'

  TransformerHandler output = saxTransFactory.newTransformerHandler();
  output.setResult(result);

  trans1.setParent(reader);
  trans2.setParent(trans1);
  trans2.setContentHandler(output);

  trans2.parse("output.xml");

# stylesheet 문서 내에서의 프로그래밍

  stylesheet 문서 내에서 확장 함수나 element들을 생성할 수 있는 방법을 정의하고 있다.

1. 확장함수
  사용자 정의 함수를 이용하기 위해서는 새로운 namespace를 생성하여 XSLT 변환 엔진이 새로 정의된 함수를 인식할 수 있도록 해야 한다.

  <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                  xmlns:lxslt="http://xml.apache.org/xslt"
      xmlns:results="http://www.example.com/results"
      extension-element-prefixes="results"
      version="1.0">
  <lxslt:component prefix="results" functions="addVote, getResults">
 <lxslt:script lang="javascript">
      var sparkle, dregraal;

   sparkle = 0;
   dregraal = 0;

   function addVote(thisVote) {
     if( thisVote.equals("Sparkle") ) {
     sparkle++;
     } else {
       dregraal++;
     }
     return null;
   }

   function getResults() {
     return "Sparkle : " + sparkle + " Dregraal : " + dregraal;
   }
    </lxslt:script>
  </lxslt:component>

'그거 > Tech' 카테고리의 다른 글

구조적 VS 객체지향적  (0) 2007.02.27
자바서비스넷의 기술자료 링크  (0) 2007.02.23
09. XSLT(eXtensible Stylesheet Language Transformations)  (0) 2007.02.20
08.XML Schema  (0) 2007.02.16
07.DTD(Document Type Definition)  (0) 2007.02.15
:
Posted by 뽀기

# XSLT (eXtensible Stylesheet Language Transformations)
  XSL(XML Stylesheet Language)
   : CSS의 기능과 유사하게 XML 문서에 대한 style을 정의하고 적용할 때 사용하는 언어
  XSLT
   : XSL 표준을 구성하는 일부, XML 데이터를 변경할 때 필요한 '규칙'을 정의할 목적으로 고안됨.
   : 주로 XML 데이터를 HTML 페이지로 변환하여 이를 브라우저에 출력하는데 이용

# XSL, XSLT, XSL-FO
  XSLT : 문서의 변환 규칙을 정의하기 위한 언어
  XSL-FO : XSL, 즉 XML을 위한 stylesheet 정의 언어에서 이용될 formatting 객체를 정의하는 언어. 문서가 어떻게 꾸며져야 하는지 지정하기 위해 사용.

#. XSLT의 기본 구조

1. stylesheet 문서
  XSLT 문서는 transform element를 root로 하며, XSL에 대한 namespace와 하나 이상의 template 정보를 포함한다.

  <?xml version="1.0"?>
  <xsl:transform xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
  <xsl:template match="/">
    <html>
   <head><title>Thank you letter</title></head>
   <body>
   ...
   </body>
 </html>
  </xsl:template>
  </xsl:transform>

2. 값의 출력
  XSLT의 value-of element를 이용하여 프로세서를 통해 특정 정보 아이템을 출력할 수 있다.

# XPath의 개요

1. 자식과 후손 엘리먼트
  XPath는 XML 문서 내에 현재 방문중인 노드(context node)에서 이동하고자 하는 노드에 대한 위치 정보를 제공
  context node가 결정되면 다른 node로의 방문은 file system 이나 URL과 유사하다.

 <?xml version="1.0"?>
 <content>
  <events>
   <eventitem eventid="A335">
    <eventdate>6.20.3425</eventdate>
    <title>Making Friends With The Venusian Flu Virus</title>
    <description>Dr. Biff Mercury discusses his theory on coexisting with useful organism.</description>
   </eventitem>
   <eventitem eventid="B963" optional="no">
    <eventdate>6.21.3425</eventdate>
    <title>Putting the Manners in Bedside Manner</title>
    <description>Dr. Zingzowpowie, the famous xenoneurosurgen lectures on Bedside Manner and the benefits of using cold tentacles during a physical</description>
   </eventitem>
   <eventitem eventid="C934" optional="yes">
    <eventdate>6.25.3425</eventdate>
    <title>An evening of Fun</title>
    <description>This evening join us for the monthly "Identify that Food" contest.</description>
   </eventitem>
  </events>
  <news>
   <newsitem itemnum="1">
    <newsdate>6.18.3425</newsdate>
    <title>End of the line for the incumber?</title>
    <body>
     The Universal News Network is reporting that <person>His Magnificence The Supreme Leader For Life</person>
     announced today that he has decided not to be cloned for a 14th term.
    </body>
   </newsitem>
   <newsitem itemnum="2">
    <newsdate>6.19.3425</newsdate>
    <title>New Fall Lineup</title>
    <body>
     The Omega Channel has announced two new shows for its new fall lineup.
     <program>Who's Running the Galaxy?</program>
     features a team of government scientists who accidentally clone two Supreme Leaders.
     If you think you're confused, imagine what the first family must be going through.
     <program>Trading Species</program> follows two temas of aliens who trade species
     and have only 48 hours to adjust and fool their neighbors.
    </body>
   </newsitem>
  </news>
 </content>

  context node가 content node 라면
   - newsdate element로 이동하기 위한 XPath 표현식은 news/newsitem/newsdate 이다.
   - events/eventitem/eventdate와 같은 경우는 문서 내 모든 eventdate element를 지칭한다.
   - content//title 과 같은 경우는 eventitem element 또는 newsitem element의 자식 element인 title element 모두를 가리킨다.
  news node가 context node인 경우 newsdate element로 이동하기 위해서는 newsitem/newsdate 와 같이 표기할 수 있다.
  //title과 같은 경우는 root element의 모든 후손 element 중에서 title element를 가리킨다.

2. 문서의 root
  절대 경로를 지원한다.
  newsdate element는 /content/news/newsitem/newsdate 과 같이 표기할 수 있다.

  / 는 한 문서의 root 이며 content 는 이 문서의 root element 이다.

  content는 문서 root(/)의 자식 element(/content)로 표현된다.

3. attribute
  attribute를 element의 자식으로 취급하지 않는다.
  XPath에서의 attribute 표현은 @를 이용한다.

  news element가 context node일 경우 다음과 같이 표현할 수 있다.

  /content/events/eventitem@eventid
  /content//newsitem@newsid
  newsitem@newsid

4. 검색조건
  element들의 그룹에서 특정 기준을 만족하는 element만 추려낼 수 있는 필터
  XPath에서는 []를 이용하여 특정 조건을 기술할 수 있다.

  예)
  attribute 값이 C934인 eventid attribute를 가지는 eventitem element를 선택하는 경우
  /content/events/eventitem[@eventid='C934']

  [] 내의 텍스트는 검색 대상과 검색 조건을 타나내며, 검색 조건읜 괄호 내 오른쪽에 표기한다.

  이 표현식의 처리 결과는 element 목록을 반환한다.

  문서내에서 특정 element에 대한 정보의 존재 유무를 확인하려면 다음과 같이 사용한다.

  /content/events/eventitem[@eventid]

# template
  XSLT 문서에서 모든 변환 과정은 하나 이상으 template으로 정의, 실행된다.
  template은 입력 문서에서 변환할 부분을 선택하고 출력 형식을 정의한다.

1. template의 생성
 
  <?xsml version="1.0"?>
  <xsl:transform xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
  <xsl:template match="/content/events/evenetitem">
    <h2>An event title</h2>
 <h3>(Date</h3>
 <p>An event description</p>
 <hr/>
  </xsl:template>
  <xsl:template match="/content/news">
  </xsl:template>
  </xsl:transform>

  match attribute는 template이 처리할 노드나 노드들을 지정하는데 이용된다.
  eventitem element를 방문할 때 마다 정보를 변환하여 출력한다.

2. template의 적용
  stylesheet에서는 하나의 template으로 문서를 변환하는 것보다 여러 개의 template으로 입력XML 문서의 정보들을 단계적으로 처리하는 것이 더 효과적이다.

 <xsl:template match="/">
  <xsl:apply-templates/>
 </xsl:template>

 <xsl:template match="/content/events/eventitem/title">
  <h2><xsl:value-of select="."/></h2>
 </xsl:template>

 <xsl:template match="/content/events/eventitem/eventdate">
  <h3>(<xsl:value-of select="." />)</h3>
 </xsl:template>

 <xsl:template match="/content/events/eventitem/description">
  <p><xsl:value-of select="."/></p>
  <hr/>
 </xsl:template>
  apply-templates element를 이용해서 stylesheet에 정의된 다른 template을 적용할 수 있다.

  아래와 같이 하면 각 element의 순서를 입력문서에 나타나는 순서로 맞출 수 있다.

 <xsl:template match="/content/events/eventitem">
  <xsl:apply-templates select="title"/>
  <xsl:apply-templates select="eventdate"/>
  <xsl:apply-templates select="description"/>
  <hr/>
 </xsl:template>

 <xsl:template match="title">
  <h2><xsl:value-of select="."/></h2>
 </xsl:template>
 <xsl:template match="eventdate">
  <h2><xsl:value-of select="."/></h2>
 </xsl:template>
 <xsl:template match="description">
  <h2><xsl:value-of select="."/></h2>
 </xsl:template>

3. 내장 template
  template 규칙이 정의되지 않은 영역에 대해 내부적으로 적용되는 template을 내장 template으로 정의한다.

# 컨텐츠의 생성

1. 동적 element
  element element를 이용하여 생성할 수 있다.

  <xsl:template match="title">
    <xsl:element name="h2">              --+
   <xsl:value-of select="."/>           +- <h2><xsl:value-of select="title"/></h2> 와 같은 표현
 </xsl:element>                       --+
  <xsl:template>

  =>

  <h2>Making Friends with... </h2>

2. 동적 attribute
 element element로 생성한 element에 attribute를 추가하기 위해서는 attribute element를 이용한다.

  <xsl:template match="title">
    <xsl:element name="h2">
      <xsl:element name="a">
        <xsl:attribute name="href">register.php?event=<xsl:value-of select="../@eventid"/></xsl:attribute>
        <xsl:value-of select="."/>
      </xsl:element>
    </xsl:element>
  </xsl:template>

  =>

  <h2><a href="register.php?event=A335">Making Friedns ...</a></h2>

3. XML에서 XML로의 변환
  XLST는 XML 문서를 다른 문서 구조를 가지는 XML 문서로 변환하기 위해 이용할 수 있다.

  <xsl:template match="/">
    <schedule>
   <xsl:apply-templates />
 </schedule>
  </xsl:template>

  <xsl:template match="content/events/eventitem">
    <xsl:element name="action">
   <xsl:attribute name="optinal"><xsl:value-of select="@optional"/></xsl:attribute>
   <title><xsl:value-of select="title"/></title>
 </xsl:element>
  </xsl:template>

  =>

  <!-- If an event is not explicitly marked as "optional", then it's mandatory -->

4. 주석문의 추가
  comment element를 이용한다.

  <xsl:comment>If an event is not explicitly marked as "optional", then it's mandatory</xsl:comment>

5. 처리 지시문
  XSLT를 이용해 문서 변환을 수행하는 application이 처리 지시문을 보려 할 경우, 이를 template에 직접 추가할 수는 없으나 명시적으로 생성할 수는 있다.

  <xsl:template match="content/events/eventitem">
    <xsl:processing-instruction name="updateSched">id="<xsl:value-of select="@eventid"/>"</xsl:processing-instruction>
 ...
  </xsl:template>

  =>

  <?updateSched id="A335'?>

6. 데이터의 정렬
  sort element를 제공

  <xsl:template match="/">
    <schedule>
   <xsl:comment>If an event is not explicitly marked as "optional", then it's mandatory</xsl:comment>
   <xsl:apply-templates select="content/events/eventitem">
     <xsl:sort select="eventdate" order="descending"/>
   </xsl:apply-templates>
 </schedule>
  </xsl:template>

7. 반복문의 생성
  for-each element를 이용

  <xsl:template match="/">
    <xsl:for-each select="eventitem">
   <xsl:apply-templates select="title"/>
 </xsl:for-each>
  </xsl:template>

8. copy-of와 value-of
  value-of : 해당 element의 값
  copy-of : element의 값 뿐만 아니라 element나 attribute를 포함한 node 집합의 전체 구조

  노드의 복사(eventitem element 단위로 출력 문서를 작성)
    <?xml version="1.0"?>
 <xsl:transform xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
   <xsl:template match="content/events/eventitem">
     <xsl:copy-of select="."/>
   </xsl:template>
 </xsl:trasnform>

# 변수와 파라미터

1. named template
  template을 적용할 대상을 match attribute로 지정하지 않으며, template의 이름만 지정.
  이 template은 call-template element로 직접 적용한다.

  <xsl:template match="/content/events">
    <xsl:call-template name="eventTemplate"/>
  </xsl:template>

  <xsl:template name="eventTemplate">
    <xsl:for-each select="eventitem">
   <xsl:apply-templdate select="title"/>
   <xsl:apply-templdate select="eventdate"/>
   <xsl:apply-templdate select="description"/>
 </xsl:for-eachL
  </xsl:template>

  <xsl:template match="title">
  ...
  </xsl:template>
  ...

2. parameter
  parameter를 미리 정의하고 이를 나중에 참조할 수 있다.
  param element를 이용해 parameter를 생성한다.
  문서에서 parameter를 참조할 때 parameter의 이름 앞에 $ 기호를 붙인다.

  <xsl:param name="optionalChoice" select="'no'"/>

  <xsl:for-each select="eventitem[@optional=$optionalChoice]">
  ...
  </xsl:for-each>

3. named template and parameter
  template을 호출할 때 parameter를 설정할 수 있다.

  <xsl:call-template name="eventTemplate">
    <xsl:with-param name="isOptional"><xsl:value-of select="$optionalChoice"/></xsl:with-param>
  </xsl:call-template>
  <xsl:call-template name="eventTemplate">
    <xsl:with-param name="isOptional"><xsl:value-of select="$optionalChoice"/>x</xsl:with-param>
  </xsl:call-template>

  ...

  <xsl:template name="eventTemplate">
    <xsl:param name="isOptional" select="'no'"/>
 <xsl:for-each select="eventitem[@optiona=$isOptional]">
   <xsl:apply-templates select="title"/>
   ...
 </xsl:for-each>
  </xsl:template>
  </xsl:call-template>

4. 변수
  parameter와 다르게 사용된 이후에 새로운 값으로 설정이 가능하다.

  변수 정의의 문법
  1. select attribute를 이용해 변수 값을 직접 설정할 수 있다.
  2. variable element의 contents를 설정함으로써 변수 값을 설정할 수 있다.

  <xsl:variable name="optionalChoiceValue" select="$optionalChoice"/>
  <xsl:call-template name="eventTemplate">
    <xsl:with-param name="isOptional"><xsl:value-of select="$optionalChoiceValue"/></xsl:with-param>
  </xsl:call-template>

# 흐름제어
  XSLT는 변환 엔진이 어떤 template을 처리해야 하는지 명시할 수 있도록 흐름 제어 기능을 제공한다.

1. if-then element

if element는 명령어 치리를 위한 조건을 가질 수 있도록 test attribute를 갖는다.
  <xsl:element name="div">
    <xsl:if test="$isOptional='no'">
   <xsl:attribute name="style">color:red</xsl:attribute>
    </xsl:if>
 ...
  </xsl:element>

2. choose element
  if element를 이용하여 처리할 수 없는 else 문제 해결
  choose element는 잘 구성된 element들로 표현되는 분기 조건들을 담을 수 있는 container를 제공.
  하나 이상의 when element를 포함.
  when element는 if element와 유사한 동작 수행.
  otherwise element를 통해 when 문장들을 참으로 만족시키지 않는 다른 모든 조건들을 처리할 수 있도록 함.

  <xsl:call-template name="eventTemplate">
    <xsl:with-param name="isOptional">
   <xsl:value-of select="$optionalChoice"/></xsl:with-param>
  </xsl:call-template>

  <xsl:choose>
    <xsl:when test="$optionalChoice='yes'">
   <xsl:call-template name="eventTemplate">
     <xsl:with-param name"isOptional">no</xsl:with-param>
 </xsl:when>
    <xsl:when test="$optionalChoice='no'">
   <xsl:call-template name="eventTemplate">
     <xsl:with-param name"isOptional">yes</xsl:with-param>
 </xsl:when>
 <xsl:otherwise>
   <!-- If a yes or no value was not originally specified, assume it should have been no. That means the opposite is yes. -->
   <xsl:call-template name="eventTemplate">
     <xsl:with-param name="isOptional">yes</xsl:with-param>
   </xsl:call-template>
 </xsl:otherwise>

# 출력 모드의 설정
  mode attribute를 이용하여 어떤 template이 이용되어야 하는지 그리고 어떤 template이 처리되어야 하는지 지정할 수 있다.

  ...
  <xsl:apply-templates select="eventitem[$optional='no']" mode="no"/>
  ...

  <xsl:template match="eventitem" mode="yes'>
    <xsl:element name="div">
 ...
 </xsl:element>
  </xsl:template>

  ...

'그거 > Tech' 카테고리의 다른 글

자바서비스넷의 기술자료 링크  (0) 2007.02.23
10. XML 문서의 변환과 응용  (0) 2007.02.22
08.XML Schema  (0) 2007.02.16
07.DTD(Document Type Definition)  (0) 2007.02.15
06. XML 문서에 대한 유효성 검증  (0) 2007.02.15
:
Posted by 뽀기
2007. 2. 16. 16:30

08.XML Schema 그거/Tech2007. 2. 16. 16:30

# XML Schema의 구조
  XML Schema는 그 자체가 XML 문서이며, XML과 동일한 문법을 이용한다.

1. 기본구조
  <schema> root element와 namespace 선언을 갖는다.

  <?xml version="1.0" encoding="EUC-KR"?>
  <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  </xs:schema>

2. system에 문서 정보의 제공

  스키마에 대한 정보를 문서화하는 표준화된 방법을 제공.
  스키마를 처리하는 application이 이 정보를 처리.

  <?xml version="1.0" encoding="EUC-KR"?>
  <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:annotation>
   <xs:documentation>
     이 문서는 그룹 목록에 대한 스키마를 설명한다.
   </xs:documentation>

   <xs:appinfo>
     <config xmlns="http://www.example.com/externalapp">
    <customertype>pop culture</customertype>
    <destination id="I43"/>
  </config>
   </xs:appinfo>
 </xs:annotation>
  </xs:schema>

3. 스키마 문서의 사용

  스키마 문서(XML문서에 대한 XML Schema가 정의되어 있는 문서) - 인스턴스 문서(XML 문서)

  <?xml version="1.0" encoding="EUC-KR"?>
  <collection xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                    xsi:noNamespaceSchemaLocation="collectibles.xsd">
  </collection>

# 단순 element

  XML Schema에서는 <element> element로 element를 정의.
  element에 data type을 지원할 수 있다.(현재 44개의 내장 data type 지원)

  <xs:element name="description" type="xs:string"/>
  <xs:element name="originDate" type="xs:date"/>
  <xs:element name="numOwners" type="xs:positiveInteger"/>

1. 내장 data type
  . 문자열 : string, normalizedString, token
  . 정수   : byte, unsignedByte, integer, positiveInteger, negativeInteger, nonNegativeInter, nonPositiveInteger, int, unsignedInt, long, unsignedLong, short, unsignedShort
  . 소수   : float, double
  . boolean : Boolean
  . 날짜/시간 : gMonth, gYear, gYearMonth, gDay, gMonthDay, duration, time, dateTime, date
  . binary    : base64Binary, hexBinary
  . DTD 호환성 : attribute만 사용 가능. ID, IDREF, IDREFS, ENTITY, ENTITIES, NOTATION, NMTOKEN, NMTOKENS
  . namespace 연관 : QName, NCName
  . 그 외 : anyURI, lang, Name

2. 고정값과 기본값
 
  <xs:element name="obtainable" type="xs:string" fixed="yes"/>
  <xs:element name="originalOwner" type="xs:string" default="unknown"/>

  변환과정
    <obtainable/> => <obtainable>yes</obtainable>
    <originalOwner/> => <originalOwner>unknown</originalOwner>

  일반 entity를 대체하여 이용되는 경우
    <xs:element name="copy" fixed="@"/>

    <rights>Copyright <copy/>2003</rights>


# 복합 element
  element내에 element가 포함되는 경우를 복합 타입으로 간주.

1. 자식 element의 정의

  <?xml version="1.0" encoding="EUC-KR"?>
  <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="obtainable" type="xs:string" fixed="yes"/>
    <xs:element name="originalOwner" type="xs:string" default="unknown"/>

   <xs:element name="collection">
     <xs:complexType>
    <xs:sequence>   <- element들이 순서대로 나타나야 한다. <xs:all> 로 하면 임의의 순서로 나타난다.
      <xs:element name="toys" type="xs:string"/>
      <xs:element name="furniture" type="xs:string"/>
      <xs:element name="pottery" type="xs:string"/>
      <xs:element name="autographs" type="xs:string"/>
      <xs:element name="advertising" type="xs:string"/>
    </xs:sequence>
  </xs:complexType>
   </xs:element>
  </xs:schema>

  <?xml version="1.0" encoding="EUC-KR"?>
  <collection xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                    xsi:noNamespaceSchemaLocation="collectibles.xsd">

    <toys></toys>
 <furniture></furniture>
 <pottery></pottery>
 <autographs></autographs>
 <advertising></advertising>
  </collection>

  자식 element의 선택
    <?xml version="1.0" encoding="EUC-KR"?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
      <xs:element name="obtainable" type="xs:string" fixed="yes"/>
      <xs:element name="originalOwner" type="xs:string" default="unknown"/>

        <xs:element name="collection">
          <xs:complexType>
            <xs:choice>    <- DTD에서의 '|'와 같은 기능
              <xs:element name="toys" type="xs:string"/>
              <xs:element name="furniture" type="xs:string"/>
              <xs:element name="pottery" type="xs:string"/>
              <xs:element name="autographs" type="xs:string"/>
              <xs:element name="advertising" type="xs:string"/>
            </xs:choice>
          </xs:complexType>
        </xs:element>
    </xs:schema>

2. 출연 횟수의 제어
  minOccurs와 maxOccurs attribute를 사용하여 특정 element의 출현 횟수를 제어할 수 있다.
  sequence, choice, all element와 minOccurs, maxOccurs attribute를 적절히 취합하여 구성가능

  <xs:element name="previousOwner" type="xs:string" minOccurs="0" maxOccurs="5"/>

  <xs:element name="collection">
    ...
    <xs:choice minOccurs="1" maxOccurs="unbounded">
    </xs:choice>
  </xs:element>

3. 혼합 contents
  complexType element에 mixed attribute를 사용.

  <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="collection">
    <xs:complexType mixed="false">
   <xs:choice minOccurs="1" maxOccurs="unbounded">
     <xs:element name="toys">
    <xs:complexType>
      <xs:sequence>
     <xs:element name="previousOwner" type="xs:string" minOccurs="0" maxOccurs="5"/>
     <xs:element name="description"
       <xs:complexType mixed="true">
      <xs:choice maxOccurs="unbounded">
        <xs:element name="condition" type="xs:string"/>
     <xs:element name="brand" type="xs:string"/>
     <xs:element name="tradeName" type="xs:string"/>
      </xs:choice>
    </xs:complexType>
     <xs:element>
   </xs:sequence>
    </xs:complexType>
  </xs:element>
      </xs:choice>
 </xs:complexType>
  </xs:element>
  </xs:schema>

4. anyType
  DTD의 ANY 타입 element와 동일한 기능을 수행하며, anyType으로 선언된 element는 contents model에 어떤 text 값도 가질 수 있다.

  <xs:element name="condition" type="xs:string"/>
  <xs:element name="brand" type="xs:string"/>
  <xs:element name="tradeName" type="xs:string"/>
  <xs:element name="collection">
    <xs:element name="description" type="xs:anyType"/>
  </xs:element>

  description이 anyType으로 설정되어있기 때문에
  description element 외부에 선언되어 있는 condition, brand, tradeName element를 자식 element로 가질 수 있다.

# 미리 정의된 element 들의 참조

  element에 대한 참조

  <xs:element name="condition" type="xs:string"/>

  ref attribute를 이용해서 참조
  <xs:element name="item">
    <xs:complexType>
   <xs:sequence>
     <xs:element ref="condition" minOccurs="0" maxOccurs="5"/>
   </xs:sequence>
 </xs:complexType>
  </xs:element>

  참조되는 element들의 fixed, default attribute 등은 element 선언 내에서 정의되며,
  minOccurs, maxOccurs attribute는 element를 참조하는 위치에서 정의된다.
  전역으로 정의된 element를 참조 형식으로 이용하는 경우 element 선언의 재사용이 가능하다.

1. 범위의 설정
  동일한 이름을 갖는 element는 상위 element의 범위 내에서만 유효하다.

  전역 선언된 item element와 pottery element 내부에 선언된 item element가 있을 경우
  pottery element 내부에 선언된 item element에 material 이라는 element를 하나 추가할 경우
  material element를 갖는 item element는 pottery element 내부에서만 유효하다.

2. element group의 설정
 
  <xs:group name="itemCommon">
    <xs:sequence>
   <xs:element ref="previousOwner" minOccurs="0" maxOccurs="5"/>
   <xs:element ref="description"/>
   <xs:element ref="originDate"/>
   <xs:element ref="numOwners"/>
   <xs:element ref="obtainable"/>
   <xs:element ref="originalOwner"/>
 </xs:sequence>
  </xs:group>

  <xs:element name="item">
    <xs:complexType>
   <xs:sequence>
     <xs:group ref="itemCommon"/>
   </xs:sequence>
 </xs:complexType>
  </xs:element>
  ....
  <xs:element name="pottery">
    <xs:complexType>
   <xs:sequence>
     <xs:element name="item" minOccurs="0" maxOccurs="unbounded">
    <xs:complexType>
      <xs:sequence>
     <xs:group ref="itemCommon"/>
     <xs:element name="material" type="xs:string"/>
   </xs:sequence>
    </xs:complexType>
  </xs:element>
   </xs:sequence>
 </xs:complexType>
  </xs:element>

# attribute의 정의

  attribute element를 통해 선언

  <xs:element name="item">
    <xs:complexType>
   <xs:sequence>
     <xs:group ref="itemCommon"/>
   </xs:sequence>
   <xs:attribute name="itemid" type="xs:integer"/>
   <xs:attribute name="keeper" type="xs:integer"/>
   <xs:attribute name="demand" type="xs:integer"/>
   <xs:attribute name="legal" type="xs:integer"/>
 </xs:complexType>
  </xs:element>

  XML schema의 모든 내장 data type을 이용할 수 있다.

1. attribute의 속성 결정

  DTD        : #REQUIRED #IMPLIED #FIXED
  XML schema : use, default, fixed

  <xs:attribute name="itemid" type="xs:integer" use="required"/>
  <xs:attribute name="keeper" type="xs:string" default="yes"/>
  <xs:attribute name="demand" type="xs:string" use="optional"/>
  <xs:attribute name="legal" type="xs:string" fixed="yes"/>

  use, default, fixed는 attribute 선언에서 함께 사용될 수 없다.

2. attribute의 전역 선언과 attribute group

  <xs:attribute name="itemid" type="xs:integer"/>
  <xs:attribute name="keeper" type="xs:string"/>
  <xs:attribute name="demand" type="xs:string"/>
  <xs:attribute name="legal" type="xs:string"/>

  ref를 이용하여 참조한다.
  <xs:attribute ref="itemid" use="required"/>

  attribute의 group의 선언에서 group에 포함될 attribute들은 미리 선언되어 있어야 한다.
  <xs:attribute name="itemid" type="xs:integer"/>
  <xs:attribute name="keeper" type="xs:string"/>
  <xs:attribute name="demand" type="xs:string"/>
  <xs:attribute name="legal" type="xs:string"/>

  <xs:attributeGroup name="itemAtts">
    <xs:attribute ref="itemid" use="required"/>
    <xs:attribute ref="keeper" default="yes"/>
    <xs:attribute ref="demand" use="optional"/>
    <xs:attribute ref="legal" fixed="yes"/>
  </xs:attributeGroup>

  attribute group의 사용
  <xs:element name="item">
    <xs:complexType>
   <xs:sequence>
     <xs:group ref="itemCommon"/>
   </xs:sequence>
      <xs:attributeGroup ref="itemAtts"/>
 </xs:complexType>
  </xs:element>

# 새로운 타입의 생성
  내장 data type 외에 새로운 type을 사용자가 정의할 수 있다.
  범위 값 등 단순한 것부터 element와 attribute 들을 포함하는 계층 구조 같은 복잡한 type도 가능.

1. 이름이 부여된 type
  복합 type을 선언하고, 이 선언에 대해 이름을 부여

  <xs:complexType name="itemType">
    <xs:sequence>
   <xs:group ref="itemCommon"/>
 </xs:sequence>
 <xs:attributeGroup ref="itemAtts"/>
  </xs:complexType>

  ...

  <xs:element name="item" type="itemType" minOccurs="0" maxOccurs="unbounded"/>

2. 제약 사항의 부여
  내장 data type에 여러가지 제약 사항을 추가함으로써 새로운 type을 생성할 수 있다.

  <xs:simpleType name="USCurrency">
    <xs:restriction base="xs:decimal>
   <xs:fractionDigits value="2"/>
 </xs:restriction>
  </xs:simpleType

  <xs:element name="originalPrice" type="USCurrency"/>

  XML schema에서 제공하는 facet
  minInclusive     : 수의 최소값. 이상
  minExclusive     : 초과해야 하는 최소값. 초과
  maxInclusive     : 수의 최대값
  maxExclusive     : 미만이어야 하는 최대값
  totalDigits      : 소수점 앞,뒷자리를 포함한 수의 전체 자릿수 지정
  fractionDigits   : 소수점 뒷자리 수 지정
  length           : 값의 길이 지정
  minLength        : 문자형 데이터의 최소 길이
  maxLength        : 문자형 데이터의 최대 길이
  pattern          : 문자열 정보에 대한 정규 표현식
  enumeration      : 나열형 데이터에 대한 표기
  whiteSpace       : line feed, tab, carriage return 같은 특수 문자 처리. preserve(그대로), replace(한 개의 공백으로 대체), collapse(여러 개의 공백으로 대체)

  - 나열형 타입
    element와 attribute에 대한 선택을 제한

    <xs:attribute name="demand">
      <xs:simpleType>
        <xs:restriction base="xs:string">
          <xs:enumeration value="low"/>
          <xs:enumeration value="medium"/>
          <xs:enumeration value="high"/>
          <xs:enumeration value="money is no object"/>
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>

    demand attribute의 값은 low, medium, high, money is no object 중 하나만 선택되어야 한다.

  - List 타입
    공백으로 구분되는 여러 개의 값을 포함할 수 있다.

 <xs:simpleType name="possibleOutlets">
   <xs:restriction base="xs:string">
     <xs:enumeration value="oBoy"/>
     <xs:enumeration value="YoHoo!"/>
     <xs:enumeration value="ConJunction"/>
     <xs:enumeration value="Anazone"/>
   </xs:restriction>
 </xs:simpleType>

 <xs:simpleType name="outletList">
   <xs:List itemType="possibleOutlets"/>
 </xs:simpleType>

 <xs:simpleType name="outlets">
   <xs:restriction base="outletList">
     <xs:maxLength value="3"/>
      </xs:restriction>
 </xs:simpleType>


 <item itemid="1">
   ....
   <outlets>oBoy Yoohoo!</outlets>
 </item>

3. 확장을 통해 단순 타입에 attribute 추가
 
  <xs:element name="originalOwner">
    <xs:complexType>                                            <- element를 갖고 있기 때문에 복합타입으로 contents model 선언
   <xs:simpleContent>                                        <- 자식 element 없이 text 정보만을 가는 단순 컨텐츠만 취한다
     <xs:extension base="xs:string">
    <xs:attribute name="confirmed" default="no"/>
  </xs:extension>
   </xs:simpleContent>
 </xs:complexType>
  </xs:element>

# custom type 의 유도
  custom type의 확장

  <xs:complexType name="itemType">
    <xs:sequence>
 ...
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="potteryItemType">
    <xs:complexContent>
   <xs:extension base="itemType">                           <- itemType을 상속
     <xs:sequence>
    <xs:element name="material" type="xs:string"/>       <- element 하나 추가
  </xs:sequence>
      </xs:extension>
 </xs:complexContent>
  </xs:complexType>

  ...

  <xs:element name="item" type="potteryItemType" minOccurs="0" maxOccurs="unbounded"/>

  ...

1. 제약을 통한 타입의 유도

  복합 타입에 대한 제약 사항의 부여
  <xs:complexType name="advertisingItemType">
    <xs:complexContent>
   <xs:restriction base="itemType">
     <xs:sequence>
    <xs:element href="previousOwner" minOccurs="0" maxOccurs="unbounded"/>
  </xs:sequence>
   </xs:restriction>
 </xs:complexContent>
  </xs:complexType>

  ...

  <xs:element name="item" type="advertisingItemType" minOccurs="0" maxOccurs="unbounded"/>

  ...


  제약과 확장
  <xs:complexType name="autographRestrictType">
    <xs:complexContent>
   <xs:restriction base="itemType">
     <xs:sequence>
    <xs:element ref="previousOwner" minOccurs="5" maxOccurs="5"/>
    ...
    <xs:element name="lastPrice" type="USCurrency"/>
  </xs:sequence>
   </xs:restriction>
 </xs:complexContent>
  </xs:complextType>

  <xs:complexType name="autographItemType">
    <xs:complexContent>
   <xs:extension base="autographRestrictType">                <- autographRestrictType을 상속 받음
     <xs:sequence>
    <xs:element name="description" type="xs:string"/>      <- description, personFirst element 추가
    <xs:element name="personFirst" type="xs:string"/>
  </xs:sequence>
   </xs:extension>
 </xs:complexContent>
  </xs:complexType>

  원래 있는 element를 재정의 하기 xs:restriction
  원래 있는 element에 element를 추가하기 위해서는 xs:extension 사용


# 데이터 무결성

1. 유일 키의 지원
  XML schema는 데어터 무결성을 지원한다.

  <xs:unique name="itemIdKey">
    <xs:selector xpath=".//item"/>
 <xs:field xpath="@itemid"/>
  </xs:unique>

2. key 와 keyref
  DB의 foreign key 역할
  foreign key : 한 relation에 대한 primary key로, 반드시 나타나야 하는 값이면서 다른 relation에서 이를 참조하는 키 값

  <xs:element name="onSale">
    <xs:complexType>
   <xs:sequence>
     <xs:element name="itemForSale" minOccurs="0" maxOccurs="unbounded">
    <xs:complexType>
      <xs:sequence>
     <xs:element name="outlet" type="outlets"/>
     <xs:element name="itemid" type="xs:integer"/>
   </xs:sequence>
    </xs:complexType>
    <xs:keyref name="onSaleItems" refer="existingItems">
      <xs:selector xpath="."/>
   <xs:field xpath="itemid"/>
       </xs:keyref>
  </xs:element>
   </xs:sequence>
 </xs:complexType>
  </xs:element>
  </xs:unique>

  <xs:key name="existingItems">
    <xs:selector xpath=".//item"/>
 <xs:field xpath="@itemid"/>
  </xs:key>

# namespace의 지원

1. noNamespaceSchemaLocation
  namespace 접어를 이용하지 않으려 할 경우

  <collection xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                    xsi:noNamespaceSchemaLocation="collectibles.xsd">

2. targetnamespace
  스키마 문서에서 정의하는 element가 특정 namespace에 속해야 할 필요가 있을 경우

  <schema xmlns="http://www.w3.org/2001/XMLSchema"
          xmlns:col="http://www.example.com/collection"
    targetNamespace="http://www.example.com/collection"
    elementFormDefault="qualified"
    attributeFormDefault="qualified"
  >

3. 다중 namespace

  다른 namespace에 속하는 element 정의의 이용
  <?xml version="1.0" encoding="EUC-KR"?>
  <schema xmlns="http://www.w3.org/2001/XMLSchema"
         xmlns:col="http://www.example.com/collection"
   xmlns:spec="http://www.example.com/spec"
   targetNamespace="http://www.example.com/collection"
   elementFormDefault="qualified"
   attributeFormDefault="qualified"
  >
  ...
  <complexType name="itemType">
    <sequence>
   <element ref="col:previousOwner" minOccurs="0" maxOccurs="5"/>
   <element ref="spec:specifications" minOccurs="0"/>
    </sequence>
  </complexTyhpe>
  ...

  다중 namespace의 참조
  <?xml version="1.0" encoding="EUC-KR"?>
  <c:collection xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                xmlns:c="http://www.example.com/collection"
    xmlns:s="http://www.example.com/spec"
    xsi:schemaLocation="http://www.example.com/collection collectibles.xsd
                        http://www.example.com/spec specs.xsd">
  <c:toys>
    <c:item c:itemid="1" c:demand="money is no object">
   <c:previousOwner>John Sorhed</c:previousOwner>
   <c:description>
     This piece is a genuine wooden <c:brand>Silhaven</c:brand>
  .....
   </c:description>
   <s:sepcifications>The specifications are...</s:specification>
   <c:originDate>1940</c:originDate>
 </c:item>
  </ctoys>


:
Posted by 뽀기
2007. 2. 15. 19:13

07.DTD(Document Type Definition) 그거/Tech2007. 2. 15. 19:13

# DTD의 유형
  DTD는 XML 문서의 문서 구조를 정의하고, 해당 문서들이 정의된 문서 구조를 지키도록 하는데 이용된다.

1. 외부 DTD
  외부 문서에 XML 문서의 모든 정의를 가지고 있는 형식

  - 간단한 DTD 정의의 예

    <!ELEMENT orchestra (instruments)>
    <!ELEMENT instruments (woodwind)>
    <!ELEMENT woodwind (#PCDATA)>

  - 외부 DTD 사용의 예
    <!DOCTYPE orchestra SYSTEM "orchestra.dtd">

  - DOCTYPE 선언부
    <!DOCTYPE : 현재부터 > 기호 이전까지 문서 형식의 선언을 위한 영역임을 표시
 orchestra : 이 XML 문서에서의 root element 이름. XML 문서내의 다른 element로 변경 가능

  - SYSTEM 식별자
    해당 DTD 문서가 시스템의 어디에 위치하는지 알리기 위해서 사용

  - PUBLIC 식별자
    DTD 파일의 위치를 표시하는 것이 아니라 공식정인 이름을 지정하는데 사용

 XHTML 문서에 대한 DTD PUBLIC 식별자의 이름
   -//W3C//DTD XHTML 1.0 Transitional//EN
 
 문서가 변경되거나 이동될 때, 문서 작성자가 DTD에 대한 위치 경로를 신경쓰지 않도록 함으로써 더 쉽게 관리할 수 있도록 함

 PUBLIC 식별자를 인식하지 못하는 XML 프로세서를 위해 PUBLIC, SYSTEM 둘 다 표시하는 것이 일반적

 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitinal//EN"
                       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-trasitional.dtd">

    {표준지시자}//{조직 이름}//{DTD 이름}//{언어}

 표준지시자 : 이 문서가 표준 기구에서 승인되었는지 여부(표준이면 +, 아니면 -)
 조직 이름  : 이 DTD의 생성과 유지에 대한 책임이 있는 조직의 이름
 DTD 이름   : DTD의 이름
 언어       : 이 문서가 어떤 문서로 작성되었는지 ISO 639 언어 코드값으로 표기

2. 내부 DTD
  DTD 정보는 [] 안에 위치한다.
  내부 DTD는 standalone 문서를 작성하기 위해 사용하며, 이는 XML 선언부에서 standalone="yes"로 선언한다.
  XML 선언부에 standalone에 대한 언급이 없으면 기본으로 standalone="no" 이다.


# element와 contents model의 생성

  element 선언문의 구조
  <!ELEMENT {이름} ({content smodel})>

1. 컨텐츠 변경자
  element의 출현 빈도 명시

  ? : 선택적인 element. 나타나지 않을 수도 있으며, 나타나면 한 번만 나타남
  + : 반드시 나타나야 하는 element. 한 번 이상
  * : 반복하여 나타나는 element. 0 번 이상

  <!ELEMENT orchestra (performance, instruments)>
  <!ELEMENT performance (piece+)>                       : 하나 이상의 piece element를 갖는다.
  <!ELEMENT piece (#PCDATA)>
  <!ELEMENT instruments (violin*, glockenspiel?)>       : violin은 한 번도 안나타나거나 여러번 나타나고, glockenspiel은 없거나 한 번만 나타남
  <!ELEMENT violin (#PCDATA)>
  <!ELEMENT glockenspiel (#PCDATA)>

2. element 선택자
  | : A or B

  <!ELEMENT orchestra (performance, instruments)>
  <!ELEMENT performance (piece+ | improv)>              : 한 개의 improv element나 한 개 이상의 piece element 중 하나만 선택
  <!ELEMENT piece (#PCDATA)>
  <!ELEMENT improv (#PCDATA)>

  <!ELEMENT instruments (violin*, glockenspiel?) | (piano?, clarinet+)>       : instrumenets element는 violin, glockenspiel element를 갖거나 piano, clarinet element의 조합을 갖게 된다.
  <!ELEMENT violin (#PCDATA)>
  <!ELEMENT glockenspiel (#PCDATA)>
  <!ELEMENT piano (#PCDATA)>
  <!ELEMENT clarinet (#PCDATA)>

  DTD가 가지는 한계
    XML 문서의 작성자가 컨텐츠 모델 변경자와 OR 연산자를 통해 임의의 순서로 element가 나타나게 할 수 있으나 element의 출현 횟수를 제어할 수 없다.

3. 혼합 컨텐츠
  element가 자식 element와 text contets를 모두 갖는 경우

  <description>
    this rehearsal will showcase <violin>Joel Borgnine</violin>L and his brilliant improvisation, <improv>Jazz on the Shore</improt>.
  </description>
 
  <!ELEMENT description ( #PCDATA | violin | improv | piece )*>

4. ANY element
  한 element가 DTD 내에 정의되어 있는 다른 어떠한 element들도 포함할 수 있는 기능을 제공

  <!ELEMENT description ANY>

  description element는 DTD 내에 정의되어 있는 다른 어떠한 element도 포함할 수 있다.

5. EMPTY element
  element의 contents model이 아무런 정보를 갖지고 있지 않은 경우
  예)<img src="../test.gif"/>

  <!ELEMENT intermission EMPTY>

  <intermission/> == <intermission></intermission>

  <intermission/> != <intermission> </intermission>
  intermission의 contents model에 공백 문자가 삽입되므로 같지 않다.


# attribute의 정의

  attribute list의 형식
  <!ATTLIST {element 이름} {attribute 이름} {타입} {기본값} {옵션}>

1. attribute의 기본값

  intermission element의 생략 가능한 setup attribute, length attribute
  <!ATTLIST intermission setup CDATA #IMPLIED
                         length CDATA #IMPLIED>

  intermission element에서 꼭 있어야 하는 setup attribute, 생략가능한 length attribute
  <!ATTLIST intermission setup CDATA "full" #REQUIRED
                         length CDATA #IMPLIED>

  intermission element에서 생략가능한 setup attribute, 생략가능하지만 기본값은 "15 minutes"로 고정되서 바꿀 수 없는 length attribute
  <!ATTLIST intermission setup CDATA "full"
                         length CDATA #FIXED "15 minutes">

2. 나열형 attribute
  DTD에서는 attribute에 대한 고정값을 명시할 수 있을 뿐만 아니라 이용 가능한 값의 집합을 나열할 수 있다.

  setup attribute에 대해서 기본값은 full, partial, minimal 중에 하나를 가질 수 있으며, 지정하지 않을 경우는 full을 값으로 설정
  <!ATTLIST intermission setup (full | partial | minimal) "full"
                         length CDATA #FIXED "15 minutes">

 
  <!ATTLIST intermission setup (full | partial | minimal) "full"
                         length CDATA #FIXED "15 minutes">
  <!ATTLIST piano type (accoustic | electronic) #IMPLIED>
  <!ATTLIST violin seat (first | second | other) #REQUIRED>

3. ID, IDREF 타입
  XML DTD에서는 DB의 기본키/외래키 기능을 지원하기 위해 ID, IDREF attribute를 정의해 놓고 있다.

  piece element에 대해서 IDREF 타입으로 pid attribute를 꼭 사용하도록 정의
  <!ATTLIST piece pid IDREF #REQUIRED>

  improv element에 대해서 IDREF 타입으로 iid attribute를 꼭 사용하도록 정의
  <!ATTLIST improv iid IDREF #REQUIRED>

  concertpiece element에 대해서 ID 타입으로 pieceid attribute를 꼭 사용하도록 정의
  <!ATTLIST concertpiece pieceid ID #REQUIRED>

  제약조건
    ID attribute의 값은 숫자로 시작할 수 없다.
                     구두점이나 공백문자를 포함할 수 없으며,
      이 값은 문서 내에서 유일해야 한다.
    IDREF attribute의 값은 문서 내에서 유일하지 않아도 무방하다.
                        문서 내에 존재하는 ID attribute의 값과 일치해야 한다.

    IDREF 의 값은 ID의 값과 같아야 한다.

 <piece pid="_1"/>
 <piece pid="_2"/>        <-- "_2"라는 ID 값이 없기 때문에 오류 발생
 <concertpieces>
   <concertpiece pieceid="_1">test</concertpiece>
 </concertpieces>

  IDREFS 타입 : attribute list의 선언에서 사용될 수 있으며, 공백문자로 구분되는 여러 개의 IDREF 값을 취급한다.
 
  <!ATTLIST piece pid IDREFS #REQUIRED>

  <performance>
    <piece pid="_1 _3"/>
  </performance>

  IDREFS 의 각 값은 문서 내에 존재하는 ID의 값이어야 한다.

4. NMTOKEN 타입
  ID 타입처럼 공백문자를 포함할 수 없으나 ID와는 달리 숫자로 시작할 수 있다.

  <!ATTLIST concertpiece pieceid ID #REQUIRED
                         genre NMTOKENS #IMPLIED>

  <concertpiece pieceid="_1" genre="jazz modern">Jazz on the Shore</concertpiece>

  IDREF 타입과는 달리 문서 내의 다른 구성 요소나 attribute 들을 참조하지 않는다.

# 일반 entity
  entity : XML 문서에서 다른 contents에 대한 참조를 나타내며,
           이를 문서 내에서 이용하기 위해서는 entity 이름의 앞과 뒤에 &와 ;를 붙여 호출한다.

  <p>&quot;To levitate a human being would take a magnet....&quot;</p>

1. custom entity
  문서 내에서 빈번하게 출현하는 data를 간략화ㅗ 할 수 있다.

  <!DOCTYPE orchestra SYSTEM "orchestra.dtd" [
    <!ENTITY callwarning "Please arrive prepared to play!">
    ]>

  <description>
    &callwarning;
    This rehearsal will showcase ....
  </description>

  parsed entity
  일반적인 text 정보

2. 이름 entity와 산술형 entity

  산술형 entity
  <!DOCTYPE orchestra SYSTEM "orchestra.dtd" [
    <!ENTITY flat "&#9837;">
  ]>

  <description>>
    This rehearsal will showcase... improvisation in B&flat;,....
  </description>

3. 외부 entity
  파일과 같은 외부 자원들을 참조하는 entity

  parsed entity
    일반 entity의 생성 방법과 비슷하나 특정 문자를 참조하는 대신 SYSTEM이나 PUBLIC 식별자를 이용한다.

 <!DOCTYPE orchestra SYSTEM "orchestra.dtd" [
   <!ENTITY flat "&#9837;">
   <!ENTITY concertpieces SYSTEM "musicalnumbers.xml">
 ]>

 </orchestra>
   <instruments>
     <violin seat="first">...</violin>
   </instruments>
   &concertpieces;
 </orchestra>

 일반 entity는 문서 내에서 정의되기 때문에 XML 문서의 파싱 과정에서 이 entity들이 text 정보로 대체되면서 XML 문서의 잘 구성됨 조건을 위배할 수 있다.
 XML 문서가 유효성 검사를 수행하지 않는 XML parser를 이용한다면, 이 parser는 외부 문서에 대한 유효성 검사를 수행하지 않음으로써 문제를 발생시킬 수 있다.

  unparsed entity
    image 파일과 같은 바이너리 데이터를 XML 문서에서 참조할 경우, 이 파일의 내용 정보를 XML 문법으로 파싱하지 못하도록 하기 위해 이용
 notation을 이용하여 해당 파일의 타입을 정의하고 외부 entity 선언으로 이 notation에 대한 참조를 설정한다.

 <!DOCTYPE orchestra SYSTEM "orchestra.dtd" [
   ...
   <!ENTITY concertpieces SYSTEM "musicalnumbers.xml">
   <!NOTATION gif SYSTEM "c:\winnt\system32\mspaint.exe">
   <!ENTITY logo SYSTEM "logo.gif" NDATA gif>

   <!ENTITY violinimg SYSTEM "violing.gif" NDATA gif>
   <!ENTITY firstseatimg SYSTEM "firstseat.gif" NDATA gif>
   <!ENTITY glockenspielimg SYSSTEM "glockenspiel.gif" NDATA gif>

   <!ATTLIST violin graphics ENTITIES #IMPLIED>
   <!ATTLIST glockenspiel graphics ENTITY #IMPLIED>

 ]>

 ...
   <violin seat="first" graphics="violinimg firstseatimg">Joel Borgnine</violin>
   <glockenspiel graphics="glockenspielimg">Marie Andrassy</glockenspiel>
 ...

 entity를 이용할 경우 entity의 호출은 &와 ;를 앞뒤에 붙이지 않는다.


# 파라미터 엔티티
  DTD에서 사용되는 entity. % 기호화 하나의 공백이 정의할 때 함께 추가된다.
  일반 attribute나 element group 처럼 미리 정의된 DTD 정의의 일부를 다시 DTD에서 여러 번 이용해야 할 경우

  <!DOCTYPE orchestra SYSTEM "orchestra.dtd" [
    <!ENTITY % flatEnt "<!ENTITY flat &#34;&#x266F;&#24;>">
    %flatEnt;

    <!ENTITY sharp "&#x266F;">
    <!ENTITY natural "&#x266E;">
    ...
  ]>

  <!ENTITY % seatAtt "first | second | other">

  <!ATTLIST violin seat (%seatAtt;) #REQUIRED>
  <!ELEMENT concertpieces (concertpiece*)>

1. DTD 정의의 취사 선택
 
  DTD에서의 조건 절
  <![INCLUDE[
    <!ELEMENT instruments (piano?, clarinet+)>
  ]]>
  <![IGNORE[
    <!ELEMENT instruments (violin*, glockenspiel?)>
  ]]>

  조건절과 parameter entity를 사용하여 아래와 같이 변경 가능하다

  <!ENTITY % woodwind "INCLUDE">
  <!ENTITY % string "IGNORE">

  <!ELEMENT orchestra (performance, description, instruments, concertpieces)>
  ...
  <!ELEMENT description ANY>

  <![%woodwind;[
    <!ELEMENT instruments (piano?, clarinet+)>
  ]]>
  <![%string;[
    <!ELEMENT instruments (violin*, glockenspiel?)>
  ]]>

  parameterized DTD

  <!ENTITY % woodwind "INCLUDE">
  <!ENTITY % string "IGNORE">
  <!ENTITY % custom "IGNORE">
  <!ENTITY % customSet "">

  ...

  <![%woodwid;[
    <!ELEMENT instruments (piano?, clarinet+)>           // INCLUDE
  ]]>
  <![%string;[
    <!ELEMENT instruments (viloin*, glockenspiel?)>      // IGNORE
  ]]>
  <![%custom;[
    <!ELEMENT instruments (%customSet;)>                 // IGNORE
  ]]>

  parameter entity의 이용

  <!ENTITY % woodwind "IGNORE">
  <!ENTITY % string "IGNORE">
  <!ENTITY % custom  "INCLUDE">                          // INCLUDE 됐기 때문에 위에서 <!ELEMENT instruments (%customSet;)>을 사용함
  <!ENTITY % customSet "piano, glockenspiel">

  ...

    <instruments>                                                     // <!ELEMENT instruments (%customSet;)>을 사용하는데 %customSet; 이 piano, glockenpiel 이기 때문에
   <piano>xxx</piano>                                              // instruments element는 piano, glockenpiel element를 포함한다
   <glockenspiel graphics="glockenspielimg">xxxa</glockenspiel>
 </instruments>
  ...


'그거 > Tech' 카테고리의 다른 글

09. XSLT(eXtensible Stylesheet Language Transformations)  (0) 2007.02.20
08.XML Schema  (0) 2007.02.16
06. XML 문서에 대한 유효성 검증  (0) 2007.02.15
05. XML 스트림 (SAX)  (0) 2007.02.14
04. DOM의 활용(고급편)  (0) 2007.02.14
:
Posted by 뽀기