JavaRush /Java Blog /Random-TL /Mga Pangunahing Kaalaman sa XML para sa Java Programmer. ...

Antas

Днепр

28 February 2021
38 views
0 comments

Mga Pangunahing Kaalaman sa XML para sa Java Programmer. Bahagi 2 ng 3

Panimula

Kumusta, mahal na mga mambabasa ng aking artikulo. Ito ang pangalawang artikulo sa serye tungkol sa XML, at tatalakayin ng artikulong ito ang tungkol sa XML Namespace at XML Schema.

Kamakailan lamang, ako mismo ay walang alam tungkol dito, ngunit pinagkadalubhasaan ko ang maraming materyal at susubukan kong ipaliwanag ang dalawang mahahalagang paksang ito sa mga simpleng salita. Gusto kong sabihin kaagad na ang mga schema ay isang napaka-advance na mekanismo para sa pagpapatunay ng mga XML na dokumento at higit na gumagana kaysa sa mga DTD, kaya hindi magkakaroon ng kumpletong pag-aaral ng mga ito dito. Magsimula na tayo :)

XML Namespace

Nangangahulugan ang namespace na "name space", gayunpaman sa artikulong ito ay madalas kong papalitan ang Russian expression ng simpleng namespace, dahil ito ay mas maikli at mas madaling maunawaan. Ang XML Namespace ay isang teknolohiya na ang pangunahing layunin ay upang matiyak na ang lahat ng mga elemento ay natatangi sa isang XML file at walang kalituhan. At dahil ito ay mga kurso sa Java, ang parehong teknolohiya ay magagamit din sa mga pakete ng Java. Kung maaari tayong maglagay ng dalawang klase na may parehong pangalan sa tabi ng bawat isa at gamitin ang mga ito, paano natin matutukoy kung aling klase ang kailangan natin? Ang problemang ito ay nalutas sa pamamagitan ng mga pakete - maaari lamang nating ilagay ang mga klase sa iba't ibang mga pakete at i-import ang mga ito mula doon, tinutukoy ang eksaktong pangalan ng nais na pakete at ang landas patungo dito, o simpleng pagtukoy ng buong landas patungo sa nais na klase. Mga Pangunahing Kaalaman sa XML para sa Java Programmer. Bahagi 2 ng 3 - 1

Mga Pangunahing Kaalaman sa XML para sa Java Programmer. Bahagi 2 ng 3 - 1

Ngayon, magagawa natin ito:

public class ExampleInvocation {
    public static void main(String[] args) {
        // Creation экземпляра класса из первого пакета.
        example_package_1.Example example1 = new example_package_1.Example();

        // Creation экземпляра класса из второго пакета.
        example_package_2.Example example2 = new example_package_2.Example();

        // Creation экземпляра класса из третьего пакета.
        example_package_3.Example example3 = new example_package_3.Example();
    }
}

Sa XML Namespace lahat ay halos pareho, medyo naiiba. Ang kakanyahan ay pareho: kung ang mga elemento ay pareho (tulad ng mga klase), kung gayon kailangan lang nating gamitin ang mga ito sa iba't ibang mga namespace (tukuyin ang mga pakete), kung gayon kahit na ang mga pangalan ng mga elemento (mga klase) ay magsisimulang magkasabay, tayo pa rin. i-access ang isang partikular na elemento mula sa espasyo ( package). Halimbawa: mayroon kaming dalawang elemento sa XML - hula (oracle) at Oracle database.

<?xml version="1.0" encoding="UTF-8"?>
<root>
    <oracle>
        <connection value="jdbc:oracle:thin:@10.220.140.48:1521:test1" />
        <user value="root" />
        <password value="111" />
    </oracle>

    <oracle>
        Сегодня вы будете заняты весь день.
    </oracle>
</root>

At kapag naproseso namin ang XML file na ito, seryoso kaming malito kung sa halip na ang database ay makakatanggap kami ng hula, at kabaliktaran din. Upang malutas ang banggaan ng mga elemento, maaari nating ilaan ang bawat isa sa kanila ng sarili nitong espasyo upang makilala ang mga ito. Mayroong isang espesyal na katangian para dito – xmlns:prefix= “natatanging halaga para sa namespace”. Pagkatapos ay maaari nating i-prefix ang mga elemento upang ipahiwatig na bahagi ito ng namespace na iyon (sa pangkalahatan, kailangan nating lumikha ng path ng package - namespace, at pagkatapos ay i-prefix ang bawat elemento kung saan kabilang ang package).

<?xml version="1.0" encoding="UTF-8"?>
<root>
    <database:oracle xmlns:database="Unique ID #1">
        <connection value="jdbc:oracle:thin:@10.220.140.48:1521:test1" />
        <user value="root" />
        <password value="111" />
    </database:oracle>

    <oracle:oracle xmlns:oracle="Unique ID #2">
        Сегодня вы будете заняты весь день.
    </oracle:oracle>
</root>

Sa halimbawang ito, nagdeklara kami ng dalawang namespace: database at oracle. Ngayon ay maaari kang gumamit ng mga prefix ng namespace bago ang mga elemento. Hindi na kailangang matakot kung may hindi malinaw ngayon. Sa katunayan, ito ay napaka-simple. Sa una, nais kong isulat ang bahaging ito ng artikulo nang mas mabilis, ngunit pagkatapos ng Miyerkules ay nagpasya akong kailangan kong bigyang pansin ang paksang ito, dahil madaling malito o hindi maunawaan ang isang bagay. Ngayon, maraming pansin ang ibibigay sa katangian ng xmlns. At kaya, isa pang halimbawa:

<?xml version="1.0" encoding="UTF-8"?>
<root xmlns="https://www.standart-namespace.com/" xmlns:gun="https://www.gun-shop.com/" xmlns:fish="https://www.fish-shop.com/">
    <gun:shop>
        <gun:guns>
            <gun:gun name="Revolver" price="1250$" max_ammo="7" />
            <gun:gun name="M4A1" price="3250$" max_ammo="30" />
            <gun:gun name="9mm Pistol" price="450$" max_ammo="12" />
        </gun:guns>
    </gun:shop>

    <fish:shop>
        <fish:fishes>
            <fish:fish name="Shark" price="1000$" />
            <fish:fish name="Tuna" price="5$" />
            <fish:fish name="Capelin" price="1$" />
        </fish:fishes>
    </fish:shop>
</root>

Makikita mo ang regular na XML gamit ang spaces gun para sa mga natatanging elemento ng tindahan ng baril at mga natatanging elemento ng tindahan ng isda para sa pangingisda. Makikita mo na sa pamamagitan ng paglikha ng mga puwang, gumamit kami ng isang elemento ng tindahan para sa dalawang magkaibang bagay nang sabay-sabay - isang tindahan ng armas at isang tindahan ng isda, at alam namin kung anong uri ito ng tindahan salamat sa katotohanang idineklara namin ang mga puwang. Ang pinaka-kagiliw-giliw na bagay ay magsisimula sa mga scheme, kapag magagawa nating patunayan ang iba't ibang mga istraktura na may parehong mga elemento sa ganitong paraan. Ang xmlns ay isang katangian para sa pagdedeklara ng isang namespace; maaari itong tukuyin sa anumang elemento. Isang halimbawa ng deklarasyon ng namespace:

xmlns:shop= «https://barber-shop.com/»

Pagkatapos ng colon ay isang prefix - isa itong sanggunian sa espasyo na maaaring gamitin bago ang mga elemento upang ipahiwatig na nanggaling ang mga ito sa espasyong iyon. Ang halaga ng xmlns ay dapat na isang NATATANGING STRING. Napakahalaga nitong maunawaan: karaniwan nang gumamit ng mga link sa website o URI upang magdeklara ng namespace. Ang panuntunang ito ay karaniwan dahil ang URI o URL ng link ay natatangi, PERO dito ito nagiging lubhang nakakalito. Tandaan lamang: ang halaga ay maaaring ANUMANG string na gusto mo, ngunit para makatiyak na ito ay natatangi at karaniwan, kailangan mong gumamit ng URL o URI. Ang katotohanan na maaari mong gamitin ang anumang mga string ay ipinapakita sa halimbawa sa orakulo:

xmlns:oracle="Unique ID #2"
xmlns:database="Unique ID #1"

Kapag nagdeklara ka ng namespace, magagamit mo ito sa mismong elemento at sa lahat ng elemento sa loob nito, kaya ang mga namespace na ipinahayag sa root element ay maaaring gamitin sa lahat ng elemento. Ito ay makikita sa huling halimbawa, at narito ang isang mas tiyak na halimbawa:

<?xml version="1.0" encoding="UTF-8"?>
<root>
    <el1:element1 xmlns:el1="Element#1 Unique String">
        <el1:innerElement>

        </el1:innerElement>
    </el1:element1>


    <el2:element2 xmlns:el2="Element#2 Unique String">
        <el2:innerElement>

        </el2:innerElement>
    </el2:element2>


    <el3:element3 xmlns:el3="Element#3 Unique String">
        <el3:innerElement>
            <el1:innerInnerElement> <!-- Так нельзя, потому что пространство el1 объявлено только в первом элементе, потому может использовать только внутри первого element и его внутренних элементов. -->

            </el1:innerInnerElement>
        </el3:innerElement>
    </el3:element3>
</root>

Narito ang isang mahalagang detalye: mayroon ding karaniwang namespace sa root element. Kung idedeklara mo ang iba pang mga namespace, i-override mo ang default at hindi ito magagamit. Pagkatapos ay kailangan mong maglagay ng ilang uri ng space prefix sa harap ng root element, anuman na idineklara mo kanina. Gayunpaman, maaari rin itong dayain: maaari mong ideklara nang tahasan ang karaniwang espasyo. Sapat na ang hindi gumamit ng prefix pagkatapos ng xmlns, ngunit agad na isulat ang ilang halaga, at lahat ng iyong elemento na walang prefix ay mapabilang sa partikular na namespace na ito. Ginamit ito ng huling halimbawa:

<root xmlns="https://www.standart-namespace.com/" xmlns:gun="https://www.gun-shop.com/" xmlns:fish="https://www.fish-shop.com/">

Tahasang idineklara namin ang karaniwang espasyo upang maiwasan ang pangangailangang gumamit ng baril o isda, dahil ang elementong ugat ay hindi entidad ng alinman sa tindahan ng pangingisda o armas, kaya lohikal na hindi tama ang paggamit ng alinmang espasyo. Susunod: kung gumawa ka ng xmlns:a at xmlns:b, ngunit pareho sila ng halaga, ito ang parehong espasyo at hindi sila natatangi. Iyon ang dahilan kung bakit dapat mong palaging gumamit ng mga natatanging halaga, dahil ang paglabag sa panuntunang ito ay maaaring lumikha ng isang malaking bilang ng mga error. Halimbawa, kung mayroon kaming mga puwang na ipinahayag tulad nito:

xmlns="https://www.standart-namespace.com/" xmlns:gun="https://www.gun-shop.com/" xmlns:fish="https://www.gun-shop.com/"

Pagkatapos ang aming tindahan ng pangingisda ay magiging isang tindahan ng armas, at ang prefix ay magiging isang tindahan ng isda. Ito ang lahat ng mga pangunahing punto ng mga puwang. Gumugol ako ng maraming oras sa pagkolekta ng lahat at bawasan ang mga ito, at pagkatapos ay malinaw na ipinahayag ang mga ito, dahil ang impormasyon sa mga puwang sa Internet ay napakalaki at madalas na tubig lamang, kaya karamihan sa lahat ng narito - natutunan ko ito sa aking sarili sa pamamagitan ng pagsubok at pagkakamali. Kung mayroon ka pa ring mga katanungan, maaari mong subukang basahin ang mga materyales gamit ang mga link sa dulo ng artikulo.

XML Schema

Gusto kong sabihin kaagad na ang artikulong ito ay magiging dulo lamang ng malaking bato ng yelo, dahil ang paksa ay napakalawak. Kung nais mong makilala ang mga scheme nang mas detalyado at matutunan kung paano isulat ang mga ito sa iyong sarili ng anumang pagiging kumplikado, pagkatapos ay sa dulo ng artikulo magkakaroon ng isang link kung saan ang lahat ay magiging tungkol sa iba't ibang uri, mga paghihigpit, mga extension, at iba pa. Gusto kong magsimula sa teorya. Ang mga scheme ay may format na .xsd (xml scheme definition) at ito ay isang mas advanced at sikat na alternatibo sa mga DTD: maaari din silang lumikha ng mga elemento, ilarawan ang mga ito, at iba pa. Gayunpaman, maraming mga bonus ang naidagdag: pagsuri ng uri, suporta sa namespace at mas malawak na pag-andar. Tandaan kapag pinag-uusapan natin ang tungkol sa DTD, mayroong isang minus na hindi ito sumusuporta sa mga puwang? Ngayong napag-aralan na natin ito, ipapaliwanag ko: kung posible na mag-import ng dalawa o higit pang mga schema mula sa isang DTD, kung saan mayroong magkaparehong elemento, magkakaroon tayo ng mga banggaan (mga pagkakataon) at hindi natin magagamit ang mga ito, dahil hindi malinaw kung aling elemento ang kailangan natin. Niresolba ng XSD ang problemang ito dahil maaari kang mag-import ng mga schema sa isang partikular na espasyo at gamitin ito. Sa pangkalahatan, ang bawat XSD schema ay may target na espasyo, na nangangahulugang kung saan puwang ang schema ay dapat na nakasulat sa XML file. Kaya, sa XML file mismo, kailangan lang nating likhain ang mga puwang na ito na paunang natukoy sa mga schema at magtalaga ng mga prefix sa mga ito, at pagkatapos ay ikonekta ang mga kinakailangang schema sa bawat isa sa kanila, pagkatapos nito ay ligtas nating magagamit ang mga elemento mula sa schema, na pinapalitan ang mga prefix mula sa ang espasyo kung saan namin na-import ang mga schematics. At kaya, mayroon kaming isang halimbawa:

<?xml version="1.0" encoding="UTF-8"?>
<house>
    <address>ул. Есенина, дом №5</address>
    <owner name="Ivan">
        <telephone>+38-094-521-77-35</telephone>
    </owner>
</house>

Gusto naming patunayan ito gamit ang isang schema. Una, kailangan namin ng isang schema:

<?xml version="1.0"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="https://www.nedvigimost.com/">
    <element name="house">
        <complexType>
            <sequence>
                <element name="address" type="string" maxOccurs="unbounded" minOccurs="0" />
                <element name="owner" maxOccurs="unbounded" minOccurs="0" >
                    <complexType>
                        <sequence>
                            <element name="telephone" type="string" />
                        </sequence>
                        <attribute name="name" type="string" use="required"/>
                    </complexType>
                </element>
            </sequence>
        </complexType>
    </element>
</schema>

Tulad ng nakikita mo, ang mga schema ay mga XML file din. Isusulat mo ang kailangan mo nang direkta sa XML. Ang schema na ito ay may kakayahang patunayan ang XML file mula sa halimbawa sa itaas. Halimbawa: kung walang pangalan ang may-ari, makikita ito ng circuit. Gayundin, salamat sa elemento ng pagkakasunud-sunod, ang address ay dapat palaging mauna, at pagkatapos ay ang may-ari ng bahay. May mga ordinaryong at kumplikadong elemento. Ang mga regular na elemento ay mga elemento na nag-iimbak lamang ng ilang uri ng data. Halimbawa:

<element name="telephone" type="string" />

Ito ay kung paano namin idedeklara ang isang elemento na nag-iimbak ng isang string. Dapat ay walang ibang elemento sa loob ng elementong ito. Mayroon ding mga kumplikadong elemento. Ang mga kumplikadong elemento ay may kakayahang mag-imbak ng iba pang mga elemento at katangian sa loob ng kanilang sarili. Pagkatapos ay hindi mo kailangang tukuyin ang uri, ngunit simulan lamang ang pagsulat ng isang kumplikadong uri sa loob ng elemento.

<complexType>
    <sequence>
        <element name="address" type="string" maxOccurs="unbounded" minOccurs="0" />
        <element name="owner" maxOccurs="unbounded" minOccurs="0" >
            <complexType>
                <sequence>
                    <element name="telephone" type="string" />
                </sequence>
                <attribute name="name" type="string" use="required"/>
            </complexType>
        </element>
    </sequence>
</complexType>

Posible rin itong gawin sa ibang paraan: maaari kang lumikha ng kumplikadong uri nang hiwalay, at pagkatapos ay palitan ito ng uri. Habang isinusulat lamang ang halimbawang ito, sa ilang kadahilanan ay kinakailangan na ideklara ang puwang sa ilalim ng ilang uri ng prefix, at hindi gamitin ang karaniwang isa. Sa pangkalahatan, naging ganito:

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="https://www.nedvigimost.com/">
    <xs:element name="house" type="content" />

    <xs:complexType name="content">
        <xs:sequence>
            <xs:element name="address" type="xs:string" maxOccurs="unbounded" minOccurs="0" />
            <xs:element name="owner" maxOccurs="unbounded" minOccurs="0" >
                <xs:complexType>
                    <xs:sequence>
                        <xs:element name="telephone" type="xs:string" />
                    </xs:sequence>
                    <xs:attribute name="name" type="xs:string" use="required"/>
                </xs:complexType>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
</xs:schema>

Sa ganitong paraan, maaari tayong lumikha ng sarili nating mga uri nang hiwalay at pagkatapos ay palitan ang mga ito sa isang lugar sa katangian ng uri. Ito ay napaka-maginhawa dahil pinapayagan ka nitong gumamit ng isang uri sa iba't ibang lugar. Gusto kong makipag-usap nang higit pa tungkol sa pagkonekta ng mga circuit at tapusin dito. Mayroong dalawang paraan upang ikonekta ang isang circuit: sa isang partikular na espasyo at kumonekta lamang.

Ang unang paraan upang ikonekta ang circuit

Ipinapalagay ng unang paraan na ang circuit ay may isang tiyak na target na espasyo. Tinukoy ito gamit ang katangian ng targetNamespace sa elemento ng scheme. Pagkatapos ay sapat na upang lumikha ng PAREHONG puwang na ito sa XML file, at pagkatapos ay "i-load" ang schema doon:

<?xml version="1.0" encoding="UTF-8"?>
<nedvig:house xmlns:nedvig="https://www.nedvigimost.com/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="https://www.nedvigimost.com/ example_schema1.xsd">
    <address>ул. Есенина, дом №5</address>
    <owner name="Ivan">
        <telephone>+38-094-521-77-35</telephone>
    </owner>
</nedvig:house>

Mahalagang maunawaan ang dalawang linya:

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemeLocation="https://www.nedvigimost.com/ example_schema1.xsd"

Ang unang linya - tandaan lamang ito. Isipin ito bilang isang bagay na tumutulong sa pag-load ng mga schematic kung saan kailangan nilang pumunta. Ang pangalawang linya ay isang partikular na pag-download. Tumatanggap ang schemaLocation ng isang listahan ng mga halaga ng form na "value - value", na pinaghihiwalay ng espasyo. Ang unang argument ay ang namespace, na dapat tumugma sa target na namespace sa schema (ang halaga ng targetNamespace). Ang pangalawang argumento ay ang kamag-anak o ganap na landas sa schema. At dahil ito ay isang halaga ng LIST, maaari kang maglagay ng puwang pagkatapos ng scheme sa halimbawa, at muling ipasok ang target na espasyo at ang pangalan ng isa pang scheme, at iba pa hangga't gusto mo. Mahalaga:Upang mapatunayan ng schema ang isang bagay sa ibang pagkakataon, kailangan mong ideklara ang puwang na ito at gamitin ito nang may prefix. Tingnang mabuti ang huling halimbawa:

<?xml version="1.0" encoding="UTF-8"?>
<nedvig:house xmlns:nedvig="https://www.nedvigimost.com/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="https://www.nedvigimost.com/ example_schema1.xsd">
    <address>ул. Есенина, дом №5</address>
    <owner name="Ivan">
        <telephone>+38-094-521-77-35</telephone>
    </owner>
</nedvig:house>

Ginawa namin ang target na puwang na ito sa prefix ng nedvig at pagkatapos ay ginamit ito. Kaya, nagsimulang ma-validate ang aming mga elemento, dahil nagsimula kaming gumamit ng espasyo kung saan naka-reference ang target na schema space.

Ang pangalawang paraan upang ikonekta ang circuit

Ang pangalawang paraan upang kumonekta sa isang circuit ay nagpapahiwatig na ang circuit ay walang tiyak na target na espasyo. Pagkatapos ay maaari mo lamang itong ikonekta sa XML file at ito ay magpapatunay nito. Ginagawa ito sa halos parehong paraan, tanging hindi ka maaaring magpahayag ng mga puwang sa lahat ng XML file, ngunit ikonekta lamang ang schema.

<?xml version="1.0" encoding="UTF-8"?>
<house xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="example_schema1.xsd">
    <address>ул. Есенина, дом №5</address>
    <owner name="Ivan">
        <telephone>+38-094-521-77-35</telephone>
    </owner>
</house>

Gaya ng nakikita mo, ito ay ginagawa gamit ang noNamespaceSchemaLocation at tinutukoy ang landas patungo sa schema. Kahit na ang schema ay walang target na espasyo, ang dokumento ay mapapatunayan. At ang huling pagpindot: maaari tayong mag-import ng iba pang mga diagram sa mga diagram, at pagkatapos ay gumamit ng mga elemento mula sa isang diagram sa isa pa. Kaya, maaari tayong gumamit ng mga elemento sa ilang mga circuit na nasa iba na. Halimbawa:

Schema kung saan idineklara ang uri ng may-ari:

<?xml version="1.0" encoding="UTF-8" ?>
<schema targetNamespace="bonus" xmlns="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
        <complexType name="owner">
            <all>
                <element name="telephone" type="string" />
            </all>
            <attribute name="name" type="string" />
        </complexType>
</schema>

Ang pangalawang schema, na gumagamit ng uri ng may-ari mula sa unang schema:

<?xml version="1.0" encoding="UTF-8"?>
<schema targetNamespace="main" xmlns="http://www.w3.org/2001/XMLSchema" xmlns:bonus="bonus" elementFormDefault="qualified">
    <import namespace="bonus" schemaLocation="xsd2.xsd" />
    <element name="house">
        <complexType>
            <all>
              <element name="address" type="string" />
                <element name="owner" type="bonus:owner" />
            </all>
        </complexType>
    </element>
</schema>

Ang pangalawang scheme ay gumagamit ng sumusunod na konstruksiyon:

<import namespace="bonus" schemaLocation="xsd2.xsd" />

Gamit ito, nag-import kami ng mga uri at elemento mula sa isang schema patungo sa isa pa sa bonus space. Kaya, mayroon kaming access sa bonus:uri ng may-ari. At sa susunod na linya ginamit namin ito:

<element name="owner" type="bonus:owner" />

Gayundin ng kaunting pansin sa sumusunod na linya:

elementFormDefault="qualified"

Idineklara ang attribute na ito sa schema at nangangahulugan na sa mga XML file, dapat ideklara ang bawat elemento na may tahasang prefix bago ito. Kung wala ito, kailangan lang nating magdeklara ng panlabas na elemento na may prefix, at kailangan din nating magtakda ng mga prefix sa lahat ng elemento sa loob, na malinaw na nagpapahiwatig na ginagamit natin ang eksaktong mga elemento ng scheme na ito. At narito, sa katunayan, ay isang halimbawa ng isang XML file na napatunayan ng isang schema na nag-import ng isa pang schema:

<?xml version="1.0" encoding="UTF-8"?>
<nedvig:house xmlns:nedvig="main" xmlns:bonus="bonus" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="main xsd.xsd">
    <nedvig:address>ул. Есенина, дом №5</nedvig:address>
    <nedvig:owner name="Ivan">
        <bonus:telephone>+38-094-521-77-35</bonus:telephone>
    </nedvig:owner>
</nedvig:house>

Sa linya:

<bonus:telephone>+38-094-521-77-35</bonus:telephone>

Kailangan nating tahasan na ideklara ang bonus namespace, na tumuturo sa target na espasyo ng unang schema, dahil ang elementFormDefault ay kwalipikado (suriin), kaya dapat tahasang ipahiwatig ng lahat ng elemento ang kanilang espasyo.

Katapusan ng artikulo

Ang susunod na artikulo ang magiging huli sa serye at tungkol na sa pagproseso ng mga XML file gamit ang Java. Matututo tayong kumuha ng impormasyon sa iba't ibang paraan at iba pa. Umaasa ako na ang artikulong ito ay naging kapaki-pakinabang at, kahit na may mga error sa isang lugar, ito ay magtuturo sa iyo ng isang bagay na kapaki-pakinabang at bago, o maaaring bigyan ka lamang ng pagkakataon na mas maunawaan ang mga XML file. Para sa mga gustong tuklasin ito nang mas detalyado, nagpasya akong magsama ng isang maliit na hanay ng mga link:

Mga Simpleng Elemento ng XSD - simula sa artikulong ito, simulan ang pagbabasa at sumulong, ang lahat ng impormasyon sa mga scheme ay nakolekta doon at ipinaliwanag nang higit pa o hindi gaanong malinaw, sa Ingles lamang. Maaari kang gumamit ng tagasalin.
video sa mga namespace, palaging kapaki-pakinabang na makinig sa isa pang punto ng view sa isang bagay kung hindi malinaw ang una.
Ang Namespace XML ay isang magandang halimbawa ng paggamit ng mga namespace at medyo komprehensibo.
Mga Pangunahing Kaalaman sa XML - Mga Namespace - Isa pang maikling artikulo sa mga namespace.
Ang Mga Pangunahing Kaalaman sa Paggamit ng XML Schema upang Tukuyin ang Mga Elemento ay isa ring lubhang kapaki-pakinabang na sanggunian sa mga schema, ngunit kailangan mo itong basahin nang dahan-dahan at maingat, pag-aralan ang materyal.

Iyon lang ang sigurado, umaasa ako na kung nais mong matuto ng mas malalim mula dito, ang mga link ay makakatulong sa iyo. Sinuri ko ang lahat ng mga mapagkukunang ito sa aking sarili, pinag-aaralan ang lahat ng materyal, at, sa pangkalahatan, ito ang pinakakapaki-pakinabang sa lahat ng mga mapagkukunang tiningnan ko, dahil ang bawat isa sa kanila ay nagpabuti ng pag-unawa sa kung ano ang nabasa ko na sa ibang lugar, o hayaan mo akong matuto ng bago, ngunit marami ang ginawa habang nagsasanay. Kaya, para sa mga talagang gustong maunawaan ang lahat ng ito nang maayos, ang payo ko ay: pag-aralan ang mga namespace, pagkatapos ay kung paano madaling ikonekta ang mga schema sa mga XML file, at pagkatapos ay kung paano isulat ang istraktura ng dokumento sa mga schemas. At higit sa lahat, magsanay. Salamat sa lahat para sa iyong pansin at good luck sa programming :) Nakaraang artikulo: [Kumpetisyon] Mga Pangunahing Kaalaman sa XML para sa isang Java Programmer - Bahagi 1 ng 3 Susunod na artikulo: [Kumpetisyon] Mga Pangunahing Kaalaman sa XML para sa isang Java Programmer - Bahagi 3.1 ng 3 - SAX

Mga komento

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION