RSS è un‘applicazione per 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 ed è basato su XML.
Introduzione
Nello scorso articolo si è parlato in generale di Web 2.0 [MOKAWEB2_I], si è parlato poi del Wiki come un‘importante strumento Web 2.0 [MOKAWEB2_II] introducendo poi le tecnologie Web 2.0 come Ajax [MOKAWEB2_III].
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).
Figura 1 – Stack RSS
È 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 [RSS-1.0].
Parlando di RDF Site Summary si fa riferimento all‘RSS 0.9 [RSS-0.9] o alla sua naturale evoluzione sviluppata dall‘RSS-DEV Working Group secondo le specifiche RDF [W3CRDF]. Di seguito si riporta un esempio 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/">
Il Web 2.0
https://www.mokabyte.it/
RSS che controlla le uscite sull‘argomento Web 2.0
Alessandro Rocca
IT
II parte: Wiki
https://www.mokabyte.it/wiki
Articolo sullo strumento Wiki
III parte: Ajax
https://www.mokabyte.it/Ajax
Articolo sulle tecniche Ajax
IV parte: RSS
https://www.mokabyte.it/RSS
Articolo sulle specifiche RSS
RSS come Rich Site Summary
Per contrastare la complessità derivante dall‘uso dell‘RDF, Dave Winer rilasciò il 10 luglio del 1999 una nuova versione di RSS. Si trattava dell‘RSS 0.91 [RSS-0.91], una versione semplificata delle specifiche 0.9 e soprattutto arricchita di nuovi tag.
Dal momento che l‘RSS 0.91 presentava una struttura completamente priva di qualsiasi riferimento all‘RDF, Dave Winer decise di rimuovere i riferimenti a RDF e di dare un nuovo nome a questo formato chiamandolo appunto Rich Site Summary.
Di seguito si riporta un esempio RSS 0.91:
Il Web 2.0
https://www.mokabyte.it/
RSS che controlla le uscite sull‘argomento Web 2.0
IT
II parte: Wiki
https://www.mokabyte.it/wiki
Articolo sullo strumento Wiki
III parte: Ajax
https://www.mokabyte.it/Ajax
Articolo sulle tecniche Ajax
IV parte: RSS
https://www.mokabyte.it/RSS
Articolo sulle specifiche RSS
RSS come Really Simple Syndication
Questo significato si riferisce all‘ultimo dei formati RSS pubblicati, ovvero l‘RSS 2.0 [RSS-2.0] rilasciato nuovamente da Dave Winer. Questo termine (“syndication” proviene dal gergo giornalistico e dei media, e si riferiva inizialmente alla distribuzione coordinata di informazione da parte di catene di quotidiani) è stato coniato per sottolineare la semplicità d‘uso che contraddistingue questa versione, in contrasto con la precedente 1.0 rilasciata qualche mese prima dall‘RSS-DEV Working Group.
Di seguito si riporta un esempio RSS 2.0:
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">
Il Web 2.0
https://www.mokabyte.it/
RSS che controlla le uscite sull‘argomento Web 2.0
IT
Alessandro Rocca
IT
II parte: Wiki
https://www.mokabyte.it/wiki
Articolo sullo strumento Wiki
https://www.mokabyte.it/wiki
III parte: Ajax
https://www.mokabyte.it/Ajax
Articolo sulle tecniche Ajax
https://www.mokabyte.it/Ajax
IV parte: RSS
https://www.mokabyte.it/RSS
Articolo sulle specifiche RSS
https://www.mokabyte.it/RSS
Mentre con i primi due acronimi ci si riferisce al sommario di una singola fonte di informazioni, con il terzo si vuole puntare a dare una visione più globale di raccolta delle informazioni, introducendo il concetto di “canale” (syndication) attraverso il quale accedere al flusso (feed) di news proprio come si farebbe con una radio o una TV.
Nonostante le differenti implementazioni delle diverse versioni, i documenti RSS condividono tutti la stessa struttura di base, che prevede:
- un elemento
, che contiene le informazioni sulla fonte dei contenuti (nel caso di un quotidiano online potrebbe contenere il nome della testata, la data di pubblicazione, informazioni sul copyright, etc.); - una serie di elementi
- , ognuno dei quali corrisponde ad un singolo elemento di contenuto (p.e. l‘articolo di un giornale) e ne presenta tutte le informazioni (titolo, testo completo, nome dell‘autore, ecc.).
Dei vari formati esistenti, la versione 2.0, per la sua semplicità di utilizzo, è attualmente il formato RSS più diffuso.
ATOM
Atom, come i vari formati RSS, è un implementazione XML per la sottoscrizione di contenuti web, come blog o testate giornalistiche. È basato sull‘esperienza delle varie versioni del protocollo lanciato da Netscape, RSS. La specifica completata di Atom è stata presentata, nel giugno 2005, alla IETF per l‘approvazione: l‘ultimo passo per diventare uno standard internet RFC. Benchè la diffusione del formato RSS 2.0 sia nettamente superiore anche sul piano dello sviluppo rispetto ad Atom, la versione 1.0 di quest ultimo si sta affermando come standard nonchà© potenziale antagonista di RSS 2.0
Di seguito si riporta un esempio Atom 1.0:
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/">
Il Web 2.0
RSS che controlla le uscite sull‘argomento Web 2.0
Alessandro Rocca
IT
II parte: Wiki
Articolo sullo strumento Wiki
III parte: Ajax
Articolo sulle tecniche Ajax
IV parte: RSS
Articolo sulle specifiche RSS
Modalità di fruizione di un RSS
I flussi (feed) Rss rappresentano dunque il metodo ideale per la notifica degli aggiornamenti dei contenuti, soprattutto in presenza di più fonti/canali (syndication).
Mentre una volta (il cosidetto Web 1.0) questa funzionalità veniva fatta “a mano” aggiungendo tutti gli indirizzi di interesse tra i preferiti per poi navigarli periodicamente, ora (Web 2.0) il tutto viene fatto “in automatico”.
Un feed reader è un programma in grado di effettuare il download di un feed RSS (è sufficiente che l‘utente indichi al programma l‘URL del feed), effettuarne il parsing e visualizzarne i contenuti in base alle preferenze dell‘utente.
Spesso i feed reader sono dotati di funzionalità avanzate; ad esempio sono in grado di rilevare automaticamente se il produttore del feed ha effettuato aggiornamenti al feed stesso, effettuandone il download a intervalli di tempo regolari. In questo modo l‘utente può essere informato quasi in tempo reale quando un sito è stato aggiornato. [WPRSS]
Un generico feed RSS, proveniente da un sito, può essere facilmente importato da un altro sito Web, per incorporarne i contenuti all‘interno delle proprie pagine. Questa modalità di fruizione è possibile mediante un web aggregator.
In seguito all‘aumento di popolarità del formato RSS e alla sua standardizzazione, sono nati diversi servizi online che fungono da web aggregator.
Il vantaggio per l‘utente è notevole, poiché ha la possibilità di accedere a tutte le notizie attraverso un unico sito Web (web aggregator), evitando dunque di dover visitare, uno per uno, i siti da cui provengono le notizie stesse (magari solo per scoprire che non ci sono stati aggiornamenti dopo la sua ultima visita).
Tali aggregatori vengono distinti in base alla modalità con cui si accede al feed. Le due categorie standard di aggregatori sono i web aggregator (o online aggregator) accessibili via web e i desktop aggregator, applicazioni stand alone che risiedono sulla macchina dell‘utente. L‘obiettivo di entrambi è quello di fornire un unico punto d‘accesso a notizie provenienti da varie fonti.
Esempi di web aggregator sono OKNotizie [OKNotizie], Digg [Digg], Bloglines [Bloglines] per la promozione di propri contenuti Bloglines.
Figura 2 – Esempio di web aggregator: OKNotizie di Alice
Un esempio di feed reader stand alone è FeedReader, programma free (distribuito con licenza GNU GPL) per piattaforme Microsoft Windows [MFEEDRD].
Una volta installato, basta avviarlo che subito si ottengono dei feed da tutta la rete potendo successivamente aggiungerne o toglierne a secondo dei propri specifici interessi.
Figura 3 – Esempio di feed reader stand alone
Occorre ricordare che un feed RSS è in formato XML per cui l‘elaborazione da parte di un qualunque aggregatore deve prevedere un‘operazione di parsing, ovvero una scansione del documento che individui i tag e isoli i diversi elementi, per poi convertire i contenuti decodificati nel formato utile all‘obiettivo: ad esempio un feed reader può estrarre i titoli di tutti gli elementi item per visualizzare la lista degli articoli di un giornale online, mentre un aggregatore Web può estrarre i contenuti del feed per convertirli in linguaggio HTML e incorporarli all‘interno delle proprie pagine.
I browser di ultima generazione (Firefox 2.0 e anche Internet Explorer 7.0) incorporano già la funzionalità di Feed Reader. Ad esempio, nella versione 2.0 di Firefox, è presente un aggregatore integrato e il suo segnalibri raccoglie in automatico i feed RSS come se fossero dei link già memorizzati. L‘utente potrà scegliere se salvarli o meno. Una volta connessi ad un sito che offre uno o più canali RSS o Atom, Firefox mostra vicino alla barra degli indirizzi la classica icona di notifica.
Figura 4 – RSS in Firefox
Selezionando l‘icona si viene indirizzati alla nuova pagina intermedia di gestione dei feed, dove è presente una descrizione del canale. A questo punto l‘utente ha la possibilità di iscriversi al feed scegliendo una tra le opzioni disponibili.
Generalmente i browser riconoscono la presenza di feed RSS all‘interno di una pagina nel caso in cui sia stato inserito all‘interno della pagina stessa un tag link così definito:
Figura 5 – Esempio di feed reader di IE 7.0
Alla luce di quanto detto si può evincere quanto sia semplice l‘utilizzo degli RSS considerando anche che sono estensibili e versatili e aggiornabili in tempo reale e quindi consentono ad esempio di metterne in tempi brevissimi i contenuti su un portale o su un weblog. Credo che per il responsabile di un sito (content manager) o per chi si occupa di comunicazione in Rete siano diventati indispensabili proprio per la loro praticità d‘uso e per i molteplici campi di applicazione.
Rome: RSS in Java!
Ci sono diversi prodotti open source che permettono la creazione di RSS. Ad esempio Rome [ROME] è una libreria Java open source(sotto licenza Apache) che permette di gestire i documenti RSS nelle sue verie versioni (2.0, 1.9 e 0.9x) oltre ad Atom.
Rome include un insieme di parser e generatori per i vari formati RSS, oltre a convertitori da un formato all‘altro. Rome si basa su un modello astratto di News Feed o Syndication Feed. Su tale modello si basano le varie operazioni di generazione, lettura e conversione di feed nei vari formati. Tali operazioni si appoggiano su vari componenti quali parser XML SAX e DOM, jdom.
Lo schema seguente mostra le fasi di elaborazione di un feed RSS:
Figura 6 – Funzionamento di Rome [HRW]
Rome rappresenta un feed (RSS ed Atom) come oggetto di tipo com.sun.syndication.synd.SyndFeed. L‘interfaccia SyndFeed e le relative proprietà seguono il modello JavaBean. Le implementazioni di default fornite da Rome sono tutti codici categoria leggeri.
Generare un feed tramite un SyndFeed bean consiste nel‘istanziare tale bean per poi impostarne le proprietà . Il codice seguente mostre un esempio sull‘utilizzo di tale oggetto.
Viene creata un‘istanza di tipo SyndFeed, specificando il tipo di feed (versione RSS o Atom), il titolo, il link e la descrizione:
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");
Viene predisposta la lista delle entry (item).
List entries = new ArrayList();
SyndEntry entry;
SyndContent description;
Vengono create le varie entry, per poi essere inserite nella lista precedente. Per ogni entry vengono specificati il titolo, il link, la data di pubblicazione e la descrizione.
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);
...
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("More Bug fixes, more API changes,
"+
some new features and some Unit testing
"For details check the ="http://wiki.java.net/bin/view/Javawsxml/RomeChangesLog
");
#RomeV03">Changes Log
entry.setDescription(description);
entries.add(entry);
feed.setEntries(entries);
A questo punto l‘oggetto SyndFeed è pronto per essere scritto come documento XML.
Attraverso l‘oggetto SyndFeedOutput, viene creato un output stream da agganciare a un oggetto Writer e procedere alla scrittura del documento XML:
SyndFeed feed = ...;
Writer writer = ...;
SyndFeedOutput output = new SyndFeedOutput();
output.output(feed,writer);
Figura 7 – Esempio di RSS 2.0 generato con le API Rome
Relazione tra RSS e RDF
Come definito all‘inizio dell‘articolo la versione 1.0 di RSS viene riconosciuta come “RDF Site Summary”. Tale versione si basa su RDF, qualsiasi processore RDF può quindi elaborare documenti RSS 1.0. Proprio perché la sua natura deriva da RDF, RSS 1.0 si presta a elaborazioni in ottica web semantico.
Per dimostrare l‘analogia e quindi l‘interscambiabilità in termini di strumenti di elaborazione, si riportano due differenti RSS 1.0 generati con due diversi strumenti. Il primo è Rome, visto precedentemente, il secondo invece è Jena, framework utilizzato per l‘elaborazione di documenti RDF [JENA] e il cui utilizzo è stato riportato negli articoli della serie “web semantico” [MOKA_SEMW_1] [MOKA_SEMW_2].
Figura 8 – API Rome & API Jena
Figura 9 – Analogia RSS 1.0 & RDF
Esempio
Si conclude l‘articolo con un esempio pratico.
In un progetto Offshore (che quindi coinvolgeva due gruppi di lavoro distanti tra loro) a volte venivano modificate le pagine WIKI [Web2_II] senza comunicarlo opportunamente. Magari venivano aggiunte informazioni utili ma che non venivano sfruttate a dovere perché ci si dimenticava di dare evidenza all‘altro team non segnalando l‘aggiornamento mediante il WIKI stesso o e-mail o ICQ.
Per sopperire a tale carenza si è pensato di fare un programma che creasse un Feed RSS aggiornato quotidianamente. Il programma deve monitorare le pagine Wiki d‘interesse per la notifica. Di fatto [XWIKI] deve interrogare l‘URL della relativa Wiki history postfissando all‘URL di interesse
?viewer=history&language=it.
ottenendo quindi, per esempio
http://localhost:8080/xwiki/bin/view/<>?viewer=history
Gli URL del Wiki d‘interesse devono essere opportunamente configurati in un file di properties (url.properties):
Project_1=http:///xwiki/bin/view/Offshore/Project_1?viewer=history&language=it
Project_2=http:///xwiki/bin/view/Offshore/Project_2?viewer=history&language=it
Project_3=http:///xwiki/bin/view/Offshore/Project_3?viewer=history&language=it
Il programma legge il file di properties
Properties p=Configurator.loadPropertiesFile(pathUrlFile);
e per ogni URL configurato procede alla sua invocazione.
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);
Dalla risposta HTTP ottenuta, il programma effettua un parsing Xerces e applica una trasformazione XSLT al fine di ottenere un XML minimale contenente le informazioni relative alla versione più aggiornata, l‘autore, l‘URL e la data del documento.
Dall‘XML, attraverso xStream [xStream], le informazioni vengono incapsulate nel bean di classe LastWikiUrlVersion che mette a disposizione gli opportuni getter e setter:
public class LastWikiUrlVersion {
private String version = null;
private String author = null;
private String date = null;
private String link = null;
Il valore della versione del bean viene comparato con l‘ultima precedentemente ottenuta, se l‘ultima versione del documento indicata nell‘history è più aggiornata rispetto a quella storicizzata, viene creato l‘RSS mediante le API di Rome.
boolean res=this.checkIfUpdated(historyWikiUrl,lwuv);
if(res){
// aggiorno l‘RSS !
this.createRSS(rssFileName, pageModified);
}
dove il metodo createRSS risulta essere:
private void createRSS(String fileName, List objectList) {
...
SimpleDateFormat DATE_PARSER = new SimpleDateFormat("yyyy/MM/dd HH:mm");
// type
String feedType = "rss_2.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 monitorate xWiki project pages changing - created on "
+ new java.util.Date());
feed.setAuthor("A. Rocca, S. Rossini");
Iterator iter=objectList.iterator();
// Per ogni URL configurato ...
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);
// set dell‘item nella lista
entries.add(entry);
}
// aggancio gli item al feed
feed.setEntries(entries);
// scrittura documento RSS
Writer writer;
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());
}
}
Figura 10 – Visione d‘insieme dell‘esempio
L‘RSS così generato viene copiato nella webApp dell‘XWiki. Per visualizzare il contenuto dell‘RSS è sufficiente inserire il tag {rss:feed} nell‘opportuna pagina Web:
{rss:feed=http://<>:8080/xwiki/myfeed.rss}
Conclusioni
Con questo articolo terminiamo questa mini-serie dedicata al Web 2.0. In [MOKAWEB2_I] è stata data una visione introduttiva dei principi e delle tecnologie Web 2.0. In [MOKAWEB2_II] si è parlato del Wiki, un importante strumento Web 2.0. In[MOKAWEB2_III] e in questo articolo si è dato spazio a tecniche e tecnologie adottate in Web 2.0.
Riferimenti
[MOKAWEB2_I] S. Rossini – G. Morello, “Il Web 2.0. I parte: principi e tecnologie, una visione introduttiva”, MokaByte 117, Aprile 2007
[MOKAWEB2_II] S. Rossini, “Il Web 2.0. II parte: WIKI”, MokaByte 118, Maggio 2007
[MOKAWEB2_III] A. Rocca – S. Rossini, “Il Web 2.0. III parte: Ajax”, MokaByte 120, Luglio/Agosto 2007
[MOKA_SEMW_1] A. Rocca – S. Rossini, “Semantic Web. I parte: Introduzione a RDF, principi e Data Model”, MokaByte 119, Giugno 2007
[MOKA_SEMW_1] A. Rocca – S. Rossini, “Semantic Web. II parte: RDFS e vocabolari controllati”, MokaByte 120, Luglio/Agosto 2007
[WPRSS]
http://it.wikipedia.org/wiki/Really_simple_syndication
[MFEEDRD]
http://www.feedreader.com
[ROME]
http://wiki.java.net/bin/view/Javawsxml/Rome
[HRW]
HowRomeWorks
http://wiki.java.net/bin/view/Javawsxml/Rome04HowRomeWorks
[W3CRDF]
http://www.w3.org/RDF
[RSS-1.0]
http://web.resource.org/rss/1.0/
[RSS-2.0]
http://cyber.law.harvard.edu/rss/rss.html
[RSS-0.91]
http://backend.userland.com/rss091
[RSS-0.9]
http://channel.netscape.com/publish/help/quickstart.html
[OKNotizie]
http://oknotizie.alice.it/
[Digg]
http://www.digg.com/
[xStream]
http://xstream.codehaus.org
[XWIKI]
http://www.xwiki.org/xwiki/bin/view/Main/WebHome