Lucas Teixeira

Neste fim de ano, estarei me divertindo com um novo projeto por aqui.

Usaremos JDeveloper como IDE e JSF como framework web. Particularmente não tenho boas impressões de JSF nem do JDeveloper, mas como apenas conheço comentários e opiniões de amigos, acredito ser uma boa oportunidade para tentar entender e um pouco deles e poder formar uma opinião própria com propriedade . Mas já adianto, não vou me apaixonar :)

Enfim, precisei já instalar o JDeveloper no meu Mac, e como várias coisas no mundo Oracle, precisam de alguns ajustes para rodar sem problemas no Mac.

O primeiro passo, é baixar o produto diretamente do site. O arquivo já vem no genérico .jar, então para rodar é na base do clássico

java -jar jdevstudio11111install.jar

Só que por algum motivo ele não identifica os JREs instaladas por default no mac, para isso, um pequeno ajuste deve ser feito, criando um link dentro da pasta onde a instalação do JDeveloper irá procurar o JRE.

Lembre-se que este processo deve ser feito antes de executar a instalação do pacote. Se você já havia iniciado, encerre-a e comece novamente.

cd /System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home
sudo mkdir -p jre/lib
cd /System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/classes/
sudo ln -s classes.jar ../Home/jre/lib/rt.jar

Pronto, agora basta iniciar a instalação padrão do JDeveloper sem mais problemas.

Bom pessoal, como disse no post anterior, hoje foi lançado o Solr 1.4 versão final.

O link para download é: http://linorg.usp.br/apache/lucene/solr/1.4.0/

Segue abaixo o e-mail oficial de lançamento, que acabou de cair na Lista de e-mails do framework, enviado pelo Grant Ingersoll.

Apache Solr 1.4 has been released and is now available for public download!
http://www.apache.org/dyn/closer.cgi/lucene/solr/

Solr is the popular, blazing fast open source enterprise search
platform from the Apache Lucene project.  Its major features include
powerful full-text search, hit highlighting, faceted search, dynamic
clustering, database integration, and rich document (e.g., Word, PDF)
handling.  Solr is highly scalable, providing distributed search and
index replication, and it powers the search and navigation features of
many of the world’s largest internet sites.

Solr is written in Java and runs as a standalone full-text search server
within a servlet container such as Tomcat.  Solr uses the Lucene Java
search library at its core for full-text indexing and search, and has
REST-like HTTP/XML and JSON APIs that make it easy to use from virtually
any programming language.  Solr’s powerful external configuration allows it to
be tailored to almost any type of application without Java coding, and
it has an extensive plugin architecture when more advanced
customization is required.

New Solr 1.4 features include
- Major performance enhancements in indexing, searching, and faceting
- Revamped all-Java index replication that’s simple to configure and
can replicate config files
- Greatly improved database integration via the DataImportHandler
- Rich document processing (Word, PDF, HTML) via Apache Tika
- Dynamic search results clustering via Carrot2
- Multi-select faceting (support for multiple items in a single
category to be selected)
- Many powerful query enhancements, including ranges over arbitrary
functions, and nested queries of different syntaxes
- Many other plugins including Terms for auto-suggest, Statistics,
TermVectors, Deduplication

Getting Started
——————–
New to Solr?  Follow the steps below to get up and running ASAP.

1. Download Solr at http://www.apache.org/dyn/closer.cgi/lucene/solr/
2. Check out the tutorial at http://lucene.apache.org/solr/tutorial.html
3. Read the Solr wiki (http://wiki.apache.org/solr) to learn more
4. Join the community by subscribing to solr-user@lucene.apache.org
5. Give Back (Optional, but encouraged!)  See http://wiki.apache.org/solr/HowToContribute

For more information on Apache Solr, see http://lucene.apache.org/solr

Pra quem acompanha a lista de discussões e o andamento do projeto, o Solr 1.4 já está prontinho para ser lançado tem algum tempo. O pessoal de dev estava apenas esperando o lançamento do Lucene 2.9 para oficializar o lançamento.

Quando então foi lançado, o pessoal do Solr empacotou o framework como RC, disponibilizou para download e na hora do lançamento (pra ser mais preciso, um dia antes), dois bugs significativos foram levantados no Lucene 2.9. A equipe do Solr os avaliou com calma, entrou em alinhamento com os devs do Lucene (alguns fazem parte de ambas as equipes) e decidiram por bem aguardar o Lucene 2.9.1 para efetuar o anúncio oficial do Solr 1.4.

Pois bem, com o lançamento oficial do Lucene 2.9.1 hoje a tarde, o pessoal do Solr já correu, e empacotou em uma versão final a release tão esperada, 1.4.

Amanhã, dia 07, será feito o lançamento final do Solr 1.4 sem mais delongas. Pois bem, é só aguardar! Mas se você quiser dar uma olhadinha antes, é só baixar os pacotes antes de serem replicados para o mirror central entrando aqui: http://people.apache.org/~gsingers/solr/1.4.0/.

Eu, em uma olhada muito, mas muito rápida por cima de algumas funcionalidades do Solr 1.4 (direto no wiki), levantei alguns pontos e encaminhei na lista de e-mails dos colaboradores da empresa em que trabalho. Não estão agrupados, muito menos organizados, mas segue como esboço e rascunho de um post que valeria a pena.

• SolrServer – SolrJ HTTP
  • Configuração
    • Timeout
    • Quantidade de retentativas
  • SolrJ altamente evoluído para criação da queries e integrado aos searchcomponents
• DataImportHandler
  • Transformers
    • Clob Transformer: Permite pegar dados direto de colunas clob no banco de dados
    • HTML Stripper: Atua em campos com conteúdo HTML, removendo tags e deixando apenas o conteúdo
  • Agora é possível usar o DIH indexando até conteúdos de um ‘datasource’ de e-mail, deixando ele fazer pooling em um e-mail e indexando o que chega.
  • Eventos callback após indexação
• Replicação
  • Configuração interna a aplicação – Funciona como um RequestHandler
  • Dashboard de administração, permite ver como estão as replicações, qual indice está em cada nó, status do download de novos indices
  • Permite replicação interna, via HTTP, não sendo mais necessário usar apenas rsync
    • Com isso, possibilidade de usar em windows
    • Menos configuração de infra estrutura
    • Maior visibilidade do status da replicação
• Indexação
  • indexação de grandes quantidades de documentos via streaming
    • conexão é aberta com o master, e permanece assim enquanto necessário.
  • Anotação @Field para poder adicionar um POJO direto ao índice, sem ter que transformar em SolrInputDocument
• Componentes de busca (alguns presentes no 1.3 completos, outros eram beta, outros nem existiam)
  • Sugestão de busca
  • Spelling
  • Highlight
• Resposta da busca em vários novos formatos
  • php nativo
  • json (já existia mas não era oficial)
  • xml (normal)
  • ruby

E muito mais…

Se você usa um Mac e navega com o Safari, com certeza sofre pra visualizar XMLs nele, fica como o firefox antigo, uma bagunça.

Neste caso, acaba tendo que abrir o source da página para conseguir ler o conteúdo.

Este plugin do safari, chamado XMLView Plugin com certeza me ajuda muito e pode te ajudar. É muito simples, basta descompactar seu conteúdo em $HOME/Library/Internet Plug-Ins e reiniciar o navegador.

Depois de reiniciar o Safari, abra qualquer XML e faça o teste! Use e abuse do layout bem definido e opções de expand/collapse dos nós. Veja abaixo um exemplo:

Safari vendo XML com o plugin XMLView Plugin

Se gostou, me deve um real. :)

Já precisou alterar as opções de uma combo com javascript? Pra variar, o JQuery tem algo pronto para isso, basta usar a função appendTo.

É como eu estava dizendo para a @loiane e para o @cmilfont no twitter sexta. Não tem nada mais poderoso que javascript. :)

//insere faixas de preço para compra
$("<option value='0-200000'>Até 200 mil</option>").appendTo("#cmbValor");
$("<option value='200000-300000'>De 200 mil a 300 mil</option>").appendTo("#cmbValor");
$("<option value='300000-400000'>De 300 mil a 400 mil</option>").appendTo("#cmbValor");
$("<option value='400000-500000'>De 400 mil a 500 mil</option>").appendTo("#cmbValor");
$("<option value='500000-700000'>De 500 mil a 700 mil</option>").appendTo("#cmbValor");
$("<option value='700000-1000000'>De 700 mil a 1 milhão</option>").appendTo("#cmbValor");
$("<option value='1000000-2000000'>De 1 a 2 milhões</option>").appendTo("#cmbValor");
$("<option value='2000000-0'>Acima de 2 milhões</option>").appendTo("#cmbValor");

Para limpar o conteúdo do select, basta definir o html interno como vazio.

$("#idDoMeuSelect").html("");

Passei agora pela seguinte situação:

Possuía uma lista de objetos (pogos) com várias propriedades, e a partir desta lista, eu precisaria de uma nova lista com apenas os ids de cada um destes objetos, ao invés da clássica iteração para se resgatar os valores, acabei usando o método collect, que recebe uma closure, e para cada objeto da lista, aplica esta closure!

Para quem conhece, funciona da mesma maneira que o FileFilter do Java, que é usado para filtrar arquivos dentro de um diretório.

def listaPogos = ...
def listaIds = listaPogos.collect { pogo ->
   pogo.id
}

Quer ver funcionando? Clique aqui para rodar o código no Groovy Web Console

Uma dica pra acompanhar o uso do seu banco de dados, e saber o que o hibernate e o gorm estão fazendo por trás dos panos, é logar as queries que estão sendo feitas.

Você pode acompanhar isto detalhadamente configurando seu DataSource.groovy para fazer isso com o parâmetro loggingSql. E o mais bacana na minha opinião é poder fazer isso de forma independente para cada ambiente. Lembre-se que por default esta configuração vem desligada.

environments {
  development {
    dataSource {
      url = "..."    //banco de dev
      loggingSql = true
    }
  }
  test {
    dataSource {
      url = "..." //banco de testes
    }
  }
  production {
    dataSource {
      url = "..." //banco de produção
    }
  }
}

Se em grails você precisar renderizar um XML como resposta de uma action, use o método render junto com o builder de XML que temos disponível. Muito fácil, rápido e objetivo.

No exemplo abaixo, um parâmetro nome é passado para a action, que faz uma consulta baseado neste parâmetro e nos nomes dos clientes.

def busca = {
   def clientes = Cliente.findAllByNomeIlike("%${params.nome}%")

   render(contentType: "text/xml") {
      results() {
         clientes.each {
            cliente -> result() {
               id(cliente.id)
               nome(cliente.nome)
            }
         }
      }
   }
}

Explicando o auto-explicativo:

Linha 2: Usamos um método dinâmico do grails (não, este método não existe na classe) que permite que eu localize todos os clientes (findAll) por seus nomes (byNome) Ilike (case insensitive) usando o parâmetro nome que veio no request. Esta lista é armazenada na referência clientes.

Linha 4: Pela funcão render deixamos claro que iremos renderizar um conteúdo text/xml

Linha 5: Esta será a nossa tag root do xml: results. A closure que se abre definirá os filhos deste nó.

Linha 6: Cada cliente na lista retornada…

Linha 7: Será um novo nó result do XML de resposta

Linhas 8 e 9: Os fois filhos de result, teremos o id do cliente e seu nome, suficiente para uma combo com auto-complete!
O resultado foi como esperado, e o tempo de fazer o exemplo funcionar foi definitivamente menor que o de escrever este post!

<results>
   <result>
      <id>313</id>
      <nome>JOSE DA SILVA</nome>
   </result>
   <result>
      <id>817</id>
      <nome>PATRICIA MARIA SILVA E SILVA</nome>
   </result>
   <result>
      <id>91</id>
      <nome>MARCOS SILVINO</nome>
   </result>
</results>