PRATICANDO: ARMAZENANDO TWEETS COM MONGODB

Criado em 2009, MongoDB foi desde o início projetado para ser um banco de dados escalável, de alto desempenho e de fácil acesso aos dados. Os documentos no MongoDB são armazenados em formato BSON, uma representação binária de um documento no formato JSON. Os documentos são agrupados nesse banco de dados em formato de coleções, que podemos pensar como sendo as tabelas de um banco de dados relacional.

Embora não seja adequado para todas as soluções, como por exemplo as que necessitam da garantia ACID, MongoDB é muitas vezes o candidato ideal para soluções de Big Data. Foursquare e

Sourceforge são exemplos de soluções que adotaram esse banco. Essa atividade representa bem um exemplo de como a Big Compras pode compreender melhor seus clientes e assim oferecer uma melhor experiência na utilização do aplicativo. A equipe pode, por exemplo, armazenar todos os tweets relacionados à hashtag #BigCompras, para posteriormente analisar esses dados e identificar o que os clientes estão elogiando, sugerindo e/ou reclamando sobre a empresa.

A seguir, é apresentada a descrição do código utilizado nessa atividade. Porém o código também está disponível no repositório git do livro pelo seguinte link:

https://github.com/rosangelapereira/livrobigdata

Para capturarmos os dados que serão armazenados no MongoDB, usaremos a biblioteca open source Twitter4J. Com ela, podemos fazer chamadas à API do Twitter utilizando a linguagem Java. Ela oferece métodos para obtermos autorização de acesso à API, bem como realizarmos operações de captura e inclusão de dados no Twitter.

Em resumo, para realizar essa atividade utilizaremos as

TwitterApp.java. Aqui será necessário referenciar as seguintes bibliotecas: import com.mongodb.BasicDBObject; import com.mongodb.DB; import com.mongodb.DBCollection; import com.mongodb.Mongo; import com.mongodb.MongoClient; import com.mongodb.MongoException; import java.net.UnknownHostException; import twitter4j.*; import twitter4j.conf.ConfigurationBuilder;

Na classe TwitterApp precisaremos criar objetos das seguintes

classes: ConfigurationBuilder, DB e DBCollection. Esses

objetos são necessários para conectarmos ao MongoDB e inserirmos informações em uma coleção. Além disso, também serão implementados 4 métodos: main, configuraCredenciais,

conectaMongo e capturaTweets, descritos na sequência.

Confira o esqueleto da classe a seguir.

public class TwitterApp {

private ConfigurationBuilder cb;

private DB banco;

private DBCollection collection;

public void capturaTweets()

throws InterruptedException {

//implementação do método

}

public void configuraCredenciais(){

//implementação do método

}

public void conectaMongoDB(){

//implementação do método

}

public static void main(String[] args)

throws InterruptedException {

//implementação do método

}

}

Para o método capturaTweets, devemos instanciar um objeto TwitterStream e um objeto StatusListener. Ambos fazem

parte da biblioteca Twitter4J e são utilizados para captura destreams do Twitter.

Sempre que o objeto listener capturar um stream do Twitter, utilizaremos o método onStatus para salvar esse stream em nossa

collection no MongoDB. Nesse exemplo, estamos salvando somente os campos tweet_ID, usuario e tweet oferecidos pela API,

porém temos a possibilidade de capturar inúmeras outras informações, tais como a localização do tweet e o contador de retweets.

Como queremos capturar somente tweets que possuem a palavra "BigCompras" no corpo da mensagem, precisamos criar um objeto

FilterQuery

e informar no método

track

qual é a palavra que estamos buscando. Esse método recebe como parâmetro um vetor de Strings e, por isso, você pode indicar não somente uma, mas um conjunto de palavras para serem pesquisadas no Twitter.

public void capturaTweets() throws InterruptedException { TwitterStream twitterStream =

new TwitterStreamFactory(cb.build()).getInstance(); StatusListener listener = new StatusListener() {

@Override

public void onStatus(Status status) { BasicDBObject obj = new BasicDBObject(); obj.put("tweet_ID", status.getId());

obj.put("usuario", status.getUser().getScreenName()); obj.put("tweet", status.getText());

try {

collection.insert(obj); } catch (Exception e) {

System.out.println("Erro de conexão: "

+ e.getMessage());

} } };

String palavras[] = {"BigCompras"}; FilterQuery fq = new FilterQuery(); fq.track(palavras);

twitterStream.addListener(listener); twitterStream.filter(fq);

}

O próximo método a ser implementado é o

configuraCredenciais, no qual devemos inserir as credenciais

obtidas noPasso 1. Substitua o valor entre parênteses com as suas respectivas credenciais.

public void configuraCredenciais(){ cb = new ConfigurationBuilder(); cb.setDebugEnabled(true); cb.setOAuthConsumerKey("xxxxxxxxxxxxxxxx"); cb.setOAuthConsumerSecret("xxxxxxxxxxxxxxxx"); cb.setOAuthAccessToken("xxxxxxxxxxxxxxxx"); cb.setOAuthAccessTokenSecret("xxxxxxxxxxxxxxxx"); }

Agora implementaremos o método de conexão com o MongoDB, conectaMongoDB. Nesse exemplo a aplicação cliente

do MongoDB está sendo executada localmente, mas caso você já tenha o MongoDB instalado em outro endereço, basta substituir o localhost ("127.0.0.1") pelo endereço IP adequado.

public void conectaMongoDB(){

try {

Mongo mongoCli;

mongoCli = new MongoClient("127.0.0.1"); banco = mongoCli.getDB("twDB");

collection = banco.getCollection("tweets");

BasicDBObject index = new BasicDBObject("tweet_ID",1); collection.ensureIndex(index,

new BasicDBObject("unique", true)); } catch (UnknownHostException | Exception ex) {

System.out.println("MongoException :" + ex.getMessage( ));

} }

Por fim, no método main faremos a chamada dos métodos

anteriormente implementados, conforme o código apresentado a seguir.

public static void main(String[] args)

throws InterruptedException { TwitterApp tw = new TwitterApp(); tw.conectaMongoDB();

tw.configuraCredenciais(); tw.capturaTweets();

}

Após todos os métodos estarem implementados, devemos salvar as alterações realizadas e gerar um jar da aplicação. Este conterá

as bibliotecas e o código binário necessário para a execução. Para gerá-lo, no NetBeans clique com o botão direito do mouse no nome do projeto e selecione a opçãoConstruir . Ao final, deverá ser criado um jar com o nome TwitterApp.jar.

Tendo criado o TwitterApp.jar, acessaremos um terminal

para executar a aplicação criada. Para essa operação, estamos partindo do princípio que já existe um serviço do MongoDB em execução no ambiente que vamos executar a aplicação. Você pode verificar como instalar e executar o MongoDB no seguinte site:

https://docs.mongodb.com/manual/installation/.

Para executar a aplicação, acesse a pasta onde está localizado o

jar e execute o seguinte comando no terminal:

$ java -jar TwitterApp.jar

Esse comando deverá iniciar a aplicação que desenvolvemos.