XML per il principiante assoluto

HTML e il World Wide Web sono ovunque. Come esempio della loro ubiquità, quest'anno andrò in America Centrale per Pasqua e, se voglio, potrò navigare sul Web, leggere le mie e-mail e persino fare operazioni bancarie online dagli Internet café di Antigua Guatemala e Belize City. (Non ho intenzione di farlo, tuttavia, dal momento che ciò richiederebbe tempo lontano da un appuntamento che ho con una palma e una noce di cocco piena di rum.)

Eppure, nonostante l'onnipresenza e la popolarità dell'HTML, è fortemente limitato in ciò che può fare. Va bene per diffondere documenti informali, ma ora l'HTML viene utilizzato per fare cose per cui non è mai stato progettato. Cercare di progettare sistemi di dati resistenti, flessibili e interoperabili dall'HTML è come provare a costruire una portaerei con seghetti e saldatori: gli strumenti (HTML e HTTP) non sono all'altezza del lavoro.

La buona notizia è che molti dei limiti dell'HTML sono stati superati in XML, l'Extensible Markup Language. XML è facilmente comprensibile a chiunque capisca l'HTML, ma è molto più potente. Più che un semplice linguaggio di markup, XML è un metalinguaggio , un linguaggio utilizzato per definire nuovi linguaggi di markup. Con XML, puoi creare un linguaggio creato appositamente per la tua applicazione o dominio.

XML completerà, anziché sostituire, HTML. Mentre l'HTML viene utilizzato per la formattazione e la visualizzazione dei dati, XML rappresenta il significato contestuale dei dati.

Questo articolo presenterà la storia dei linguaggi di markup e come è nato XML. Esamineremo i dati di esempio in HTML e passeremo gradualmente a XML, dimostrando perché fornisce un modo migliore per rappresentare i dati. Esploreremo i motivi per cui potresti aver bisogno di inventare un linguaggio di markup personalizzato e ti insegnerò come farlo. Tratteremo le basi della notazione XML e come visualizzare XML con due diversi tipi di linguaggi di stile. Quindi, ci immergeremo nel Document Object Model, un potente strumento per manipolare i documenti come oggetti (o manipolare le strutture degli oggetti come documenti, a seconda di come lo guardi). Vedremo come scrivere programmi Java che estraggono informazioni da documenti XML, con un puntatore a un programma gratuito utile per sperimentare questi nuovi concetti. Infine, noi 'Daremo uno sguardo a una società Internet che basa la sua strategia tecnologica di base su XML e Java.

XML fa per te?

Sebbene questo articolo sia stato scritto per chiunque sia interessato a XML, ha una relazione speciale con la serie JavaWorld su XML JavaBeans. (Vedi Risorse per collegamenti ad articoli correlati.) Se hai letto quella serie e non hai ancora capito, questo articolo dovrebbe chiarire come usare XML con i bean. Se lo stai ricevendo, questo articolo funge da compagno perfetto per la serie XML JavaBeans, poiché copre argomenti non trattati in essa. E, se sei uno dei pochi fortunati che hanno ancora gli articoli XML JavaBeans da guardare al futuro, ti consiglio di leggere prima il presente articolo come materiale introduttivo.

Una nota su Java

C'è così tanta attività XML recente nel mondo dei computer che anche un articolo di questa lunghezza può solo sfiorare la superficie. Tuttavia, il punto centrale di questo articolo è fornire il contesto necessario per utilizzare XML nella progettazione del programma Java. Questo articolo copre anche il modo in cui XML opera con la tecnologia Web esistente, poiché molti programmatori Java lavorano in tale ambiente.

XML apre la programmazione Internet e Java a funzionalità portatili, non browser. XML libera il contenuto Internet dal browser nello stesso modo in cui Java libera il comportamento del programma dalla piattaforma. XML rende il contenuto Internet disponibile per applicazioni reali.

Java è un'eccellente piattaforma per l'utilizzo di XML e XML è un'eccezionale rappresentazione dei dati per le applicazioni Java. Indicherò alcuni dei punti di forza di Java con XML man mano che procediamo.

Cominciamo con una lezione di storia.

Le origini dei linguaggi di markup

L'HTML che tutti conosciamo e amiamo (beh, lo sappiamo, comunque) è stato originariamente progettato da Tim Berners-Lee al CERN ( le Conseil Européen pour la Recherche Nucléaire, or the European Laboratory for Particle Physics) a Ginevra per consentire ai nerd della fisica ( e anche non nerd) per comunicare tra loro. HTML è stato rilasciato nel dicembre 1990 all'interno del CERN ed è diventato pubblicamente disponibile nell'estate del 1991 per il resto di noi. Il CERN e Berners-Lee hanno fornito le specifiche per HTML, HTTP e URL, nella vecchia e raffinata tradizione di condivisione e divertimento in Internet.

Berners-Lee ha definito l'HTML in SGML, lo Standard Generalized Markup Language. SGML, come XML, è un metalinguaggio, un linguaggio utilizzato per definire altri linguaggi. Ciascun linguaggio così definito è chiamato un'applicazione di SGML. HTML è un'applicazione di SGML.

SGML è emerso da una ricerca condotta principalmente presso IBM sulla rappresentazione di documenti di testo alla fine degli anni '60. IBM creò GML ("General Markup Language"), un linguaggio predecessore di SGML, e nel 1978 l'American National Standards Institute (ANSI) creò la sua prima versione di SGML. Il primo standard è stato rilasciato nel 1983, con il progetto di standard rilasciato nel 1985, e il primo standard è stato pubblicato nel 1986. È interessante notare che il primo standard SGML è stato pubblicato utilizzando un sistema SGML sviluppato da Anders Berglund al CERN, l'organizzazione che, come abbiamo visto, ci ha fornito HTML e il Web.

SGML è ampiamente utilizzato in grandi industrie e governi come nelle grandi società aerospaziali, automobilistiche e di telecomunicazioni. SGML è utilizzato come documento standard presso il Dipartimento della Difesa degli Stati Uniti e l'Internal Revenue Service. (Per i lettori al di fuori degli Stati Uniti, l'IRS è il fisco.)

Albert Einstein ha detto che tutto dovrebbe essere reso il più semplice possibile e non più semplice. Il motivo per cui SGML non si trova in più posti è che è estremamente sofisticato e complesso. E l'HTML, che puoi trovare ovunque, è molto semplice; per molte applicazioni è troppo semplice.

HTML: tutta la forma e nessuna sostanza

HTML è un linguaggio progettato per "parlare di" documenti: intestazioni, titoli, didascalie, caratteri e così via. È fortemente orientato alla struttura del documento e alla presentazione.

Certo, artisti e hacker sono stati in grado di fare miracoli con lo strumento relativamente noioso chiamato HTML. Ma l'HTML presenta seri inconvenienti che lo rendono poco adatto alla progettazione di sistemi informativi flessibili, potenti ed evolutivi. Ecco alcune delle principali lamentele:

  • HTML non è estensibile

    Un linguaggio di markup estensibile consentirebbe agli sviluppatori di applicazioni di definire tag personalizzati per situazioni specifiche dell'applicazione. A meno che tu non sia un gorilla di 600 libbre (e forse nemmeno allora) non puoi richiedere a tutti i produttori di browser di implementare tutti i tag di markup necessari per la tua applicazione. Quindi, sei bloccato con ciò che i grandi produttori di browser o il W3C (World Wide Web Consortium) ti permetteranno di avere. Ciò di cui abbiamo bisogno è un linguaggio che ci consenta di creare i nostri tag di markup senza dover chiamare il produttore del browser.

  • L'HTML è molto incentrato sulla visualizzazione

    L'HTML è un ottimo linguaggio per scopi di visualizzazione, a meno che tu non richieda una formattazione precisa o un controllo di trasformazione (nel qual caso fa schifo). HTML rappresenta una combinazione di struttura logica del documento (titoli, paragrafi e simili) con tag di presentazione (grassetto, allineamento immagine e così via). Poiché quasi tutti i tag HTML hanno a che fare con la modalità di visualizzazione delle informazioni in un browser, l'HTML è inutile per altre applicazioni di rete comuni, come la replica dei dati oi servizi applicativi. Abbiamo bisogno di un modo per unificare queste funzioni comuni con la visualizzazione, in modo che lo stesso server utilizzato per esplorare i dati possa anche, ad esempio, eseguire funzioni aziendali aziendali e interagire con i sistemi legacy.

  • L'HTML di solito non è riutilizzabile direttamente

    La creazione di documenti in elaboratori di testi e quindi l'esportazione come HTML è in qualche modo automatizzata, ma richiede comunque, per lo meno, alcune modifiche all'output per ottenere risultati accettabili. Se i dati da cui è stato prodotto il documento cambiano, l'intera traduzione HTML deve essere rifatta. I siti Web che mostrano le condizioni meteorologiche attuali in tutto il mondo, 24 ore su 24, di solito gestiscono molto bene questa riformattazione automatica. Il contenuto e lo stile di presentazione del documento sono separati, poiché i progettisti del sistema comprendono che il loro contenuto (le temperature, le previsioni e così via) cambia costantemente. Ciò di cui abbiamo bisogno è un modo per specificare la presentazione dei dati in termini di struttura, in modo che quando i dati vengono aggiornati, la formattazione possa essere "riapplicata" in modo coerente e semplice.

  • HTML only provides one 'view' of data

    It's difficult to write HTML that displays the same data in different ways based on user requests. Dynamic HTML is a start, but it requires an enormous amount of scripting and isn't a general solution to this problem. (Dynamic HTML is discussed in more detail below.) What we need is a way to get all the information we may want to browse at once, and look at it in various ways on the client.

  • HTML has little or no semantic structure

    Most Web applications would benefit from an ability to represent data by meaning rather than by layout. For example, it can be very difficult to find what you're looking for on the Internet, because there's no indication of the meaning of the data in HTML files (aside from META tags, which are usually misleading). Type

    red

    into a search engine, and you'll get links to Red Skelton, red herring, red snapper, the red scare, Red Letter Day, and probably a page or two of "Books I've Red." HTML has no way to specify what a particular page item means. A more useful markup language would represent information in terms of its meaning. What we need is a language that tells us not how to

    display

    information, but rather, what a given block of information

    is

    so we know what to do with it.

SGML has none of these weaknesses, but in order to be general, it's hair-tearingly complex (at least in its complete form). The language used to format SGML (its "style language"), called DSSSL (Document Style Semantics and Specification Language), is extremely powerful but difficult to use. How do we get a language that's roughly as easy to use as HTML but has most of the power of SGML?

Origins of XML

As the Web exploded in popularity and people all over the world began learning about HTML, they fairly quickly started running into the limitations outlined above. Heavy-metal SGML wonks, who had been working with SGML for years in relative obscurity, suddenly found that everyday people had some understanding of the concept of markup (that is, HTML). SGML experts began to consider the possibility of using SGML on the Web directly, instead of using just one application of it (again, HTML). At the same time, they knew that SGML, while powerful, was simply too complex for most people to use.

In the summer of 1996, Jon Bosak (currently online information technology architect at Sun Microsystems) convinced the W3C to let him form a committee on using SGML on the Web. He created a high-powered team of muckety-mucks from the SGML world. By November of that year, these folks had created the beginnings of a simplified form of SGML that incorporated tried-and-true features of SGML but with reduced complexity. This was, and is, XML.

In March 1997, Bosak released his landmark paper, "XML, Java and the Future of the Web" (see Resources). Now, two years later (a very long time in the life of the Web), Bosak's short paper is still a good, if dated, introduction to why using XML is such an excellent idea.

SGML was created for general document structuring, and HTML was created as an application of SGML for Web documents. XML is a simplification of SGML for general Web use.

An XML conceptual example

All this talk of "inventing your own tags" is pretty foggy: What kind of tags would a developer want to invent and how would the resulting XML be used? In this section, we'll go over an example that compares and contrasts information representation in HTML and XML. In a later section ("XSL: I like your style") we'll go over XML display.

First, we'll take an example of a recipe, and display it as one possible HTML document. Then, we'll redo the example in XML and discuss what that buys us.

HTML example

Take a look at the little chunk of HTML in Listing 1:

   Lime Jello Marshmallow Cottage Cheese Surprise   

Lime Jello Marshmallow Cottage Cheese Surprise

My grandma's favorite (may she rest in peace).

Ingredients

Qty Units Item
1 box lime gelatin
500 g multicolored tiny marshmallows
500 ml cottage cheese
dash Tabasco sauce (optional)

Instructions

  1. Prepare lime gelatin according to package instructions...

Listing 1. Some HTML

(A printable version of this listing can be found at example.html.)

Looking at the HTML code in Listing 1, it's probably clear to just about anyone that this is a recipe for something (something awful, but a recipe nonetheless). In a browser, our HTML produces something like this:

Lime Jello Marshmallow Cottage Cheese Surprise

My grandma's favorite (may she rest in peace).

Ingredients

Qty Units Item
1 box lime gelatin
500 g multicolored tiny marshmallows
500 ml Cottage cheese
  dash Tabasco sauce (optional)

Instructions

  1. Prepare lime gelatin according to package instructions...

Listing 2. What the HTML in Listing 1 looks like in a browser

Now, there are a number of advantages to representing this recipe in HTML, as follows:

  • It's fairly readable. The markup may be a little cryptic, but if it's laid out properly it's pretty easy to follow.

  • The HTML can be displayed by just about any HTML browser, even one without graphics capability. That's an important point: The display is browser-independent. If there were a photo of the results of making this recipe (and one certainly hopes there isn't), it would show up in a graphical browser but not in a text browser.

  • You could use a cascading style sheet (CSS -- we'll talk a bit about those below) for general control over formatting.

There's one major problem with HTML as a data format, however. The meaning of the various pieces of data in the document is lost. It's really hard to take general HTML and figure out what the data in the HTML mean. The fact that there's an of this recipe with a (quantity) of 500 ml () of cottage cheese would be very hard to extract from this document in a way that's generally meaningful.

Now, the idea of data in an HTML document meaning something may be a bit hard to grasp. Web pages are fine for the human reader, but if a program is going to process a document, it requires unambiguous definitions of what the tags mean. For instance, the tag in an HTML document encloses the title of the document. That's what the tag means, and it doesn't mean anything else. Similarly, an HTML tag means "table row," but that's of little use if your program is trying to read recipes in order to, say, create a shopping list. How could a program find a list of ingredients from a Web page formatted in HTML?

Sure, you could write a program that grabs the headers out of the document, reads the table column headers, figures out the quantities and units of each ingredient, and so on. The problem is, everyone formats recipes differently. What if you're trying to get this information from, say, the Julia Childs Web site, and she keeps messing around with the formatting? If Julia changes the order of the columns or stops using tables, she'll break your program! (Though it has to be said: If Julia starts publishing recipes like this, she may want to think about changing careers.)

Now, imagine that this recipe page came from data in a database and you'd like to be able to ship this data around. Maybe you'd like to add it to your huge recipe database at home, where you can search and use it however you like. Unfortunately, your input is HTML, so you'll need a program that can read this HTML, figure out what all the "Ingredients," "Instructions," "Units," and so forth are, and then import them to your database. That's a lot of work. Especially since all of that semantic information -- again, the meaning of the data -- existed in that original database but were obscured in the process of being transformed into HTML.

Now, imagine you could invent your own custom language for describing recipes. Instead of describing how the recipe was to be displayed, you'd describe the information structure in the recipe: how each piece of information would relate to the other pieces.

XML example

Let's just make up a markup language for describing recipes, and rewrite our recipe in that language, as in Listing 3.

  Lime Jello Marshmallow Cottage Cheese Surprise  My grandma's favorite (may she rest in peace).    1 lime gelatin   500 multicolored tiny marshmallows   500 Cottage cheese    Tabasco sauce     Prepare lime gelatin according to package instructions     

Listing 3. A custom markup language for recipes

It will come as little surprise to you, being the astute reader you are, that this recipe in its new format is actually an XML document. Maybe the fact that the file started with the odd header


  

gave it away; in fact, every XML file should begin with this header. We've simply invented markup tags that have a particular meaning; for example, "An is a (quantity in specified units) of a single , which is possibly optional." Our XML document describes the information in the recipe in terms of recipes, instead of in terms of how to display the recipe (as in HTML). The semantics, or meaning of the information, is maintained in XML because that's what the tag set was designed to do.

Notes on notation

It's important to get some nomenclature straight. In Figure 1, you see a start tag, which begins an enclosed area of text, known as an Item, according to the tag name. As in HTML, XML tags may include a list of attributes (consisting of an attribute name and an attribute value.) The Item defined by the tag ends with the end tag.

Not every tag encloses text. In HTML, the

tag means "line break" and contains no text. In XML, such elements aren't allowed. Instead, XML has empty tags, denoted by a slash before the final right-angle bracket in the tag. Figure 2 shows an empty tag from our XML recipe. Note that empty tags may have attributes. This empty tag example is standard XML shorthand for .

In addition to these notational differences from HTML, the structural rules of XML are more strict. Every XML document must be well-formed. What does that mean? Read on!

Ooh-la-la! Well-formed XML

The concept of well-formedness comes from mathematics: It's possible to write mathematical expressions that don't mean anything. For example, the expression

2 ( + + 5 (=) 9 > 7

looks (sort of) like math, but it isn't math because it doesn't follow the notational and structural rules for a mathematical expression (not on this planet, at least). In other words, the "expression" above isn't well-formed. Mathematical expressions must be well-formed before you can do anything useful with them, because expressions that aren't well-formed are meaningless.

A well-formed XML document is simply one that follows all of the notational and structural rules for XML. Programs that intend to process XML should reject any input XML that doesn't follow the rules for being well-formed. The most important of these rules are as follows:

  • No unclosed tags

    You can get away with all kinds of wacko stuff in HTML. For example, in most HTML browsers, you can "open" a list item with

  • and never "close" it with
  • . The browser just figures out where the would be and automatically inserts it for you. XML doesn't allow this kind of sloppiness. Every start tag must have a corresponding end tag. This is because part of the information in an XML file has to do with how different elements of information relate to one another, and if the structure is ambiguous, so is the information. So, XML simply doesn't allow ambiguous structure. This nonambiguous structure also allows XML documents to be processed as data structures (trees), as I'll explain shortly in the discussion of the Document Object Model.

  • No overlapping tags

    A tag that opens inside another tag must close before the containing tag closes. For example, the sequence

    Let's call the whole thing off

    isn't well-formed because opens inside of but doesn't close inside of . The correct sequence must be

    Let's call the whole thing off

    In other words, the structure of the document must be strictly hierarchical.

  • Attribute values must be enclosed in quotes

    Unlike HTML, XML doesn't allow "naked" attribute values (i.e., HTML tags like

    , where there are no quotes around the attribute value). Every attribute value must have quotes (

  • The text characters (), and (") must always be represented by 'character entities'

    To represent these three characters (left-angle bracket, right-angle bracket, and double quotes) in the text part of the XML (not in the markup), you must use the special character entities (

    <

    ), (

    >

    ), and (

    "

    ), respectively. These characters are special characters for XML. An XML file using, say, the double quote character in the text enclosed in tags in an XML file isn't well-formed, and correctly designed XML parsers will produce an error for such input.

  • 'Well-formed' means 'parsable'

    A generic XML parser is a program or class that can read any well-formed XML at its input. Many vendors now offer XML parsers in Java for free; (you'll find links to these packages in Resources at the bottom of this article). XML parsers recognize well-formed documents and produce error messages (much like a compiler would) when they receive input that isn't well-formed. As we'll see, this functionality is very handy for the programmer: You simply call the parser you've selected and it takes care of the error detection and so on. While all XML parsers check the well-formedness of documents (meaning, as we've seen, that all the tags make sense, are nested properly, and so on), validating XML parsers go one step further. Validating parsers also confirm whether the document is valid; that is, that the structure and number of tags make sense.

    For example, most browsers will display a document that (nonsensically) has two elements, but how can this be? Only one title or no title makes sense.

    For another example, imagine that in Listing 3 the "cottage cheese" ingredient looked like this:

      500 9 Cottage cheese  

    This XML document is certainly well-formed, but it doesn't make sense. It isn't structurally valid. It is nonsense for a to contain a <Qty>. What's the of this ?

    The problem is, we have a document that's well-formed, but it isn't very useful because the XML doesn't make sense. We need a way to specify what makes an XML document valid. For example, how can we specify that a tag may contain only text (and not any other elements) and report as errors any other case?

    The answer to this question lies in something called the document type definition, which we'll look at next.





    ). #####