Nessun risultato. Prova con un altro termine.
Guide
Notizie
Software
Tutorial

Rome: RSS feed in java

Gestione dei feed RSS in java tramite la libreria Rome
Gestione dei feed RSS in java tramite la libreria Rome
Link copiato negli appunti

In questo articolo presenteremo brevemente Rome, una libreria java per la gestione dei Feed RSS.

I feed RSS come sappiamo non sono altro che una fonte dati remota (in formato XML), dove il publisher (sia esso un portale web o un blog) rende pubbliche delle informazioni in real-time affinchè altri utenti (o portali web) possano interagire con queste.

Uno dei punti di forza dei Feed RSS è appunto il continuo aggiornamento delle informazioni in essi contenute;basta pensare ad una testata giornalistica on-line che tiene aggiornati gli RSS feed in maniera costante in base alle notizie che arrivano in redazione in modo che gli utenti iscritti (subscribers) possono essere aggiornati in real-time sulle nuove news.

I formati RSS utilizzabili con Rome

Con l’utilizzo questa libreria è possibile leggere e/o scrivere feed in differenti formati: RSS 0.91, RSS 0.92, RSS 0.93, RSS 0.94, RSS 1.0, RSS 2.0 e infine ATOM.
Uno dei vantaggi di questa libreria rispetto ad altre è sicuramente la semplicità di utilizzo nonchè la pulizia del codice che questa comporta.

Installazione delle dipendenze

Rome necessita di un JDK 1.4 o superiore. Per procedere con l’intgrazione di questa libreria nella nostra applicazione dobbiamo compiere due semplici passi:

  1. Scaricare l’ultimo jar di Rome
  2. Scaricare l’ultimo jar di JDOM (questa libreria è quella internamente utilizzata da Rome per il parsing rss in memoria)

A questo punto non resta altro che includere le dipendenze dei jar nel classpath dell'IDE utilizzato per lo sviluppo (nel nostro caso Eclipse).

Creazione di un semplice RSS feed reader (lato client)

In questa sezione creeremo un semplice lettore di Feed RSS con poche righe di codice: per semplicità ci accontenteremo di una classe da eseguire in locale tramite un metodo main.

import java.net.URL;
import java.util.Iterator;
import com.sun.syndication.feed.synd.SyndEntry;
import com.sun.syndication.feed.synd.SyndFeed;
import com.sun.syndication.io.SyndFeedInput;
import com.sun.syndication.io.XmlReader;
public class LettoreRSS {
	public LettoreRSS()throws Exception{
		//La nostra sorgente Feed
		URL url  = new URL("http://feeds.feedburner.com/htmlit_articoli");
	    XmlReader reader = null;
	    try {
	    	//Istanziamo uno stream reader dall'url della nostra sorgente feed
			reader = new XmlReader(url);
			//Diamo in pasto il nostro reader al parser RSS
			SyndFeed feed = new SyndFeedInput().build(reader);
			System.out.println("Titolo Feed: "+ feed.getAuthor());
			for (Iterator<SyndEntry> i = feed.getEntries().iterator(); i.hasNext();) {
				//Iteriamo tutte le voci presenti nel nostro feed e ne stampiano le proprietà fondmentali
				SyndEntry entry = i.next();
				System.out.println("titolo:" + entry.getTitle());
				System.out.println("link:" + entry.getLink());
				System.out.println("descrizione:" + entry.getDescription().getValue()+"n");
	        }
	     } finally {
	     	//Chiudiamo lo stream precedentemente aperto.
	     	if (reader != null) reader.close();
	     }
	}
	public static void main(String args[])throws Exception{
		LettoreRSS rss = new LettoreRSS();
	}
}

Nel costruttore della classe LettoreRSS istanziamo un oggetto XmlReader che altro non farà che leggere lo stream dell’url del feed degli articoli di html.it.

Fatto questo, viene istanziato un oggetto SyndFeed che rappresenta il nostro parser RSS che strutturerà le informazioni lette dall’url remoto in istanze di oggetti facilmente gestibili nel nostro codice.

Per prima cosa stampiamo nella console l’autore (o meglio proprietario) del Feed.

Successivamente iteriamo tutte le entry estrapolate dall’xml: a ciascuna corrisponderà uno degli articoli presenti nel feed. Per ogni articolo vogliamo capire come gestire le informazioni di nostro interesse, e quindi ancora una volta utilizziamo una semplice stampa a video, per semplicità. Le informazioni relative ad ogni articolo sono chiaramente molto intuitive: il titolo dell’articolo, il link dove l’articolo è reperibile (dove è stato pubblicato), e una breve descrizione dell’articolo.

Infine è opportuno preoccuparsi di chiudere lo stream verso la nostra sorgente dati.

Naturalmente l'esempio fornito è volutamente molto semplice, ma con piccole modifiche la classe appena creata potrebbe essere riutilizzata in vari contesti, ed anche integrata all'interno di una web application.

Pubblicazione di un semplice RSS feed (lato server)

Dopo aver visto come sia estremamente semplice realizzare in poche righe di codice un lettore di feed utilizzando la libreria Rome, vedremo adesso invece il processo inverso: come pubblicare un Feed RSS realizzato da noi. Anche qui vogliamo privilegiare la soluzione più semplice, così da fornire una suggestione e un punto di partenza per chi volesse realizzare il proprio componente ed integrarlo dentro la propria web application. A tal scopo abbiamo scelto una implementazione basata su servlet, così da renderla facilmente riutilizzabile ed integrabile in vari contesti.

import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Date;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.sun.syndication.feed.synd.SyndContent;
import com.sun.syndication.feed.synd.SyndContentImpl;
import com.sun.syndication.feed.synd.SyndEntry;
import com.sun.syndication.feed.synd.SyndEntryImpl;
import com.sun.syndication.feed.synd.SyndFeed;
import com.sun.syndication.feed.synd.SyndFeedImpl;
import com.sun.syndication.io.FeedException;
import com.sun.syndication.io.SyndFeedOutput;
public class MioFeed extends javax.servlet.http.HttpServlet {
	@Override
	public void doGet(HttpServletRequest request,HttpServletResponse response){
		process(request, response);
	}
	@Override
	public void doPost(HttpServletRequest request,HttpServletResponse response){
		process(request, response);
	}
	private void process(HttpServletRequest request,HttpServletResponse response){
		try{
				SyndFeed feed = new SyndFeedImpl();
				feed.setFeedType("rss_2.0");						// tipo di Feed
				feed.setLanguage("it");								// lingua
				feed.setPublishedDate(new Date());					// data di pubblicazione del feed
				feed.setAuthor("Massimiliano Migliaccio");			// Autore (o meglio: il proprietario del feed)
				feed.setTitle("Il mio primo feed ");				// titolo del Feed
				feed.setLink("http://www.miosito.it");				// hyperlik del feed
				feed.setDescription("Realizzo il mio primo Feed");	// descrizione del Feed
				java.util.List<SyndEntry> entries = new ArrayList<SyndEntry>();
				// creiamo la entry realtiva ad un nuovo Articolo
				SyndEntry entry;
				SyndContent description;
				entry = new SyndEntryImpl();
				entry.setTitle("Articolo");		//Titolo Contenuto
				entry.setLink("http://www.nome_mio_sito_per_feed.it/art_1");	//Hyperlink associato al contenuto
				entry.setPublishedDate(new Date());	//Data di pubblicazione articolo
				description = new SyndContentImpl();
				description.setType("text/plain");	//Content-Type del contenuto
				description.setValue("Contenuto testuale del mio articolo");	//Breve descrizione del mio articolo
				entry.setDescription(description);
				// aggiungiamo l'articolo alla lista complessiva
				entries.add(entry);					
				// qui potremmo aggiungere gli altri articoli...
				feed.setEntries(entries);
				// Definiamo per la servlet un output di tipo XML
				response.setContentType("text/xml");
				PrintWriter out = response.getWriter();	
				// un wrapper per l'output della servlet
				SyndFeedOutput output = new SyndFeedOutput();
				// viene inviato lo stream
				output.output(feed, out);
				// chiudiamo lo stream
				out.flush();
				out.close();
		}catch(IOException ioex){
			ioex.printStackTrace();
		}catch(FeedException fex){
			fex.printStackTrace();
		}
	}
}

A questo punto facendo le opportune configurazioni nel web.xml per esporre il servizio implementato dalla servlet (tramite gli usuali mapping...) nel contesto web della nostra web application avremo creato il primo Feed RSS.

Ovviamente l'esempio fornito è veramente elementare ed abbiamo semplicemente fornito una idea generale di come sia possibile creare una lista di oggetti di tipo SyndEntry (Feed Syndication Entry), ed utilizzarla per alimentare un Feed RSS consumabile da una qualsiasi applicazione.

Conclusioni

I Feeds RSS negli ultimi anni hanno riscontrato un notevole successo nell’ambito del web e sono ormai una risorsa di utilizzo comune e imprescindibile per gli utenti (basta pensare al successo di progetti come Google News) e per le applicazioni (pensiamo ad esempio ai vari aggregatori web).

Sempre più spesso non solo siti dedicati a notizie, magazine e blog, ma anche siti di e-commerce, agenzie viaggi, etc rendono disponibili pubblicamente i propri sorgenti RSS catalogando i loro servizi/prodotti offerti. Il fine di è sia interagire con portali di aggregazione o di alta natura per migliorare la visibilità sul web dei servizi offerti (i motori di ricerca hanno ormai integrato da tempo algoritmi per indicizzare correttamente questi feed), ma anche per aggiornare i propri iscritti su delle novità che un portale propone rafforzando la fidelizzazione dei suoi clienti.

  1. apache digester: un’altra soluzione a Rome per l’implementazione di Feed RSS
  2. http://www.javaworld.com/javaworld/jw-11-2007/jw-11-rome.html
  3. http://java.net/projects/rome/
  4. http://www.xml.com/pub/a/2006/02/22/rome-parse-publish-rss-atom-feeds-java.html


Ti consigliamo anche