Hvis du har integreret med en enterprise XML-API og modtaget en kryptisk afvisning med "element 'Quantity' er ikke gyldigt i denne kontekst", har du allerede mødt XSD — selv om du ikke kendte det ved navn. XML Schema Definition (XSD) er det sprog, der præcist definerer, hvordan gyldigt XML ser ud: hvilke elementer der kræves, hvilke datatyper de indeholder, hvor mange gange de må forekomme, og hvilke værdier der er tilladt. Denne guide dækker, hvordan man skriver skemaer, validerer mod dem og håndterer de fejl, man uundgåeligt støder på.

XSD er defineret af W3C XML Schema-specifikationen, der første gang blev offentliggjort i 2001. Anbefalingen XML Schema Part 2: Datatypes definerer det indbyggede typesystem. Det er omstændeligt og lidt arkaisk at skrive i hånden, men ekstremt præcist — hvilket er præcis, hvad du har brug for, når du udveksler data mellem systemer, der ikke tåler tvetydighed.

Hvorfor overhovedet validere XML?

  • Fang datafejl tidligt. Validering ved API-grænsen betyder, at et manglende påkrævet felt fejler med det samme med en tydelig fejl — ikke 3 trin senere, når din databaseindsætning kaster en constraint-violation.
  • Dokumentér kontrakten. Et XSD-skema er eksekverbar dokumentation. I modsætning til et Word-dokument, der forældes, er et skema altid præcist, fordi systemet håndhæver det.
  • Interoperabilitet. I B2B-integrationer — fakturering, ordrestyring, sundhedspleje — validerer begge parter mod et fælles offentliggjort skema. Hvis det validerer, kan begge sider behandle det.
  • Sikkerhed. Validering afviser misdannet input, før det når forretningslogikken, hvilket reducerer angrebsfladen for XML-injektionsangreb.

Et komplet XSD-skemaeksempel

Lad os bygge et skema til et produktkatalog. Dette dækker de mest anvendte XSD-funktioner — simple typer, komplekse typer, sekvenser, attributter, kardinalitet og datatypebegrænsninger:

xml
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

  <!-- Root element -->
  <xs:element name="catalog">
    <xs:complexType>
      <xs:sequence>
        <!-- One or more product elements -->
        <xs:element name="product" type="ProductType" minOccurs="1" maxOccurs="unbounded"/>
      </xs:sequence>
      <xs:attribute name="version" type="xs:string" use="required"/>
    </xs:complexType>
  </xs:element>

  <!-- Product complex type -->
  <xs:complexType name="ProductType">
    <xs:sequence>
      <xs:element name="name" type="xs:string"/>
      <xs:element name="description" type="xs:string" minOccurs="0"/>
      <xs:element name="price" type="PriceType"/>
      <xs:element name="stock" type="xs:nonNegativeInteger"/>
      <xs:element name="categories" type="CategoriesType"/>
    </xs:sequence>
    <xs:attribute name="id" type="ProductIdType" use="required"/>
    <xs:attribute name="status" type="ProductStatusType" use="optional" default="active"/>
  </xs:complexType>

  <!-- Price with currency attribute -->
  <xs:complexType name="PriceType">
    <xs:simpleContent>
      <xs:extension base="xs:decimal">
        <xs:attribute name="currency" type="CurrencyCodeType" use="required"/>
      </xs:extension>
    </xs:simpleContent>
  </xs:complexType>

  <!-- Categories — zero or more category strings -->
  <xs:complexType name="CategoriesType">
    <xs:sequence>
      <xs:element name="category" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:complexType>

  <!-- Product ID: alphanumeric, starts with P, 4-10 chars -->
  <xs:simpleType name="ProductIdType">
    <xs:restriction base="xs:string">
      <xs:pattern value="P[A-Z0-9]{3,9}"/>
    </xs:restriction>
  </xs:simpleType>

  <!-- Allowed product statuses -->
  <xs:simpleType name="ProductStatusType">
    <xs:restriction base="xs:string">
      <xs:enumeration value="active"/>
      <xs:enumeration value="discontinued"/>
      <xs:enumeration value="out_of_stock"/>
    </xs:restriction>
  </xs:simpleType>

  <!-- ISO 4217 currency codes — a subset -->
  <xs:simpleType name="CurrencyCodeType">
    <xs:restriction base="xs:string">
      <xs:enumeration value="USD"/>
      <xs:enumeration value="EUR"/>
      <xs:enumeration value="GBP"/>
      <xs:enumeration value="JPY"/>
    </xs:restriction>
  </xs:simpleType>

</xs:schema>

Meget at fordøje. Lad os gennemgå nøglebegreberne, inden vi viser validering i praksis.

Vigtige XSD-begreber forklaret

  • xs:element. Erklærer et element. minOccurs og maxOccurs styrer kardinalitet. Standard for begge er 1. Brug maxOccurs="unbounded" for ubegrænset gentagelse.
  • xs:complexType. Et element, der indeholder underordnede elementer eller har attributter. Simple elementer (kun tekst) bruger xs:simpleType eller en XSD-indbygget type direkte.
  • xs:sequence. Underordnede elementer skal vises i den definerede rækkefølge. Alternativet er xs:all (vilkårlig rækkefølge, hver højst én gang) eller xs:choice (præcis ét af de listede elementer).
  • xs:attribute use="required". Gør attributten obligatorisk. use="optional" (standard) tillader, at den mangler. Tilføj default="value" for en standardværdi, når den mangler.
  • xs:restriction. Begrænser en basistype. Almindelige facetter: xs:pattern (regex), xs:enumeration (tilladte værdier), xs:minInclusive/xs:maxInclusive (numeriske grænser), xs:minLength/xs:maxLength (strenglængde).
  • xs:simpleContent + xs:extension. Måden at tilføje attributter til et element, der også har tekstindhold — som brugt i PriceType ovenfor, hvor <price currency="USD">149.99</price> har både tekst og en attribut.

Indbyggede XSD-datatyper du faktisk bruger

  • xs:string — vilkårligt tekstindhold
  • xs:integer — heltal (positive, negative eller nul)
  • xs:nonNegativeInteger — heltal ≥ 0 (godt til mængder, tælle)
  • xs:decimal — decimal med vilkårlig præcision (god til priser)
  • xs:boolean — true eller false (accepterer også 1 og 0)
  • xs:date — ISO 8601-dato: 2024-01-15
  • xs:dateTime — ISO 8601 dato-tid: 2024-01-15T09:30:00Z
  • xs:anyURI — en URI/URL
  • xs:base64Binary — Base64-kodet binærdata

Validering af XML mod XSD i Python (lxml)

Pythons standard-xml.etree.ElementTree understøtter ikke XSD-validering. Du har brug for lxml til det. Det er afhængigheden værd — lxmls valideringsmeddelelser er detaljerede og peger dig til den præcise linje, der forårsager problemet:

bash
pip install lxml
python
from lxml import etree

# Load the schema
with open('catalog.xsd', 'rb') as f:
    schema_doc = etree.parse(f)
schema = etree.XMLSchema(schema_doc)

# Valid XML
valid_xml = """<?xml version="1.0"?>
<catalog version="1.0">
  <product id="P0012" status="active">
    <name>Mechanical Keyboard</name>
    <price currency="USD">189.00</price>
    <stock>42</stock>
    <categories>
      <category>Electronics</category>
      <category>Peripherals</category>
    </categories>
  </product>
</catalog>"""

xml_doc = etree.fromstring(valid_xml.encode())
if schema.validate(xml_doc):
    print("Valid!")
else:
    for error in schema.error_log:
        print(f"Error at line {error.line}: {error.message}")

# Invalid XML — missing required 'stock', bad product ID format
invalid_xml = """<?xml version="1.0"?>
<catalog version="1.0">
  <product id="BADID">
    <name>Test Product</name>
    <price currency="USD">10.00</price>
    <categories/>
  </product>
</catalog>"""

invalid_doc = etree.fromstring(invalid_xml.encode())
schema.validate(invalid_doc)
for error in schema.error_log:
    print(f"Line {error.line}: {error.message}")
# Line 3: Element 'product', attribute 'id': 'BADID' is not a valid value of the atomic type 'ProductIdType'.
# Line 7: Element 'categories': Missing child element(s). Expected is ( category ).  ← if minOccurs > 0

Validering i Java — JAXP

Java har indbygget XSD-validering via JAXP-validerings-API'et (intet tredjepartsbibliotek er nødvendigt). Dette er mønsteret brugt i enterprise Java-applikationer og Spring Boot XML-behandling:

java
import javax.xml.XMLConstants;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;
import javax.xml.transform.stream.StreamSource;
import java.io.File;
import org.xml.sax.SAXException;
import java.io.IOException;

SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
Schema schema = factory.newSchema(new File("catalog.xsd"));
Validator validator = schema.newValidator();

try {
    validator.validate(new StreamSource(new File("catalog.xml")));
    System.out.println("Valid!");
} catch (SAXException e) {
    System.out.println("Validation error: " + e.getMessage());
} catch (IOException e) {
    System.out.println("IO error: " + e.getMessage());
}

XML Schema vs JSON Schema

Hvis du har brugt JSON Schema, vil XSD føles bekendt i formål, men meget anderledes i syntaks. En hurtig sammenligning:

  • Syntaks. XSD er XML; JSON Schema er JSON. XSD er mere omstændeligt, men integreres naturligt i XML-værktøjskæder.
  • Modenhed. XSD 1.0 har eksisteret siden 2001 — årtiers værktøjer, valideringsprogrammer og biblioteksunderstøttelse. JSON Schema har udviklet sig siden 2009 og nåede først et stabilt udkast for nylig.
  • Typesystem. XSD har et rigere indbygget typesystem: xs:date, xs:decimal, xs:anyURI er indbyggede. JSON Schema er afhængig af formatannotationer for datoer og URI'er, som valideringsprogrammer måske eller måske ikke håndhæver.
  • Navnerumsunderstøttelse. XSD har native understøttelse af XML-navnerum. JSON Schema har intet tilsvarende koncept.
  • Hvornår man bruger hvad. Hvis du arbejder i et XML-økosystem, brug XSD. Hvis du arbejder i et JSON-økosystem, brug JSON Schema. Bland dem ikke.

Almindelige valideringsfejl og hvordan man retter dem

  • "Element X forventtes ikke." Elementet vises i forkert rækkefølge i en xs:sequence, eller er slet ikke defineret i skemaet. Tjek elementnavnet og dets position relativt til søskende.
  • "Værdien Y for attribut Z er ugyldig." Attributværdien matcher ikke dens type eller opregning. Almindeligt for statusfelter og valutakoder med slåfejl.
  • "Manglende underordnede elementer." Et påkrævet underordnet element (minOccurs > 0) mangler. Tjek skemaet for hvilke elementer der er obligatoriske under forælderen.
  • "Ikke en gyldig værdi af den atomare type." En simpel typebegrænsning mislykkedes — mønster, interval eller opregning. Tjek skemaet for xs:restriction på den type.
  • "Indholdsmodellen er ikke deterministisk." Tvetydigt skema — validereren kan ikke afgøre, hvilken gren der gælder. Normalt forårsaget af to valgmuligheder med samme tagnavn i en xs:choice.

Relaterede værktøjer

Arbejder du med XML-skemaer? Disse værktøjer hjælper: XML-validator til hurtige velformathedstjek, XML-formatering for at gøre tæt XML læsbar inden fejlfinding, XML-schemagenerator til automatisk generering af et XSD fra et eksempel-XML-dokument, og XML til JSON, når du hellere vil arbejde med JSON Schema.

Afslutning

XSD er omstændeligt, men det er det rette værktøj til at definere strenge XML-kontrakter i enterprise- og B2B-kontekster. De vigtigste mønstre at huske: brug xs:sequence med minOccurs/maxOccurs til at styre struktur, brug xs:restriction med xs:enumeration og xs:pattern til værdibegrænsninger, og brug lxml i Python til validering med tydelige fejlmeddelelser. Når du har et fungerende skema, bliver det den eneste kilde til sandhed, som begge sider af en integration kan referere til — hvilket sparer meget frem-og-tilbage-fejlfinding.

← All XML articles Browse all categories →