xml 변환

2008.01.14 13:53

Private Sub test()

Dim oXML As New Xml.XmlDocument

Dim oNode As Xml.XmlNodeList

Dim sRoot As String

Dim sFile As String

Try

sRoot = System.Windows.Forms.Application.StartupPath

sFile = "Test.xml"

oXML.Load(sRoot & "" & sFile)

oNode = oXML.SelectNodes("Test/SubTest[@value=""AttValue01""]")

For Each oEle As System.Xml.XmlElement In oNode

MsgBox(oEle.OuterXml)

Next

Catch ex As Exception

MsgBox(ex.ToString)

Finally

oXML = Nothing

oNode = Nothing

End Try

End Sub

<
신고
Posted by 나비 나비:D
태그 xml

XML 기본지식

2008.01.04 14:09

XML(Extensible Markup Language)
 - 구조를 갖는 텍스트
 - 데이터 표준 포맷
 - 모든 컴퓨터와 사람이 동시에 이해할 수 있는 정보 표현 방법
 - 어플리케이션 간의 데이터 교환
 - HTML(표현 중심), XML(내용, 구조 중심)

 - 필요 환경
  - IE 6.0(MSXML 3.0 파서 내장
  - XML 지원 브라우저(IE 6.0)

1. XML
2. DTD
3. Schema
4. CSS
5. XSL(XPath)
6. DOM

WellFormed Document 규칙
 - 모든 요소가 XML 스펙을 준수 할때 그 문서를 WellFormed 하다고 간주한다.
 - http://www.w3c.org/xml
 - http://www.trio.co.kr

 - Element
 - Attribute
 - Data
 - Entity

 1. XML 선언문를 시작으로 한다.
  - <xml version="1.0" ?>

 2. 다른 모든 엘리먼트를 포함하고 있는 하나의 루트 엘리먼트를 가져야 한다.

 3. 데이터를 포함하고 있는 엘리먼트는 시작태그와 끝태그를 가지고 있어야 한다. 태그는 대소문자를 구분한다.

 4. 데이터를 포함하고 있지 않고 하나의 태그만 을 사용하는 엘리먼트는 /> 로 끝나야 한다.

 5. 엘리먼트가 다른 엘리먼트에 포함될 수는 있지만 중첩은 안된다.

 6. 속성값을 따옴표로 표현한다.

 7. <,&는 태그에만 사용가능하고 데이터로 사용 불가능 하다. 사용하려면 Enter를 이용한다.

 8. XML의 주석은 <!-- -->를 사용한다.

 9. 태그명은 공백 사용이 불가능하다.

 10. 태그명은 문자, 숫자, 언더바, 하이퍼만 가능하고 첫문자는 문자 or 언더바


DTD
 - XML 설계도
 - XML 문서에서 사용될 태그, 속성의 종류나 제한 조건등을 기술
 - 일종의 프로토콜 개념, 저장 구조 개념
 - 구성 요소의 종류, 갯수, 순서 등을 명시
 - DTD 조건에 일치하는 문서 -> Valid XML Document

DTD 선언 형태
 1. DTD 구성요소
  - 요소 선언(<!ELEMENT ..>)
  - 속성리스트 선언(<!ATTLIST..>)
  - 엔티티선언(<!ENTITY..>)
 2. DTD 타입
  - 내부 DTD(XML 문서 내에 기술)
   : xml과 dtd를 따로 보관할 필요X, 한장으로 가능, 이동이 자유롭다, 처리시간이 빠르다
  - 외부 DTD(별도의 DTD 문서 *.dtd)
   : 재사용, 외부 지역에 있어도 통신이 가능하면 활용 가능
  - 겹치면 내부 우선
 3. 공개 DTD
  - <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
  - <!DOCTYPE 루트엘리먼트 공개유무(PUBLIC|SYSTEM) "조직명//데이터종류//언어코드">


ELEMENT 선언
 - XML 문서의 요소(태그)의 이름, 출현 횟수, 순서등을 정의

선언 형태
 - <!ELEMENT 요소명(요소형)>
 - 요소명 : 태그명
 - 요소형
  : 태그의 형태(요소내용 | 혼합 내용 | 빈요소(Empty) | 텍스트데이터)
 - ex) <!ELEMENT 이름 (#PCDATA)>

 1. 요소 내용
  - 자식의 대상이 요소로만 구성되는 경우. 텍스트X
  - 자식요소의 출현 횟수와 순서등을 결정

 2. 혼합 내용
  - 자식의 대상으로 요소와 텍스트가 둘다 나오는 경우

 3. 빈요소
  - 자식이 되는 구성 요소가 없는 경우
  - EMPTY
  - 단독태그
 
 4. 텍스트 데이터
  - 더 이상 자식 요소가 없고 텍스트 데이터만 가질 경우
  - #PCDATA
  - 말단 노드, 터미널 노드, 최하위 노드

<!-- dtdEX04.xml -->
<!-- dtdEX05.xml -->
순서 지정
 1. () : 같은 출현횟수를 가지는 요소를 묶을때...
 2. , : 나열된 요소들이 명시된 순서대로 나올때...
 3. | : 대체 가능한 요소들을 구분

<!-- dtdEX06~09.xml -->
출현횟수
 4. 표시없음 : 출현 횟수가 1, 생략불가, 중복불가
 5. ? : 출현횟수가 0 또는 1, 생략가능, 중복불가
 6. + : 출현횟수가 1이상, 생략불가, 중복가능
 7. * : 출현횟수가 0 또는 1 이상, 생략가능, 중복가능

DTD에서의 속성 선언[속성리스트 선언]
 - 엘리먼트를 설명하는 속성에 대한 정의
 - <!ATTLIST 태그명 속성명 타입  값>

속성타입
 - CDATA : 속성값으로 문자열사용
 - ENTITY : DTD에서 선언한 엔티티 참조
 - ID : 유일값
 - IDREF : ID 값 참조
 - 열거형 : 열거값

값표시방법
 - #REQUIRED : 필수
 - #IMPLIED : 생략가능
 - #FIXED : 고정값 사용
 - 기본값 : 생략하면 기본값 사용 auto (Y|N) "Y"

Entity
 -DTD와 XML Document에서 대치 가능한 컨텐츠 생성

1. General Entity
 - 모든 XML Document에서 사용 가능, Parsed Entity와 Unparsed Entity 로 나뉨
2. Parameter Entity
 - 외부 DTD에서 사용

General Entity
 - <!ENTITY 엔티티명 "대치할 내용"> : 선언시(DTD내에서..)
 - &엔티티명;:사용시(XML Document내에서..)

Built-in Entity(미리약속된)
 - &lt; &gt; &quot; &apos; &amp;
 - &#문자코드; ex) &#38; &#x26;

외부 Entity
 - 엔티티 내용만 독립파일로 생성해서 호출 가능
 - !<ENTITY 이름 SYSTEM "파일명">

Parameter Entity
 - 엔티티 선언시에만 사용 가능하고, 외부 DTD에서만 사용 가능하다.
 - !<ENTITY % 엔티티명 "대치할 내용"> : 선언시(외부 DTD내에서..)
 - %엔티티명;:사용시(엔티티 선언시..)

Schema
 - DTD의 단점을 보완, 기능 강화
 - 유효한 데이터 검증
 - DTD에서 표현하지 못하는 데이터 표시 가능
 - 사용자 정의 데이터 타입 생성 가능
 - 기존의 엘리먼트, 어트리뷰트를 상속받아 확장, 제한이 가능
 - 대체 엘리먼트 가능, 상황에 따른 구조 변경 가능
 - 데이터 모델 (XML 문서 구조) & 데이터 타입(데이터 형식 정의)

Schema 선언
 <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
 <!-- 스키마 내용 -->
 <!-- xmlns = XML NameSpace -->
  <xsd:element>
 </xsd:schema>

Schema 호출
 <루트엘리먼트 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="스키마파일.xsd">
  <!-- XML 내용 -->
 </루트엘리먼트>


CSS & XML
 - XML 데이터를 브라우저 환경에 시각적으로 표시
 - <?xml-stylesheet href="CSS파일명" type="text/css"?>


XSL(eXtensible Stylesheet Language)
 - XSLT(XSL Transformation) : XML문서를 또다른 XML문서나 비XML문서로 변환

XSL 선언문
 - <xsl:stylesheet version="1.0" xmlns:xsl="http://ww.w3.org/1999/XSL/Transform" xmlsn:fo="http://www.w3.org/1999/XSL/Format"> (표준선언문)
 - <xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl"> (비표준선언문)

XSL 기본형(*.xsl)
 <?xml version="1.0" encoding="euc-kr"?>
 <xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl">
  <xsl:template match="/">
   XSL 처리내용 기술
  </xsl:template>
 </xsl:stylesheet>

적용 XML 문서(*.xml)
 <?xml version="1.0" encoding="euc-kr"?>
 <?xml-stylesheet href="XSL파일" type="text/xsl"?>
 <root>
 </root>

XPath
 - XML문서의 노드 접근 표현식
 - XPath 표현식에선 가상의 최상위 엘리먼트 존재 -> "/"

 ex) match="표현식"
 1. /
  - 가상의 루트 노드
 2. *
  - 노드 전체
 3. .
  - 노드 자기 자신
 4. /a/b/c
  - 루트노드에서 출발해서.. a자식, b자식, c노드
 5. a
  - a노드자신(상대경로), 이전 표현식에서 /로 시작하는 표현식이 1회이상 출현
  - /a 와는 다른 표현
 6. //a
  - 전체 노드 중 a를 이름으로 갖는 노드
  - 처음 a노드를 만나면 탐색 중단
 7. a[b]
  - [] 조건
  - b노드를 자식으로 갖는 a노드
  - a/b
 8. a[b='c']
  - c텍스트데이터를 갖는 b노드를 자식으로 갖는 a노드
 9. a[b='c']/d
  - c텍스트데이터를 갖는 b노드를 자식으로 갖는 a노드의
    자식 노드인 d노드
 10. a/@b
  - a노드의 속성중 b라는 속성
 11. a[@b]
  - b라는 속성을 갖는 a노드 ex) <a b="">data</a>
 12. a[@b='c']
  - b속성값이 c인 a노드 ex) <a b="c">data</a>
 13. a[@b='c']/d
  -b속성값이 c인 a노드의 자식 노드d
 14. a/@*
  - a의 모든 속성
 15. a/*
  - a의 모든 자식엘리먼트
 16. a[@b &gt;= c and @b &lt;= d]
  - a[@b >= c and @b <= d]

XPath 함수
 - name() - 노드명 반환
 - text() - PCDATA 반환(단, 순수 자신의 PCDATA만)
 - position() - 노드의 위치를 지정 ex) //회원[position()=2]
 - last() - 노드집합의 마지막 노드 위치 반환
 - count() - 노드집합의 갯수 반환
 - sum() - 노드집합의 모든 합 반환
 - contains() - 문자열 안에 특정 문자열 포함 유무 확인
 - starts-width() - 문자열이 특정 문자열로 시작하는지 유무

Axis 표현
 1. self::*  - 자기 자신
 2. attribute::* - 속성
 3. parent::* - 부모 노드(단일)
 4. child::* - 자식 노드(집합O)
 5. ancestor::* - 직계 조상 노드(집합O)
 6. ancestor-or-self::* - 자신을 포함한 직계 조상 노드
 7. descendant::* - 자손 노드
 8. descendant-or-self::* - 자신을 포함한 자손 노드
 9. following::* - 자손을 제외하고 자신보다 하위에 표기된 노드 전체
 10. following-sibling::* - 자신보다 하위에 표기된 형제 노드
 11. preceding::* - 직계 조상을 제외하고 자신보다 상위에 표기된 노드 전체
 12. preceding-sibling::* - 자신보다 상위에 표기된 형제 노드

XSL 표현
 1. <xsl:template match="XPath표현"></xsl:template>
  - XML 문서 내용을 템플릿 지정 형태로 변환
  - 템플릿의 기본 형식은 HTML
  - 템플릿은 패턴부와 액션부 나뉜다

 2. <xsl:apply-template select="XPath표현"</xsl:template>
  - 특정 템플릿을 이 위치에서 적용하겠다..

 3. <xsl:value-of select="XPath표현"/>
  - 특정 노드의 값 출력(텍스트)

 4. <xsl:for-each select="XPath표현">
   반복 실행 구문
  </xsl:for-each>
  - 같은 태그가 반복될 경우 반복 실행

 5. <xsl:sort select="XPath표현" data-type="number|text" order="ascending|descending"/>
  - 노드값에 의한 정렬
 
 6. <xsl:if test="조건식">실행문</xsl:if>
  - 조건식
  - 조건식 부정 -> not()함수
 
 7. <xsl:choose>
   <xsl:when test="조건식1"></xsl:when>
   <xsl:when test="조건식2"></xsl:when>
   <xsl:when test="조건식3"></xsl:when>
   <xsl:otherwise></xsl:otherwise>
  </xsl:choose>
  - 다중 조건문
 
 8. <xsl:element name="요소명">요소값</xsl:element>
  - 엘리먼트 동적 생성
 
 9. <xsl:attribute name="속성명">속성값</xsl:attribute>
  - 속성 동적 생성

 10. <xsl:comment></xsl:comment>
  - 주석 동적 생성
 
 11. <xsl:text></xsl:text>
  - 텍스트 노드 동적 생성

DOM(Document Object Model)
 -객체지향 프로그래밍 언어에서 XML 문서의 내용을 쉽게 다룰 수 있도록 제작한  API의 표준 스펙
 -플랫품과 언어에 독립적
 -XML 문서와 문서의 일부를 생성하고, 문서를 탐색하고, 문서의 부분을 이동, 복사, 제거하거나 속성을 추가, 수정, 제거할 수 있다.

DOM 인터페이스
 - 기초 인터페이스
  1. Node
  2. Document
  3. Nodelist
  4. Element
  5. Attr
  6. Text
  7. Comment
 - 확장 인터페이스
  1. CDATASection
  2. ProcessingInstruction
  3. Entity

XML 접근방식
 1. DOM(Object)
 2. SAX(Stream)

XML 닷넷 지원 클래스
 - System.XML
 - DOM : XmlDataDocument
 - SAX : XmlReader, XmlWriter
 - System.Xml.XPath
 - System.Xml.Xsl

XMLTextReader/XmlTextWriter
 - 처리 속도가 빠르다
 - 메모리 효율이 높다(버퍼 사용X)
 - 커서 이동이 단순 전진
 - 수정, 삭제가 어렵다
 - 유효성 검사를 추가로 해야 한다.

XmlDocument(DOM)
 - 문서 구조를 유연하게 접근 가능(트리구조)
 - 다른 언어의 접근 방식과 유사(DOM)
 - 수정, 삭제가 용이
 - XPath 표현에서의 접근 속도가 느리고, 오버헤드가 크다
 - 메모리 효율이 낮다(버퍼 사용O)

XmlDocument
 - Document 객체
XmlNode
 - 노드(엘리먼트, 속성, PCDATA...)
XmlNodeList
 - 노드 집합(검색)
XmlElement
 - 엘리먼트
XmlAttribute
 - 속성
 
XPath 클래스
 - XPath 표현식을 이용한 노드 접근 방식 제공
 - DOM 접근방법보다 빠른 검색 속도
 - 단순 검색, 편집 기능X

신고
Posted by 나비 나비:D
태그 xml

출처 : http://miriam.tistory.com/209

<?xml version="1.0" encoding="euc-kr"?>

<!DOCTYPE Computer [
<!ELEMENT Computer (CPU, Memory, GraphicCard)>
<!ELEMENT CPU (#PCDATA)>
<!ELEMENT Memory (#PCDATA)>
<!ELEMENT GraphicCard (#PCDATA)>
]>

XML 문서의 DTD 선언문(Document Type Declaration)
    => XML의 구조가 DTD에 의해 정의되어 있다는 것을 명시하기 위한 구문
       1) <!DOCTYPE 문서타입이름 SYSTEM "DTD 파일이름">
       2) <!DOCTYPE 문서타입이름 [ DTD 정의 ]>
       3) 엘리먼트 선언 방법
   <!ELEMENT 엘리먼트 이름 엘리먼트 내용>
       4) 하위 엘리먼트를 갖는 엘리먼트 선언
   <!ELEMENT Book (Title, Author, PubDate)>
       5) 값을 갖는 엘리먼트 선언
   <!ELEMENT Title (#PCDATA)>
       6) 빈 엘리먼트 선언
   <!ELEMENT PubDate EMPTY>
 
<!DOCTYPE BookList [
<!ELEMENT BookList (Book)>
<!ELEMENT Book (Title, Author, PubDate)>
<!ELEMENT Title (#PCDATA)>
<!ELEMENT Author (#PCDATA)>
<!ELEMENT PubDate (#PCDATA)>
]>

엘리먼트의 연결자
    => , : and 의 의미로 엘리먼트가 순차적으로 발생함  <!ELEMENT A (B, C)>
       | : or 의 의미로 엘리먼트가 선택적으로 발생함   <!ELEMENT A (B | C)>

<xml version="1.0" encoding="euc-kr">
<!DOCTYPE BookList [
<!ELEMENT BookList (Book)>
<!ELEMENT Book (Title, Author, (PubDate | Author))>
<!ELEMENT Title (#PCDATA)>
<!ELEMENT Author (#PCDATA)>
<!ELEMENT PubDate EMPTY>
<!ELEMENT Date EMPTY>

엘리먼트의 발생 지시자
    => <!ELEMENT BookList (Book)> : 반드시 한번 사용된다
       <!ELEMENT BookList (Book?)> : 사용되지 않거나 한 번 사용된다
       <!ELEMENT BookList (Book+)> : 한번 이상 사용된다
       <!ELEMENT BookList (Book*)> : 사용되지 않거나 여러 번 사용된다

<!DOCTYPE BookList [
<!ELEMENT BookList (Book+)>
<!ELEMENT Book (Title, Author*, (PubDate | Date)?)>
<!ELEMENT Title (#PCDATA)>
<!ELEMENT Author (#PCDATA)>
<!ELEMENT PubDate EMPTY>
<!ELEMENT Date EMPTY>
]>

어트리뷰트의 형
    => CDATA : 일반적인 값을 갖는 어트리뷰트
       <!ATTLIST Date year CDATA #REQUIRED>
    => 열거형 : 열거된 값 중 하나를 선택적으로 갖는 어트리뷰트
       <!ATTLIST Price unit (원 | 달러 | 엔) #REQUIRED>
    => ID 형 : XML 문서 내에 유일한 값을 갖는 어트리뷰트 선언

<?xml version="1.0" encoding="euc-kr"?>
<!DOCTYPE BookList [
<!ELEMENT BookList (Book+)>
<!ELEMENT Book (Title, Author*, Price, (PubDate | Date)?)>
<!ATTLIST Book ISBN ID #REQUIRED>
<!ELEMENT Title (#PCDATA)>
<!ELEMENT Author (#PCDATA)>
<!ELEMENT Price (#PCDATA)>
<!ATTLIST Price unit (원 | 달러 | 엔) #REQUIRED>
<!ELEMENT PubDate EMPTY>
<!ATTLIST PubDate year CDATA #REQUIRED month CDATA #REQUIRED>
<!ELEMENT Date EMPTY>
]>

어트리뷰트의 디폴트 값
    => #REQUIRED : 반드시 사용되어야 하는 어트리뷰트 선언
       <!ATTLIST Book ISBN ID #REQUIRED>
    => #IMPLIED : 어트리뷰트가 사용될 수도 있고, 사용되지 않을 수도 있다
       <!ATTLIST Date year CDATA #IMPLIED>
    => #FIXED "어트리뷰트 값" : 어트리뷰트가 사용될 경우에는 반드시 선언된
       값으로 사용해야 함
       <!ATTLIST Price unit CDATA #FIXED "won">
 
******* 54 Page 참고 ********

<?xml version="1.0"?>
<!DOCTYPE Person [
<!ELEMENT Person (#PCDATA)>
<!ENTITY name "이명진">
]>

<Person> &name </Person>

<?xml version="1.0"?>
<!DOCTYPE Person [
<!ELEMENT Person (#PCDATA)>
<!ENTITY name SYSTEM name.txt>
]>

<Person> &name </Person>



<?xml version="1.0" encoding="euc-kr"?>
<!DOCTYPE BookList [
<!ELEMENT BookList (Book+)>
<!ELEMENT Book (#PCDATA)>
<!ENTITY name "XML 프로그래밍">
<!ENTITY bookContent SYSTEM "book.xml">
]>

<?xml version="1.0" encoding="euc-kr"?>
<com:Computer xmlns:com="
http://www.computer.com">
 <com:CPU>Pentium 2.0</com:CPU>
 <com:Memory>512MB</com:Memory>
 <com:GraphicCard>Radeon 9200</com:GraphicCard>
</com:Computer>

<lan:name xmlns:lan="http://www.sun.com">Java</lan:name>
<food:name xmlns:food="
http://www.food.net">Java</food:nae>

<Computer xmlns="http://www.computer.com">

<!ELEMENT title (#PCDATA)> :: <xsd:element name="title" type="xsd:string" />
<!ELEMENT number (#PCDATA)> :: <xsd:element name="number" type="xsd:integer" />
<!ELEMENT date (#PCDATA)> :: <xsd:element name="title" type="xsd:date" />


<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<xsd:schema xmlns:xsd="http//www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
 <xsd:element name="car">
  <xsd:complexType>
   <xsd:sequence>
    <xsd:element name="name" type="xsd:string" />
    <xsd:element name="CC" type="xsd:integer" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
</xsd:schema>

<?xml version="1.0" encoding="UTF-8" standalone="yes?>
<xsd:schema xmlns:xsd="
http://www.w3.org/2001/XMLSchema" elementFormDefault="qualifed">
<xsd:element name="car">
 <xsd:complexType>
  <xsd:sequence>
   <xsd:element name="name" type="xsd:string" />
   <xsd:element name="CC" type="xsd:integer" />
  </xsd:sequence>
 </xsd:complexType>
</xsd:element>
</xsd:schema>


<!ELEMENT book (name, author?)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT authors (#PCDATA)>

<xsd:element name="book">
 <xsd:complexType>
  <xsd:sequence>
   <xsd:element name="name" type="xsd:string" />
   <xsd:element name="authors" type="xsd:string" minOccurs="0" maxOccurs="1">
  </xsd:sequence>
 </xsd:complexType>
</xsd:element>

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns:xsd="
http://www.w3.org/2001/XMLSchema">
  <xsd:element name="booklist">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="book" minOccurs="1" maxOccurs="unbounded">
          <xsd:complexType>
            <xsd:sequence>
              <xsd:element name="name" type="xsd:string" />
              <xsd:element name="author" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/>
              <xsd:element name="page" type="xsd:integer" />
              <xsd:element name="price" type="xsd:integer" />
            </xsd:sequence>
          </xsd:complexType>
        </xsd:element>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>
</xsd:schema>


기본적으로 제공되는 데이터 타입
=> string / boolean / decimal / time / date / duration
   integer / ID

Complex Type - <xsd:complexType>
=> <xsd:element> 엘리먼트의 하위 요소
   엘리먼트가 하위 엘리먼트나 어트리뷰트를 갖을 경우에 사용

<element name="page">
    <simpleType>
        <restriction base="xsd:string">
            <minInclusive value="100" />
            <maxInclusive value="200" />
 </restriction>
    </simpleType>
</element>

<?xml version="1.0" encoding="UTF-8"?>

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <xsd:element name="booklist">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element name="book" minOccurs="1" maxOccurs="unbounded">
          <xsd:complexType>
            <xsd:sequence>
              <xsd:element name="part">
                <xsd:simpleType>
                  <xsd:restriction base="xsd:string">
                    <xsd:enumeration value="XML" />
                    <xsd:enumeration value="XSLT" />
                    <xsd:enumeration value="Schema" />
                  </xsd:restriction>
                </xsd:simpleType>
              </xsd:element>
              <xsd:element name="name" type="xsd:string" />
              <xsd:element name="page">
                <xsd:simpleType>
                  <xsd:restriction base="xsd:integer">
                    <xsd:minInclusive value="1" />
                    <xsd:maxInclusive value="1500" />
                  </xsd:restriction>
                </xsd:simpleType>
              </xsd:element>
            </xsd:sequence>
          </xsd:complexType>
        </xsd:element>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:element>
</xsd:schema>


Contents Model : 엘리먼트가 갖는 하위 엘리먼트들의 발생 관계를 나타낸다.
=> <xsd:sequence> : 각 엘리먼트들이 순서대로 발생
   <xsd:all> : 순서에 상관없이 한 번씩 발생
   <xsd:choice>

********* 88 / 89 페이지 ************

SAX의 7가지 이벤트 핸들러
=> ContentHandler / ErrorHandler / DTDHandler / EntityResolver
   DeclHandler / LexicalHandler / DefaultHandler


class ImplHandler implements ContentHandler {
 void startDocument() {
  System.out.println("XML Document Start");
 }
 void endDocument() {
  System.out.println("XML Document End");
 }
}

ErrorHandler : XML 문서 처리 도중 오류 발생시 호출되는 이벤트
=> fatalError(SAXParseException exception)
   error(SAXParseException exception)
   warning(SAXParseException exception)

ImplHandler errorHandler = new ImplHandler();
xmlReader.setErrorHandler(errorHandler);

SAX 파서 사용 예제
=> SAXParserFactory factory = SAXParserFactory.newInstance();
   SAXParser parser = factory.newSAXParser();
   parser.parse(filename, new DefaultHandler());

   DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
   DocumentBuilder builder = new factory.newDocumentBuilder();
   Document document = builder.parse(filename);

/**
DOM 파서를 생성하고, XML 문서를 파싱하거나 새로운 XML 문서를 생성하는 예제
**/
import javax.xml.parsers.*;
import org.w3c.dom.*;

public class CreateDOMParser {
 public static void main(String[] args) {
  try {
   DocumentBuilderFactory factory =     
                   DocumentBuilderFactory.newInstance();
   DocumentBuilder dBuilder = factory.newDocumentBuilder();

   // 빈 Document 객체 생성
   Document emptyDocument = dBuilder.newDocument();
   System.out.println("빈 Document 객체 생성 완료");
   
   // XML 파일을 로딩하여 Document 객체 생성
   Document xmlDocument = dBuilder.parse("DOMSample.xml");
   System.out.println("DOMSample.xml 문서를 입력으로 Document 객체 생성 완료");
  } catch(Exception e) {
   e.printStackTrace(System.err);
  }
 }
}

신고
Posted by 나비 나비:D
태그 xml

[XML] DOM

2008.01.03 17:19

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>

신고
Posted by 나비 나비:D
태그 DOM, xml

[XML] XML 의 기초

2008.01.03 16:28

출처 : http://cafe.naver.com/physicalcomputing.cafe?iframe_url=/ArticleRead.nhn%3Farticleid=35

이번주에는 플랙스의 MXML의 형제격인 XML(eXtensible Mark Language)의 기초에 대해 알아봅시다.

XML이 DOM(Dzcument Object Model-HTML, XML, MXML, MSXML 등등)구조언어 중에서 제일 쉽기 때문입니다.



<XML의 기본적인 설명>

- XML은 확장자가 XML이다.

- XML은 메모장등 문서편집기에서 작성하면 된다.

- XML은 태그로 만든다.

- XML은 정해진 태그들이 없다.(HTML의 <b>, <font>등과 같은 정해진 규칙들은 없다.)

- XML은 대소문자를 구분한다.



1.노드

    - 노드(node)란 html의 태그의 개념입니다. <사람>은 XML에서 사람태크라고 하지 않고 사람노드라고 부릅니다.

    - <사람>이라는 시작노드로 시작했다면</사람>이라는 끝노드로 끝납니다.

    - XML의 문서의 최상위 노드는 하나만 존재합니다.

          <사람>

          </사람>

      이것은 정상입니다.

          <사람>

          </사람>

          <동물>

          </동물>

      하지만 이것은 최상위 노드가 두개(사람,동물)이기 때문에 잘못된 방식입니다.

      최상위 노드안에 자식 노드들이 추가가 되어야 합니다.

          <사람>

            <남자>

            </남자>

            <여자>

            </여자>

          </사람>

      이렇게...

   - 노드에는 공백이 없어야 합니다.

           <  사람>

      이것은 노드앞의 공백으로 인해 에러가 납니다.


2.XML의 선언부

  - XML 문서작성을 시작할때는

    <?xml version="1.0" encoding="EUC-KR" ?>이라는 XML언어 선언부 줄을 넣어줍니다.


3.노드의 내용과 속성

  - 노드의 내용이 있을때는 끝노드와 시작노드 사이에 써주면 됩니다.

       <사람>

            조재현

         </사람>

     이렇게 써주면 사람노드의 내용은 조재현으로 가지게 됩니다.

  - 노드에는 속성을 넣어 줄 수 있습니다.

          <사람 이름="조재현" 나이="26">

          </사람>

     이렇게 써주면 사람노드는 이름과 나이라는 속성을 가지게 됩니다.


4.플래시에서 XML의 다루기

  <?xml versinon="1.0" encoding="EUC-KR" ?>

  <홍익대학교>

    <디미디>

      <조재현 나이="26" 키="174"></조재현>

      <김기환 나이="27" 키="177"></김기환>

    </디미디>

    <프디>

      <김학병 나이="26" 키="180"></김학병>

      <김준영>당구장죽돌이</김준영>

    </프디>

   </홍익대학교>

 다음과 같은 hongik.xml 문서를 플래시에서는 어떻게 다룰수 있을까요.

 

 먼저 플래시에서 myXML이라는 XML객체를 만듭니다.-> var myXML:XML = new XML();

 myXML에 load메써드로 hongik.xml문서를 로드합니다. -> myXML.load("hongik.xml);

 xml문서의 공백을 없애줍니다. -> myXML.ignoreWhite = true;

 xml문서의 공백이란, <홍익대학교>이것은공백이것은공백이것은공백이것은공백이것은공백

                               </홍익대학교>이것은공백이것은공백이것은공백이것은공백이것은공백

 노드들 사이에 빈칸을 얘기다. 이부분을 없애줌으로서 에러가 나지 않게 합니다.

 xml이 로드되었을때 일어날 이벤트를 써줍니다.->myXML.onLoad = function(){스크립트기술};

 

이제 플래시에서 hongik.xml을 다룰 수 있게 되었는데 각정보에 대한 접근법을 알아봅시다.

먼저 최상위 노드인 <홍익대학교>는 myXML.firstChild; 입니다.

<홍익대학교>노드의 첫번째 노드인<디미디>는 myXML.firstChild.firstChild; 입니다. 그렇다면<프디>

는? myXML.firstChile.firstChild.nextSibling 입니다. 같은 레벨의 노드는 nextSibling으로 표현합니다.

따라서 <김기환>은 myXML.firstChild.firstChild.firstChild.nextSibling; 이 됩니다.

<김기환>의 속성인 나이의 값을 얻고 싶다면 myXML.firstChild.firstChild.firstChild.nextSibling.attributes.나이;  이렇게 attributes를 써서 알 수 있습니다. 속성은 attributes를 사용하고 내용은 nodeValue명령을 씁니다.

<김준영>의 내용인 "당구장죽돌이"라는 텍스트는myXML.firstChild.firstChild.nextSibling.firstChild.nextSibling.nodeValue; 이 되겠습니다. 이쯤되면 노드가 무한정 많으면 어떻하나? 라는 의문이 들텐데... 그럴땐 nextSibling대신 childNodes 명령을 씁니다.

이것은 배열로 저장이 되는데요 예를들어 <프디>노드는 myXML.firstChild.childNodes[1] 로 표현합니다. <디미디>는 myXML.firstChild.childNodes[0] 이 되겠지요.

 

이상으로 플래시에서 XML을 다루는 법을 보았습니다.

그렇다면 왜 xml을 굳이 쓸까요. 플래시나 플렉스에서 이런 변수들을 그냥 만들어 두면 안될까요?

 

5. XML문서를 쓰면 좋은점

 - 먼저 XML문서는 외부파일이기 때문에 필요한 정보를 추가하거나 변경 할때는 xml문서만 어디서든(pc이라든지)

   수정하면 됩니다. 플래시프로그램이나 플렉스빌더 같은 프로그램이 필요가 없지요.

   따라서 xml문서에 따라 유동적으로 다이나믹하게 구조를 만들 수 있습니다.

-  부모자식간의 명확한 객체모델이므로 정보의 구조화가 쉽습니다.

 

이상으로 생각나는대로 써보았는데요... 부족한 점은 많지만 xml의 기초를 이해하는데에는 무리가 없을 것 같습니다.

신고
Posted by 나비 나비:D
태그 xml

애스터리스크(*) 표시가 있는 항목은 W3C DOM에 대한 Microsoft의 확장 기능을 나타낸다.


async(*) : 비동기식 다운로드를 허용할 것인지를 나타내며, 읽고 쓰기가 가능하다.

attributes : 주어진 노드에 대한 속성 목록을 저장하며, 읽기 전용이다.

baseName(*) : Namespace에서 확인된 기본 이름으로, 읽기 전용이다.

childNodes : 자식 노드들의 목록을 저장하며, 읽기 전용이다.

dataType(*) : 주어진 노드에 대한 데이터 형식을 제공하며, 읽고 쓰기가 가능하다.

definition(*) : DTD 또는 스키마에서의 노드에 대한 정의를 제공하며, 읽기 전용이다.

doctype : 주어진 노드에 대한 데이터 형식을 제공하며, 읽기 전용이다.

documentElment  : 문서의 루트 요소를 가리키며, 읽고 쓰기가 가능하다.

firstChild : 현재 노드의 첫 번째 자식을 가리키며, 읽기 전용이다.

implementation : 문서에 대한 XMLDOMImplementation 객체로서, 읽기 전용이다.

lastChild : 현재 노드의 마지막 자식 노드로서, 읽기 전용이다.

namespaceURI(*) : Namespace의 URI(Uniform Resource Identifier)를 알려주며, 읽기 전용이다.

nextSibling : 동일 레벨에서 현재 노드의 다음 노드로서, 읽기 전용이다.

nodeName : 구성요소, 속성 또는 엔티티 참조에 대한 검증된 이름, 또는 다른 노드형식에서는

                  문자열을 저장하는 속성으로, 읽기 전용이다.

nodeType : XML DOM노드 형식을 가리키며, 읽기 전용이다.

nodeTypeValue(*) : 노드의 값을 저장하며, 읽고 쓰기가 가능하다.

nodeTypeString(*) : 노드 형식을 문자열로 알려 주며, 읽기 전용이다.

nodeValue : 노드에 관련된 텍스트를 제공하며, 읽고 쓰기가 가능하다.

ondataavailable(*) : ondataavailable 이벤트의 이벤트 처리기로서, 읽고 쓰기가 가능하다.

onreadystatechange(*) : readState 속성의 변경을 처리하는 이벤트 처리기로서,

                                   읽고 쓰기가 가능하다.

onreadystatechange(*) : readyState 속성의 변경을 처리하는 이벤트 처리기로서, 읽고 쓰기가능.

ontransformnode(*) : ontransformnode이벤트에 대한 이벤트 처리기로서, 읽고 쓰기가 가능하다.

ownerDocument :  지정한 노드를 포함하는 문서의 루트를 가리키며, 읽기 전용이다.

parentNode : 부모노드(부모를 가질 수 있는 노드)로서, 읽기 전용이다.

parsed(*) : 지정한 노드와 모든 자손 노드들이 파싱되었다면 참이고, 아니면 거짓이며, 읽기전용

parseError(*) : 가장 최근의 파싱 오류에 관한 정보를 갖는 XMLDOMParseError객체로서

                      읽기 전용

prefix(*)  : Namespace접두어로서,일기 전용이다.

preserveWhiteSpace(*) : 처리 과정에서 여백이 유지되어야 한다면 참, 아니면 거짓을 가지며,

                                   읽고 쓰기가 가능하다.

previousSibling : 지정한 노드와 동일 레벨에서의 이전 노드를 가리키며, 읽기 전용이다.

readyState(*) : XML 문서의 현재 상태를 나타내며, 읽기 전용이다.

resolveExternals(*) : 파싱 할때 외부 정의를 풀어놓을 것인지 지정하며, 읽고 쓰기가 가능하다.

given(*) : 노드를 직접 지정할 것인지 기본값에서 가져올 것인지를 나타내며, 읽기 전용이다.

text(*) : 노드와 하위 트리의 텍스트 내용을 저장하며, 읽고 쓰기가 가능하다.

url(*) : 가장 최근에 로드된 XML문서의 URL(Uniform Resource Locator)을 알려주며, 읽기 전용

validateOnParse(*) : 파서에서 지정한 문서를 검증하도록 할 것인지를 지정하며, 읽고 쓰기 가능

xml(*) : 노드와 모든 자손의 XML 표현을 알려주며, 읽기 전용이다.

신고
Posted by 나비 나비:D

Parser 와 DOM 기초

  • Parser
    • XML 문서를 읽고 해석 : well-formed, valid 검사
    • 응용 개발시 파서 사용 이유 : 세부적인 XML 문법으로부터 프로그램 격리
         XML 문서 --> [파서] -->인터페이스--> [응용 프로그램]
    • 파서가 메모리에 DOM 트리를 생성 : XML 문서트리와 일치
  • 표준 API
    • DOM : 객체 기반 (Object-based) Interface
      - 메모리 상주 트리 이용, 응용에서 간단히 사용, p.208
    • SAX : 이벤트 기반 (Event-driven) Interface
      - 파서가 간단, 응용프로그램은 복잡
  • DOM 개요
    • 문서내 객체(element)를 조작하기 위한 인터페이스(API)
      -
      DOM level 1 : ’98.10 W3C Recommendation
      - DOM level 2 : 2000.11 W3C Recommendation
      - DOM level 3 : 2001.8 W3C Working Draft
    • 문서 전체가 아닌 문서 일부분에 대한 접근 가능
    • 대상 문서 : XML1.0 또는 HTML4.0
  • DOM의 역할
    • 구조의 탐색 : 각 요소와 속성에 대한 탐색/질의가 가능
    • 문서 구조의 조작 : 문서 구조에서 요소, 속성의 추가/수정/삭제가 가능
    • 컨텐츠의 조작 : 문서 요소에서 text 등 컨텐츠의 탐색/추가/수정/삭제가 가능

Document 객체

  • DOMDocument 객체 생성 및 읽기
    • Msxml2.DOMDocument 객체
    • async 속성, load 메쏘드, xml 속성
    MSXML 파서 설치할 경우   MSXML 파서 설치안한 경우  
    <HTML>
    <HEAD>
    <Script language="Javascript">
    function xload0()
    {
        var xmldoc = new
            ActiveXObject("Msxml2.DOMDocument");
        xmldoc.async = false;    xmldoc.load("ex07a.xml");
        alert(xmldoc.xml);
    }
    </script>
    </HEAD>
    <BODY>
    <input type="button" value="XML 로드0"
        onClick="xload0()">
    </BODY>
    </HTML>
     
    111<HTML>
    <HEAD>
    <Script language="Javascript">
    function xload1()
    {
        xmldoc.async = false;
        xmldoc.load("ex07a.xml");

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

     var xmlroot = xmldoc.documentElement;
     alert(xmlroot.nodeName);

     
  • 임의의 노드 찾기 : getElementsByTagName("tagName")
  • 노드의 추가 메쏘드 : 뒤에 설명
    • createElement(name), createTextNode(data), createAttribute(name), createComment(data), createProcessingInstruction(target,data), createCDATASection(data), createEntityReference(name)

Node 객체

  • nodeName, nodeType, nodeValue, attributes, text 속성
    • nodeType = 1(element), 2(attribute), 3(text) , 4(CDATA), ...  : 표7.1 [p.215]
     xmldoc.load("ex07a.xml");
     var xmlroot = xmldoc.documentElement;
     alert('nodeName: '+xmlroot.nodeName+'\nnodeType: '+xmlroot.nodeType+
           '\nnodeValue: '+xmlroot.nodeValue+'\nattributes: '+xmlroot.attributes.length);
     alert(xmlroot.text);
     
  • Node의 운행(Traversal) 관련 속성
    • 관련속성
                                  -- previousSibling 
      ...  parentNode  -- **현재노드**    --  childNodes [ firstChild, … , lastChild ]
                                  -- nextSibling 
    • hasChildNodes() 메쏘드
  • NodeList 객체
    • length 속성, item(번호) 메쏘드
     xmldoc.load("ex07a.xml");
     var xmlroot = xmldoc.documentElement;
     if (xmlroot.hasChildNodes) {
         alert(xmlroot.childNodes.length);
         var curr = xmlroot.firstChild;
         alert(curr.xml);
         alert(curr.nodeName + curr.nodeType
          +curr.nodeValue+curr.attributes.length);
     }
     else alert('No Child');
     
     xmldoc.load("ex07a.xml");
     var xmlroot = xmldoc.documentElement;
     var curr = xmlroot.firstChild.nextSibling;
     alert(curr.xml);
     curr = curr.childNodes.item(2);
     alert(curr.xml);
     curr = curr.previousSibling;
     alert(curr.text);
     alert(curr.nodeName + curr.nodeType
          +curr.nodeValue+curr.attributes.length);
     
  • NamedNodeMap 객체 
    • getNamedItem("속성명"), setNamedItem(), removeNamedItem() 메쏘드
  • Attribute 객체 
    • name, value, specified 속성
     xmldoc.load("ex07a.xml");
     var attrs = xmlroot.firstChild.attributes;
     var attr0 = attrs.getNamedItem("InStock");
     alert(attr0.name + attr0.value + attr0.specified); 
  • 노드의 추가/삭제/수정 메쏘드 : 뒤에 설명
    • appendChild(child), insertBefore(child,before), removeChild(child),
      replaceChild(child,toReplace), cloneNode(deep)

임의 노드의 검색

  • 그 이름으로 검색
    • 노드리스트 = 문서.getElementsByTagName("tagName");
     xmldoc.load("ex07a.xml");
     var nlist =
       xmldoc.
    getElementsByTagName("book");
     for (i=0; i<nlist.length; i++)
            alert(nlist.item(i).xml);
     
     xmldoc.load("ex07a.xml");
     var nlist =
        xmldoc.
    getElementsByTagName("title");
     for (i=0; i<nlist.length; i++)
            alert(nlist.item(i).xml);
     
  • 패턴으로 검색
    • 노드리스트 = 노드.selectNode("query");
    • 노드 = 노드.selectSingleNode("query");
     xmldoc.load("ex07a.xml");
     var xroot = xmldoc.documentElement;
     var node1 = xroot.selectSingleNode("title");
     alert(node1.text);
     var tlist = xroot.selectNodes('//title');
     var alist = xroot.selectNodes('//author');
     for (i=0; i<alist.length; i++)  
        alert('['+i+'] '+alist.item(i).text+', '
               +tlist.item(i).text);

     
     xmldoc.load("ex07a.xml");
     var xroot = xmldoc.documentElement;
     var node1 = xroot.
        selectSingleNode
    ('//book[@InStock=0]');
     alert(node1.xml+'\n=> 재고가 없습니다.');
     var tlist = xroot.
        selectNodes
    ('//book[@InStock!=0]/title');
     for (i=0; i<tlist.length; i++)
        alert(tlist.item(i).text+'\n=>재고 있음.');

     

 

펌 -  http://mm.sookmyung.ac.kr/~sblim/lec/xml-int02/

MSDN - http://msdn.microsoft.com/library/default.asp?url=/library/en-us/xmlsdk/html/dom_reference.asp

신고
Posted by 나비 나비:D

vb6.0 과 xml 연동

2008.01.02 20:44

출처 : http://blog.naver.com/tjddms1117?Redirect=Log&logNo=20044343228


참고할 만한 사이트 url을 가르켜 드리죠 ^^

http://myhome.naver.com/xmlmanager/xml_lecture3_startmsxml.htm

일단 msxml의 도움말이 있는 웹사이트 주소입니다.

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/xmlsdk/html/b24aafc2-bf1b-4702-bf1c-b7ae3597eb0c.asp


그리고 xml 생성에 관한 dom을 이용한 프로그래밍 데모들과 설명이 있는 페이지 입니다.

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/xmlsdk/html/40ca0fcb-ed1e-4e27-92f3-fe2ce519725f.asp


msxml을 영문이나 한글 버젼은

http://www.microsoft.com/downloads/details.aspx?FamilyID=3144b72b-b4f2-46da-b4b6-c5d7485f2b42&displaylang=en


여기서 받으실 수 있습니다 밑에 chagne language 라는 combo box가 보이죠.


그 녀석을 선택하면 korean이 있습니다. 참고하세요 ^^


devpia : http://www.devpia.com/MAEUL/Contents/Detail.aspx?BoardID=65&MAEULNo=25&no=6184&ref=6184


devpia : http://www.devpia.com/MAEUL/Contents/Detail.aspx?BoardID=65&MAEULNo=25&no=7661&ref=7661

신고
Posted by 나비 나비:D

[XML Note] DOM 정리..

2007.12.17 17:31
[XML Note] DOM 정리..

1. DOM 개념 이해하기

   1-1. DOM(Document Object Model) 이란?

         1) DOM은 문서 객체 모델의 약어로 HTML과 XML 문서를 위한 API(Application Programmi

            ng Interface)로서 문서의 물리적 구조와 문서가 접근되고 다루어지는 방법을 정의한다.

         2) DOM의 목적

          (1) 다양한 환경과 애플리케이션에서 사용할 수 있는 표준적인 프로그래밍 인터페이스 제공

          (2) 프로그램 또는 스크립트를 통해 HTML이나 XML같은 웹 문서의 내용과 구조 그리고

              스타일 정보의 검색 또는 수정이 가능하도록 해주는 플랫폼 또는 언어에 중립적인 인터

              페이스이다.

         3) DOM 문서를 이용한 XML 문서 생성 과정

            (1) XML 문서를 취급하기 위하여 프로그램에서 XML 문서를 읽어들인다.

            (2) XML 문서를 XML 파서에 의해 트리 구조로 만든다.

            (3) DOM API를 이용하여 읽어들인 XML 문서에 대한 엘리먼트, 텍스트, 애트리뷰트 내용

               을 추출한 후 XML 문서를 조작(추가,삭제,갱신) 한다.

            (4) 조작되어진 XML 문서를 프로그램이 마무리하여 생성 혹은 갱신하게 된다.

   1-2. DOM Level

         1) DOM 스펙은 W3C에서 Level 단위로 만들어지고 있는데, 처음에 만든 권고안 DOM Lev

            el 1 이었고, 현재는 DOM Level 3 권고안까지 만들어진 상태이다.

         2) DOM 레벨에 관한 정보

            ⊙ DOM Level 1  : core, HTML, 그리고 XML 문서모델에 대한 내용이다. 레벨1은 문서

                                     에 대하여 항해(navigation)하거나 조작(manipulation)하는 기능을

                                     포함한다.   

            ⊙ DOM Level 2  : 스타일 쉬트를 적용한 개체모델을 지원하고 문서에 스타일 정보를

                                     조작하는 기능을 정의한다. 또한 문서에 대한 풍부한 질의 기능과

                                     이벤트 모델에 대한 정의 기능도 포함한다.  

            ⊙ DOM Level 3  : 윈도우즈 환경 하에서 사용가능한 사용자 인터페이스를 기술하는

                                     것까지 포함한다. 이를 이용하여 사용자는 문서의 DTD를 조작하는

                                     기능과 보안 레벨까지 정의할 수 있다.

   1-3. DOM 기반 Parser

         1) DOM 기반 파서는 DOM API 라는 프로그램 라이브러리를 사용한다. 이 라이브러리를

           이용하면 XML 문서의 테이터를 엑세스하고 변경하기 위해 DOM 트리에 있는 노드를

           다룰 수 있다. 여러 언어로 작성되어 있으며 보통 무료로 다운 받을 수 있다. 여러 응용

           프로그램-인터넷 익스플로러 6(msxml 3.0 기본 내장) 에서 파서를 이미 내장하고 있다.

         2) 대표적인 DOM 기반 파서 (지원버전 : DOM Level 2 SAX 2.0)

            ⊙ JAXP    : 썬 마이크로시스템의 파서(Java API for XML Parsing)

                             http://java.sun.com/xml

            ⊙ XML4J  : IBM의 파서(XML Parser for Java)

                             http://www.alphaworks.ibm.com/tech/xml4j

            ⊙ Xerces  : 아파치의 파서(Xerces Java Parser)       http://xml.apache.org/

            ⊙ msxml    : 마이크로소프트 파서    http://msdm.microsoft.com/xml           

   1-4. DOM 구조와 원리

         DOM은 XML 문서에 노드 클래스의 하위 클래스 인스턴스로 표현되는 노드들의 트리로

        표현되는데, 특정 노드의 하위클래스는 요소, 텍스트, 주석이 될 수 있다. 따라서 DOM은

        트리 구조로서 XML 문서를 다루게 되는 것이다.

         1) DOM을 이용한 XML 문서변환

            XML 문서를 응용프로그램이 파싱 요청을 하면 XML 파서에 의해 해석한 후 DOM 인터

           페이스를 이용하여 응용프로그램과 정보를 서로 전달하여 XML문서를 조작하도록 하고

           있다.

         2) XML 문서와 DOM 트리구조

            (1) XML 문서

                <?xml version="1.0" encoding="euc-kr" ?>

                   <책>

                       <제목>XML 정목</제목>

                       <발행년도>2004년 발행</발행년도>

                   </책>

            (2) DOM 노드 트리 모델링

                                           [ Document ]

                                             (NodeList)

                                           [Element "책"]    

                                             (NodeList)     

                   (NodeList)                                        (NodeList)

                [Element "제목"]                             [Element "발행년도"]

          [NamedNodeMap "분류"]                    [NamedNodeMap "분류"] 

                 [Att Node "컴퓨터"]                        [Att Node "발행"]

                   (NodeList)                                        (NodeList)

    [Text CharacterData "XML 정복"]         [Text CharacterData "2004년 발행"]

         3) XML 문서에서의 객체

            (1) XML 문서

                <?xml version="1.0" encoding="euc-kr" ?>

                   <책>

                       <제목 분류="컴퓨터">XML 정복</제목>

                       <발행년도 분류="발행">2004년 발행</발행년도>

                   </책>

            (2) XML 객체

                ⊙ Documents  : 작성된 전체 문서를 대표하는 객체이다.

                ⊙ <책> : 2개의 하위 요소 객체인 <제목>과 <발행년도>를 포함한 루트 객체이다.

                ⊙ <제목> : 다음 요소객체로 <발행년도>를 갖고 "XML 정복"라는 text객체를 소유함.

                ⊙ XML 정복 : <제목> 객체의 text객체가 된다.

                ⊙ <발행년도> : 이전 요소객체로 <제목>를 갖고 "2004년 발행"이라는 text객체를 소유

                                      한다.      

                ⊙ 2004년 발행 : <발행년도> 객체의 text객체가 된다.  

2. DOM API

    2-1. DOM 인터페이스

          1) W3C에 의해 추천된 프로그래밍 규격으로, 프로그래머가 HTMl 페이지나 XML 문서들을

             프로그램 객체로 만들거나 수정할 수 있도록 해주며, 그저 데이터 구조의 형태로 문서를

             표현하고 있는 현재의 HTML과 XML 문서들을 DOM 인터페이스를 사용하여 마치 프로

             그램 객체처럼, 자신들의 컨텐츠나, 객체 내에 감추어진 데이터를 가질 수 있게 됨으로써,

             문서를 조작할 수 있게 된다.

             ⊙ Document

             ⊙ Node

             ⊙ Nodelist

             ⊙ Element

             ⊙ NamedNodeMap

    2-2. Document 인터페이스

          Document 인터페이스는 HTML 또는 XML 문서를 나타내기 위해 사용하는데 문서 트리

         구조에서 최상위 루트에 해당한다.

          1) Document 인터페이스의 특징

              (1) 엘리먼트, 텍스트노드, 주석(comments), 처리 명령(processing instructions) 등을

                  포함하지 않고는 Document 인터페이스가 존재할 수 없다.

              (2) Document 인터페이스는 이 객체들을 만드는데 필요한 메소드 요소들도 포함하며

                  생성된 Node 객체들은 Document와 Node를 관련짓는 속성을 가진다.

              (3) Document 인터페이스

                   ⊙ Element getDocumentElement()

                   ⊙ NodeList getElementsBytagName(String tagname)

                   ⊙ Element createElement(String tagName)

                   ⊙ Text createTextNode(String data)

                   ⊙ Attr createAttribute(String name)                 

          2) Document 인터페이스의 메소드

              (1) Element getDocumentElement()

                   XML 문서에서 루트요소를 얻기 위해 메소드로 처음 XML 트리 구조를 접할 때 가장

                  먼저 루트요소를 접근한 후에 세부적으로 접근하게 된다.

              (2) NodeList getElementsBytagName(String tagname)

                   XML 문서에서 요소리스트를 얻기 위해 사용되는 메소드인데 인자 값은 tagName이

                  올 수 있는데 tagName 이후의 모든 요소리스트를 반환하게 된다.

              (3) Element createElement(String tagName)

                   지정된 형식의 ELEMENT를 생성하는 메소드이다. 이 메소드는 인자 값으로

                  tagName을 사용할 수 있는데 XML에서 설명한 엘리먼트 형식 이름이다.          

              (4) Text createTextNode(String data)

                   지정된 문자열을 가진 Text 노드를 생성하는 메소드로 인자 값으로 그 노드에 대한

                  데이터를 가지며 리턴 되는 값은 새로운 Text 객체이다.

              (5) Attr createAttribute(String name)

                   주어진 이름의 Attribute를 생성하는데 인자 값은 속성의 이름인 name이다. 또한 반환

                  값은 새로운 Attr객체로써 만약 이름이 적당하지 않은 문자를 포함하면 에러를 발생함.

          3) Node 인터페이스

              Node 인터페이스는 XML 문서에서 노드 트리의 각 요소를 읽고 쓰기 위해 사용되는데

             DOM에서 가장 기본적인 자료형으로 쓰인다.

              (1) Node 인터페이스의 특징

                   Node 인터페이스는 원소, 주석, 속성들을 상속받으며 이중에 최하위 노드인 Text

                  노드는 자식을 가질 수 없다. 만약 Text노드에 자식을 추가하면 DOMException 에러

                  가 발생하게 된다.

                  ▣ 노드에 관한 정보(NodeType)

구분

노드종류

노드명

노드값

Element

ELEMENT_NODE

요소명

null

Attribute

ATTRIBUTE_NODE

속성명

속성값

Text

TEXT_NODE

#text

노드의 내용

CDATA

CDATA_SECTION_NODE

#cdata-section

노드의 내용

Entity

ENTITY_NODE

참조된 엔티티 이름

null

Entity

Reference

ENTITY_REFERENCE_NODE

선언된 엔티티 이름

null

Processing Instruction

PROCESSING_INSTRUCTION_NODE

PI이름

PI이름을 제외한 전체 내용

comment

COMMENT_NODE

#comment

주석 내용

Document

DOCUMENT_NODE

#document

null

Document Type

DOCUMENT_TYPE_NODE

루트요소명

null

Notation

NOTATION_NODE

Notaion선언이름

null

DOCUMENT

FRAGMENT

DOCUMENT_FRAGMENT

#document-fragment

null

 

              (2) Node 인터페이스의 메소드

                  ▣ Node getFirstChild() : 현재 노드의 첫 번째 노드를 나타내고 만약 그런 노드가

                     없으면 null값을 반환하며 리턴값은 node이다.                  

                  ▣ Node getNextSibling() : 현재 노드의 바로 다음 노드를 나타낼 때 사용되는 메소

                     드로서 만약 해당 노드가 없으면 null값을 반환하고, 리턴값은 node이다.

                  ▣ short getNodeType() : 노드의 종류를 나타내는 메소드로 반환되는 값은 정수형

                     값을 가진다.

                     < 노드의 종류와 상수 값 >

멤버필드 이름

정수값

노드 종류

Node.ELEMENT_NODE

1

Element

Node.ATTRIBUTE_NODE

2

Attr

Node.TEXT_NODE

3

Text

Node.CDATA_SECTION_NODE

4

CDATASection

Node.ENTITY_REFERENCE_NODE

5

EntityReference

Node.ENTITY_NODE

6

Entity

Node.PROCESSING_INSTRUCTION_NODE

7

ProcessingInstruction

Node.COMMENT_NODE

8

Comment

Node.DOCUMENT_NODE

9

Document

Node.DOCUMENT_TYPE_NODE

10

DocumentType

Node.DOCUMENT_FRAGMENT_NODE

11

DocumentFragment

Node.NOTATION_NODE

12

Notation


    ▣ string getNodeName() : 노드의 이름을 나타내는 메소드로 해당 노드의 이름을  문자열 형으로 반환한다.    

    ▣ string getNodeValue() : 노드의 값을 나타내는 메소드로 문자열형으로 해당 노드의 값을 반환한다.

    ▣ Document getOwnerDocument() : 현재 노드와 연결된 Document 객체를 나타내는 메소드로 새로운 노드를 만드는 데 사용되는 Document 객체이기도 하다. 이 노드가 Document이면 null값을 반환한다.

    ▣ Node appendChild(Node newChild) : appendChild 메소드는 새로운 노드를  추가할 때 사용하는데, newChild 노드를 현재 노드의 자식 리스트의 끝에 삽입한다. newChild가 DocumentFragment객체이면 DocumentFragment의 전체 내용이 현재 노드의 자식 리스트 안으로 삽입된다.

    ▣ Node getParentNode() : getParentNode 메소드는 현재 노드의 부모 노드를 나타

     내는 메소드로 All nodes, except Document, DocumentFragment, 그리고 Attribute

    를 제외한 모든 노드가 부모를 가질 수 있다. 그러나 노드가 만들어졌지만 트리에 추가되지 않았거나 트리에서 제거되지 않았을 경우 이것은 null 값을 반환한다.

    ▣ Node insertBefore(Node newChild, Node refChild) : insertBefore 메소드는 원하는 특정 위치(refChild)에 새로운 노드(newChild)를 삽입할 때 사용하느데, 이때 삽입되는 위치는 refChild의 이전 위치가 된다. 만약 refChild가 null값이면 자식 리스트의 끝에 newChild를 삽입하고, newChild가 DocumentFragment 객체이면refChild 앞에 같은 순서로 모든 자식들이 삽입된다. 만약 newChild가 이미 트리안에 있으면 먼저 제거된 후에 삽입된다.

    ▣ Node replaceChild(Node newChild, Node refChild) : replaceChild 메소드는새 노드를 나타내는 newChild와 리스트에서 대체되는 노드를 나타내는 refChild를 가지며, 노드 refChild를 newChild로 대체한다. newChild가 이미 트리상에 존재하지만 먼저 제거한 후에 삽입된다.

    ▣ Node removeChild(Node oldChild) : removeChild 메소드는 인자 값으로 제거될노드 oldChild를 가지며, 자식 리스트로부터 oldChild에 해당하는 노드를 제거한다. 만약 현재 노드가 읽기 전용일 때에는 NO_MODIFICATION_ALLOWED_ERR 에러를 발생시킨다.

    ▣ NamedNodeMap getAttributes() : 노드의 속성리스트를 얻는다.

          4) NodeList 인터페이스                       

             NodeList 인터페이스는 노드들의 집합이 구현되는 방법을 정의하거나 순서가 있는 노드

             들의 집합을 표현할 때 사용한다.

              (1) NodeList 인터페이스의 특징

                   NodeList에서의 아이템은 0부터 시작되는 정수 인덱스에 의하여 접근할 수 있으며

                  NodeList를 통해 얻은 노드들의 순서는 XML에서 부모노드로부터 추가한 순서가

                  된다.

              (2) NodeList 인터페이스의 메소드

                  ▣ int getLength() : 노드의 개수를 나타내는데 자식 노드 인덱스 범위은 0에서

                     length-1까지이다.

                  ▣ Node item(int index) : 노드리스트 안에서 노드의 인덱스 값을 인자로 가지며,

                     노드리스트에서 index가 가리키는 노드를 반환한다. 또한 index가 리스트에서의

                     노드 개수보다 많거나 같을 때에는 null값을 반환한다.    

     5) Element 인터페이스                       

         Element 인터페이스는 HTML 문서 또는 XML 문서의 원소를 표현하기 위해 사용된다.

         (1) Element 인터페이스의 특징

          Attribute 객체 또는 속성값 등을 검색할 수 있는 메소드를 가지고 있다. 그리고 모든속성이 간단한 문자열 값을 가지는 HTML에서 속성값에 직접 접근할 수 있는 방법들이 사용될 수 있다.

         (2) Element 인터페이스의 메소드

          ▣ getAttribute(String name) : 검색할 속성이름인 name을 인자로 갖는다. 이때 반환되는 값은 문자열인 Attr 값, 또는 그 속성이 지정된 값을 갖는데 만약, 기본 값이없을 경우 빈 문자열이 된다.

          ▣ setAttribute(String name, String value) : 주어진 이름과 값을 갖는 속성을 추가하  는데 동일한 이름을 가진 속성이 존재할 경우 값을 변경한다.    

          ▣ removeAttribute(String name) : 주어진 이름(name)의 속성을 제거하는 메소드인  데 현재 노드가 읽기 전용일 때 NO_MODIFICATION_ALLOWD_ERR 에러를 발생시키며 반환 값은 없다.

     6) NameNodeMap 인터페이스                       

        NameNodeMap 인터페이스는 NodeList의 기능과 유사한데 이름을 이용하여 노드에 접근하고 NameNodeMap을 구현하는 객체에 포함된 속성들을 추출할 때 사용한다.

        (1) NameNodeMap 인터페이스의 특징

         접근하려는 노드들은 이름과 0부터 시작하는 정수 인덱스 값을 이용해 추출할 수 있다.

        (2) NameNodeMap 인터페이스의 메소드

          ▣ Node getNamedItem(String name) : 이름을 이용하여 지정된 노드를 검색하고,  검색할 노드의 이름을 인자로 갖는다. 반환되는 값은 지정된 이름을 가진 노드이며지정된 이름이 맵에서 어떤 노드도 일치 않으면 null 값을 반환한다.

          ▣ Node removeNamedItem(String name) : 제거될 노드의 이름을 이자로 가지며  이름에 의해 지정된 노드를 제거한다. 만약 동일한 이름의 노드가 없다면 null값을반환한다. 그리고 맵 전체에 지정한 이름의 노드가 없을 때 NOT_FOUND_ERR 에러를 발생시킨다.    

          ▣ Node item(int index) : 정수를 인자로 가지며 index에 해당하는 Attr 노드 객체를 리턴하고, index에 해당하는 특성이 존재하지 않으면 null값을 리턴한다.

출처 : Tong - 블루라임님의 XML통

신고
Posted by 나비 나비:D
태그 DOM, xml
출처 : MSDN 도움말
RAW[('ElementName')]

쿼리 결과를 사용하여 결과 집합의 각 행을 요소 태그로 <row /> 일반 식별자를 갖는 XML 요소로 변환합니다. 이 지시어를 사용하는 경우 필요에 따라 행 요소에 대한 이름을 지정할 수 있습니다. 결과 XML은 각 행에 대해 행 요소가 생성될 때 지정된 ElementName을 사용합니다. 자세한 내용은 RAW 모드 사용새 FOR XML 기능을 참조하십시오.

AUTO

단순하게 중첩된 XML 트리로 쿼리 결과를 반환합니다. 최소한 한 개의 열이 SELECT 절에 나열되는 FROM 절의 각 테이블은 XML 요소로 표시됩니다. SELECT 절에 나열되는 열은 해당 요소의 특성에 매핑됩니다. 자세한 내용은 AUTO 모드 사용새 FOR XML 기능을 참조하십시오.

EXPLICIT

결과 XML 트리 형태가 명시적으로 정의되도록 지정합니다. 쿼리는 이 모드를 사용하여 원하는 중첩에 대한 추가 정보가 명시적으로 지정되도록 특정 방식으로 작성되어야 합니다. 자세한 내용은 EXPLICIT 모드 사용새 FOR XML 기능을 참조하십시오.

PATH

요소와 특성을 혼합하고 추가 중첩을 사용하여 복잡한 속성을 나타내는 보다 간단한 방법을 제공합니다. FOR XML EXPLICIT 모드 쿼리를 사용하여 행 집합에서 이러한 종류의 XML을 구성할 수 있지만 PATH 모드는 복잡할 수도 있는 EXPLICIT 모드 쿼리 대신 훨씬 간단한 방법을 제공합니다. XML 유형 인스턴스를 반환하는 중첩 FOR XML 쿼리 및 TYPE 지시어 작성 기능과 함께 PATH 모드를 사용하면 보다 간편하게 쿼리를 작성할 수 있습니다. 이 모드는 대부분의 EXPLICIT 모드 쿼리 작성을 대신할 방법을 제공합니다. 기본적으로 PATH 모드는 결과 집합의 각 행에 대한 <row> 요소 래퍼를 생성합니다. 필요에 따라 요소 이름을 지정할 수 있습니다. 요소 이름을 지정한 경우 지정된 이름이 래퍼 요소 이름으로 사용됩니다. 빈 문자열(FOR XML PATH (''))을 제공하면 래퍼 요소가 생성되지 않습니다. 자세한 내용은 PATH 모드 사용를 참조하십시오.

XMLDATA

인라인 XDR(XML-Data Reduced) 스키마가 반환되어야 함을 지정합니다. 스키마는 인라인 스키마로 문서 앞에 놓이게 됩니다. 작업 예제의 경우 RAW 모드 사용를 참조하십시오.

XMLSCHEMA

인라인 W3C XML 스키마(XSD)를 반환합니다. 이 지시어를 지정할 때 필요에 따라 대상 네임스페이스 URI를 지정할 수 있습니다. 이렇게 하면 스키마에 지정된 네임스페이스를 반환합니다. 자세한 내용은 인라인 XSD 스키마 생성을 참조하십시오. 작업 예제의 경우 RAW 모드 사용를 참조하십시오.

ELEMENTS

ELEMENTS 옵션이 지정되면 열이 하위 요소로 반환됩니다. 그렇지 않은 경우에는 XML 특성에 매핑됩니다. 이 옵션은 RAW, AUTO 및 PATH 모드에서만 지원됩니다. 이 지시어를 사용하는 경우 필요에 따라 XSINIL 또는 ABSENT를 지정할 수 있습니다. XSINIL은 True로 설정된 xsi:nil 특성이 있는 요소가 NULL 열 값에 대해 생성되도록 지정합니다. 기본적으로 또는 ABSENT가 ELEMENTS와 함께 지정된 경우 요소가 NULL 값에 대해 생성되지 않습니다. 작업 예제의 경우 RAW 모드 사용AUTO 모드 사용를 참조하십시오.

BINARY BASE64

BINARY Base64 옵션이 지정되면 쿼리에서 반환되는 이진 데이터가 모두 base64 인코딩 형식으로 표시됩니다. RAW와 EXPLICIT 모드를 사용하여 이진 데이터를 검색하려면 이 옵션을 지정해야 합니다. AUTO 모드에서 이진 데이터는 기본적으로 참조로 반환됩니다. 작업 예제의 경우 RAW 모드 사용를 참조하십시오.

TYPE

쿼리가 결과를 xml 형식으로 반환하도록 지정합니다. 자세한 내용은 FOR XML 쿼리의 TYPE 지시어를 참조하십시오.

ROOT [('RootName')]

단일 최상위 요소가 결과 XML에 추가되도록 지정합니다. 필요에 따라 생성할 루트 요소 이름을 지정할 수 있습니다. 기본값은 "root"입니다.

신고
Posted by 나비 나비:D

BLOG main image
by 나비:D

공지사항

카테고리

분류 전체보기 (278)
Programming? (0)
----------------------------- (0)
나비의삽질 (5)
Application (177)
SQL (51)
Web (27)
etc. (14)
Omnia (0)
---------------------------.. (0)

글 보관함

달력

«   2017/12   »
          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            
Total : 894,885
Today : 43 Yesterday : 238