# 유효성 검증(validation)
  미리 정의된 문서의 구조와 XML 문서를 비교하는 작업

1. 기본 DOCTYPE
  DOCTYPE은 XML 문서에 포함되어야 하는 element나 attribute 또는 기타 객체 등을 명시하며, 문서의 상단부에 위치하는 선언부.

  <!DOCTYPE votes [ <!-- definition for element, attribute --> ]>

2. definition for element
  content model : element가 포함하는 요소들고 이 요소들의 정렬 순서, 발생 빈드 등에 대한 정보를 표현
  <!DOCTYPE votes [
   <!ELEMENT votes (voter*)>                votes element는 하나 이상의 voter element를 갖는다.
 <!ELEMENT voter (vote, comments)>        voter element는 vote element와 comments element를 갖는다.
 <!ELEMENT vote (#PCDATA)>                vote element는 일반적인 text나 parsing된 문자 데이터를 포함한다.
 <!ELEMENT comments (#PCDATA)>            comments element는 일반적인 text나 parsing된 문자 데이터를 포함한다.
  ]>

3. definition for attributes
  <!DOCTYPE votes [
     ...
  <!ATTLIST voter personid CDATA #REQUIRED
                  status CDATA "symbiont">
  <!ATTLIST votes totalVotes CDATA #REQUIRED>
  ]>

4. 외부 DTD
  XML 문서와는 별도로 분리된 파일에 문서의 구조 정보들을 포함
  SYSTEM 또는 PUBLIC 식별자에 의해 접근 가능
  <!DOCTYPE votes PUBLIC "-//Vanguard Resort IT//DTD Voting System 2.0//EN"        PUBLIC으로 접근 가능
                         "votes.dtd">                                              SYSTEM으로 접근 가능

# 문서의 유효성 검증

1. SAX 파서의 지원 기능
  SAX의 지원 기능 중 사용 빈도수가 많은 지원 기능
    http://xml.org/sax/features/validation
    http://xml.org/sax/features/namespace (required)
    http://xml.org/sax/features/namespace-prefixes (required)
    http://xml.org/sax/features/external-general-entities
    http://xml.org/sax/features/external-parameter-entities

2. SAX 파서에서의 유효성 검증의 실행

  XMLReader reader = XMLReaderFactory.createXMLReader();
  String featuredId = "http://xml.org/sax/features/validation";
  reader.setFeature(featureId, true); // 유효성 검사 지원 기능을 true로 설정

3. DOM 파서와 유효성 검증
 
  DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
  dbf.setValidating(true);

  이 factory class가 생성하는 모든 파서 객체들은 유효성 검증 property가 true로 설정된다.

4. DOM 파서에 SAX 오류 핸들러 설정

  DocumentBuilder db = dbf.newDocumentBuilder();
  db.setErrorHandler(new ErrorProcessor());

# XML Schema 이용시의 유효성 검증
  XML Schema를 사용하면 DTD에 비해 좀더 쉽고, 유연하며, 강력한 방법으로 유효성을 검증할 수 있다.

1. XML schema의 개요
  XML을 이용해서 XML 문서의 구조를 기술하는 방법을 제공

  XML schema의 예
  <?xml version="1.0"?>
  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

    <xsd:element name="votes" type="voteType"/>

   <xsd:complexType name="voteType">
     <xsd:sequence>
    <xsd:element name="voter" type="voterType" minOccurs="0" maxOccurs="unbounded"/>
  </xsd:sequence>
        </xsd:attribute name="totalVotes" type="xsd:integer"/>
   </xsd:compexType>

   <xsd:complexType name="voterType">
     <xsd:sequence>
    <xsd:element name="vote" type+"xsd:string"/>
    <xsd:element name="comments" type+"xsd:string"/>
     </xsd:sequence>
  <xsd:attribute name="personid" type="xsd:string"/>
  <xsd:attribute name="status" type="xsd:string"/>
   </xsd:complexType>
  </xsd:schema>

2. XML schema 문서의 명시
  namespace 선언을 위한 attribute를 사용하여 XML schema 문서를 명시한다.

  <votes totalVotes="5" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                              xsi:noNamespaceSchemaLocation="votes.xsd">

3. XML Schema에 대한 유효성 검증의 설정
 
  DocumentBuilderFactory dbf = DocumentBuilderFactory.newIntance();
  dbf.setValidating(true);
  dbf.setNamespaceAware(true);
  try {
   dbf.setAttribute("http://java.sun.com/xml/jaxp/properties/schemaLanguage",
                  "http://www.w3.org/2001/XMLSchema");
  } catch(IllegalArgumentException e) {
  }

# 오류의 처리

1. 오류와 SAX
  어차피 DOM 파서는 SAX와 관련된 예외 사항을 발생하기 때문에 SAX 관점에서 오류 처리를 한다.
  ErrorHandler를 상속받아 "error, fatalError, warning" method를 override하여 사용한다.

2. 오류의 처리

  try {
    ...
  } catch(Exception e) {
    SAXParseException spe = (SAXParseException)e;

    System.out.println("Problem parsing the file :  + spe.getMessage());
    System.out.println();
    System.out.println("File :  + spe.getSystemId());
    System.out.println("Line number :  + spe.getLineNumber());
    System.out.println("Column number :  + spe.getColumnNumber());
    System.out.println();
  }

3. 문서의 수정
  유효성 검증이 Document 객체에 대한 어떠한 영향력도 갖지 못한다.
  비록 문서가 유효성이 검증되었다 하더라도 Document 객체에 Schema에 위배되는 잘못된 정보를 추가할 수 있다.

  DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
  dbf.setValidating(true);
  dbf.setNamespaceAware(true);
  try {
   dbf.setAttribute("http://java.sun.com/xml/jaxp/properties/schemaLanguage",
                  "http://www.w3.org/2001/XMLSchema");
  } catch(IllegalArgumentException e) {
    ...
  }
  DocumentBuilder db = dbf.newDocumentBuilder();
  db.setErrorHandler(new ErrorProcessor());

  Document doc = db.parse(new File("votes.xml"));

  Element root = doc.getDocumentElement();
  root.appendChild(doc.createTextNode("this node doesn't belong here.")); // Schema 정의에 없는 node를 추가
  System.out.println(root.getLastChild());

  위에서 추가한 text node는 Schema 정의에 존재하지 않는 정보임에도 불구하고, 이 application은 아무런 문제없이 계속 진행할 것이다.
  왜냐하면 이 application의 실행중에는 Document 객체에 대한 유효성을 검증할 방법이 없기 때문이다.

- SAX 란?
  . DOM에서 처리하기 어려운 연산을 지원하기 위한 목적으로 XML-DEV 메일링 리스트의 구성원들이 만든 XML 처리를 위한 API
  . SAX는 XML 파일을 정보를 전달하는 이벤트들의 스트림으로 다룬다.
  . 스트림의 순서에 따라 이벤트를 검사하여 순차적으로 처리.

  <votes totalVotes="5">
 <voter personid="1" status="primary">
  <vote>Sparkel</vote>
  <comments>It's about time we had this vote!</comments>
 </voter>
  </votes>

  DOM parser의 관점
    . votes element는 2개의 text element(줄바뀜)와 하나의 element(voter)
   <votes>#text
     <voter>..
  </voter>#text
   </votes>
 . voter element는 3개의 text element(줄바뀜)와 2개의 element(vote, comments)
  <voter>#text
    <vote>Sparkel</vote>#text
    <comments>It's about time we had this vote!</comments>#text
  </voter>

  SAX parser의 관점
    elemnt(votes) 시작
 #text 무시
 elemtn(voter) 시작
 #text 무시
 elemtn(vote) 시작
 문자(Sparkle)
 element(vote) 종료
 #text 무시
 element(comments) 시작
 문자(It's a bout time we had this vote!)
 element(comments) 종료
 #text 무시
 element(voter) 종료
 #text 무시
 element(votes) 종료

  SAX vs DOM
    다루려는 XML 문서의 유형에 따라 적용.
 SAX
  읽기 전용의 method를 제공하기 때문에 정보를 읽을 수 있으나 소스 문서에는 아무런 변화를 줄 수 없다.
  단방향 method를 제공하기 때문에 한 번 읽고 처리된 element에 재접근하려면 문서를 다시 파싱해야 한다.
  시간 순서에 따라 처리하기 때문에 사용이 확실치 않은 정보들로 메모리를 낭비할 필요가 없다.
  필요로 하는 정보를 찾은 후에는 바로 파싱의 과정을 종료할 수 있다.

- SAX parser의 생성
  . SAX parser의 구성
    Parser
 XMLReader
 ContentHandler, ErrorHandler

  . XMLReader의 생성
    XMLReader reader = XMLReaderFactory.createXMLReader();

  . ContentHandler
    10여개 정도의 event(startElement, endDocument...) 정의

  . ErrorHandler
    3개의 event(warning, error, fatalError) 정의

  . DefaultHandler
    이벤트마다 interface에 정의된 메소드들을 구현해야 하는 번거로움을 제거.

 public class DataProcessor extends DefaultHandler {
  public DataProcessor() {
   super();
  }
 }

 public class ErrorProcessor extends DefaultHandler {
  public ErrorProcessor() {
   super();
  }

  public void error(SAXParseException e) {
   System.out.println("Error : " + e.getMessage());
  }

  public void fatalError(SAXParseException e) {
   System.out.println("Fatal Error : " + e.getMessage());
  }

  public void warning(SAXParseException e) {
   System.out.println("Warning : " + e.getMessage());
  }
 }

 warning : 오류로 취급되지는 않지만 사용자에게는 전달할 필요가 있는 항목.
 error   : XML 1.0 권고안에서 정의한 오류들. 오류 발생시 파서는 더 이상 실행되지 않음.
 fatal error : 오류로 인해 파서의 계속적인 수행이 불가능하면 발생.

 DTDHandler     : 내부 DTD에서 정의되는 notation과 parsing 되지 않는 entity들에 대한 통지 수신
 DeclHandler    : DOCTYPE과 관련된 기타 event에 대한 통지 수신
 LexicalHandler : startDTD와 endCDATA 같은 이벤트들에 대한 통지 수신

  . Handler 설정
    XMLReader reader = XMLReaderFactory.createXMLReader(parserClass);
    reader.setContentHandler(new DataProcessor());
 reader.setErrorHandler(new ErrorProcessor());

  . 문서의 parsing
    InputSource file = new InputSource("votes.xml");
    reader.parse(file);

 InputStrea, Reader, String 모두 파서의 입력으로 이용 가능

- event의 처리

  . Document event
    public void startDocument() {}
 public void endDocument() {}

  . Element event
    public void startElement(String namespaceUri, String localName, String qualifiedName, Attributes attributes) {
  attributes.getLocalName(int i);
  attributes.getQName(int i);
  attributes.getValue(attributes.getQName(int i));
 }
    public void endElement(String namespaceUri, String localName, String qualifiedName) {}

  . Text event
    SAX에서 text contents는 element event가 아닌 characters event를 통해 전송된다.

 StringBuffer thisText = new StringBuffer();
 public void characters(char[] ch, int start, int length) {
  thisText.append(ch, start, length);
 }

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

  . startPrefixMapping(String prefix, String uri)
    namespace가 범주에 포함될 때 발생
  . endPrefixMapping(String prefix)
    namespace가 범주를 벗어날 때 발생
  . processingInstruction(String target, String data)
    parser가 처리 지시문에 접근했을 때 발생
  . skippedEntity(String name)
    parser과 외부 entity를 발견할 때 발생

- filter and chain

  . filter
    parser와 contents handler 사이에 위치
 데이터 처리 이전에 filter를 사용하여 application에 적합한 데이터로 변경

 parse -> filter -> content handler -> application

  . XMLFilter 생성
    public class DataFilter extends XMLFilterImpl {
  public DataFilter() {
  }

  public DataFilter(XMLReader parent) {
   super(parent);
  }
 }

 XMLFilterImpl은 DefaultHandler 클래스의 method 뿐만 아니라 XMLReader의 모든 method들도 구현한다.
 XMLFilterImpl은 DefaultHandler, XMLReader 두 class 모두의 역할을 수행

  . Stream에 filter의 삽입
    XMLFilter filter = new DataFilter();
 filter.setParent(reader);
 filter.setContentHandler(new DataProcessor());
 filter.setErrorHandler(new ErrorProcessor());
 filter.parse(new InputSource("votes.xml"));

  . Data의 filtering
 method를 overide 해서 사용한다.

- 문서 내 노드를 추출하는 방법
  . NodeList를 생성한 후, 이 list의 길이만큼 반복하여 list에 저장된 노드들을 추출
    : 우선 루트 엘리먼트의 자식 엘리먼트들에 대한 NodeList를 생성하고, 이 list의 길이만큼 for 문을 반복적으로 수행
   for( int i = 0 ; i < childNodeList.getLength() ; i++ ) {
     Node thisNode = childNodeList.item(i);
  ....
   }
  . 노드의 형제 관계성을 통하여 추출
    : 먼저 첫 번째 자식 노드에 접근한 후, 접근한 노드의 형제 노드로 이동하고, 더 이상 이동할 형제 노드가 없을 때 까지 반복된다.
   for( Node child = root.getFirstChild() ; child != null ; child = child.getNextSibling() ) {
     Node thisNode = node;
   }

- DOM 트리의 모든 노드들의 노드 타입과 이름, 값을 출력
  public void stepThrouch(Node thisNode) {
    int type = thisNode.getNodeType();
    String name = thisNode.getNodeName();
    String value = thisNode.getNodeValue();

 for(Node child = thisNode.getFirstChild() ; child != null ; ) {
   child = child.getNextSibling();
   stepThrouch(child);
 }
  }

  (9) #document:null   <--- 문서 자체
  (10) airlocksystem:null <-- DOCTYPE 선언
  (7)xml-stylesheet:href="airlocks.xsl" type="text/xsl" <--스타일 시트 선언
  (1)airlocksystem:null <-- root element
  (3)#text:

  (1)airlock:null
  (3)#text:

  (1)size:null
  (3)#text:

  (1)type:null
  (3)#text:Bronson
  (3)#text:

  (1)location:null
  (3)#text:Level 2 aft
  (3)#text:

  (1)status:null
  (3)#text:open
  (3)#text:

  (1)maintenance:null
  ....

- 정규화와 규범화
  정규화 : 텍스트 노드의 문제를 해결하기 위해서 일정한 형식을 만족하도록 XML 문서를 구성하는 작업
  규범화 : 동일한 정보에 대한 서로 다른 표현들에 대허서 XML의 처리에 도움을 주고, XML 문서 자체에서는 명시되지 않은 표현의 차이에 대해서 동일 정보에 대한 동일 표현을 가지도록 한다.
    규범적 XML 문서의 조건
 . XML 선언부와 DTD는 반드시 제거되어야 한다.
 . attribute는 알파벳 순서에 맞추어 정렬한다.
 . namespace 선언문은 적용 가능한 모든 element의 집합 중에서 가장 바깥쪽의 element에만 정의한다.
 . text node에서 <, &, >, #xD 등의 문자들은 각각 &lt; &amp; &gt; &#xD;로 대체한다.
 . attribute node에서 <, &, " 등의 문자들은 각각 &lt; &amp; &quot 등으로 대체한다.
 . element의 시작 태그 내에 있는 공백 문자들은 모두 삭제되어야 한다.

- DOM level 2.0 Traversal
  DOM 트리를 순회하는 기능을 제공

  Node root = doc.getDocumentElement();
  DocumentTraversal traversal = (DocumentTraversal)doc;
  NodeIterator nodeItrator = traversal.createNodeIterator(1, 2, 3, false);
   
 createNodeIterator(1, 2, 3, false);
    1 : 순회할 노드
 2 : 상수 필터, NodeFilter.SHOW_ALL = 모든 노드를 포함하여 순회
                NodeFilter.SHOW_ELEMENT = 요소만 순회
       NodeFilter.SHOW_TEXT = 텍스트 노드만 순회
    3 : NodeFilter 구현 객체
 false : entity 참조의 실제값을 분석할 것인가?
  
 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;
  }
 }
 aceptNode(Node n);
 NodeFilter.FILTER_SKIP = 필터로 들어온 노드는 건너뛰고 그 자식노드를 계속 탐색
 NodeFilter.FILTER_REJECT = 필터로 들어온 노드와 그 자식 모두 건너뜀
 NodeFilter.FILTER_ACCEPT = 필터로 들어온 노드 사용

- DOM level 3.0 Load and Save
  XML 문서의 적재
   1. factory method를 포함하는 DOMImplementationLS를 생성한다.
   2. DOMBuilder를 생성한다.
   3. 소스를 명시하기 위해 DOMInput을 생성한다.
   4. DOMInput으로 명시된 소스 문서를 파싱하기 위해 DOMBuilder를 사용하고, DOM Document를 반환한다.

   DOMImplementationLS DOMLS = new DOMImplementationImpl();
   DOMBuilder db = DOMLS.createDOMBuilder(1);
   DOMInputSource dinput = DOMLS.createDOMInputSource();
   dinput.setSystemId("airlocks.xml");
   doc = db.parse(dinput);

  XML 문서의 저장
   DOMWriter dw = DOMLS.createDOMWriter();
   DOMOutputStream doutput = DOMLS.createDOMOutputStream();
   doutput.setSystemId("output.xml");
   dw.writeNode(doutput, doc.getDocumentElement());

DOM ( Document Object Model)

DOM level 0 : HTML ver.3.x를 대상으로 한 비공식 버전
DOM level 1 : Node, Element, Attribute로 구성되는 기본 구조
DOM level 2 : DOM level 1의 보강
DOM level 3 :

- Node
  DOM의 기본 구성 요소
  문서 그 자체, element, attribute, text, 처리 지시문, 주석문 등이 모두 Node interface의 특별한 경우로 인식됨

  <?xml version="1.0"?>
  <friend>
   <handle degree="close">Harold</handle>
  </friend>

  하나의 문서 노드
  두 개의 element 노드(friend와 handle)
  네 개의 텍스트 노드(close, Harold, handle element의 앞/뒤 줄바꿈)
  하나의 애트리뷰트 노드(degree)

  document - root element(firned) +-  text(whitespace)
                                               +-  element(handle)      - text(Harold)
                                               |    |
                                               |    +- attribute(degree) - text(close)
                                               +- text(whitespace)

- DOM에 정의된 interface
  Node                     - 모든 노드 타입에 대한 상위 클래스. getParentNode(), getNodeName(), insertBefore(), removeChild()...
  Document                 - 거의 모든 타입의 노드들을 포함하는 노드, 문서 자체를 대표하는 interface. createElement(), createTextNode() ...
  Element                  - element를 대표하는 타입. Attr 노드와 관련될 수 있는 노드 타입. getElementsByTagName() ...
  Attr                     - 자식으로 Text 노드나 EntityReference 노드를 가질 수 있다.
  Text                     - 마크없이 없는 문자열. 혼합 컨텐츠에 대한 텍스트 노드는 Text와 Element 노드로 분리될 수 있다.
  CDATASection             - 마크업 기호(<, >)를 단순한 텍스트로 취급
  DocumentType             - DTD 내부에 문자열로 표현된 모든 정보를 포함하는 노드 타입.
  Comment                  -
  Notation                 -
  Entity                   -
  EntityReference          -
  ProcessingInstruction    -

  DocumentFragment         - 이 Node 인터페이스의 구현은 자신의 고유 메소드를 갖는 대신에 옮기고자 하는 노드의 그룹을 포함하는 컨테이너나 작은 문서의 역할
  DOMImplementation        - hasFeature() 메소드를 사용해서 지원되는 기능의 가동 여부를 확인할 수 있다.
  DOMException, ExceptionCode - application 에서 발생한 예외 사항에 대한 보고를 위해 사용.
  NodeList                 - Node의 자식들처럼 정렬된 목록을 제공
  NamedNodeMap             - 한 element가 포함하는 attribute들 처럼 이름에 의해 접근 가능한, 정렬되지 않은 목록을 제공.

- DOM 관련 권고안들
  DOM level 2.0 Traversal and Range
    : XML 문서에 대한 효율적인 조회를 위한 NodeItreator 와 TreeWalker의 두 가지 새로운 interface가 포함.
  DOM level 2.0 HTML
    : Core 권고안 내에 HTMLDocument와 HTMLFormElement와 같은 HTML 문서에 대한 정의를 포함.
  DOM level 2.0 Style Sheets
    : CSS나 CSS 내부에 포함된 데이터의 처리를 위한 interface에 대한 정의를 제공.
  DOM level 2.0 Views
    : 문서의 버전을 구별하는 방법을 제공(DOM level 3.0 에서 삭제된 모듈)
  DOM level 2.0 Events
    : 마우스 클릭과 같은 액션이 발생했을 때 객체의 행동을 결정하는 방법을 제공하며, 해당 객체의 상휘/하위의 모든 객체에 영향을 미친다.
  DOM level 3.0 Load and Save
    : 문서의 적재와 저장에 대한 interface를 제공.
  DOM level 3.- Validation
    : Document 객체가 특정 문법과 연관되어 유효성을 갖는지 검사하는 방법을 제공.
  DOM level 3.0 XPath
    : 문서 내에서 노드의 위치를 찾아내거나 기술하기 위해 XPath 문법을 사용해 높은 유연성을 제공. DOM 에서의 XPath 1.0 이용 방법을 정의

- DOM interface 구현
  Java => JAXP, Apache, Xerces-Java
  C++  => MS Visual C++ .NET - COM과 MSXML 4.0
  VB   => MS VB .NET - MSXML 4.0
  Perl => Apache Xerces
  PHP  => PHP 4.2.1 또는 이후 버전

- Java를 이용한 XML 문서의 파싱

  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import java.io.File;
  import org.w3c.dom.Document;
  import org.w3c.dom.DOMImplementation;

  public class ActivityListing {
   public static void main(String[] args) {
  File docFile = new FIle("activities.xml");
  Document doc = null;

  try {
   DocumentBuilderFactory dbf = DocumentBuilderFactory.netInstance();
   DocumentBuilder db = dbf.newDocumentBuilder();
   doc = db.parse(docFile);

   DOMImplementation domImpl = doc.getImeplementation();

   if( domImpl.hasFeature("Core", "2.0") ) {
    System.out.println("2.0 is supported");
   } else {
    System.out.println("2.0 is not supported");
   }

   if( domImpl.hasFeature("Core", "5.0") ) {
    System.out.println("5.0 is supported");
   } else {
    System.out.println("5.0 is not supported");
   }
  } catch(Exception e) {
   System.out.println("Problem parsing the file.");
  }
 }
  }
 
  ELEMENT_NODE                = 1
  ATTRIBUTE_NODE              = 2
  TEXT_NODE                   = 3
  CDATA_SECTION_NODE          = 4
  ENTITY_REFERENCE_NODE       = 5
  ENTITY_NODE                 = 6
  PROCESSING_INSTRUCTION_NODE = 7
  COMMENT_NODE                = 8
  DOCUENT_NODE                = 9
  DOCUMENT_TYPE_NODE          = 10
  DOCUMENT_FRAGMENT_NODE      = 11
  NOTATION_NODE               = 12

- Document
  Element
  Child   - 아래 level
  Sibling - 같은 level
  getFirstChild()
  getNextSibling()
  getElementsByTagName()
  getElementById()
  getOwnerDocument()
  .
  .
  .
  .

  API 참조
  javax.xml.*
  org.w3c.dom(interface 정의들)
  org.xml.*

- 목적과 목표의 정의

  . 목적
    : 프로젝트의 수행으로 얻고자 하는 모든 결과
  . 목표
    : 목적을 달성하기 위한 측정 가능한 중간 과정

    -----------------------------------------+--------------------------------------------------------------
                                     목적                      |                        목표
    -----------------------------------------+--------------------------------------------------------------
    . 리조트와 리조트 주변 시설의 안정성에       | . 관리 스케줄과 결과를 구체화하고 이를 공지한다.
   대한 방문객들의 인식을 개선하다.                | . 관리 표지판을 개선한다.
                                                                 | . 관리 기간이 지난 장비들은 자동으로 사용을 금한다.
                                                                 | . 관리 기간 동안 이벤트 스케줄을 금지한다.
    ----------------------------------------------+---------------------------------------------------------
 . 방문객의 유람과 이벤트에 대한                    | . 방문객들이 온라인상으로 스케줄을 만들 수 있도록 지원한다.
   참여도를 높이다.                                       | . 사용자들이 리조트 관계자와 직접 만나지 않더라도
                                                                 |   온라인으로 예약 가능하도록 한다.
                                                                 | . 과거의 경험이나 선호도 등을 바탕으로 방문객의 공간에
                                                                 |   개인 취향에 맞는 광고를 싣는다.
    -----------------------------------------+--------------------------------------------------------------
  
- Data Modeling
  . 개체(Entity)
    : 필요로 하는 정보에 대해 물질적 또는 관념적으로 중요한 개념
  . 속성(Attribute)
    : 개체의 특성이나 상태를 나타낸다.
  . 관계성(Relationship)
    : 두개의 entity의 연결 상태를 설명한다.

- XML 문서는 element와 attribute 들의 부모-자식 관계를 갖는 계층 구조로 표현된다

##############################################

- 파일 구조
  well-formed

  XML 선언부(필수)
    <?xml version="1.0" encoding="EUC-KR" standalone="no"?>
  DOCTYPE 선언부(선택)
    <!DOCTYPE airlocksystem SYSTEM "airlocks.dtd">
  root element
    has only one.

- Element
  시작 태그, 문자 데이터, 종료 태그
  element의 이름은 element를 정의하는 마크업의 중요한 특징
  element 이름 지정 규칙
   . 문자 또는 '_' 로만 시작 가능하다.
   . 시작 태그와 종료 태그의 이름은 반드시 일치
   . : 을 포함할 수 없다.
   . 공백이 있어서는 안된다.

- Attribute
  elememt에 추가 정보를 기술하기 위해 시작 태그 내에 추가한 이름-값 쌍
  attribute 이름 지정 규칙
   . element 이름과 동일한 규칙을 따른다
   . 동일 element 내에서 attribute 이름은 유일해야 한다.

- Entity
  & 와 ; 를 이용하여 표현되는 값
  &lt; = <
  &gt; = >
  &amp; = &
  &quot; = "
  &apos; = '

- CDATA
  character data
  attribute 값과 마찬가지로 XML application에 의해서 parsing 되지 않는 값

- 처리 지시문
  XML 데이터를 처리하는 application에 전달항 정보를 기입
  <? .... ?>
  XML 선언부의 <? ?>는 처리 지시문이 아니다.

- 주석문
  <!-- ... -->

##############################################

- well-formed XML documenet vs valid XML document
 . well-formed XML document
   : XML 문서가 기본적으로 갖춰야 할 요구 조건을 만족하는 문서.
     그러나 어떤 element가 어떤 타입의 컨텐츠를 가지든지,
     어떤 순서로 표현해야 하는지에 대한 제약은 없다.
 . valid XML document
   : DTD 내의 element와 attribute 들에 대한 정의(이 정의에는 컨첸츠 타입, 출현 순서 등이 포함된다)를 준수하는 문서
 
- pre-requsite for well-formed XML document
  . XML 문서는 문서 내의 다른 모든 element를 포함하는 단일한 root element를 가져야 한다.
  . 모든 element는 올바르게 중첩되어야 한다. 임의의 element 내에서 시작 태그를 갖는 element는 반드시 동일한 element 내에 종료 태그를 가져야 한다.
  . 모든 attribute의 값은 반드시 인용 부호로 둘러싸여야 한다.
  . attribute 값은 < 문자를 포함할 수 없다.
  . 하나의 element는 이름이 다른 여러 개의 attribute를 가질 수 있다. 하지만 같은 이름의 여러 attribute를 가질 수 없다.
  . XML 문서 내의 모든 문자는 적법한 문자여야 한다.
    XML 문서에서 적법한 문자란 유니코드 표준에서 정의한 65,000개 이상의 문자를 뜻한다. 하지만 이러한 문자를 이용하기 위해서는
 먼저 문서 내에서 문자 인코딩 체계를 정의해야 한다.
 만약 독자가 어떤 XML 문서의 인코딩 체계를 ISO 8859-1로 정의했다면, 이 인코딩 체계에 따른 문자 집합 내의 문자만 이용해야 한다.
  . attrivute 값은 외부 entity를 참조할 수 없다.
  . parameter entity라 불리는 특정 타입의 entity 들은 DTD 내에서는 참조될 수 있지만, XML 문서 내에서는 참조 될 수 없다.
  . parameter entity는 자신을 참조할 수 없다.
  . parsed entity는 그래픽 파일처럼 unparsed entity에 대한 참조를 포함할 수 없다.

##############################################

- namespace
  . 언제든지 단일 이름으로 변수, 함수 파일 등과 같은 아이템에 대해 유일하고 중복되지 않는 참조를 가능하게 가는 것
  . 이름으로 인한 혼동을 없애기 위해 고안됨.
  . 여러 XML 문서의 element를 조합해서 다른 XML 문서를 작성할 때 혼동을 없애기 위해 namespace를 사용한다.

  . namespace 지정
    : xmlns:NameSpace="URI"
  . default namespace
    : xmlns="URI"
  . namespace 삭제
    : xmlns=""