sumário

UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ
CAMPUS DE CURITIBA
CURSO DE ENGENHARIA DE COMPUTAÇÃO
BRUNNO BRAGA
BRUNO WEINGRABER
TELMO FRIESEN
BUSCADOR OPEN SOURCE DE ARTIGOS – TB²uscador
CURITIBA
2007
ii
BRUNNO ALBERTO BRAGA
BRUNO WEINGRABER
TELMO FRIESEN
BUSCADOR OPEN SOURCE DE ARTIGOS: TB²uscador
Trabalho acadêmico apresentado à disciplina
Oficina de Integração, como requisito parcial
para
obtenção
de
nota
no
Curso
de
Engenharia de Computação da Universidade
Tecnológica Federal do Paraná.
Orientadores: Prof. Arandi Ginane Bezerra Jr.
Prof. Gustavo Alberto Gimenez Lugo
Prof. Luiz Ernesto Merkle.
CURITIBA
2007
iii
BUSCADOR OPEN SOURCE DE ARTIGOS: TB²uscador
BRUNNO ALBERTO BRAGA
BRUNO WEINGRABER
TELMO FRIESEN
Aprovada em ____/____/_____.
BANCA EXAMINADORA
_________________________________________________
Nome Completo (orientador)
Titulação
Instituição
_________________________________________________
Nome Completo
Titulação
Instituição
_________________________________________________
Nome Completo
Titulação
Instituição
CONCEITO FINAL: _____________________
iv
SUMÁRIO
INTRODUÇÃO ................................................................................................... 01
CAPÍTULO I – Problema de Pesquisa .............................................................. 02
CAPÍTULO II - Hipótese ..................................................................................... 03
CAPÍTULO III - Justificativa ............................................................................... 04
CAPÍTULO IV - Objetivos ................................................................................... 05
CAPÍTULO V – Fundamentação Teórica .......................................................... 06
5.1 Teoria de Busca. ...................................................................................... 06
5.1.1 O mecanismo de busca (Crawler-Based Search Engines) ........... 06
5.1.2 Diretórios (Human-Powered Directories) . ...................................... 07
5.1.3 Diferenças entre mecanismo de busca e diretórios ..................... 07
5.2 Lucene ............................................................................................. 08
5.3 Nutch ............................................................................................... 12
5.3.1 Funcionamento.......................................................................... 12
5.3.1.1 Crawler..................................................................... ...................13
5.3.1.2 Searcher.....................................................................................14
CAPÍTULO VI – TB²uscador...............................................................................15
6.1 Passos do Projeto....................................................................................20
CONCLUSÃO ..................................................................................................... 22
REFERENCIA BIBLIOGRÁFICA ........................................................................ 23
ANEXOS,,,,,........................................................................................................25
v
RESUMO
Atualmente, com o advento da Web, os trabalhos escolares perderam e
muito na qualidade devido à falta de pesquisa por parte dos alunos e a falta
de fontes confiáveis. Uma forma de despertar o interesse dos alunos é um
projeto que recomende e busque artigos relevantes ao tema discutido,
denominado Nuts. Desta forma, a população teria uma importante ferramenta
open source que varreria a internet em busca de artigos a respeito do
assunto proposto pelo usuário. Para alcançar este objetivo, foi utilizado como
base um programa desenvolvido em java, o Nutch. Ele é ba seado no Lucene,
um Frame Work inteiramente escrito em java para busca e indexação de
textos. O projeto consiste em um programa que recebe o tema do usuário e
utiliza o Nutch para realizar a pesquisa. Ao contrário dos atuais oligopólios de
buscas, que visam seus interesses comerciais, o Nuts oferece uma
alternativa transparente aos sistemas comerciais de localização na web.
Todos os principais sistemas de localização existentes têm fórmulas de
ranking próprias e não vão explicar porque foi dado um ranking a um
determinado
resultado.
Além
disso,
alguns
sistemas
de
localização
determinam em que locais posicionar os resultados baseados mais em
pagamentos do que nos méritos deles mesmos. Ao contrário disso, um
programa open source não tem nada a esconder e nenhu m motivo para
direcionar seus resultados de nenhuma maneira exceto o de tentar dar a
cada usuário os melhores resultados possíveis.
vi
LISTA DE ILUSTRAÇÕES
FIGURA 1 Fluxo do processo de indexação no Lucene............................ .....09
FIGURA 2 Exemplo de código para Indexação usando o Lucene.............................10
FIGURA 3 Arquivo nutch-site.xml configurado ..........................................................14
FIGURA 4 Exemplo de código usando a API do Nutch.............................................15
FIGURA 5 Programa TB²uscador...............................................................................16
FIGURA 6 Pesquisa no TB²uscador...........................................................................17
FIGURA 7 Menu Configuration...................................................................................18
FIGURA 8 Menu Crawl...............................................................................................20
FIGURA 9 Diagrama de classes................................................................................25
1
INTRODUÇÃO
Em toda história humana, para se realizar um trabalho de pesquisa
cientificamente
relevante
são
necessárias
referências
bibliográficas
confiáveis. Com a vinda da internet atualmente, os estudiosos possuem mais
uma importante ferramenta para pesquisa, os famosos sites de busca .
Porém, muitos destes levam em questão os interesses econômicos na
formulação da ordem de sites dispostos no retorno da pesquisa feita pelo
usuário.
Portanto, este projeto consiste na implementação de um programa de
código-aberto (open source) que realize buscas na rede WWW (World Wide
Web) e forneça um retorno justo para a pesquisa, de acordo com a relevância
da fonte de pesquisa. Na construção deste, foi utilizado o Nutch, um
programa open source desenvolvido pela Apache Software Foundation, que
faz a busca em escala mundial e local (intranet).
Pretende-se, com este projeto, fornecer à população uma ferramenta
de fácil uso, que encontre as muitas fontes de qualidade a respeito do tema
apresentado pelo usuário e, desta forma, ajudá-los com suas pesquisas
científicas.
Foi escolhido este tema de estudo, pois esta é uma área de interesse
da equipe, e assim pretende-se aprimorar o conhecimento em programação e
sistemas
de
busca.
2
CAPÍTULO I - PROBLEMA DE PESQUISA
Antigamente, para se realizar uma pesquisa o estudante certamente ia
em busca de livros e revistas, as quais eram as principais referências (foi
desta forma que surgiu o termo “bibliografia”, referências de livros). Com a
popularização mundial da internet atualmente, há mais uma opção para a
busca de fontes de pesquisa, as páginas na internet. Estas são de grande
magnitude, devido à facilidade de busca por referências e a vasta área de
conteúdo disponibilizado na rede.
Para facilitar ainda mais este processo de busca na rede, foram
implementadas diversas ferramentas que realizam este serviço, como é o
caso do Google e do Alta Vista, por exemplo. Estas recebem o tema do
usuário e varrem a rede em busca de artigos relacionados. Porém, estas
ferramentas possuem critérios de ordem que dizem respeito a interesses
econômicos, e não somente ao conteúdo disponibilizado pelo site.
Este é um problema grave, pois muitos sites que possuem um vasto
conteúdo relevante ao tema proposto não são encontrados devido a
interesses econômicos dos oligopólios de busca. Desta forma, estudos e
trabalhos escolares são prejudicados, pois faltam referências confiáveis na
internet para aprimorá-los.
Como se pode modificar esta atual situação? Qual seria uma hipótese
relevante para solucionar este problema que atinge a população mundial?
3
CAPÍTULO II - HIPÓTESE
Como uma tentativa de solucionar este problema, este projeto consiste
em um programa open source que busca referências de pesquisa, e que
estas estejam ordenadas com o critério de relevância ao tema proposto pelo
usuário, sem interesses comerciais em jogo.
Denominado
NUTS,
o
programa
é
baseado
numa
importante
ferramenta de busca, o Nutch. Ele, por sua vez, é baseado no Lucene, um
frame work escrito em java para busca e indexação de artigos. Ambos foram
desenvolvidos pela Apache Software Foundation e seus funcionamentos
serão aprofundados em seguida.
4
CAPÍTULO III - JUSTIFICATIVA
Com este software, os alunos e usuários em geral teriam fontes de
pesquisa confiáveis, ordenadas de acordo com o grau de relevância para com
o tema proposto, e não utilizando como critérios interesses econômicos. Este
projeto visa beneficiar todos os estudantes para a realização de pesquisas
científicas, proporcionando a estes referências consistentes e livres de
interesses para benefício próprio.
Esta preocupação é demonstrada também pela Apache Software
Foundation (2006), a qual afirma:
Apesar do número de sistemas de localização na web estarem diminuíndo,
a localização na web é um requisito básico para a navegação na internet.
Os atuais oligopólios poderão, em breve, vir a tornar monopólios, tendo
uma
única
empresa
controlando
praticamente
todo
o
sistema
de
localiazção na web, visando seus interesses comerciais. Isso não seria
bom para os usuários da internet.¹
Além de ser uma solução para o problema de referências, este projeto
possibilita um avanço teórico-prático com relação à programação em
linguagem java, orientação a objetos e principalmente na área da Teoria de
Busca.
1 APACHE SOFTWARE FOUNDATION. Disponível em:
< http://lucene.apache.org/nutch/docs/> Acesso em: 31 out. 2007.
5
CAPÍTULO IV – OBJETIVOS
O principal objetivo deste projeto é o de fornecer ajuda aos estudantes
para a confecção de pesquisas escolares, teses de mestrado e trabalhos
científicos em geral, apresentando importantes e referências relevantes de
pesquisa na internet. Para que se alcance este objetivo geral, é necessária
uma ferramenta open source, de interface simples, para busca de artigos
científicos.
Ao ler e se aprofundar em determinado assunto, o estudante formará
uma opinião própria a respeito do mesmo, e não desta forma não precisará
mais seguir o raciocínio e a visão de outros, ou seja, o seu senso crítico é
aprofundado.
6
CAPÍTULO V – FUNDAMENTAÇÃO TEÓRICA
5.1 Teoria de Busca
Uma ferramenta de busca é um programa que auxilia a encontrar
informações armazenadas na World Wide Web, numa rede local ou em uma
computador pessoal. O usuário faça a pesquisa (geralmente uma frase ou
palavra) e este retorna uma lista de links relevantes ao tema proposto.
Um sistema de busca é um conjunto organizado constituído de computadores,
índices, bases de dados e algoritmos. Todas estas questões são reunidas com a
missão de analisar e indexar as páginas da Web, armazenar estes resultados numa
base de dados e, quando for feita uma busca, o sistema irá procurar a pesquisa
realizada em sua base de dados e fornecerá os resultados ao usuário do sistema de
busca.
O sistema de busca é o termo genérico que engloba duas categorias:
os mecanismos de busca (Crawler-Based Search Engines) e os diretórios
(Human-Powered Directories). Os mecanismos de busca, como o Google, são
os sistemas de busca baseados no uso exclusivo de programas de
computador para a indexação das páginas da web automaticamente. Se uma
página for modificada, o mecanismo de busca encontra esta mudança . Já os
diretórios são os sistemas de busca nos quais a indexação das páginas da
web é realizada por humanos.
5.1.1 O mecanismo de busca (Crawler-Based Search Engines)
O
mecanismo
de
busca
é
formado
principalmente
por
três
componentes:
- um programa denominado crawler, o qual acessa as páginas web e
faz uma cópia do conteúdo textual desta. Esta cópia será armazenada em
sua base de dados.
- a base de dados que é formada pelas cópias que o crawler realizou.
Esta fica armazenada no computador, o qual também, é chamado de servidor
do mecanismo de busca.
7
- o programa de busca, o qual é acionado quando o usuário realiza uma
pesquisa. Este então percorre a base de dados em busca das URLs que
contém a palavra ou frase pesquisada. Logo após, estes links são retornados
ao usuário.
Para criar a base de dados de um mecanismo de busca, o crawler
acessa os sites da web. Ao passar pelas páginas de cada site, ele anota as
URLs existentes nestas para depois acessá-las. Portanto, visitar as páginas
web, fazer a cópia e o armazenamento na base de dados do que ele
encontrar nesses sites é uma das formas de um mecanismo de busca
encontrar os sites na web. Uma outra maneira é o proprietário do site
informar ao mecanismo de busca sua URL.
5.1.2 Diretórios (Human-Powered Directories)
Os diretórios são formados por dois componentes principais: a base de
dados e o buscador que realiza a pesquisa.
A análise, indexação das páginas e armazenamento destas na base de
dados é realizada por humanos, e não por programas (crawler) como no
mecanismo de busca. Ao contrário dos mecanismos de busca, que copiam
todo o conteúdo das páginas que encontram pela frente e armazenam isto em
suas bases de dados, os diretórios armazenam somente um resumo do
conteúdo do site catalogado em sua base de dados. Muitas vezes esse
resumo que fica na base de dados do diretório contém, apenas, o título do
site mais duas ou três frases sobre o assunto nele contido. Esse resumo
tanto pode ser elaborado pelo autor da página ou por quem a submete como
por um editor, dependendo do diretório.
5.1.3 Diferenças entre Mecanismos de Busca e Diretórios
Ambos têm a mesma finalidade, que é a indexação e a recuperação de
páginas da web. Porém, existem duas diferenças fundamentais entre os
diretórios e os mecanismos de busca.
Uma diferença é a maneira de o diretório encontrar na web os sites a
serem por ele indexados. No mecanismo de busca, o crawler vai acessando
8
os sites na internet mundial. Já o diretório espera que o usuário ou o dono do
site apresente a página a ele.
Porém, a principal diferença entre eles é que nos d iretórios, são
humanos que constroem suas bases de dados e analisam as páginas a
serem indexadas nesta. É você que deve informar ao diretório o título, o URL, a
descrição do conteúdo e a categoria a que o site pertence.
Seja utilizando mecanismos de busca ou diretórios, vale destacar que
ao realizar uma pesquisa, você não está pesquisando diretamente a web,
mas sim uma base de dados localizada num site da web. Nessa base de
dados, encontra-se uma cópia dos sites e páginas existentes na web, como
se fosse uma fotografia do site.
Outro ponto relevante é que nenhum sistema de busca tem em sua
base de dados toda a Wweb catalogada, todas as 1 bilhão de páginas.
5.2 Lucene
Uma ferramenta extremamente útil para indexação de textos com alta
performance é o Lucene, desenvolvido inteiramente em Java pela Apache
Software Foundation. Isso torna possível executar buscas de qualquer dado
que possa ser transformado em texto. O recurso pode ser aplicado para, por
exemplo, localizar palavras inclusive em documentos PDF, que anteriormente
foram transformados em textos e indexados pelo Lucene. O Lucene também
suporta outras linguagens além do Java, como C, C++, Delphi, C#, PHP e
Ruby.
O processo de indexação possui uma fase de análise e transformação
do documento em questão para arquivo de texto puro (txt). Esta passo é
realizado a partir da classe Analyser, que possui as devidas regras para este
processo de retirada do conteúdo. Porém, existem várias implementações
desta
classe
Analyser
que
fazem
este
trabalho.
Uma
delas
é
a
BrazilianAnalyser, que contém as stopwords portuguesas. Stop words são
palavras irrelevantes para o nosso índice. Por isso, nada impede que você
crie o seu Analyser com as suas próprias stop words.
9
O passo seguinte é a organização do índice, que será acessado
futuramente em pesquisa, já que o Lucene possui classes que defi nem a
estrutura interna do sumário a ser gerado.
A seguir outras classes importantes do Lucene:
- Document: A classe Document é responsável pela indexação e
pesquisa, que permite armazenar campos (Fields).
- Fields: um field pode somente ser armazenado em um Document,
pois possui como característica um nome e um valor. Desta forma, é
impossível armazenar dois Fields com o mesmo nome em um documento.
Porém, um documento pode ter mais de um Fields.
- Directory: a classe Directory é responsável por indicar onde está o
índice. O armazenamento dos Documents é feito no Directory.
Na ilustração do fluxo do processo de indexação no Lucene o processo
fica mais claro:
Figura 1 – Fluxo do processo de indexação no Lucene
- IndexWriter: o IndexWriter é o responsável pela criação do índice, ao
qual, através desta classe, pode-se adicionar Documents.
- IndexSearcher: tem o papel de executar a busca no índice.
10
- Query: é através do objeto Query que os critérios de busca são
passados para a função de busca do Searcher.
- TermQuery: o objeto Query é construído através da TermQuery, para
o qual passamos como parâmetro o nome do campo a ser procurado e o valor
que ele contém.
Segue um exemplo simples de Indexação:
1 import java.io.FileInputStream;
2 import java.io.FileReader;
3 import java.io.IOException;
4 import org.apache.lucene.analysis.Analyzer;
5 import org.apache.lucene.analysis.standard.StandardAnalyzer;
6 import org.apache.lucene.document.Document;
7 import org.apache.lucene.document.Field;
8 import org.apache.lucene.index.IndexWriter;
9 import org.apache.lucene.store.Directory;
10 import org.apache.lucene.store.FSDirectory;
11
12 public class Main {
13
public static void main(String[] args) {
14
Document document = new Document();
15
try {
16
FileInputStream arquivo = new
FileInputStream("c:/arquivo.txt");
17
Directory directory =
FSDirectory.getDirectory("c:/indice", true);
18
Analyzer analyzer = new StandardAnalyzer();
19
IndexWriter writer = new IndexWriter(directory,
analyzer, true);
20
document.add(new Field("arquivo",
"c:/arquivo.txt",Field.Store.YES, Field.Index.NO));
21
document.add(new Field("conteudo", new
FileReader(arquivo.getFD())));
22
writer.addDocument(document);
23
writer.close();
24
arquivo.close();
25
26
27
} catch (IOException e) {
28
e.printStackTrace();
29
}
30
}
31 }
Figura 2 – Exemplo de código para Indexação usando o Lucene
Na linha 14 é declarado o Document, o qual será armazenado no índice.
Então se carrega o arquivo.txt através do FileInputStream. Este possui o seguinte
conteúdo:
11
“JDK 6 with Java EE
Java EE provides web services, component-model, management, and
communications APIs that make it the industry standard for implementing
enterprise-class service-oriented architecture (SOA) and Web 2.0 applications.
Build native code with easy Java Native Interface (JNI) connections, or
accelerate your Java development by leveraging DTrace, Containers, and ZFS.
Get Sun's latest development platform with Sun Studio compilers and tools for
C/C++/Fortran, NetBeans IDE, and the next-generation Solaris operating
system all in the Solaris Express, Developer Edition.”
Foi escolhido este texto pois o exemplo utiliza a classe StandardAnalyser, que
utiliza as stop words em inglês.
A classe Directory informa o diretório onde serão armazenados os arquivos do
Lucene. O parâmetro “true” informa que um novo índice será criado, ou apagado
se existir um. A classe Analyser é responsável pela extração do texto. A IndexWriter
recebe como parâmetro o Directory e o Analyser para salvar do índice.
Um das partes do código mais importantes é a criação do objeto Document e
a disposição dos respectivos Fields. No exemplo está sendo criado dois Fields, um
para armazenar o nome do arquivo e o outro para guardar o conteúdo.
Na linha 20, adiciona-se um Field para o Document com o nome arquivo e o
seu
conteúdo
é
o
nome
do
arquivo
do
FileInputStream.
O
parâmetro
“Field.Store.YES” define que o Field deve ser armazenado no índice. Já o
segundo parâmetro define que o Field não deve ser indexado. Em outras palavras, o
campo arquivo é armazenado no índice, mas não é um campo indexado, servindo
somente para informar o nome do arquivo que foi indexado.
Na linha 21, o primeiro parâmetro indica o nome do Field e o segundo um
FileReader que fornece a leitura de uma cadeia de caracteres. Este Field será
armazenado e indexado.
O Lucene é utilizado por várias engines de busca, como por exemplo o site da
Wikipedia, SouceForge, e por outro software de busca desenvolvido pela Apache, o
Nutch.
12
5.3 Nutch
A ferramenta Nutch é um programa open source de busca na Web escrita
inteiramente em Java, que pode ser usada em escala global, local e até pessoal.
Seu objetivo inicial era de proporcionar uma alternativa transparente para busca na
Web atendendo aos interesses do usuário. Uma de suas características é a
habilidade de explicar os seus resultados. Para fazer um crawl na escala global, são
necessárias várias máquinas rodando no mesmo instante e, mesmo assim, pode
demorar semanas para ser finalizada. Portanto, será usado o processo de crawl para
sites específicos.
O Nutch fornece todas as ferramentas necessárias para a construção de seu
próprio sistema de busca. Mas qual o motivo de uma pessoa querer construir sua
própria máquina de busca? O primeiro motivo é a transparência no retorno de
resultados. Estes estão livres de interesses comerciais numa ferramenta própria.
Outro é o entendimento de como um sistema de busca funciona e seus critérios de
retorno da pesquisa, os quais no caso de um sistema próprio é a relevância para
com o assunto abordado pelo usuário.
5.3.1 Funcionamento
A ferramenta Nutch é dividida em praticamente quatro partes, que são:
- Searcher: tendo uma pesquisa, ele rapidamente deve retornar os links para
os artigos mais relevantes.
- Crawler: cria um índice de onde o searcher busca seus resultados. O Nutch
usa o Lucene para armazenar os índices.
- Database: armazena as propriedades dos documentos para indexação e
mais tarde para a sumarização pelo searcher. Também são armazenadas
informações adicionais da página, como a estrutura do link da página e a última vez
que o documento foi modificado.
- Fetcher: pede as páginas da Web, as analisa, e extrai seus links.
13
5.3.1.1 Crawler
Este realiza a ação de varrer as páginas da Web, indexa e segmenta seu
conteúdo para armazenamento. Estes segmentos são armazenados na WebDB
(Web data base), a base de dados do Nutch.
Para iniciar um crawl, basta dar o seguinte comando:
bin/nutch crawl urls.txt -dir diretorio_crawl -depth 3 >& crawl.log
Com este comando, o crawl vai indexar as páginas do domínio descrito no
arquivo urls.txt com profundidade 3 e armazenará este na pasta diretório_crawl,
criando um log deste.
O crawl é um processo cíclico. Este gera um jogo de fetchlists (lista que
contém as URLs para indexação) do WebDB, atualiza a base de dados com novos
links encontrados e então o crawler gera um novo jogo de listas. Este é o cilco
conhecido como generate/fetch/update, o qual é executado até que o índice (index)
esteja atualizado.
A seguir, os passos que a ferramenta crawl percorre durante o processo:
1. Criação da base de dados (WebDB).
2. Armazenamento da URL do domínio do site em questão na WebDB.
3. Geração de uma lista (fetchlist) da WebDB num novo segmento (contém os
dados retirados da WebDB).
4. Atualização da WebDB com os links das páginas encontradas.
5. Atualização dos segmentos com os links da WebDB.
6. Indexação das páginas encontradas.
7. Eliminação das URLs duplicadas do índice.
8. Junção das indexações em um único índice.
Após criar uma base de dados (1), é iniciado o ciclo generate / fetch / update
(3-6). Este ciclo é repetido até a profundidade requisitada pelo comando do crawl for
atingida. Logo após este passo, indexam-se os segmentos separadamente até que
as URLs duplicadas sejam removidas (7-10). Enfim, as indexações são organizadas
num único índice (10).
14
5.3.1.2 Searcher
O sistema de busca do Nutch utiliza o índice e os segmentos gerad os
durante o processo de crawl para responder à pesquisa do usuário.
Os resultados da pesquisa são retornados utilizando o formato aplicado
pela maioria dos sistemas de busca. Porém, cada resultado possui uma
opção a mais que os sistemas de busca comuns, a qual e o link explain.
Ao clicar no link explain, aparecerão alguns dados da página e a
explicação do escore. Este último é uma propriedade do Lucene , a qual
mostra todos os fatores que contribuíram para o cálculo do escore da página
em questão. Esta característica ilustra o conceito de transparência no
programa open source, que mostra ao usuário o motivo pelo qual uma página
da Web ficou mais bem posicionada que outra.
Para utilizar o Nutch para pesquisa, é necessária a ferramenta Apache
Tomcat. Basta instalá-la, acessar o link http://localhost:8080/manager/html e
fazer o deploy do arquivo nutch-0.9.war. Logo após, é necessária a
modificação do arquivo nutch-site.xml, encontrado na pasta do diretório
do tomcat (.../webapps/nutch-0.9/WEB-INF/classes/) para que o Tomcat
encontre a sua pasta do crawl. Este arquivo nutch-site.xml deverá ficar
da seguinte forma:
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<!-- Put site-specific property overrides in this file. -->
<nutch-conf>
<property>
<name>searcher.dir</name>
<value>DIRETÓRIO DA PASTA CRAWL</value>
</property>
</nucth-conf>
Figura 3 – Arquivo nutch-site.xml cofigurado
Após isso, basta clicar sobre o link nutch-0.9 no Tomcat e pesquisar.
Porém, o projeto consiste na utilização do Nutch como ferramenta de
programação, e não somente como programa. Portanto no capítulo seguinte
será descrito como usar suas bibliotecas para construir um programa de
busca.
15
CAPÍTULO VI - TB²uscador
Este capítulo irá se aprofundar em como este projeto foi implementado,
os passos dados e de onde partimos para chegar ao programa implementado.
O objetivo deste projeto é o de facilitar a pesquisa na internet por
referências. Uma maneira de chegar a este é fornecer uma ferramenta open
source de fácil manuseio que busque fontes na Web.
Mas como pode-se utilizar as bibliotecas do Nutch para implementação
de um programa de busca? Para poder utilizar com mais facilidade, o é
interessante que o programa seja escrito em Java, pois o Nutch é
inteiramente
escrito
nesta
linguagem.
Para
demonstrar
uma
simples
aplicação da Application Programming Interface (API) do Nutch, segue o
código abaixo com os devidos comentários:
package org.tiling.nutch.intro;
import java.io.IOException;
import org.apache.nutch.searcher.Hit;
import org.apache.nutch.searcher.HitDetails;
import org.apache.nutch.searcher.Hits;
import org.apache.nutch.searcher.NutchBean;
import org.apache.nutch.searcher.Query;
public class SearchApp {
//número de links que irão aparecer como resultado, se encontrados
private static final int NUM_HITS = 10;
public static void main(String[] args)throws IOException {
//classe central do Nutch, que faz a busca
NutchBean bean = new NutchBean();
//a fila de busca
Query query = Query.parse(args[0]);
Hits hits = bean.search(query, NUM_HITS);
//pega os resultados da busca
for (int i = 0; i < hits.getLength(); i++) {
Hit hit = hits.getHit(i);
//pega os detalhes da página em questão
HitDetails details = bean.getDetails(hit);
String title = details.getValue("title");
String url = details.getValue("url");
String summary = bean.getSummary(details, query);
//mostra os resultados
System.out.print(title);
System.out.print(" (");
System.out.print(url);
System.out.println(")");
System.out.println("\t" + summary);
}
}
}
Figura
4 – Exemplo de código usando a API do Nutch
16
Partindo das bibliotecas do Nutch, que por sua vez utiliza o Lucene, foi
implementado uma versão inicial do programa TB²uscador. Ele consiste na
utilização do Nutch para realizar o processo de crawl e de busca.
O TB²uscador foi implementado em Java, para facilitar o uso das
bibliotecas do Nutch. Ele é separado principalmente em duas partes: a
interface gráfica e a lógica do programa. Ao abrir o programa, o usuário irá
ver a seguinte imagem:
Figura 5 – Programa TB²uscador
Ao realizar a pesquisa, o programa irá utilizar o Nutch para fazer tal. A classe
NutchBean
da
API
do
Nutch
irá
chamar
o
seu
método
search(query,NUM_HITS), o qual recebe como parâmetro a busca e o número
máximo de resultados que o programa irá retornar. A busca é feita nos sites
indexados. Então, o programa captura os detalhes de cada página encontrada e as
retorna, respeitando a formatação padrão dos principais buscadores atuais. Cada
resultado é armazenado num array da classe Resultado. Esta classe possui como
atributos o title (título da página), contexto (resumo do conteúdo) e a própria URL da
17
página. Podem ser realizadas diversas pesquisas, com cada uma delas encontradas
em uma nova aba no programa.
Figura 6 – Pesquisa no TB²uscador
O número de resultados retornados pode ser configurado no menu
Configuration do programa.
Para fazer com que os links aparecessem no EditorArea do programa, foi
necessário um tratamento especial com html. A classe HTMLCreator cria apartir
dos resultados da classe Resultados o html que é carregado pelo Editorarea.
Os evento gerados pelo clique nos links são capturados e enviados a classe
Console.
A classe Console é responsável pelo acesso aos links. Ao clicar num dos
links
retornados,
será
executado
o
comando
do
shell
pelo
Java
(Runtime.getRuntime().exec("firefox "+url)) para abrir o documento
em questão pelo Mozilla Firefox sendo ele qualquer tipo. Se o Firefox já estiver
18
aberto,
então
o
documento
será
acessado
em
uma
(Runtime.getRuntime().exec("firefox -new-tab "+url)).
nova
aba
Portanto, o
usuário faz a pesquisa, o TB²ucador usa a API do Nutch para realizar a busca nos
sites indexados, mostra os resultados para o usuário em formato de hyperlink e, ao
clicar sobre estes, o conteúdo da página é aberto utilizando o Firefox.
Figura 7 – Menu Configuration
Para a próxima versão do programa, está sendo implementada a opção busca
avançada, a qual faz uma busca aprofundada sobre o assunto. Ela utilizará a
seguinte estratégia: fará uma busca simples, acessará o conteúdo de quantos site o
usuário configurar, armazenará as principais palavras destes documentos e fará a
busca novamente, só que agora serão estas palavras principais que serão a
pesquisa em si. Para realizar este processo, está sendo usada como base para
implementação uma importante ferramenta: o WVTool, que retira as principais
palavras do documento. Porém, está sendo necessária a implementação de um
novo WVTool, pois este apresenta o problema de freqüência das palavras, ou seja,
ele retira as palavras importantes do texto, mas com a freqüência errada com que
19
aparecem. O problema parece estar relacionado à escala de busca; por meio de
testes realizados pôde-se ver que quanto maior o número de fontes, maior era a
precisão das freqüências. Assim, a nova versão do WVTool esta sendo adaptada
para varreduras em menor escala, como é o caso do projeto. Este usa como critério
de seleção as Stop Words. Estas são palavras irrelevantes para aplicar numa nova
busca. São palavras como: a, aos, apenas, bem.
Devido a esse problema do WVTool foi implementada uma versão inicial de
uma pequena framework com as funcionalidades necessárias para a partir de um
documento no formato texto retirar as palavras mais freqüentes excluindo as Stop
Words.
Outra ferramenta necessária para o programa é a opção de o usuário realizar
as suas próprias crawls de maneira fácil, em ambiente gráfico. Para isso, são
necessárias algumas modificações. Estas consistem na configuração do arquivo
nutch-default.xml e nutch-site.xml, em que ambos é necessária a
modificação para indicar o diretório da pasta do novo crawl realizado. Para isso, será
desenvolvida uma classe Java, a qual executará comandos no Shell para extrair os
devidos arquivos da biblioteca nutch-0.7.2.jar, modificá-los, compactá-los
novamente e adiciona-los no projeto outra vez. Algo parecido com o que já foi
implementado para indicar o diretório plugins no arquivo nutch-default.xml, o
que é necessário para o funcionamento correto da busca do nutch.
Com esta opção, o usuário facilmente poderá indexar suas próprias páginas
com facilidade, é só digitar a URL e adicionar. Pode-se observar também a opção
profundidade neste menu, a qual controla com que profundidade a o domínio em
questão será indexado.
20
Figura 8 – Menu Crawl
6.1 Passos do Projeto
O primeiro passo para chegar a este ponto foi o de analisar o problema de
pesquisa. Qual seria o tema abordado pelo projeto? Ao refletir a respeito do assunto,
chegou-se a uma conclusão de que o projeto abordaria a área de buscas na Web.
Primeiramente, foi proposto o tema de busca de plágios por parte dos
estudantes. Este seria uma nova extensão de documentação (.bbt por exemplo) que
faria a contagem de caracteres realmente digitados, ou seja, iria detectar o famoso
“CTRL+C CTRL+V”. Porém, este seria inviável devido ao tempo máximo para
concluir o projeto e por falta de conhecimento por parte dos projetistas, pois este
exige um nível de conhecimento não adquirido ainda. Com a mesma idéia de
detecção de plágio, surgiu um outro método para este fim: implementar um buscador
que retirasse trechos do trabalho em questão e buscasse pela Web artigos
parecidos. Porém, este projeto não teria a devida relevância acadêmica, pois os
estudantes em vez de realizar a pesquisa, tentariam burlar o programa.
21
Descartada esta primeira hipótese, surgiu a idéia de implementar um
programa que realizasse a busca por artigos científicos, o TB²uscador. Após um
aprofundamento teórico em sistemas de busca, foi iniciada a procura por uma
ferramenta open source que realizasse a busca. Com a ajuda dos orientadores, foi
enfim encontrada a ferramenta Nutch. Então, inicio-se a fase de configuração do
Nutch. A versão do programa sendo configurada era a mais atual, a Nutch-0.9.
Seguindo o tutorial do deste, foram realizadas as devidas configurações e, com um
site indexado, o Nutch fazia a pesquisa neste. Para rodá-lo, foi necessária a
ferramenta Apache Tomcat. Porém, para utilizar a API do Nutch, era necessária a
versão Nutch-0.7, para o código exemplo encontrado. Portanto, houve a migração
de versão. A 0.7 possui diferentes configurações. Desta forma, levou-se um bom
tempo para a adaptação com este. Com as devidas mudanças feitas, iniciou-se a
fase de implementação.
Partindo de um código exemplo, foi implementado um buscador (que
pesquisa no site indexado) que retornava seus resultados num array na forma de
Strings. Esta versão se chamava Nuts. Então, foi utilizado um tratamento com html
para a que estes aparecessem em forma de link. Com isso, começou-se a
implementar a parte gráfica do programa e houve a mudança no nome: TB²uscador.
Para acessar os links, primeiro foi construída uma maneira que abriam estes
no próprio programa. Mas surgiram dificuldades, como abrir um documento PDF e
doc. Então, surgiu a idéia de executar o Mozilla Firefox para o acesso a estes
resultados, o qual abre vários tipos de documento. As novas pesquisas são abertas
em novas abas no TB²uscador, tornando mais prático o manuseio do programa.
A fase atual é a de implementação da busca avançada, a qual utiliza uma
ferramenta implementada que retira as palavras relevantes do documento da busca
simples para utilizar numa nova busca. Porém, esta ferramenta está funcionando
somente com documentos txt no momento. Está sendo desenvolvido um script para
retirada destas em documentos no formato PDF.
22
CONCLUSÃO
O desenvolvimento deste projeto é extremamente importante para a formação
teórico-prática dos desenvolvedores em programação Java, manuseio com html,
teoria e sistemas de busca e construção de scripts. Não somente por este motivo,
mas também por beneficiar a população com uma ferramenta open source de fácil
manuseio, que retorna resultados de acordo com a relevância da página para com o
tema pesquisado. Sem contar com a ferramenta de crawl facilitada, que indexa a
página que o usuário propor.
23
REFERÊNCIAS BIBLIOGRÁFICAS
SULLIVAN, D. Major Search Engines and Directories. Disponível em:
<http://searchenginewatch.com/showPage.html?page=2156221>. Acesso em:
29 out. 2007.
SULLIVAN,
D.
How
Search
Engines
Work.
Disponível
em:
<http://searchenginewatch.com/showPage.html?page=2168031>. Acesso em:
30 out. 2007.
MOURA, Gevilacio Aguiar Coêlho de. Sistemas de busca da web: diretórios e
mecanismos de busca. Disponível em: <http://www.quatrocantos.com/
tec_web/sist_busca/index.htm>. Acesso em: 31 out. 2007.
APACHE
LUCENE.
Getting
Started
Guide.
Disponível
em:
<http://lucene.apache.org/java/2_2_0/gettingstarted.html>. Acesso em: 30
out. 2007.
GOETZ, Brian. The Lucene search engine: Powerful, flexible, and free .
Disponível em: < http://www.javaworld.com/javaworld/jw-09-2000/jw-0915lucene.html >. Acesso em: 30 out. 2007.
MANNING, Christopher D.; RAGHAVAN, Prabhakar.; SCHUTZE, Hinrich.
Introduction to Information Retrieval. Cambridge University Press, 2008.
Disponível em:<http://www-csli.stanford.edu/~hinrich/information-retrieval-book.html>
Acesso em: 30 out. 2007. Slides.
APACHE SOFTWARE FOUNDATION. About Nutch. Disponível em:
< http://lucene.apache.org/nutch/docs/> Acesso em: 31 out. 2007.
APACHE SOFTWARE FOUNDATION. Nutch version 0.7 tutorial. Disponível
em: < http://lucene.apache.org/nutch/tutorial.html>. Acesso em: 28 out. 2007.
KHARE, Rohit.; CUTTING, Doug.; SITAKER, Kragen. Nutch: A Flexible and
Scalable
Open-Source
Web
Search
Engine.
Disponível
em:
<http://wiki.commerce.net/images/0/06/CN-TR-04-04.pdf>. Acesso em: 31
out. 2007.
24
WHITE,
Tom.
Introduction
to
Nutch.
Disponível
em:
<http://today.java.net/pub/a/today/2006/01/10/introduction-to-nutch-1.html>.
Acesso em: 31 out. 2007.
GUERRA, Gláucio. Possibilitando alta performance na indexação com o
Apache Lucene. Disponível em: <http://del.icio.us/lucasgameiro>. Acesso
em: 01 nov. 2007.
PAUL,
Thomas.
The
Lucene
Search
Engine.
Disponível
em:
<http://www.javaranch.com/newsletter/200404/Lucene.html>. Acesso em: 02
nov. 2007.
CAFARELLA, Mike.; CUTTING, Doug. Building Nutch: Open Source
Search.
Disponível
em:
<http://www.acmqueue.com/modules.php?name=Content&pa=showpage&pid=
144&page=1>. Acesso em 02 nov. 2007.
CASA BRASIL. Oficina do Astrolábio Digital: navegação e pesquisa na
internet.
Disponível
em:
<http://www.casabrasil.gov.br/oficinas/files/OficinaAstrolabioDigital ManualParticipante.pdf>. Acesso em: 02 nov. 2007.
BLUM, Thom ,; KEISLAR, Doug .; WHEATON, Jim .; WOLD, Erling. Writing a Web
Crawler in the Java Programming Language. Disponível em:
<http://java.sun.com/developer/technicalArticles/ThirdParty/WebCrawler>.
Acesso em: 04 nov. 2007
25
ANEXOS
Figura 9 – Diagrama de Classes
26