Usa un validatore che verifica sintassi e opzionalmente lo schema XSD.

Web Services Description Language, descrive interfacce di web service SOAP.

XML WSDL Viewer Online: Formatta e Valida File Gratis

Cos'è XML e Perché è Importante

XML (eXtensible Markup Language) è un formato di markup standardizzato per strutturare dati in modo leggibile sia dagli esseri umani che dalle macchine. Creato dal W3C nel 1998, XML è diventato lo standard de facto per lo scambio di dati tra sistemi eterogenei, configurazioni applicative, documenti strutturati e servizi web.

A differenza di HTML, che è progettato per visualizzare dati, XML è progettato per trasportare e memorizzare dati. È auto-descrittivo, estensibile e indipendente dalla piattaforma, rendendolo ideale per:

Configurazioni applicative: Maven POM, Spring beans, Log4j config
Servizi web SOAP: WSDL, messaggi request/response
Documenti strutturati: RSS feed, sitemaps, SVG, DocBook
Scambio dati B2B: EDI, fatturazione elettronica, HL7 healthcare
Formati Office: .docx, .xlsx, .pptx (basati su XML)

XML Formatter & Validator: Funzionalità Principali

Il nostro XML & WSDL Viewer offre un set completo di strumenti per lavorare con XML in modo efficiente:

1. XML Validation (Validazione Sintattica)

La validazione XML verifica che il documento rispetti le regole di sintassi XML well-formed:

Ogni tag di apertura deve avere un tag di chiusura corrispondente
I tag devono essere correttamente annidati (no sovrapposizioni)
Un solo elemento radice (root element)
Gli attributi devono essere racchiusi tra virgolette
Caratteri speciali (< > &) devono essere escaped

Esempio di XML valido:

<?xml version="1.0" encoding="UTF-8"?>
<libreria>
  <libro isbn="978-88-1234-567-8">
    <titolo>Guida Completa a XML</titolo>
    <autore>Mario Rossi</autore>
    <prezzo valuta="EUR">29.99</prezzo>
    <anno>2024</anno>
  </libro>
</libreria>

Esempio di XML non valido (errore rilevato):

<libro>
  <titolo>Titolo errato</autor>  <!-- Tag chiusura errato -->
  <prezzo>19.99</titolo>          <!-- Tag annidamento sbagliato -->
</libro>

Il validatore mostrerà esattamente la linea e colonna dell'errore, facilitando il debug.

2. XML Formatting (Prettify & Minify)

Prettify formatta XML con indentazione per renderlo leggibile:

<!-- Prima (minificato) -->
<root><user><name>John</name><age>30</age></user></root>

<!-- Dopo (prettified con indent 2) -->
<root>
  <user>
    <name>John</name>
    <age>30</age>
  </user>
</root>

Minify rimuove whitespace inutili per ridurre dimensione file:

Rimuove spazi e tab tra tag
Elimina newline non necessarie
Mantiene solo gli spazi significativi (dentro contenuto testuale)
Riduzione dimensione file: tipicamente 20-40%

3. XML to JSON Conversion (Bidirezionale)

Converti XML in JSON per usarlo in applicazioni JavaScript/REST API moderne:

<!-- XML Input -->
<person>
  <name>Mario Rossi</name>
  <age>35</age>
  <skills>
    <item>JavaScript</item>
    <item>Python</item>
    <item>Java</item>
  </skills>
</person>

// JSON Output
{
  "person": {
    "name": "Mario Rossi",
    "age": "35",
    "skills": {
      "item": [
        "JavaScript",
        "Python",
        "Java"
      ]
    }
  }
}

Conversione inversa JSON → XML:

// JSON Input
{
  "utente": {
    "id": 12345,
    "attivo": true,
    "ruoli": ["admin", "editor"]
  }
}

<!-- XML Output -->
<?xml version="1.0" encoding="UTF-8"?>
<root>
  <utente>
    <id>12345</id>
    <attivo>true</attivo>
    <ruoli>
      <item>admin</item>
      <item>editor</item>
    </ruoli>
  </utente>
</root>

4. WSDL Parser & Viewer

WSDL (Web Services Description Language) descrive servizi web SOAP. Il parser estrae automaticamente:

Services & Endpoints: URL dei servizi SOAP esposti
Operations: Metodi disponibili con input/output message types
Types: Tipi di dati complessi definiti (ComplexType, SimpleType)
Bindings: Protocollo di comunicazione (SOAP 1.1/1.2, HTTP)
Target Namespace: Namespace del servizio

Esempio WSDL parsing output:

📋 Service: CalcolatriceService
   Port: CalcolatoreSoapPort
   Endpoint: http://example.com/calculator

⚙️ Operations:
   - addizione(int a, int b) → int result
   - sottrazione(int a, int b) → int result
   - moltiplicazione(int a, int b) → int result
   - divisione(int a, int b) → float result

📦 Types: AddRequest, AddResponse, DivideRequest, DivideResponse

Casi d'Uso Reali

1. Debug Configurazioni Spring/Maven

Developer backend che lavorano con Spring Boot o Maven spesso hanno configurazioni XML complesse. Il formatter aiuta a:

Validare sintassi di pom.xml prima del build
Formattare applicationContext.xml per leggibilità
Confrontare versioni di configurazioni (con Diff Checker)

<!-- Spring beans configuration -->
<beans xmlns="http://www.springframework.org/schema/beans">
  <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
    <property name="username" value="root"/>
    <property name="password" value="password"/>
  </bean>
</beans>

2. Integrazione SOAP Web Services

Quando si integra con servizi SOAP legacy (banking, ERP, public services), il WSDL parser permette di:

Visualizzare tutte le operations disponibili
Capire struttura dei messaggi request/response
Identificare endpoint e binding da configurare
Generare client code basandosi su types estratti

3. Analisi RSS Feed e Sitemap

RSS feed e sitemap XML possono essere validati e formattati:

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://thejord.it/</loc>
    <lastmod>2024-12-01</lastmod>
    <changefreq>weekly</changefreq>
    <priority>1.0</priority>
  </url>
  <url>
    <loc>https://thejord.it/xml-wsdl-viewer</loc>
    <lastmod>2024-12-03</lastmod>
    <changefreq>monthly</changefreq>
    <priority>0.8</priority>
  </url>
</urlset>

4. Fatturazione Elettronica XML (FatturaPA)

In Italia, le fatture elettroniche seguono il formato XML FatturaPA. Il validatore aiuta a:

Verificare sintassi XML prima dell'invio al Sistema di Interscambio (SDI)
Formattare per leggibilità durante controlli manuali
Convertire in JSON per processamento automatizzato

5. Migrazione da SOAP a REST

Team che stanno migrando da architetture SOAP a REST API possono:

Parsare WSDL per estrarre tutte le operations
Mappare operations SOAP a endpoint REST equivalenti
Convertire message types XML in JSON schemas
Documentare API REST basandosi su documentazione WSDL

Esempi di Codice

JavaScript: Parse XML con DOMParser

// Browser-based XML parsing
const xmlString = '<books><book id="1"><title>XML Guide</title></book></books>';

const parser = new DOMParser();
const xmlDoc = parser.parseFromString(xmlString, 'application/xml');

// Check for parsing errors
const parserError = xmlDoc.querySelector('parsererror');
if (parserError) {
  console.error('XML Parsing Error:', parserError.textContent);
} else {
  const books = xmlDoc.getElementsByTagName('book');
  console.log(`Found ${books.length} books`);

  const title = xmlDoc.querySelector('title').textContent;
  console.log(`First book title: ${title}`);
}

Python: XML Processing con lxml

from lxml import etree

# Parse XML
xml_string = '''<?xml version="1.0"?>
<catalog>
  <product id="101">
    <name>Laptop</name>
    <price currency="EUR">899.99</price>
  </product>
</catalog>'''

root = etree.fromstring(xml_string.encode('utf-8'))

# Extract data
product = root.find('.//product')
name = product.find('name').text
price = product.find('price').text
currency = product.find('price').get('currency')

print(f"Product: {name} - {price} {currency}")

# Validate with XSD schema
schema = etree.XMLSchema(etree.parse('schema.xsd'))
is_valid = schema.validate(root)
print(f"Valid XML: {is_valid}")

Java: JAXB per XML Binding

import javax.xml.bind.*;
import java.io.StringReader;

@XmlRootElement
class Person {
    @XmlElement
    private String name;

    @XmlElement
    private int age;

    // Getters/Setters omessi
}

public class XmlExample {
    public static void main(String[] args) throws JAXBException {
        String xml = "<person><name>Mario</name><age>35</age></person>";

        JAXBContext context = JAXBContext.newInstance(Person.class);
        Unmarshaller unmarshaller = context.createUnmarshaller();

        Person person = (Person) unmarshaller.unmarshal(
            new StringReader(xml)
        );

        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

Node.js: XML to JSON con xml2js

const xml2js = require('xml2js');

const xmlString = `
  <config>
    <database>
      <host>localhost</host>
      <port>5432</port>
      <name>mydb</name>
    </database>
  </config>
`;

xml2js.parseString(xmlString, (err, result) => {
  if (err) {
    console.error('Parse error:', err);
    return;
  }

  const dbConfig = result.config.database[0];
  console.log(`DB: ${dbConfig.host}:${dbConfig.port}/${dbConfig.name}`);

  // Convert back to XML
  const builder = new xml2js.Builder();
  const xml = builder.buildObject(result);
  console.log(xml);
});

XML vs JSON: Quando Usare XML

Caratteristica	XML	JSON
Leggibilità	Verboso, più pesante	Conciso, più leggero
Parsing	Più lento (DOM/SAX)	Più veloce (nativo JS)
Validazione	XSD Schema, DTD	JSON Schema
Supporto Attributi	✅ Sì	❌ No (solo key-value)
Namespaces	✅ Sì	❌ No
Commenti	✅ Sì (<!-- -->)	❌ No (standard)
Uso Tipico	Config, SOAP, Documenti	REST API, NoSQL, Web

Usa XML quando:

Necessiti di validazione rigorosa con XML Schema
Lavori con servizi SOAP o legacy systems
Hai bisogno di metadati (attributi, namespaces)
Documenti complessi con struttura mista (testo + markup)
Standard di settore richiedono XML (healthcare HL7, finance FpML)

Usa JSON quando:

Sviluppi REST API moderne
Prioritizzi performance e dimensione payload
Integri con JavaScript/frontend
Lavori con database NoSQL (MongoDB, Couchbase)

FAQ

Come posso validare XML contro un XML Schema (XSD)?

Il nostro tool valida la sintassi XML (well-formedness). Per validare contro un XSD, usa librerie specializzate:

Online: XMLValidation.com, FreeFormatter.com
JavaScript: libxmljs, xsd-schema-validator
Python: lxml con XMLSchema
Java: javax.xml.validation.SchemaFactory

Il tool supporta XML namespaces?

Sì, il validatore e formatter gestiscono correttamente namespaces XML, inclusi prefissi (xmlns:ns) e default namespaces. Il WSDL parser riconosce automaticamente namespaces SOAP, WSDL e XSD.

Posso convertire XML in CSV o Excel?

Direttamente no, ma puoi seguire questo workflow:

XML → JSON (con il nostro tool)
JSON → CSV (con il nostro JSON Formatter)
Importa CSV in Excel

Come gestisco file XML molto grandi (>10MB)?

Il tool browser-based ha limiti di memoria. Per file grandi usa:

Command line: xmllint --format large.xml (Linux/Mac)
Python SAX parser: Parsing incrementale senza caricare tutto in memoria
Java StAX: Streaming API for XML

Il WSDL parser supporta WSDL 2.0?

Attualmente supportiamo WSDL 1.1 (più diffuso). WSDL 2.0 ha adozione limitata. Se hai necessità specifiche, contattaci.

Come minify XML preservando formattazione interna a CDATA?

Le sezioni <![CDATA[...]]> vengono preservate esattamente come sono, includendo whitespace interno. Il minify rimuove solo spazi tra tag XML.

Qual è la differenza tra well-formed e valid XML?

Well-formed XML rispetta le regole sintattiche di base (tag chiusi, annidamento corretto). Valid XML rispetta anche uno schema specifico (DTD o XSD) che definisce struttura e tipi consentiti.

Posso usare il tool offline?

Sì! Tutto il processing avviene nel browser (client-side). Puoi salvare la pagina HTML e usarla offline. Nessun dato viene inviato a server esterni.

Risorse e Tool Correlati

Altri Tool THEJORD Utili

JSON Formatter - Valida e formatta JSON, converti JSON → XML/CSV/YAML
Diff Checker - Confronta due versioni di XML per trovare differenze
Base64 Encoder - Codifica XML in Base64 per trasmissione sicura
RegEx Tester - Testa pattern per estrarre dati da XML

Documentazione Esterna

W3C XML Specification - Standard ufficiale XML
W3C WSDL Specification - WSDL 2.0 spec
MDN DOMParser API - JavaScript XML parsing
HL7 Healthcare Standards - XML in ambito medicale

Conclusione

Il XML & WSDL Viewer di THEJORD è uno strumento completo per sviluppatori che lavorano con XML: validazione real-time, formatting professionale, parsing WSDL avanzato e conversione bidirezionale XML ↔ JSON.

Vantaggi chiave:

✅ 100% gratuito e privacy-first (nessun caricamento server)
⚡ Veloce: processing client-side istantaneo
🛡️ Sicuro: nessun dato lascia il tuo browser
🔧 Completo: validator, formatter, parser WSDL, converter
💻 Sempre disponibile: funziona anche offline

Prova subito il tool e semplifica il tuo workflow XML!