Twitter è un noto servizio online che mette a disposizione funzionalità per il micro-blogging e per il social networking; iscrivendosi, ogni utilizzatore avrà la possibilità di aprire un account tramite il quale di pubblicare e condividere dei post (tweets, letteralmente "cinguettii") della lunghezza massima di 140 caratteri; ogni account potrà avere dei "seguaci" (followers), cioè utenti interessati ai contenuti da esso postati e, a sua volta, potrà essere seguace di un altro account.
La piattaforma mette a disposizione delle fonti di dati, sotto forma di file XML, da interrogare per inserire informazioni relative al proprio status su Twitter nel proprio sito Internet, blog o servizio online.
Nel corso di questa trattazione verrà descritta la procedura per la creazione di una classe, tramite la quale interagire con Twitter, che permetta di svolgere le seguenti funzioni:
- connessione al servizio e autenticazione;
- pubblicazione dei post;
- visualizzazione dei post.
- visualizzazione e conteggio dei followers;
Connessione all'account: il costruttore della classe
N:B.: per poter utilizzare molti dei metodi messi a disposizione dalla classe descritta, dovranno essere disponibili le estensioni cURL e simpleXML per il linguaggio PHP 5, si raccomanda quindi di abilitarle se non disponibili per il proprio ambiente di sviluppo.
La classe sviluppata per l'interazione con la piattaforma sociale Twitter descritta in questo articolo, si chiamerà semplicemente "twitterClass" e sarà contenuta in un file denominato twitter_Class.php, che potrà essere richiamato tramite una comune inclusione; metodi, oggetti e funzioni della classe saranno contenuti all'interno di esso:
// definizione della classe
class twitterClass {
// codice della classe
}Il primo passaggio da affrontare sarà quello relativo alla connessione al proprio account su Twitter; per far questo, verrà definito un costruttore a cui passare come argomenti i dati necessari per l'autenticazione (essenzialmente la propria username e la propria password); fortunatamente, a partire da PHP 5, è stata introdotta la possibilità di utilizzare un nome standard per i costruttori, in questo modo, nel caso in cui la classe dovesse cambiare nome, non sarà necessario rinominare anch'esso:
// introduzione del costruttore e definizione dei metodi per il login
function __construct($utente, $password) {
$this->autenticazione = $utente. ":".$password;
$this->utente = $utente;
}La funzione relativa al costruttore introduce due metodi, il primo consente di mettere a disposizione i dati relativi all'autenticazione, il secondo fornisce l'username dell'account in connessione; il costruttore sarà sempre disponibile, dal momento in cui verrà inizializzata la classe di appartenenza, attraverso una semplice istanza:
// inclusione del file di classe
@require "twitter_Class.php";
// istanza della classe
$data = new twitterClass("username", "password");Una volta istanziata la classe, sarà possibile accedere ai metodi e agli oggetti messi a disposizione per le altre operazioni di interazione con Twitter.
Pubblicazione dei post
Per pubblicare i propri post su Twitter tramite la classe twitterClass, sarà necessario definire un nuovo metodo appositamente dedicato, esso sarà public (livello di visibilità) in quanto disponibile sia all'interno che all'esterno della classe di appartenenza.
Il metodo prenderà il nome di inserisci_tweets() e accetterà come parametro il testo del tweet da pubblicare; il metodo permetterà di interagire con il file update.xml messo a disposizione da Twitter per l'invio di contenuti, esso presenta una semplice struttura:
<hash>
<request>/statuses/update.xml</request>
<error>Questo metodo richiede un POST.</error>
</hash>Il tag <request> indica il percorso al file tramite il quale effettuare la procedura di inserimento, mentre <error> fornisce una notifica relativamente al metodo con cui l'inserimento dovrà essere inviato.
Di seguito verrà proposto il codice del metodo, immediatamente dopo ne verranno descritte le funzioni:
// metodo per l'inserimento dei post
public function inserisci_tweets($testo) {
// inizializzazione della sessione cURL
$sessione = curl_init();
// chiamata al metodo per l'autenticazione
$autenticazione = $this->autenticazione;
// file XML per l'inserimento
$sorgente = "http://www.twitter.com/statuses/update.xml";
# impostazione delle opzioni per la sessione
// definizione dell'url per il salvataggio del file
curl_setopt($sessione, CURLOPT_URL, $sorgente);
// connessione al servizio
curl_setopt($sessione, CURLOPT_USERPWD, $autenticazione);
// trasferimento dei dati
curl_setopt($sessione, CURLOPT_RETURNTRANSFER, TRUE);
// metodo per l'invio dei dati
curl_setopt($sessione, CURLOPT_POST, 1);
// dati per l'inserimento via metodo
curl_setopt($sessione, CURLOPT_POSTFIELDS, "status=$testo&source=web");
// esecuzione delle istruzioni di sessione
$input = curl_exec($sessione);
// chiusura della sessione cURL
curl_close($sessione);
}Si analizzi il listato appena proposto:
- viene introdotto il metodo con livello di visibilità public;
- viene inizializzata la sessione cURL tramite la funzione
curl_init(), cURL (Client URL Library) è una estensione di PHP che consente di accedere alla libreria libcurl per la comunicazione con i server tramite differenti tipi di protocolli; - si esegue la chiamata al metodo per l'autenticazione all'account su Twitter;
- viene memorizzato in una variabile (
$sorgente) il file update.xml tramite il quale verrà effettuato l'aggiornamento dei tweets con un nuovo post.
A questo punto, tramite la funzione curl_setopt(), sarà possibile impostare le opzioni richieste per la sessione cURL aperta; curl_setopt() richiede il passaggio di tre parametri:
- la variabile di sessione;
- l'opzione da impostare;
- il valore da associare all'opzione.
Nel caso specifico verranno utilizzati i seguenti argomenti:
- CURLOPT_URL che indica l'URL relativa al file che si desidera salvare, il terzo parametro della funzione dovrà essere quindi il file update.xml, in questo caso memorizzato in una variabile;
- CURLOPT_USERPWD ha il compito di passare alla funzione una stringa formattata sul modello [username]:[password] da utilizzare in fase di connessione, la stringa verrà fornita dal metodo per l'autenticazione messo a disposizione dal costruttore della classe;
- CURLOPT_RETURNTRANSFER permette di impostare come terzo parametro un valore diverso da
FALSE(o da "0"), se si desidera che la sessione cURL restituisca direttamente un trasferimento di dati invece di effettuarne la stampa; - CURLOPT_POST consente di impostare come terzo parametro un valore diverso da
FALSE(o da "0"), se si desidera che venga utilizzato come metodo per l'invio il POST del protocollo HTTP; - l'argomento CURLOPT_POSTFIELDS permette di utilizzare, quale ultimo argomento della funzione
curl_setopt(), una stringa al cui interno sono presenti i dati che dovranno essere inviati al momento della richiesta effettuata tramite metodo POST.
Una volta impostate le opzioni necessarie, sarà possibile passare alla fase relativa all'esecuzione delle funzioni per cui è stata aperta la sessione cURL; a questo scopo dovrà essere utilizzata la funzione curl_exec() a cui passare come argomento la sessione inizializzata tramite curl_init().
Una volta terminata la fase di esecuzione, sarà possibile chiudere la sessione cURL tramite la funzione curl_close() che necessita, come unico parametro, della variabile in cui è stata memorizzata la sessione.
A questo punto non resta che provare l'efficacia del metodo creato, per far questo è sufficiente una semplice chiamata posta di seguito all'istanza della classe:
@require "twitter_Class.php";
// istanza della classe
$data = new twitterClass("username", "password");
// inserimento di un post
$data->inserisci_tweets("Tweet inserito con una classe realizzata in PHP.");Una volta eseguito il codice proposto, sarà possibile loggarsi al proprio account su Twitter per visualizzare l'esito della chiamata al metodo, se tutto dovesse andare per il meglio, nella propria timeline personale dovrebbe essere mostrato l'ultimo post inserito:
Conclusioni
Questa trattazione presenta la prima parte relativa alla procedura di creazione di una classe per l'interazione con il servizio di microblogging Twitter; sono state affrontate le fasi riguardanti la definizione della classe e la costruzione dei metodi necessari per l'autenticazione a Twitter e l'inserimento dei post; la seconda parte riguarderà invece la definizione dei metodi da utilizzare per la creazione di un elenco dei Tweets e della lista dei followers di un account.
Nel corso della prima parte di questo articolo è stato affrontato l'argomento relativo alla creazione di una classe realizzata in PHP per l'interazione con il servizio di microblogging Twitter; sono state descritte le procedure necessarie per l'implementazione dei metodi di autenticazione sulla piattaforma e di inserimento di post per il proprio account.
In questa seconda parte verranno sviluppati i metodi per la creazione della lista dei tweet pubblicati e per il conteggio e la visualizzazione dei propri follower.
Visualizzazione dei tweet
Il metodo per la visualizzazione dei tweet pubblicati interrogherà il file user_timeline.xml che Twitter mette a disposizione per mostrare gli ultimi 20 post pubblicati dal proprietario di un determinato account.
Al metodo verranno passati tre parametri:
$num_tweet: ad essa può essere associato un valore numerico intero che rappresenta il numero massimo dei post da stampare;tagliatweet: se ad essa si associa il valore "1", verranno mostrati al massimo il numero di caratteri definito dal parametro successivo, il valore "0" permetterà di disattivarla;$num_caratteri: definisce il numero massimo di caratteri da mostrare per ogni post.
Di seguito verrà proposto il codice per l'implementazione del metodo, seguirà un approfondimento delle istruzioni in esso presenti:
// metodo per la visualizzazione dei tweet
public function mostra_tweet($num_tweet, $tagliatweet, $num_caratteri) {
// inizializzazione della sessione cURL
$sessione = curl_init();
// chiamata al metodo per l'autenticazione
$autenticazione = $this->autenticazione;
// file sorgente remoto
$sorgente = "http://www.twitter.com/statuses/user_timeline.xml";
# opzioni di sessione
// URL del sorgente
curl_setopt($sessione, CURLOPT_URL, $sorgente);
// connessione al sorgente
curl_setopt($sessione, CURLOPT_USERPWD, $autenticazione);
// regola per il trasferimento
curl_setopt($sessione, CURLOPT_RETURNTRANSFER, TRUE);
// esecuzione delle istruzioni di sessione
$visualizza = curl_exec($sessione);
// inizializzazione dell'oggetto SimpleXMLElement
$twitters = new SimpleXMLElement($visualizza);
// ciclo per la visualizzazione
$conta_tweet = 0;
foreach($twitters->status as $value) {
$sorgente = "http://www.twitter.com/". $this->utente ."/statuses/". $value->id;
// estrazione del dato relativo alla data del post
$data_tweet = str_replace(" +0000","",$value->created_at);
$data_tweet = substr($data_tweet,4,20);
// visualizzazione dei tweet sulla base del valore di $num_tweet
if (++$conta_tweet > $num_tweet) {
break;
} else {
// visualizzazione dei caratteri dei tweet sulla base del valore di $num_caratteri
if ($tagliatweet) {
if (strlen($value->text) > $num_caratteri) {
$tweet = substr($value->text, 0 , $num_caratteri)."...";
} else {
$tweet = substr($value->text, 0 , $num_caratteri);
}
// stampa a video dei risultati
echo $tweet . "<br />Pubblicato il: " .$data_tweet. "<br />n";
}
}
}
}
Si analizzi il codice proposto:
- viene definito un metodo (
mostra_tweet()) con visibilitàpublice con esso le variabili che dovranno essere passate come parametri; - viene inizializzata la sessione cURL, a cui fa seguito la chiamata del metodo per l'autenticazione;
- viene memorizzata la variabile relativa al file XML da interrogare;
- vengono definite ed eseguite le opzioni di sessione per l'accesso all'URL sorgente e per le regole di trasferimento dei dati;
- viene inizializzato l'oggetto
SimpleXMLElementper il parsing (apertura e lettura) del sorgente XML; - si utilizza un ciclo
foreachper la visualizzazione dei dati ricavati dal sorgente; - viene mostrato soltanto il numero di post definito dal valore associato alla variabile
$num_tweet, anche se i post sono in numero superiore al valore della variabile; - viene mostrato soltanto il numero di caratteri definito dalla variabile
$num_caratteri", tweet più lunghi verranno tagliati e saranno aggiunti dei puntini di sospensione al posto dei caratteri mancanti.
Si noti come all'interno del codice sia stato estratto anche il dato relativo alla data di pubblicazione di ogni post:
$data_tweet = str_replace(" +0000","",$value->created_at);
$data_tweet = substr($data_tweet,4,20);
Ciò è possibile grazie al tag <created_at> presente nel file XML che memorizza una stringa come la seguente: Wed Feb 17 09:09:45 +0000 2010.
Questa stringa viene prima depurata dal valore " +0000" per poi associare alla variabile $data_tweet soltanto i caratteri presenti nell'intervallo (tra il 4° e il 20° carattere) passato come parametro alla funzione substr(); per cui l'output finale della data sarà simile al seguente: Feb 17 09:09:45 2010.
Infine, per utilizzare il metodo descritto, bisognerà procedere all'istanza della classe per poi passare alla chiamata al metodo come nell'esempio seguente:
// inclusione del file di classe
@require "twitter_Class.php";
// istanza della classe
$data = new twitterClass("username", "password");
// visualizzazione dei tweet
$data->mostra_tweet(10, 1, 50);
Nell'esempio vengono passati al metodo tre valori:
- 10: il metodo mostrerà al massimo gli ultimi 10 tweet elencati nel sorgente;
- 1: viene attivata la funzione per mostrare soltanto il numero di caratteri definiti dal valore successivo;
- 50: verranno mostrati soltanto i primi 50 caratteri di ogni post.
Conteggio e visualizzazione dei follower
I follower su Twitter sono gli utenti che seguono gli aggiornamenti dei post di un account, sono in pratica persone interessate a quello che viene scritto da qualcun altro e desiderano visualizzarne i tweet sulla propria timeline.
Per l'implementazione di un metodo con il quale contare e mostrare una lista dei propri follower, il sito sociale mette a disposizione un apposito file XML denominato followers.xml, in esso sono presenti numerose informazioni (delimitate da tag) relative alle caratteristiche degli account elencati .
Per lo sviluppo del metodo proposto di seguito sono stati utilizzati i tag <user>, <screen_name> e <name>, in ogni caso nulla impedisce che esso possa essere implementato mostrando il contenuto dei tag restanti:
// metodo per il conteggio e la visualizzazione dei follower
public function mostra_follower() {
// inizializzazione della sessione cURL
$sessione = curl_init();
// chiamata al metodo per l'autenticazione
$autenticazione = $this->autenticazione;
// file sorgente remoto
$sorgente = "http://www.twitter.com/statuses/followers.xml";
# opzioni di sessione
// URL del sorgente
curl_setopt($sessione, CURLOPT_URL, $sorgente);
// connessione al sorgente
curl_setopt($sessione, CURLOPT_USERPWD, $autenticazione);
// regola per il trasferimento
curl_setopt($sessione, CURLOPT_RETURNTRANSFER, TRUE);
// esecuzione delle istruzioni di sessione
$visualizza_follower = curl_exec($sessione);
// inizializzazione dell'oggetto SimpleXMLElement
$follower = new SimpleXMLElement($visualizza_follower);
// conteggio dei follower
echo "Hai <strong>" . count($followers->user) . "</strong> follower su Twitter.<br />n";
// visualizzazione dei follower
foreach($follower->user as $value) {
echo "Nick: ". $value->screen_name . " - Nome: ". $value->name . "<br />n";
}
}
Si analizzi il codice appena proposto:
- anche in quest'ultimo caso il metodo (
mostra_follower()) hapubliccome livello di visibilità; - viene inizializzata una sessione cURL per poi richiamare il metodo necessario per l'autenticazione al servizio;
- viene definito il file sorgente da cui si andranno a recuperare i dati;
- vengono definite le opzioni di sessione relative all'URL del sorgente, all'accesso ad esso e alle regole per il trasferimento dei dati;
- definite le opzioni per la sessione si passa all'esecuzione delle istruzioni previste;
- viene inizializzato l'oggetto
SimpleXMLElementper il parsing dei metadati; - vengono conteggiati gli elementi contenuti all'interno del tag
<users>per ottenere il numero dei follower; - viene utilizzato un ciclo
foreachper mostrare tutti i nick e i nomi dei follower elencati nel file XML.
Per utilizzare il metodo sarà sufficiente istanziare la classe di appartenenza e richiamare il metodo implementato, che non prevede il passaggio di parametri:
// inclusione del file di classe
@require "twitter_Class.php";
// istanza della classe
$data = new twitterClass("username", "password");
// visualizzazione dei follower
$data->mostra_followers();
Conclusioni
Nel corso di questa trattazione suddivisa in due parti, è stato affrontato l'argomento relativo alla creazione di una classe per l'interazione con Twitter; grazie ai metodi disponibili sarà possibile autenticarsi al servizio, pubblicare post, mostrare un elenco dei propri tweet e una lista dei propri follower; ulteriori implementazioni potranno essere effettuate sviluppando metodi sull'esempio di quelli già proposti sfruttando la struttura dei file XML messi a disposizione da Twitter.
