JavaRush /בלוג Java /Random-HE /יסודות XML עבור מתכנת Java. חלק 2 מתוך 3
Ярослав
רָמָה
Днепр

יסודות XML עבור מתכנת Java. חלק 2 מתוך 3

פורסם בקבוצה

מבוא

שלום, קוראים יקרים של המאמר שלי. זהו המאמר השני בסדרה על XML, ומאמר זה ידבר על XML Namespace ו-XML Schema.
יסודות XML
רק לאחרונה, אני עצמי לא ידעתי על זה דבר, אבל שלטתי בחומר רב ואנסה להסביר את שני הנושאים החשובים הללו במילים פשוטות. אני רוצה לומר מיד שסכמות הן מנגנון מתקדם מאוד לאימות מסמכי XML והן הרבה יותר פונקציונליות מ-DTD, כך שלא יהיה כאן מחקר שלם שלהן. בואו נתחיל :)

מרחב שמות XML

מרחב שמות פירושו "מרחב שמות", אולם במאמר זה לרוב אחליף את הביטוי הרוסי במרחב שמות פשוט, מכיוון שהוא קצר וקל יותר להבנה. XML Namespace היא טכנולוגיה שמטרתה העיקרית היא לוודא שכל האלמנטים ייחודיים בקובץ XML ואין בלבול. ומכיוון שמדובר בקורסי Java, אותה טכנולוגיה זמינה גם בחבילות Java. אם היינו יכולים לשים שתי מחלקות באותו שם אחת ליד השנייה ולהשתמש בהן, איך היינו קובעים לאיזה מחלקה אנחנו צריכים? בעיה זו נפתרת על ידי חבילות - אנחנו יכולים פשוט למקם מחלקות בחבילות שונות ולייבא אותן משם, לציין את השם המדויק של החבילה הרצויה והנתיב אליה, או פשוט לציין את הנתיב המלא למחלקה הרצויה. יסודות XML עבור מתכנת Java.  חלק 2 מתוך 3 - 1עכשיו, אנחנו יכולים לעשות את זה:
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();
    }
}
ב-XML Namespace הכל די אותו דבר, רק קצת שונה. המהות זהה: אם האלמנטים זהים (כמו מחלקות), אז אנחנו רק צריכים להשתמש בהם במרחבי שמות שונים (לפרט חבילות), אז גם אם שמות האלמנטים (מחלקות) יתחילו להתאים, עדיין גישה לאלמנט מסוים מהמרחב (חבילה). לדוגמא: יש לנו שני אלמנטים ב-XML - חיזוי (אורקל) ומסד נתונים של Oracle.
<?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>
וכאשר נעבד את קובץ ה-XML הזה, נתבלבל ברצינות אם במקום בסיס הנתונים נקבל חיזוי, וגם בחזרה. על מנת לפתור את ההתנגשות של אלמנטים, נוכל להקצות לכל אחד מהם מרחב משלו כדי להבדיל ביניהם. יש לזה תכונה מיוחדת - xmlns:prefix= "ערך ייחודי למרחב השמות". לאחר מכן נוכל להקדים את האלמנטים כדי לציין שהוא חלק מאותו מרחב שמות (בעיקרון, עלינו ליצור נתיב חבילה - מרחב שמות, ולאחר מכן להוסיף קידומת לכל רכיב לאיזו חבילה הוא שייך).
<?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>
בדוגמה זו, הכרזנו על שני מרחבי שמות: מסד נתונים ואורקל. כעת אתה יכול להשתמש בקידומות מרחב שמות לפני אלמנטים. אין צורך לפחד אם משהו לא ברור עכשיו. למעשה, זה מאוד פשוט. בהתחלה רציתי לכתוב את החלק הזה של המאמר מהר יותר, אבל אחרי יום רביעי החלטתי שאני צריך לשים לב יותר לנושא הזה, מכיוון שקל להתבלבל או לא להבין משהו. כעת תוקדש תשומת לב רבה לתכונה xmlns. וכך, דוגמה נוספת:
<?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>
אתה יכול לראות את ה-XML הרגיל באמצעות האלמנטים הייחודיים של אקדח עבור חנות רובים ואלמנטים ייחודיים של חנות Fish for Fishing. אפשר לראות שביצירת החללים השתמשנו באלמנט חנות אחד לשני דברים שונים בו-זמנית – חנות נשק וחנות דגים, ואנחנו יודעים בדיוק באיזו חנות מדובר בזכות העובדה שהכרזנו על החללים. הדבר המעניין ביותר יתחיל בסכמות, כאשר נוכל לאמת מבנים שונים עם אותם אלמנטים בדרך זו. xmlns היא תכונה להכרזה על מרחב שמות; ניתן לציין אותה בכל אלמנט. דוגמה להצהרת מרחב שמות:
xmlns:shop= «https://barber-shop.com/»
אחרי שהנקודתיים היא קידומת - זוהי הפניה לרווח שניתן להשתמש בה לפני אלמנטים כדי לציין שהם מגיעים מאותו מרחב. ערך xmlns חייב להיות UNIQUE STRING. חשוב מאוד להבין זאת: מקובל מאוד להשתמש בקישורי אתרים או ב-URI כדי להכריז על מרחב שמות. כלל זה הוא סטנדרטי מכיוון שה-URI או ה-URL של הקישור הם ייחודיים, אבל כאן זה נעשה מאוד מבלבל. רק זכור: הערך יכול להיות כל מחרוזת שתרצה, אבל כדי להיות בטוח שהוא ייחודי וסטנדרטי, עליך להשתמש ב-URL או URI. העובדה שאתה יכול להשתמש בכל מחרוזות מוצגת בדוגמה באורקל:
xmlns:oracle="Unique ID #2"
xmlns:database="Unique ID #1"
כאשר אתה מצהיר על מרחב שמות, אתה יכול להשתמש בו על האלמנט עצמו ועל כל האלמנטים בתוכו, כך שניתן להשתמש במרחבי שמות המוצהרים על אלמנט השורש על כל האלמנטים. ניתן לראות זאת בדוגמה האחרונה, והנה דוגמה ספציפית יותר:
<?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>
הנה פרט חשוב: יש גם מרחב שמות סטנדרטי באלמנט השורש. אם אתה מצהיר על מרחבי שמות אחרים, אתה עוקף את ברירת המחדל ולא יכול להשתמש בו. אז אתה צריך לשים איזושהי קידומת רווח לפני אלמנט השורש, כל מה שהצהרת קודם לכן. עם זאת, אפשר להערים על זה: אתה יכול להכריז במפורש על המרחב הסטנדרטי. זה מספיק פשוט לא להשתמש בקידומת אחרי xmlns, אלא לרשום מיד ערך כלשהו, ​​וכל האלמנטים שלך ללא קידומת יהיו שייכים למרחב השמות המסוים הזה. הדוגמה האחרונה השתמשה בזה:
<root xmlns="https://www.standart-namespace.com/" xmlns:gun="https://www.gun-shop.com/" xmlns:fish="https://www.fish-shop.com/">
הכרזנו על המרחב הסטנדרטי במפורש כדי להימנע מהצורך להשתמש ברובה או בדגים, מכיוון שאלמנט השורש אינו ישות של חנות דייג או נשק, כך ששימוש בכל אחד מהרווחים יהיה שגוי מבחינה לוגית. הבא: אם יצרת את xmlns:a ו-xmlns:b, אבל יש להם אותו ערך, אז זה אותו רווח והם לא ייחודיים. זו הסיבה שאתה תמיד צריך להשתמש בערכים ייחודיים, מכיוון שהפרת כלל זה עלולה ליצור מספר רב של שגיאות. לדוגמה, אם היו לנו רווחים שהוכרזו כך:
xmlns="https://www.standart-namespace.com/" xmlns:gun="https://www.gun-shop.com/" xmlns:fish="https://www.gun-shop.com/"
ואז חנות הדיג שלנו תהפוך לחנות נשק, והקידומת עדיין תהיה חנות דגים. אלו כל הנקודות העיקריות של החללים. ביליתי די הרבה זמן באיסוף כולם וצמצום, ואז ביטוי אותם בצורה ברורה, מכיוון שהמידע על מרחבים באינטרנט הוא עצום מאוד ולרוב רק מים, אז רוב כל מה שיש כאן - למדתי את זה בעצמי באמצעות ניסיון ושגיאה. אם עדיין יש לך שאלות, תוכל לנסות לקרוא את החומרים באמצעות הקישורים בסוף המאמר.

סכימת XML

אני רוצה לומר מיד שהמאמר הזה יהיה רק ​​קצה הקרחון, מכיוון שהנושא רחב מאוד. אם אתה רוצה להכיר תוכניות בפירוט רב יותר וללמוד איך לכתוב אותן בעצמך בכל מורכבות, אז בסוף המאמר יהיה קישור שבו הכל יהיה על סוגים שונים, הגבלות, הרחבות וכו'. אני רוצה להתחיל בתיאוריה. לסכימות יש את הפורמט .xsd (הגדרת סכמת xml) והן אלטרנטיבה מתקדמת ופופולרית יותר ל-DTDs: הן יכולות גם ליצור אלמנטים, לתאר אותם וכו'. עם זאת, נוספו בונוסים רבים: בדיקת סוגים, תמיכה במרחב שמות ופונקציונליות רחבה יותר. זוכרים שכשדיברנו על DTD, היה מינוס שהוא לא תומך ברווחים? כעת, לאחר שלמדנו זאת, אסביר: אם ניתן היה לייבא שתי סכמות או יותר מ-DTD, שבו היו אלמנטים זהים, היו לנו התנגשויות (צירופי מקרים) ולא היינו יכולים להשתמש בהם כלל, כי לא ברור איזה אלמנט אנחנו צריכים. XSD פותר את הבעיה הזו מכיוון שאתה יכול לייבא סכמות לחלל ספציפי אחד ולהשתמש בו. בעיקרו של דבר, לכל סכימת XSD יש מרחב יעד, כלומר באיזה מרחב הסכימה צריכה להיכתב בקובץ ה-XML. לפיכך, בקובץ ה-XML עצמו, אנחנו רק צריכים ליצור את הרווחים המוגדרים מראש בסכמות ולהקצות להן קידומות, ולאחר מכן לחבר את הסכמות הדרושות לכל אחת מהן, ולאחר מכן נוכל להשתמש בבטחה באלמנטים מהסכימה, תוך החלפת קידומות מ- החלל שבו ייבאנו את הסכמות. אז יש לנו דוגמה:
<?xml version="1.0" encoding="UTF-8"?>
<house>
    <address>ул. Есенина, дом №5</address>
    <owner name="Ivan">
        <telephone>+38-094-521-77-35</telephone>
    </owner>
</house>
אנחנו רוצים לאמת את זה עם סכמה. ראשית, אנחנו צריכים סכמה:
<?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>
כפי שאתה יכול לראות, סכימות הן גם קבצי XML. אתה כותב את מה שאתה צריך ישירות ב-XML. סכימה זו מסוגלת לאמת את קובץ ה-XML מהדוגמה שלמעלה. לדוגמה: אם לבעלים אין שם, המעגל יראה זאת. כמו כן, הודות לאלמנט הרצף, הכתובת צריכה תמיד לבוא קודם, ולאחר מכן הבעלים של הבית. יש אלמנטים רגילים ומורכבים. אלמנטים רגילים הם אלמנטים המאחסנים רק סוג מסוים של נתונים. דוגמא:
<element name="telephone" type="string" />
כך אנו מכריזים על אלמנט שמאחסן מחרוזת. לא אמורים להיות אלמנטים אחרים בתוך האלמנט הזה. יש גם אלמנטים מורכבים. אלמנטים מורכבים מסוגלים לאחסן בתוכם אלמנטים ותכונות אחרות. אז אתה לא צריך לציין את הסוג, אלא פשוט להתחיל לכתוב סוג מורכב בתוך האלמנט.
<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>
אפשר היה גם לעשות את זה אחרת: אתה יכול ליצור סוג מורכב בנפרד, ואז להחליף אותו בטיפוס. רק בעת כתיבת הדוגמה הזו, מסיבה כלשהי היה צורך להכריז על הרווח תחת איזושהי קידומת, ולא להשתמש בסטנדרטי. באופן כללי, זה יצא כך:
<?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>
בדרך זו, נוכל ליצור סוגים משלנו בנפרד ואז להחליף אותם איפשהו בתכונת type. זה מאוד נוח מכיוון שהוא מאפשר לך להשתמש בסוג אחד במקומות שונים. אני רוצה לדבר יותר על חיבור מעגלים ולסיים כאן. ישנן שתי דרכים לחבר מעגל: לחלל ספציפי ופשוט להתחבר.

הדרך הראשונה לחבר את המעגל

השיטה הראשונה מניחה שלמעגל יש מרחב מטרה ספציפי. הוא מצוין באמצעות התכונה targetNamespace ברכיב הסכמה. אז זה מספיק כדי ליצור את אותו מקום בקובץ ה-XML, ואז "לטעון" את הסכימה שם:
<?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>
חשוב להבין שני קווים:
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemeLocation="https://www.nedvigimost.com/ example_schema1.xsd"
השורה הראשונה - רק תזכור אותה. תחשוב על זה כעל אובייקט שעוזר לטעון סכמות לאן שהם צריכים להגיע. השורה השנייה היא הורדה ספציפית. schemaLocation מקבל רשימת ערכים בצורה "ערך - ערך", מופרדים ברווח. הארגומנט הראשון הוא מרחב השמות, שעליו להתאים למרחב השמות של היעד בסכימה (ערך מרחב ה-targetNamespace). הארגומנט השני הוא נתיב יחסי או מוחלט לסכימה. ומכיוון שזה ערך LIST, אתה יכול לשים רווח אחרי הסכמה בדוגמה, ושוב להזין את רווח המטרה ואת השם של סכמה אחרת, וכך הלאה כמה שאתה רוצה. חָשׁוּב:כדי שהסכימה תאמת משהו מאוחר יותר, עליך להכריז על המרחב הזה ולהשתמש בו עם קידומת. הסתכלו היטב על הדוגמה האחרונה:
<?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>
יצרנו את מרחב היעד הזה בקידומת nedvig ולאחר מכן השתמשנו בו. לפיכך, האלמנטים שלנו החלו להיות מאומתים, מאז שהתחלנו להשתמש במרחב שבו מתייחסים למרחב סכימת היעד.

הדרך השנייה לחבר את המעגל

הדרך השנייה לחבר מעגל מרמזת שלמעגל אין מרחב יעד ספציפי. אז אתה יכול פשוט לחבר אותו לקובץ ה-XML והוא יאמת אותו. זה נעשה כמעט באותו אופן, רק שלא ניתן להכריז על רווחים כלל בקובץ ה-XML, אלא פשוט לחבר את הסכימה.
<?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>
כפי שאתה יכול לראות, זה נעשה באמצעות noNamespaceSchemaLocation וציון הנתיב לסכימה. גם אם לסכימה אין שטח יעד, המסמך יאושר. והמגע האחרון: נוכל לייבא דיאגרמות אחרות לתוך דיאגרמות, ולאחר מכן להשתמש באלמנטים מתרשים אחד באחר. לפיכך, אנו יכולים להשתמש באלמנטים במעגלים מסוימים שכבר נמצאים באחרים. דוגמא:

סכימה שבה מוצהר סוג הבעלים:

<?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>

הסכימה השנייה, המשתמשת בסוג הבעלים מהסכמה הראשונה:

<?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>
התוכנית השנייה משתמשת במבנה הבא:
<import namespace="bonus" schemaLocation="xsd2.xsd" />
באמצעותו, ייבאנו סוגים ואלמנטים מסכמה אחת לאחרת למרחב הבונוס. לפיכך, יש לנו גישה לסוג הבונוס:בעלים. ובשורה הבאה השתמשנו בו:
<element name="owner" type="bonus:owner" />
גם קצת תשומת לב לשורה הבאה:
elementFormDefault="qualified"
תכונה זו מוצהרת בסכימה ומשמעותה שבקובצי XML יש להצהיר על כל רכיב עם קידומת מפורשת לפניו. אם זה לא שם, אז אנחנו רק צריכים להכריז על אלמנט חיצוני עם קידומת, ועלינו גם להגדיר קידומות בכל האלמנטים בפנים, מה שמציין בבירור שאנחנו משתמשים בדיוק באלמנטים של סכמה זו. והנה, למעשה, היא דוגמה לקובץ XML מאומת על ידי סכימה שייבאה סכמה אחרת:
<?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>
בשורה:
<bonus:telephone>+38-094-521-77-35</bonus:telephone>
עלינו להכריז במפורש על מרחב השמות של הבונוס, המצביע על מרחב היעד של הסכימה הראשונה, מכיוון ש-elementFormDefault הוא qualified (סמן), כך שכל האלמנטים חייבים לציין במפורש את המרחב שלהם.

סוף המאמר

המאמר הבא יהיה האחרון בסדרה וכבר יעסוק בעיבוד קבצי XML באמצעות Java. נלמד להשיג מידע בדרכים שונות וכן הלאה. אני מקווה שהמאמר הזה היה שימושי, וגם אם יש כאן שגיאות איפשהו, הוא ילמד אותך משהו שימושי וחדש, או אולי רק ייתן לך את ההזדמנות להבין טוב יותר קבצי XML. למי שרוצה לחקור את זה ביתר פירוט, החלטתי להרכיב סט קטן של קישורים:
  • XSD Simple Elements - החל ממאמר זה, התחל לקרוא והתקדם, כל המידע על הסכמות נאסף שם ומוסבר פחות או יותר ברור, רק באנגלית. אתה יכול להשתמש במתרגם.

  • סרטון על מרחבי שמות, תמיד שימושי להקשיב לנקודת מבט אחרת על משהו אם הראשונה לא ברורה.

  • XML של מרחב שמות הוא דוגמה טובה לשימוש במרחבי שמות והוא די מקיף.

  • XML Basics - מרחבי שמות - עוד מאמר קצר על מרחבי שמות.

  • היסודות של שימוש בסכמת XML להגדרת אלמנטים הם גם התייחסות שימושית ביותר על סכמות, אך עליך לקרוא אותה לאט ובזהירות, להתעמק בחומר.

זה הכל בטוח, אני מקווה שאם אתה רוצה ללמוד משהו יותר עמוק מזה, הקישורים יעזרו לך. עברתי בעצמי על כל המקורות הללו, למדתי את כל החומר, ובסך הכל, אלו היו המקורות השימושיים ביותר מכל המקורות שבהם הסתכלתי, מכיוון שכל אחד מהם שיפר את ההבנה של מה שכבר קראתי במקום אחר, או תן לי ללמוד משהו חדש, אבל הרבה נעשה רק במהלך האימון. אז, למי שבאמת רוצה להבין את כל זה די טוב, העצה שלי היא: ללמוד מרחבי שמות, ואז איך לחבר בקלות סכמות לקובצי XML, ואז איך לכתוב את מבנה המסמך בסכמות. והכי חשוב, להתאמן. תודה לכולכם על תשומת הלב ובהצלחה בתכנות :) מאמר קודם: [תחרות] יסודות XML למתכנת Java - חלק 1 מתוך 3 המאמר הבא: [תחרות] יסודות XML עבור מתכנת Java - חלק 3.1 מתוך 3 - SAX
הערות
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION