El primer pas es descarregar l'API per al llenguatge de desenvolupament triat del lloc dels desenvolupadors de Twitter: https://dev.twitter.com/docs/twitter-libraries
Tenim APIs per a diferents llenguatges i amb diferents orígens. En particular per a Java, PHP, Python i C++ a la mateixa web dels desenvolupadors en destaquen aquestes:
C++: Twitcurl, http://code.google.com/p/twitcurl/.
Java: Twitter4J, http://twitter4j.org/.
PHP: TmhOAuth, http://github.com/themattharris/tmhOAuth.
Python: Tweepy, https://github.com/tweepy/tweepy
En el meu cas, desenvoluparé l'aplicació amb Java, així que el primer que faig és descarregar Twitter4j
A la web de Twitter4J en podem llegir algunes de les característiques d'aquesta API
"Twitter4J és una biblioteca java (jar) no oficial per a l'API de Twitter.
Amb Twitter4J, es pot integrar fàcilment una aplicació Java amb el servei de Twitter.
Twitter4J ofereix:
✔ és Java pur 100%. Funciona a partir de la versió de plataforma Java 1.4.2
✔ Preparat per a la plataforma Android i per a Google App Engine.
✔ Sense dependències. No li cal cap jar addicional.
✔ suport OAuth inclòs
✔ suport de GZip inclòs
Requeriments de sistema
Windows o Unix amb suport de Java.
JVM: Java 1.4.2 o superior
Com utilitzar Twitter4J?
Només cal afegir twitter4j-core-2.2.5.jar al classpath de l'aplicació.
El millor lloc per on començar és llegir el JavaDoc
El millor lloc per on començar a llegir el JavaDoc és la interface twitter4j.Twitter."
Però potser el primer que cal per a poder treballar amb Twitter és conèixer el protocol per a autenticar-se amb el servei: El protocol OAuth (rfc5849). Podem consultar també a http://oauth.net/core/1.0/.
El document de la rfc5849 ocupa 39 pàgines. però en un primer moment no cal llegir-lo per a poder fer servir la Twitter4J, perquè els detalls del funcionament estan encapsulats a la llibreria.
El que sí que caldrà és registrar l'aplicació que estem construint al servei Twitter, per a que aquest la reconegui i sigui capaç d'identificar-ne l'origen dels tweets. Això es fa a l'adreça https://dev.twitter.com/apps/new
També hi podrem posar una icona, el tipus d'accés...el registre no resulta complicat.
Un cop registrada l'aplicació obtindrem les claus per autoritzar l'aplicació al Twitter.
En el llenguatge de OAuth un Consumer és una aplicació, o una web, que accedeix a un proveïdor de servei en representació d'un usuari. Al registrar l'aplicació obtindrem el parell de valors que ens caldran per a autenticar l'aplicació, o consumer:
Consumer Key: Un valor utilitzat per l'aplicació per a identificar-se ella mateixa enfront del servei Twitter (el "login" de l'aplicació).
Consumer Secret: Un valor secret utilitzat per l'aplicació per a certificar la propietat de la Consumer Key (el password).
A més, se'ns proporcionarà un conjunt d'URLs a les que caldrà accedir per a que l'usuari que faci servir l'aplicació també pugui autenticar-se
Request token URL: https://api.twitter.com/oauth/request_token
Authorize URL: https://api.twitter.com/oauth/authorize
Access token URL: https://api.twitter.com/oauth/access_token
Aquestes adreces permetran el diàleg entre el consumer i el servei per a autenticar a l'usuari final.
Request Token: és un valor utilitzat pel Consumer per a obtenir autorització de l'usuari i que es tradueix en un Access Token.
Access Token: és un valor utilitzat pel Consumer per a obtenir accés als Protected Resources (en el cas del Twitter, als tweets emesos o adreçats a l'usuari) en representació de l'usuari, en comptes de fer servir les pròpies credencials de l'usuari al Servei. És dir, l'aplicació no fa servir directament el login i el password de twitter de l'usuari. Podriem dir que l'Access Token és un login temporal.
Access Token Secret: un valor secret utilitzat pel Consumer per a certificar la propietat de l'Access Token (seria el password temporal corresponent al login temporal).
En la pàgina que es registra l'aplicació també podem obtenir un Acces Token i un Access Token Secret que es poden fer servir directament a l'aplicació per a piular des del propi compte de Twitter.
Guardem molt bé els diferents tokens rebuts. I mantinguem en secret els "passwords"
Finalment, un cop registrada l'aplicació, podrem veure la nova aplicació registrada (i totes aquelles altres que puguem tenir) a https://dev.twitter.com/apps
A la pàgina de Twitter4J ens diuen com fer servir aquests parells.
Amb un fitxer de propietats estàndard: twitter4j.properties. Cal que el fitxer "twitter4j.properties" es trobi a les rutes del classpath.
debug=true
oauth.consumerKey=*********************
oauth.consumerSecret=******************************************
oauth.accessToken=**************************************************
oauth.accessTokenSecret=******************************************
Amb un objecte ConfigurationBuilder
ConfigurationBuilder cb = new ConfigurationBuilder();
cb.setDebugEnabled(true)
.setOAuthConsumerKey("*********************")
.setOAuthConsumerSecret("******************************************")
.setOAuthAccessToken("**************************************************")
.setOAuthAccessTokenSecret("******************************************");
TwitterFactory tf = new TwitterFactory(cb.build());
Twitter twitter = tf.getInstance();
O amb variables de sistema passades a la JVM.
$ java -Dtwitter4j.debug=true
-Dtwitter4j.oauth.consumerKey=*********************
-Dtwitter4j.oauth.consumerSecret=******************************************
-Dtwitter4j.oauth.accessToken=**************************************************
-Dtwitter4j.oauth.accessTokenSecret=******************************************
-cp twitter4j-core-2.2.5.jar:yourApp.jar yourpackage.Main
Arribats a aquest punt, un cop obtinguts els parells Consumer Key, Consumer Secret i Access Token i Access Token Secret ja estic en condicions de fer una petita aplicació amb java que "Piuli" al twitter en nom del meu compte.
Una cosa tan senzilla com això:
package com.sticipl.proves;
import twitter4j.Status;
import twitter4j.Twitter;
import twitter4j.TwitterException;
import twitter4j.TwitterFactory;
import twitter4j.conf.ConfigurationBuilder;
public final class ProvaTwitter {
/**
* Usage: java twitter4j.examples.tweets.UpdateStatus [text]
*
* @param args message
*/
public static void main(String[] args) {
try {
ConfigurationBuilder cb = new ConfigurationBuilder();
cb.setDebugEnabled(true)
.setOAuthConsumerKey("[El consumer Key obtingut]")
.setOAuthConsumerSecret("[el consumer secret obtingut]")
.setOAuthAccessToken("[l'access token obtingut]")
.setOAuthAccessTokenSecret("[l'access token secret obtingut]");
TwitterFactory tf = new TwitterFactory(cb.build());
Twitter twitter = tf.getInstance();
Status status = twitter.updateStatus("Aquest és el missatge enviat des de l'aplicació #Java de prova fent us de #Twitter4J");
System.out.println("Actualitzat status a [" + status.getText() + "].");
System.exit(0);
} catch (TwitterException te) {
te.printStackTrace();
System.out.println("Excepció de Twitter: " + te.getMessage());
System.exit(-1);
}
}
}
En executar aquesta mini-aplicació, obtinc:
Actualitzat status a [Aquest és el missatge enviat des de l'aplicació #Java de prova fent us de #Twitter4J].
I en anar a Twitter puc comprovar que, efectivament, així és:
En aquesta primera aproximació a Twitter4J he fet un petit "piulador" personal. En un proper post presentaré un "Piulador" general.
Cap comentari:
Publica un comentari a l'entrada