XSD - Kurzanleitung

Die XML-Schemadefinition, allgemein bekannt als XSD, ist eine Möglichkeit, die XML-Sprache genau zu beschreiben. XSD überprüft die Gültigkeit der Struktur und des Vokabulars eines XML-Dokuments anhand der grammatikalischen Regeln der entsprechenden XML-Sprache.

Ein XML-Dokument kann definiert werden als -

Well-formed- Wenn das XML-Dokument allen allgemeinen XML-Regeln entspricht, z. B. Tags müssen ordnungsgemäß verschachtelt sein, öffnende und schließende Tags müssen ausgeglichen sein und leere Tags müssen mit '/>' enden, wird es als wohlgeformt bezeichnet .

OR
Valid- Ein XML-Dokument gilt als gültig, wenn es nicht nur wohlgeformt ist , sondern auch der verfügbaren XSD entspricht, die unter anderem angibt, welche Tags verwendet werden, welche Attribute diese Tags enthalten können und welche Tags in anderen Tags vorkommen können .

Das folgende Diagramm zeigt, wie XSD zum Strukturieren von XML-Dokumenten verwendet wird.

Hier ist ein einfacher XSD-Code. Schau es dir an.

<?xml version = "1.0"?>

<xs:schema xmlns:xs = "http://www.w3.org/2001/XMLSchema">
   targetNamespace = "http://www.tutorialspoint.com" 
   xmlns = "http://www.tutorialspoint.com"
   elementFormDefault = "qualified">

   <xs:element name = 'class'>
      <xs:complexType>
         <xs:sequence>
            <xs:element name = 'student' type = 'StudentType' minOccurs = '0' 
               maxOccurs = 'unbounded' />
         </xs:sequence>
      </xs:complexType>
   </xs:element>

   <xs:complexType name = "StudentType">
      <xs:sequence>
         <xs:element name = "firstname" type = "xs:string"/>
         <xs:element name = "lastname" type = "xs:string"/>
         <xs:element name = "nickname" type = "xs:string"/>
         <xs:element name = "marks" type = "xs:positiveInteger"/>
      </xs:sequence>
      <xs:attribute name = 'rollno' type = 'xs:positiveInteger'/>
   </xs:complexType>
   
</xs:schema>

Eigenschaften

Hier ist eine Liste einiger der beliebtesten Funktionen von XSD -

XSDs können für zukünftige Ergänzungen erweiterbar sein.
XSD ist umfangreicher und leistungsfähiger als DTD.
XSD ist in XML geschrieben.
XSD unterstützt Datentypen.
XSD unterstützt Namespaces.
XSD ist eine W3C-Empfehlung.

Eine XML-XSD wird in einem separaten Dokument gespeichert. Anschließend kann das Dokument mit einem XML-Dokument verknüpft werden, um es zu verwenden.

Syntax

Die grundlegende Syntax einer XSD lautet wie folgt:

<?xml version = "1.0"?>

<xs:schema xmlns:xs = "http://www.w3.org/2001/XMLSchema">
   targetNamespace = "http://www.tutorialspoint.com"
   xmlns = "http://www.tutorialspoint.com" elementFormDefault = "qualified">
   
   <xs:element name = 'class'>
      <xs:complexType>
         <xs:sequence>
            <xs:element name = 'student' type = 'StudentType' minOccurs = '0' 
               maxOccurs = 'unbounded' />
         </xs:sequence>
      </xs:complexType>
   </xs:element>

   <xs:complexType name = "StudentType">
      <xs:sequence>
         <xs:element name = "firstname" type = "xs:string"/>
         <xs:element name = "lastname" type = "xs:string"/>
         <xs:element name = "nickname" type = "xs:string"/>
         <xs:element name = "marks" type = "xs:positiveInteger"/>
      </xs:sequence>
      <xs:attribute name = 'rollno' type = 'xs:positiveInteger'/>
   </xs:complexType>
   
</xs:schema>

<Schema> -Element

Schema ist das Stammelement von XSD und wird immer benötigt.

<xs:schema xmlns:xs = "http://www.w3.org/2001/XMLSchema">

Das obige Fragment gibt an, dass Elemente und Datentypen, die im Schema verwendet werden, in definiert sind http://www.w3.org/2001/XMLSchema Namespace und diesen Elementen / Datentypen sollte ein Präfix vorangestellt werden xs. Es ist immer erforderlich.

targetNamespace = "http://www.tutorialspoint.com"

Das obige Fragment gibt an, dass die in diesem Schema verwendeten Elemente in definiert sind http://www.tutorialspoint.comNamespace. Es ist optional.

xmlns = "http://www.tutorialspoint.com"

Das obige Fragment gibt den Standard-Namespace an http://www.tutorialspoint.com.

elementFormDefault = "qualified"

Das obige Fragment gibt an, dass alle in diesem Schema deklarierten Elemente Namespace-qualifiziert sein müssen, bevor sie in einem XML-Dokument verwendet werden können. Es ist optional.

Referenzschema

Schauen Sie sich das folgende Referenzierungsschema an -

<?xml version = "1.0"?>

<class xmlns = "http://www.tutorialspoint.com"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://www.tutorialspoint.com student.xsd">  
   
   <student rollno = "393">    
      <firstname>Dinkar</firstname>
      <lastname>Kad</lastname>
      <nickname>Dinkar</nickname>
      <marks>85</marks>
   </student>
   
   <student rollno = "493">	 
      <firstname>Vaneet</firstname>
      <lastname>Gupta</lastname>
      <nickname>Vinni</nickname>
      <marks>95</marks>
   </student>
   
   <student rollno = "593">    
      <firstname>Jasvir</firstname>
      <lastname>Singh</lastname>
      <nickname>Jazz</nickname>
      <marks>90</marks>
   </student>
</class>

xmlns = "http://www.tutorialspoint.com"

Das obige Fragment gibt die Standard-Namespace-Deklaration an. Dieser Namespace wird vom Schema-Validator verwendet, um zu überprüfen, ob alle Elemente Teil dieses Namespace sind. Es ist optional.

xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.tutorialspoint.com student.xsd">

Verwenden Sie nach dem Definieren der XMLSchema-Instanz xsi schemaLocationAttribut. Dieses Attribut hat zwei Werte, den Namespace und den Speicherort des XML-Schemas, die durch ein Leerzeichen getrennt verwendet werden sollen. Es ist optional.

Wir werden den Java-basierten XSD-Validator zur Validierung verwenden students.xml gegen die students.xsd.

Studenten.xml

<?xml version = "1.0"?>

<class>  
   <student rollno = "393">
      <firstname>Dinkar</firstname>    
      <lastname>Kad</lastname>
      <nickname>Dinkar</nickname>
      <marks>85</marks>	 
   </student>
   
   <student rollno = "493">	 
      <firstname>Vaneet</firstname>
      <lastname>Gupta</lastname>
      <nickname>Vinni</nickname>
      <marks>95</marks>
   </student>
   
   <student rollno = "593">    
      <firstname>Jasvir</firstname>
      <lastname>Singh</lastname>
      <nickname>Jazz</nickname>
      <marks>90</marks>
   </student>
</class>

Studenten.xsd

<?xml version = "1.0"?>

<xs:schema xmlns:xs = "http://www.w3.org/2001/XMLSchema">
   <xs:element name = 'class'>
      <xs:complexType>
         <xs:sequence>
             <xs:element name = 'student' type = 'StudentType' minOccurs = '0' 
                maxOccurs = 'unbounded' />
         </xs:sequence>
      </xs:complexType>
   </xs:element>

   <xs:complexType name = "StudentType">
      <xs:sequence>
         <xs:element name = "firstname" type = "xs:string"/>
         <xs:element name = "lastname" type = "xs:string"/>
         <xs:element name = "nickname" type = "xs:string"/>
         <xs:element name = "marks" type = "xs:positiveInteger"/>
      </xs:sequence>
      <xs:attribute name = 'rollno' type = 'xs:positiveInteger'/>
   </xs:complexType>			 
</xs:schema>

XSDValidator.java

import java.io.File;
import java.io.IOException;

import javax.xml.XMLConstants;
import javax.xml.transform.stream.StreamSource;

import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;

import org.xml.sax.SAXException;

public class XSDValidator {
   public static void main(String[] args) {
      if(args.length !=2){
         System.out.println("Usage : XSDValidator <file-name.xsd> <file-name.xml>" );
      } else {
         boolean isValid = validateXMLSchema(args[0],args[1]);
         
         if(isValid){
            System.out.println(args[1] + " is valid against " + args[0]);
         } else {
            System.out.println(args[1] + " is not valid against " + args[0]);
         }
      }
   }
   
   public static boolean validateXMLSchema(String xsdPath, String xmlPath){
      try {
         SchemaFactory factory =
            SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
            Schema schema = factory.newSchema(new File(xsdPath));
            Validator validator = schema.newValidator();
            validator.validate(new StreamSource(new File(xmlPath)));
      } catch (IOException e){
         System.out.println("Exception: "+e.getMessage());
         return false;
      } catch(SAXException e1){
         System.out.println("SAX Exception: "+e1.getMessage());
         return false;
      }
		
      return true;
   }
}

Schritte zum Validieren von XML gegen XSD

Kopiere das XSDValidator.java Datei an einen beliebigen Ort, sagen wir E: > Java
Kopiere das students.xml zum gleichen Ort E: > java
Kopiere das students.xsd zum gleichen Ort E: > java
Kompilieren XSDValidator.javamit Konsole. Stellen Sie sicher, dass JDK 1.5 ab Ihrem Computer installiert ist und Klassenpfade konfiguriert sind. Einzelheiten zur Verwendung von JAVA finden Sie im JAVA-Lernprogramm

E:\java\javac XSDValidator.java

Ausführen XSDValidator mit students.xsd und students.xml als Argument übergeben.

E:\java\java XSDValidator students.xsd students.xml

Überprüfen Sie die Ausgabe

Sie sehen das folgende Ergebnis -

students.xml is valid against students.xsd

In diesem Kapitel sehen wir einfache Typen, die XSD definiert.

S.No.	Einfacher Typ & Beschreibung
1	Element Einfaches Element kann nur Text enthalten. Es darf kein anderes Element enthalten.
2	Attribut Das Attribut ist selbst ein Typ und wird in Complex Element verwendet.
3	Beschränkung Einschränkung definiert die akzeptablen Werte eines XML-Elements.

Komplexes Element ist ein XML-Element, das andere Elemente und / oder Attribute enthalten kann. Wir können ein komplexes Element auf zwei Arten erstellen -

Definieren Sie einen komplexen Typ und erstellen Sie dann ein Element mit type Attribut
Definieren Sie einen komplexen Typ direkt durch Benennen

Definieren Sie einen komplexen Typ und erstellen Sie dann ein Element mit dem Typattribut.

<xs:complexType name = "StudentType">
   <xs:sequence>
      <xs:element name = "firstname" type = "xs:string"/>
      <xs:element name = "lastname" type = "xs:string"/>
      <xs:element name = "nickname" type = "xs:string"/>
      <xs:element name = "marks" type = "xs:positiveInteger"/>
   </xs:sequence>
   <xs:attribute name = 'rollno' type = 'xs:positiveInteger'/>
</xs:complexType>

<xs:element name = 'student' type = 'StudentType' />

Definieren Sie einen komplexen Typ direkt durch Benennen.

<xs:element name = "student">
   <xs:complexType>   
      <xs:sequence>
         <xs:element name = "firstname" type = "xs:string"/>
         <xs:element name = "lastname" type = "xs:string"/>
         <xs:element name = "nickname" type = "xs:string"/>
         <xs:element name = "marks" type = "xs:positiveInteger"/>
      </xs:sequence>
   <xs:attribute name = 'rollno' type = 'xs:positiveInteger'/>
   </xs:complexType>
<xs:element>

Im Folgenden finden Sie eine Liste der von XSD unterstützten komplexen Typen.

S.No.	Einfacher Typ & Beschreibung
1	Leer Komplex Leeres komplexes Element kann nur Attribute, aber keinen Inhalt haben.
2	Nur Elemente Komplexe Elemente vom Typ "Nur Elemente" können nur Elemente enthalten
3	Nur Text Komplexes Nur-Text-Element kann nur Attribute und Text enthalten.
4	Gemischt Gemischte komplexe Elemente können Elemente, Attribute und Text enthalten.
5	Indikatoren Indikatoren steuern, wie Elemente in einem XML-Dokument organisiert werden sollen.
6	Das <any> -Element wird für Elemente verwendet, die nicht durch ein Schema definiert sind
7	Das Attribut <anyAttribute> wird für Attribute verwendet, die nicht durch ein Schema definiert sind.

String-Datentypen werden verwendet, um Zeichen in den XML-Dokumenten darzustellen.

Datentyp <xs: string>

Der Datentyp <xs: string> kann Zeichen, Zeilenvorschübe, Zeilenumbrüche und Tabulatorzeichen enthalten. Der XML-Prozessor ersetzt keine Zeilenvorschübe, Zeilenumbrüche und Tabulatorzeichen im Inhalt durch Leerzeichen und behält sie bei. Beispielsweise bleiben während der Anzeige mehrere Leerzeichen oder Tabulatoren erhalten.

<xs: string> Beispiel

Elementdeklaration in xsd -

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

Elementverwendung in xml -

<name>Dinkar</name>
<name>Dinkar    Kad</name>

Datentyp <xs: token>

Der Datentyp <xs: token> wird vom Datentyp <string> abgeleitet und kann Zeichen, Zeilenvorschübe, Zeilenumbrüche und Tabulatorzeichen enthalten. Der XML-Prozessor entfernt Zeilenvorschübe, Tabulatoren, Zeilenumbrüche, führende und nachfolgende Leerzeichen sowie mehrere Leerzeichen.

<xs: token> Beispiel

Elementdeklaration in xsd -

<xs:element name = "name" type = "xs:token"/>

Elementverwendung in xml -

<name>Dinkar</name>
<name>Dinkar    Kad</name>

String-Datentypen

Im Folgenden finden Sie eine Liste häufig verwendeter Datentypen, die vom Datentyp <string> abgeleitet sind.

S.No.	Name & Beschreibung
1	ID Stellt das ID-Attribut in XML dar und wird in Schemaattributen verwendet.
2	IDREF Repräsentiert das IDREF-Attribut in XML und wird in Schemaattributen verwendet.
3	language Stellt eine gültige Sprach-ID dar
4	Name Stellt einen gültigen XML-Namen dar
5	NMTOKEN Stellt ein NMTOKEN-Attribut in XML dar und wird in Schemaattributen verwendet.
6	normalizedString Stellt eine Zeichenfolge dar, die keine Zeilenvorschübe, Zeilenumbrüche oder Tabulatoren enthält.
7	string Stellt eine Zeichenfolge dar, die Zeilenvorschübe, Zeilenumbrüche oder Registerkarten enthalten kann.
8	token Stellt eine Zeichenfolge dar, die keine Zeilenvorschübe, Zeilenumbrüche, Tabulatoren, führenden oder nachfolgenden Leerzeichen oder mehrere Leerzeichen enthält

Beschränkungen

Die folgenden Arten von Einschränkungen können mit String-Datentypen verwendet werden:

enumeration
length
maxLength
minLength
pattern
whiteSpace

Datums- und Uhrzeitdatentypen werden verwendet, um Datum und Uhrzeit in den XML-Dokumenten darzustellen.

Datentyp <xs: date>

Der Datentyp <xs: date> wird verwendet, um das Datum im Format JJJJ-MM-TT darzustellen.

YYYY - repräsentiert das Jahr
MM - steht für Monat
DD - repräsentiert den Tag

<xs: date> Beispiel

Elementdeklaration in XSD -

<xs:element name = "birthdate" type = "xs:date"/>

Elementverwendung in XML -

<birthdate>1980-03-23</birthdate>

Datentyp <xs: time>

Der Datentyp <xs: time> wird verwendet, um die Zeit im Format hh: mm: ss darzustellen.

hh - steht für Stunden
mm - steht für Minuten
ss - steht für Sekunden

<xs: time> Beispiel

Elementdeklaration in XSD -

<xs:element name = "startTime" type = "xs:time"/>

Elementverwendung in XML -

<startTime>10:20:15</startTime>

Datentyp <xs: datetime>

Der Datentyp <xs: datetime> wird verwendet, um Datum und Uhrzeit im Format JJJJ-MM-TTThh: mm: ss darzustellen.

YYYY - repräsentiert das Jahr
MM - steht für Monat
DD - repräsentiert den Tag
T - repräsentiert den Beginn des Zeitabschnitts
hh - steht für Stunden
mm - steht für Minuten
ss - steht für Sekunden

<xs: datetime> Beispiel

Elementdeklaration in XSD -

<xs:element name = "startTime" type = "xs:datetime"/>

Elementverwendung in XML -

<startTime>1980-03-23T10:20:15</startTime>

Datentyp <xs: duration>

Der Datentyp <xs: duration> wird verwendet, um das Zeitintervall im PnYnMnDTnHnMnS-Format darzustellen. Jede Komponente außer P. ist optional.

P - repräsentiert den Abschnitt zum Beginn des Datums
nY - repräsentiert das Jahr
nM - steht für Monat
nD - repräsentiert den Tag
T - repräsentiert den Beginn des Zeitabschnitts
nH - steht für Stunden
nM - steht für Minuten
nS - steht für Sekunden

<xs: duration> Beispiel

Elementdeklaration in XSD -

<xs:element name = "period" type = "xs:duration"/>

Elementverwendung in XML für einen Zeitraum von 6 Jahren, 3 Monaten, 10 Tagen und 15 Stunden.

<period>P6Y3M10DT15H</period>

Datumsdatentypen

Im Folgenden finden Sie eine Liste der häufig verwendeten Datumsdatentypen.

S.No.	Name & Beschreibung
1.	date Stellt einen Datumswert dar
2.	dateTime Stellt einen Datums- und Zeitwert dar
3.	duration Stellt ein Zeitintervall dar
4.	gDay Stellt einen Teil eines Datums als Tag dar (DD)
5.	gMonth Stellt einen Teil eines Datums als Monat (MM) dar
6.	gMonthDay Stellt einen Teil eines Datums als Monat und Tag dar (MM-DD)
7.	gYear Stellt einen Teil eines Datums als Jahr dar (JJJJ)
8.	gYearMonth Stellt einen Teil eines Datums als Jahr und Monat dar (JJJJ-MM)
9.	time Stellt einen Zeitwert dar

Beschränkungen

Die folgenden Arten von Einschränkungen können mit Datumsdatentypen verwendet werden:

enumeration
maxExclusive
maxInclusive
minExclusive
minInclusive
pattern
whiteSpace

Numerische Datentypen werden verwendet, um Zahlen in XML-Dokumenten darzustellen.

Datentyp <xs: decimal>

Der Datentyp <xs: decimal> wird zur Darstellung numerischer Werte verwendet. Es unterstützt Dezimalzahlen mit bis zu 18 Stellen.

<xs: decimal> Beispiel

Elementdeklaration in XSD -

<xs:element name = "score" type = "xs:decimal"/>

Elementverwendung in XML -

<score>9.12</score>

Datentyp <xs: integer>

Der Datentyp <xs: integer> wird zur Darstellung ganzzahliger Werte verwendet.

<xs: integer> Beispiel

Elementdeklaration in XSD -

<xs:element name = "score" type = "xs:integer"/>

Elementverwendung in XML -

<score>9</score>

Numerische Datentypen

Im Folgenden finden Sie eine Liste häufig verwendeter numerischer Datentypen.

S.No.	Name & Beschreibung
1.	byte Eine vorzeichenbehaftete 8-Bit-Ganzzahl
2.	decimal Ein Dezimalwert
3.	int Eine vorzeichenbehaftete 32-Bit-Ganzzahl
4.	integer Ein ganzzahliger Wert
5.	long Eine vorzeichenbehaftete 64-Bit-Ganzzahl
6.	negativeInteger Eine ganze Zahl mit nur negativen Werten (.., - 2, -1)
7.	nonNegativeInteger Eine ganze Zahl mit nur nicht negativen Werten (0,1,2, ..)
8.	nonPositiveInteger Eine ganze Zahl mit nur nicht positiven Werten (.., - 2, -1,0)
9.	positiveInteger Eine ganze Zahl mit nur positiven Werten (1,2, ..)
10.	short Eine vorzeichenbehaftete 16-Bit-Ganzzahl
11.	unsignedLong Eine vorzeichenlose 64-Bit-Ganzzahl
12.	unsignedInt Eine vorzeichenlose 32-Bit-Ganzzahl
13.	unsignedShort Eine vorzeichenlose 16-Bit-Ganzzahl
14.	unsignedByte Eine vorzeichenlose 8-Bit-Ganzzahl

Beschränkungen

Die folgenden Arten von Einschränkungen können mit Datumsdatentypen verwendet werden:

enumeration
fractionDigits
maxExclusive
maxInclusive
minExclusive
minInclusive
pattern
totalDigits
whiteSpace

XSD verfügt über einige andere wichtige Datentypen, z Boolean, binary, und anyURI.

Datentyp <xs: boolean>

Der Datentyp <xs: boolean> wird verwendet, um den Wert true, false, 1 (für true) oder 0 (für false) darzustellen.

<xs: boolean> Beispiel

Elementdeklaration in XSD -

<xs:element name = "pass" type = "xs:boolean"/>

Elementverwendung in XML -

<pass>false</pass>

Binäre Datentypen

Die Binärdatentypen werden zur Darstellung von Binärwerten verwendet. Zwei Binärtypen werden häufig verwendet.

base64Binary - repräsentiert base64-codierte Binärdaten
hexBinary - repräsentiert hexadezimal codierte Binärdaten

<xs: hexbinary> Beispiel

Elementdeklaration in XSD -

<xs:element name = "blob" type = "xs:hexBinary"/>

Elementverwendung in XML -

<blob>9FEEF</blob>

Datentyp <xs: anyURI>

Der Datentyp <xs: anyURI> wird zur Darstellung des URI verwendet.

<xs: anyURI> Beispiel

Elementdeklaration in XSD -

<xs:attribute name = "resource" type = "xs:anyURI"/>

Elementverwendung in XML -

<image resource = "http://www.tutorialspoint.com/images/smiley.jpg" />

Numerische Datentypen

Im Folgenden finden Sie eine Liste häufig verwendeter numerischer Datentypen.

S.No.	Name & Beschreibung
1.	byte Eine vorzeichenbehaftete 8-Bit-Ganzzahl
2.	decimal Ein Dezimalwert
3.	int Eine vorzeichenbehaftete 32-Bit-Ganzzahl
4.	integer Ein ganzzahliger Wert
5.	long Eine vorzeichenbehaftete 64-Bit-Ganzzahl
6.	negativeInteger Eine ganze Zahl mit nur negativen Werten (.., - 2, -1)
7.	nonNegativeInteger Eine ganze Zahl mit nur nicht negativen Werten (0,1,2, ..)
8.	nonPositiveInteger Eine ganze Zahl mit nur nicht positiven Werten (.., - 2, -1,0)
9.	positiveInteger Eine ganze Zahl mit nur positiven Werten (1,2, ..)
10.	short Eine vorzeichenbehaftete 16-Bit-Ganzzahl
11.	unsignedLong Eine vorzeichenlose 64-Bit-Ganzzahl
12.	unsignedInt Eine vorzeichenlose 32-Bit-Ganzzahl
13.	unsignedShort Eine vorzeichenlose 16-Bit-Ganzzahl
14.	unsignedByte Eine vorzeichenlose 8-Bit-Ganzzahl

Beschränkungen

Die folgenden Arten von Einschränkungen können für verschiedene Datentypen verwendet werden, außer für den booleschen Datentyp:

enumeration
length
maxLength
minLength
pattern
whiteSpace