Il Web 2.0 - MokaByte n. 122

Introduzione a RSS, il formato standard per la distribuzione di contenuti web basato su XML. L'articolo copre le diverse versioni di RSS (RDF Site Summary, Rich Site Summary, Really Simple Syndication), il formato Atom, e presenta un esempio pratico di generazione di feed RSS con la libreria ROME per monitorare aggiornamenti su wiki XWiki.

Introduzione

Nello scorso articolo si è parlato in generale di Web 2.0, si è parlato poi del Wiki come un importante strumento Web 2.0 introducendo poi le tecnologie Web 2.0 come Ajax. In questo articolo ci concentreremo su RSS.

Cos'è RSS

RSS è un'applicazione XML, introdotta originariamente da Netscape nel tentativo di agevolare la distribuzione di contenuti attraverso il web (ottimizzando tempi e risorse). RSS è uno dei più popolari formati (in pratica rappresenta lo standard de facto) per la distribuzione di contenuti Web ed è basato su XML.

La continua produzione e revisione di informazioni recuperabili in Internet comporta un aumento dei tempi di consultazione, si pensi, ad esempio, alla necessità che un utente ha di verificare la presenza di aggiornamenti e/o informazioni nei vari siti di interesse. Collegarsi al sito, attenderne l'apertura, navigarlo alla ricerca delle novità nella speranza che nel frattempo non sia cambiata l'interfaccia utente, che non subentrino problemi di connessione, etc. Queste operazioni possono essere risparmiate in presenza di uno strumento (aggregatore) che ci avvisa automaticamente della presenza di nuovi contenuti da più fonti.

RSS è un formato standard per l'esportazione di contenuti e rappresenta il linguaggio di comunicazione tra la fonte e l'aggregatore.

Le sue successive variazioni sono state adottate progressivamente dalla comunità dei "blogger" per il post o il recupero dei blog. La popolarità dei blog è forse una delle ragioni principali del successo di RSS: migliaia di Weblog iniziarono a produrre contenuti in RSS e iniziarono a proliferare siti che raccoglievano una selezione di post dai blog più seguiti (i cosiddetti blog aggregator) e programmi per fruire i contenuti di un blog direttamente sul proprio desktop o su altri dispositivi (RSS reader).

È molto interessante notare come, durante la sua evoluzione, l'acronimo RSS abbia assunto ben tre diversi significati. Li analizziamo qui di seguito.

RSS come RDF Site Summary

Il primo significato assunto dall'RSS è RDF Site Summary: la prima versione ufficialmente denominata RSS era in realtà una semplificazione di una struttura basata sulle specifiche RDF. Struttura in seguito ripresa e attualmente mantenuta nel formato RSS 1.0. Parlando di RDF Site Summary si fa riferimento all'RSS 0.9 o alla sua naturale evoluzione sviluppata dall'RSS-DEV Working Group secondo le specifiche RDF. Di seguito si riporta un esempio RSS 1.0:

<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
  xmlns="http://purl.org/rss/1.0/"
  xmlns:content="http://purl.org/rss/1.0/modules/content/"
  xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/"
  xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
  xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel rdf:about="http://www.mokabyte.it/">
    <title>Il Web 2.0</title>
    <link>http://www.mokabyte.it/</link>
    <description>RSS per controllare le uscite dei numeri relativi all'argomento Web 2.0</description>
    <items>
      <rdf:Seq>
        <rdf:li resource="http://www.mokabyte.it/wiki" />
        <rdf:li resource="http://www.mokabyte.it/Ajax" />
        <rdf:li resource="http://www.mokabyte.it/RSS" />
      </rdf:Seq>
    </items>
    <dc:creator>Alessandro Rocca</dc:creator>
    <dc:language>IT</dc:language>
  </channel>
  <item rdf:about="http://www.mokabyte.it/wiki">
    <title>II parte: Wiki</title>
    <link>http://www.mokabyte.it/wiki</link>
    <description>Articolo sullo strumento Wiki</description>
  </item>
  <item rdf:about="http://www.mokabyte.it/Ajax">
    <title>III parte: Ajax</title>
    <link>http://www.mokabyte.it/Ajax</link>
    <description>Articolo sulle tecniche Ajax</description>
  </item>
  <item rdf:about="http://www.mokabyte.it/RSS">
    <title>IV parte: RSS</title>
    <link>http://www.mokabyte.it/RSS</link>
    <description>Articolo sulle specifiche RSS</description>
  </item>
</rdf:RDF>

RSS come Rich Site Summary

Il secondo significato è Rich Site Summary. Questo termine fu introdotto con la versione RSS 0.91 sviluppata da Netscape. Di seguito un esempio:

<?xml version="1.0" encoding="UTF-8"?>
<rss xmlns:content="http://purl.org/rss/1.0/modules/content/" version="0.91">
  <channel>
    <title>Il Web 2.0</title>
    <link>http://www.mokabyte.it/</link>
    <description>RSS per controllare le uscite dei numeri relativi all'argomento Web 2.0</description>
    <language>IT</language>
    <item>
      <title>II parte: Wiki</title>
      <link>http://www.mokabyte.it/wiki</link>
      <description>Articolo sullo strumento Wiki</description>
    </item>
    <item>
      <title>III parte: Ajax</title>
      <link>http://www.mokabyte.it/Ajax</link>
      <description>Articolo sulle tecniche Ajax</description>
    </item>
    <item>
      <title>IV parte: RSS</title>
      <link>http://www.mokabyte.it/RSS</link>
      <description>Articolo sulle specifiche RSS</description>
    </item>
  </channel>
</rss>

RSS come Really Simple Syndication

Il terzo significato è Really Simple Syndication, introdotto con RSS 2.0. Questa versione è la più diffusa oggi. Esempio:

<?xml version="1.0" encoding="UTF-8"?> <rss xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" version="2.0"> <channel> <title>Il Web 2.0</title> <link>http://www.mokabyte.it/</link> <description>RSS per controllare le uscite dei numeri relativi all'argomento Web 2.0</description> <language>IT</language> <dc:creator>Alessandro Rocca</dc:creator> <dc:language>IT</dc:language> <item> <title>II parte: Wiki</title> <link>http://www.mokabyte.it/wiki</link> <description>Articolo sullo strumento Wiki</description> <guid>http://www.mokabyte.it/wiki</guid> </item> <item> <title>III parte: Ajax</title> <link>http://www.mokabyte.it/Ajax</link> <description>Articolo sulle tecniche Ajax</description> <guid>http://www.mokabyte.it/Ajax</guid> </item> <item> <title>IV parte: RSS</title> <link>http://www.mokabyte.it/RSS</link> <description>Articolo sulle specifiche RSS</description> <guid>http://www.mokabyte.it/RSS</guid> </item> </channel> </rss>

## Atom

Atom è un formato alternativo a RSS, sviluppato come standard IETF. Esempio:

<?xml version="1.0" encoding="UTF-8"?> <feed xmlns="http://www.w3.org/2005/Atom" xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:sy="http://purl.org/rss/1.0/modules/syndication/" xmlns:dc="http://purl.org/dc/elements/1.1/"> <title>Il Web 2.0</title> <link rel="alternate" href="http://www.mokabyte.it/" /> <subtitle>RSS per controllare le uscite dei numeri relativi all'argomento Web 2.0</subtitle> <dc:creator>Alessandro Rocca</dc:creator> <dc:language>IT</dc:language> <entry> <title>II parte: Wiki</title> <link rel="alternate" href="http://www.mokabyte.it/wiki" /> <author> <name /> </author> <summary type="TEXT">Articolo sullo strumento Wiki</summary> </entry> <entry> <title>III parte: Ajax</title> <link rel="alternate" href="http://www.mokabyte.it/Ajax" /> <author> <name /> </author> <summary type="TEXT">Articolo sulle tecniche Ajax</summary> </entry> <entry> <title>IV parte: RSS</title> <link rel="alternate" href="http://www.mokabyte.it/RSS" /> <author> <name /> </author> <summary type="TEXT">Articolo sulle specifiche RSS</summary> </entry> </feed>

## Includere un feed RSS in una pagina HTML

Per aggiungere un feed RSS a una pagina HTML si utilizza il tag link nell'head:

## ROME: libreria Java per RSS e Atom

ROME è una libreria Java open source per la lettura e scrittura di feed RSS e Atom. Vediamo un esempio di creazione di un feed:

SyndFeed feed = new SyndFeedImpl(); feed.setFeedType(feedType); feed.setTitle("Sample Feed (created with Rome)"); feed.setLink("http://rome.dev.java.net"); feed.setDescription("This feed has been created using Rome (Java syndication utilities)");

Creazione di una entry (item):

entry = new SyndEntryImpl(); entry.setTitle("Rome v1.0"); entry.setLink("http://wiki.java.net/bin/view/Javawsxml/Rome01"); entry.setPublishedDate(DATE_PARSER.parse("2004-06-08"));

description = new SyndContentImpl(); description.setType("text/plain"); description.setValue("Initial release of Rome"); entry.setDescription(description); entries.add(entry);

// Altra entry entry = new SyndEntryImpl(); entry.setTitle("Rome v3.0"); entry.setLink("http://wiki.java.net/bin/view/Javawsxml/Rome03"); entry.setPublishedDate(DATE_PARSER.parse("2004-07-27"));

description = new SyndContentImpl(); description.setType("text/html"); description.setValue("<p>More Bug fixes, more API changes, some new features and some Unit testing</p>" + "<p>For details check the <a href=\"http://wiki.java.net/bin/view/Javawsxml/RomeChangesLog#RomeV03\">Changes Log</a></p>"); entry.setDescription(description); entries.add(entry);

feed.setEntries(entries);

Per scrivere il feed su file:

SyndFeed feed = ...; Writer writer = ...; SyndFeedOutput output = new SyndFeedOutput(); output.output(feed, writer);

## Esempio pratico: monitoraggio wiki con RSS

Vediamo ora un esempio pratico di utilizzo di RSS per monitorare le modifiche su pagine wiki XWiki. L'URL per visualizzare lo storico di una pagina è:

http://localhost:8080/xwiki/bin/view/

<<PAGE>>

?viewer=history&language=it

http://localhost:8080/xwiki/bin/view/<<PAGE>>?viewer=history&language=it

Configuriamo un file properties con gli URL delle pagine da monitorare:

Project1=http://<web server URL>/xwiki/bin/view/Offshore/Project1?viewer=history&language=it Project2=http://<web server URL>/xwiki/bin/view/Offshore/Project2?viewer=history&language=it Project3=http://<web server URL>/xwiki/bin/view/Offshore/Project3?viewer=history&language=it

Carichiamo il file properties:

Properties p = Configurator.loadPropertiesFile(pathUrlFile);

Iteriamo sugli URL e invochiamo ciascuno:

Collection c = p.values(); Iterator iter = c.iterator();

while(iter.hasNext()) { String historyWikiUrl = (String)iter.next(); System.out.println("==>" + historyWikiUrl); String response = UrlInvoker.invokeUrl(historyWikiUrl); // Analisi della risposta... }

Definiamo una classe per memorizzare l'ultima versione:

public class LastWikiUrlVersion { private String version = null; private String author = null; private String date = null; private String link = null; // getter e setter... }

Verifichiamo se ci sono aggiornamenti e generiamo l'RSS:

boolean res = this.checkIfUpdated(historyWikiUrl, lwuv); if(res) { // aggiorno l'RSS this.createRSS(rssFileName, pageModified); }

Il metodo per creare l'RSS:

private void createRSS(String fileName, List objectList) { SimpleDateFormat DATEPARSER = new SimpleDateFormat("yyyy/MM/dd HH:mm"); String feedType = "rss2.0";

SyndFeed feed = new SyndFeedImpl(); feed.setFeedType(feedType); feed.setTitle("RSS xWiki changes (created with ROME) - created at: " + new java.util.Date()); feed.setLink("http://rome.dev.java.net"); feed.setDescription("RSS to monitor xWiki project pages changing - created on " + new java.util.Date()); feed.setAuthor("A. Rocca, S. Rossini");

Iterator iter = objectList.iterator(); List entries = new ArrayList(); SyndEntry entry; SyndContent description;

// Creazione degli item (uno per ogni url di history consultato) while(iter.hasNext()) { LastWikiUrlVersion lwuv = (LastWikiUrlVersion)iter.next(); entry = new SyndEntryImpl(); description = new SyndContentImpl();

if (lwuv.isModified()) { entry.setTitle("NEW version " + lwuv.getVersion() + " of project " + lwuv.getTitle() + " is available"); description.setValue("Version changed since " + lwuv.getDate()); } else { entry.setTitle("OLD version " + lwuv.getVersion() + " of project " + lwuv.getTitle() + " is available"); description.setValue("Version is not changed since " + lwuv.getDate()); }

entry.setLink(lwuv.getLink()); try { entry.setPublishedDate(DATE_PARSER.parse(lwuv.getDate())); } catch (ParseException pe) { pe.printStackTrace(); System.out.println("ERROR: " + pe.getMessage()); }

description.setType("text/plain"); entry.setDescription(description); entries.add(entry); }

feed.setEntries(entries); // Scrittura su file... }

Scrittura del feed su file:

try { writer = new FileWriter(fileName); SyndFeedOutput output = new SyndFeedOutput(); output.output(feed, writer); writer.flush(); writer.close(); } catch (IOException ioe) { ioe.printStackTrace(); System.out.println("ERROR: " + ioe.getMessage()); } catch (FeedException fe) { fe.printStackTrace(); System.out.println("ERROR: " + fe.getMessage()); }

## Visualizzare il feed in XWiki

Per visualizzare il feed RSS generato all'interno di una pagina XWiki si può utilizzare la macro RSS:

{rss:feed=http://

<<server_name>>

:8080/xwiki/myfeed.rss}

{rss:feed=http://<<server_name>>:8080/xwiki/myfeed.rss}

## Conclusioni

RSS rappresenta uno strumento fondamentale per la distribuzione e l'aggregazione di contenuti nel Web 2.0. La libreria ROME semplifica notevolmente la generazione e il parsing di feed RSS e Atom in Java, rendendo possibile l'integrazione di funzionalità di syndication in applicazioni web moderne. L'esempio pratico mostrato dimostra come sia possibile creare sistemi di monitoraggio automatizzati che notificano gli utenti di aggiornamenti tramite feed RSS.