java.lang.UnsupportedClassVersionError: Bad version number in .class file

Após decompilar uma classe (aproveitando, usei o JD-GUI que funcionou bem no MacOS) que estava rodando no servidor (e *MEH* eu não tinha o fonte), alterar, recompilar na minha máquina e jogar de volta pro servidor, comecei a receber a mensagem de erro. Após revisar todas as configurações do Eclipse (Java Compiler específico no projeto, JRE System Library correto) continuei recebendo o mesmo erro.

Depois de procurar muito, descobri que mesmo alterando todas as configurações no Eclipse, na pasta do projeto ainda ficou um arquivo configurado pra java 6.0. Então se enfrentar o mesmo problema, procure pelo arquivo:

$PROJECT_ROOT/.settings/org.eclipse.jst.common.project.facet.core.prefs

E edite alterando a JRE para a correta para o seu projeto.

É exatamente esse a impressão que eu tenho depois de migrar os nossos servidores para o Jetty. Depois de ver muita gente reclamando de OutOfMemory no Tomcat, inclusive aqui da empresa, resolvemos tentar o Jetty.

A tempo que escutava o pessoal da Caelum (e principalmente o Kung) falando bem do Jetty, mas só quando se começa a usar que se percebe as vantagens. Como temos várias aplicações rodando (diferente do GUJ, que era só o JForum, acredito), imaginei que a troca não seria tão smooth assim.

Claro que antes de sair trocando tudo, fizemos alguns testes pra ter certeza que tudo ia ocorrer bem. Por sinal, a troca foi bem tranquila do ponto de vista da aplicação, só tivemos que fazer alguns ajustes:

• o Jetty lança java.util.Collections$UnmodifiableMap ao tentar modificar diretamente o (Hash)Map devolvido com request.getParameterMap() ao invés de usar o método setAttribute() do request – coisa que o Tomcat deixa;
• Diferenças ao tentar recuperar um resource do sistema utilizando como pasta base “.”, ou usar “..” pra navegar na estrutura de pastas. Para resolver, basta usar como pasta base “/” (ex: “/com/foo/resources/xpto.xml”) e colocar dentro do WEB-INF/classes;
• E a última, mas simples de resolver, é que o Jetty deixa habilitado listagem de diretórios. Você pode alterar isso no etc/webdefault.xml, trocando o atributo dirAllowed para false;

Feitos esses ajustes, chegou a vez de configurar o Jetty para atender aos diferentes domínios. E é aqui que vi uma das grandes vantagens do Jetty. A parte de configuração dele fica muito organizada. Fizemos da seguinte forma:

• Para cada aplicação (pra cada .war na pasta /webapps do Jetty), criamos um arquivo de contexto no /contexts (não é necessário, mas como temos urls diferentes e contextos diferentes, tivemos que customizar – e acabamos ganhando um brinde que conto depois)
• Cada arquivo de context tem uma estrutura estupidamente simples:

  
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE Configure PUBLIC "-//Mort Bay Consulting//DTD Configure//EN" "http://jetty.mortbay.org/configure.dtd">
<Configure class="org.mortbay.jetty.webapp.WebAppContext">
  <Set name="contextPath">/</Set>
  <Set name="war"><SystemProperty name="jetty.home" default="."/>/webapps/demo_foo.war</Set>
  <Set name="defaultsDescriptor"><SystemProperty name="jetty.home" default="."/>/etc/webdefault.xml</Set>

  <Set name="virtualHosts">
    <Array type="String">
      <Item>demo.foo.com</Item>
    </Array>
  </Set>

</Configure>


Explicando por partes:

• WebAppContext é o tipo de contexto que você vai usar, estamos usando esse pois permite o hotdeploy
• contextPath serve para dizer (óbvio) o contexto que quer que a aplicação fique disponível. Aqui prefirimos colocar todas no contexto / e configurar diferentes Virtual Hosts pra cada aplicação.
• a propriedade war só diz qual .war (que pode ser um exploded war também) que vai ser deployado naquele contexto
• na seção que diz virtualHosts, você pode configurar todos os endereços que quer que sua aplicacão responda. Para ela aceitar mais de um endereço, basta ir adicionando Item’s com as outras URLs. Aproveitando, no Jetty 7 será possível usar wildcards!

Com isso feito, ficou muito fácil configurar o deploy automático de todas nossas aplicações, pois basta substituir o arquivo .war e dar um touch no arquivo de contexts que o Jetty faz reload do contexto (e esse é o brinde! )! Agora, com o Jetty combinado ao Hudson, com um clique podemos fazer deploy de qualquer uma das nossas aplicações em um ambiente específico ou mesmo em todos, automaticamente. Mas isso já é assunto para um outro post.

Links Relacionados

• Melhorando o GUJ: Jetty, NIO e load balancing
• Jetty Documentation

Quem programa em Java e nunca passou por esse problema? Você está desenvolvendo, tudo funciona perfeitamente, quando a aplicação vai para produção e os usuários começam a usar você percebe que o contador de conexões disponíveis no seu pool só diminui.

As razões para isso podem ser as mais variadas (sendo a maioria deles problemas da aplicação e não algo ligado ao data source, servidor de aplicação ou mesmo driver jdbc), mas as mais comuns são:

• ausência de chamada ao connection.close();
• falta de um tratamento de excessões, e conseqüentemente, o método close() não é chamado;

É importante saber, que sempre que você estiver lidando diretamente com Connection (o que não é algo muito aconselhável, sabendo que já existem diversos frameworks que abstraem/simplificam a utilização de jdbc), você deve fechar ela através do método close() e o mesmo deve estar dentro de um bloco finally{}, para que ele seja executado mesmo se ocorrer um problema durante a execução do seu código.

Mas e quando você já revisou “todo” seu código e mesmo assim as conexões continuam vazando? Você olha as conexões do seu pool e elas simplesmente parecem ir para o limbo. Aqui alguns já podem começar a se perguntar, “mas tem como eu monitorar as conexões do meu pool?”. E é aqui que entra um recurso não muito conhecido (e menos ainda, usado): Java Management Extensions ou simplesmente JMX.

Copiando o site da Sun:

JMX technology provides the tools for building distributed, Web-based, modular and dynamic solutions for managing and monitoring devices, applications, and service-driven networks. By design, this standard is suitable for adapting legacy systems, implementing new management and monitoring solutions, and plugging into those of the future.

A maioria (se não todos) dos application servers já vem com recursos JMX prontos pra monitoramento e diagnóstico de connection leaks. Ativar o monitoramento do data source pode muitas vezes sacrificar um pouco da performance da aplicação (principalmente em um arquitetura Database-Centered), mas normalmente é um custo aceitável para descobrir os pontos de perda das conexões.

No JBoss, servidor de aplicação que eu utilizo no meu atual projeto, ligar o monitoramento é bem simples. Quando ativo, ele basicamente armazena o stack trace de todos os pontos onde temos chamadas à getConnection(), até que essa conexão sehja devolvida ao pool. Para ligar o monitoramento, altere o arquivo de configuração do seu data source(provavelmente um *-ds.xml) adicionando a linha abaixo
<local-tx-datasource>
.....
<track-statements>true</track-statements>
</local-tx-datasource>

Agora basta acessar o mbean CachedConnectionManager através da interface JMX do Jboss e invocar listInUseConnections() para ver o stack trace das conexões que não foram fechadas. Provavelmente vai ser algo semelhante à essa. Se você quizer apenas ver como anda seu pool, acesse o mbean ManagedConnectionPool, procurando principalmente pelos seguinte valores:

• AvailableConnectionCount – total de conexões disponíveis no pool
• InUseConnectionCount – total de conexões sendo usadas atualmente
• ConnectionCount – indica o total de conexões abertas atualmente no pool

Utilizando esses recursos e tendo um pouco de paciência, fica bem mais fácil achar os pontos de vazamento da aplicação.

Mais informações:

• Jboss DataSources
• Connection Leak Tracing – Sun Application Server
• Bea WebLogic – Profile Connection Leak
• IBM Web Sphere Aplication Server – Connection Leak Diagnostics
• The Joy of Finding Connection Leaks

Quem lê meu blog já à algum tempo, sabe que eu uso o Eclipse como principal ferramenta de trabalho. O que poucos sabem é que todos podem colaborar nas decisões do projeto, e de quebra, priorizar as correções de bugs e melhorias. Pra dar um empurrãozinho nos preguiçosos, segue minha lista atual de votos.

Community

• 71735 – Eclipse source repository should convert to subversion.
• 177497 – Bug status explanation page does not mention RESOLVED REMIND
• 178923 – Remove LATER and REMIND resolutions when Bugzilla 3.0 is released

JDT

• 182064 – Should be possible to “Migrate JAR File” in User Libraries
• 182071 – [1.5][compiler] Unnecessary cast detection fails on ternary operation

Platform

• 2009 – [EditorMgmt] Need to sort out handling of out-of-synch resources (1GDFD96)
• 8009 – [Editor Mgmt] Split File Editor
• 14916 – [Navigator] How can I recover from a “resource is out of sync” problem ?
• 19419 – [resources] Cancellation during file transfer leaves files out-of-sync
• 35973 – [resources] Better project organization
• 46207 – [Workbench] [Services] Combine, compose, nest workbenchparts and editorparts
• 52338 – [find/replace] regex replace with newline doesn’t insert anything
• 92250 – [Workbench] Excessive amount of Permanent Generation memory reported by the VM
• 102527 – [Wizards] Add support for projects refactoring (ie add/remove nature)
• 118294 – Renaming an External Tool Builder (set to run during Auto Builds) causes error
• 134416 – “Run As..” – “Ant Build” results in “Unable to find ant file to run”
• 142364 – Replacing a large number of files hangs Eclipse
• 163714 – Update manager interactively asks for mirror selection
• 167660 – Out of sync not refreshed after file is closed
• 169121 – cpu get >50 when I did refactor to a method
• 169386 – [Edit] Local side of java compare should be more like java editor

Web Tools

• 95450 – add extract include file for JSP source refactoring
• 100511 – JavaScript refactoring and better code complete
• 107052 – jsp editor error if jsp is under a subdirectory
• 119334 – [jsp20] jsp:directive.tag import= list not recognized in .tagx XML tag files
• 124288 – [Plan] Improve JSP 2.0 support
• 124796 – [refactoring] moving a servlet is not reflected in web.xml
• 136850 – JSTL Code Assist from imported projects.
• 157465 – jsp fragment does not see any variables/tags from its parent
• 168538 – “Convert to a Dynamic Web Project” should work for Java projects

Uns meses atrás tive um problema com o uso do Hibernate, em um caso um tanto quanto incomum: o projeto usava Ingres, um banco de dados muito pouco usado, e com algumas particularidades idiotas (sendo gentíl com eles). O tipo responsável por armazenar as datas no Ingres, diferentemente de todos os outros bancos que já vi, aceita três “estados” nas colunas de data: uma data (óbvio), null, ” – sim, uma empty string.

Com isto, eu não poderia usar as classes padrão para datas no Java, acabei criando uma classe Data para tratar desses estados. Como o tipo foi criado por mim, o Hibernate não oferece nada pronto (por razões óbvias), tive que achar uma alternativa.

Lendo um pouco a referência, mais especificamente o capítulo Custom value types, descobri que para esses casos especiais, onde muitos já apelariam para alguma forma menos ortodoxa, o Hibernate oferece um mecanismo muito poderoso : os UserTypes.

Um UserType é basicamente uma interface que permite a implementação de como um determinado tipo será recuperado e persistido no seu banco de dados. Este recurso é extremamente útil e me salvou graciosamente.

E porque estou escrevendo isso tudo? Recebi hoje uma dúvida bem interessante por mensagem privada no GUJ. O usuário perguntava se haveria possibilidade de usar Hibernate em conjunto com o banco PostGIS – focado em armazenar dados geométricos.

O principal desafio é como mapear os dados que são armazenados em Geometry, como são chamados os tipos geométricos no PostGIS. Como não existe nenhum tipo nativo do Java que seria correspondente (e nem a especificação do JDBC preve isso – tipos clob, lobs e variantes não contam!), o trabalho pode ser um pouco mais complicado que se imagina.

Dando uma pesquisada, acabei encontrado uma thread da lista de users do PostGIS que trata exatamente disso. Nela é apresentada uma solução elegante para o tratamento dos tipos no Hibernate – e que acabou virando parte do projeto. SpatialEJB3 nada mais é que um UserType (GeometryType no caso) com a implementação responsável por tratar o tipo Geometry. Ele pode ser usadao tanto com Hibernate puro, quanto para EJB3. Só achei estranho que as classes ainda não estão no postgis.jar.

Para usar o recurso, fica extremamente simples:

@Type(type = "org.postgis.hibernate.GeometryType")
public Geometry getLocation(){
return location;
}

No site é possível encontrar a documentação do projeto.

Por mais vasta que a documentação do Hibernate seja, sempre ficam pontos da API que precisam de melhorias na documentação. Um exemplo claro disso é esclarecer qual a diferença entre dois métodos da Session, o save() e o persist(). Ambos tem a mesma função: tornar uma instância transient em persistent. Segundo a doc da API:

• persist() – Make a transient instance persistent.
• save() – Persist the given transient instance, first assigning a generated identifier.

O método persist(), não garante que será atribuito um id à instância imediatamente, sendo que a associação ocorrerá quando o flush ocorrer. Além disso, ele garante que só irá executar um insert se estiver dentro do contexto de uma transaction. Já o save(), atribui a chave imediatamente, não importando se isso exige um insert (no caso do identity generator) ou se existe um contexto de transação. Isso explica também porque o save() retorna o Id gerado e o persist() é void.

Mais informações podem ser encontradas no Jira e no fórum do Hibernate.

update: não é somente eu que acha que a documentação precisa de melhorias nesse caso: HHH-1682

update 2: acabei de comitar a alteração na documentação, para a próxima versão do Hibernate (3.2.5), a seção Making objects persistent irá trazer informações mais detalhadas sobre a diferença entre os dois métodos.

O Villela recém postou no seu blog, um pequeno recado pro pessoal do JCP, que espero que seja lido, re-lido e repassado até que alguém lá da nave-mãe veja: static reflection. A idéia seria prover alguma forma de reflexão estaticamente, algo do tipo:

Foo.class.instanceMethods.bar(String.class)

Ócio criativo faz bem para qualquer linguagem.

Segundo a Wikipedia,

Hot swapping can also refer to the ability to alter the running code of a program without having to interrupt its execution, although only a few languages support it. Those that do include Lisp, Erlang, and Smalltalk. The Java programming language also supports this technology, but only through the Java Platform Debugger Architecture (JPDA) : it is only possible to change the code while the program is in the control of a Debugger. Interactive programming is a paradigm that makes extensive use of hot swapping so that the programming activity becomes part of the program flow itself.

O post do Daniel (Hot Code Replacement), contando como fazer hot swap de classes com o OC4J, me fez pensar numa coisa: será que realmente são poucos que conhecem a “feature” de trocar classes em tempo de execução, sem parar sua aplicação, e nem a VM?

Bom, mesmo sem ter 1/3 de conhecimento sobre VMs que o Rodrigo (louds), por exemplo, vou tentar explicar. Parada para comentário de utilidade pública: se você não assina o blog dele, faça um favor a si mesmo e vai lá. Hoje mesmo ele anunciou que vai liberar os fontes da máquina virtual que ele começou a desenvolver.

Voltando ao assunto, desde a JDK 1.4 (sim, hot swap é relativamente velho), é possível trocar a implementação de métodos sem reiniciar a aplicação. Notem bem, implementação, ou seja, se você trocou qualquer coisa na assinatura de um método, criou algum novo, adicionou uma variável de instância da classe, você precisa parar a VM, compilar a classe, e iniciar novamente.

No entando, linguagens dinâmicas, como Ruby (com site novo), permitem trocar trocar qualquer coisa das suas classes em tempo de execução, seja métodos, atributos, whatever. Parece covardia comparar, né?

Porém, lendo um pouco mais à respeito, fazer com que a JVM suporte isso também é perfeitamente possível tecnicamente (louds!!), mas precisariam ser feitas enormes mudanças no seu funcionamento, e acredito que seja esse, um dos principais motivos de não terem feito nos primórdios do hot swap – JDK 1.4.

O assunto parece estar realmente chamando ateção, pois acabou de sair um artigo no Artima, The JVM as an (Un)Common Language Runtime, e um dos pontos que o autor destaca como sendo um dos principais desafios para a implementação de linguagens dinâmicas na JVM:

Hotswapping: The main idea is to allow code changes on the fly, while they are running. The full capability of hotswapping implies any kind of change to be supported, addition/modification/removal of methods and attributes including changes in inheritance hierarchy.

Se isso não fosse suficiente, existe um tópico na SDN, Hotswap support for schema / shape changes discutindo o assunto, e o bug report 4910812 – Enhance Hot Code Replacement com 300+ votos.

Isso permitiria baixar para praticamente zero o turnaround de desenvolivmento de aplicações, dando um grande fôlego para Java como linguagem, pois já aumentaria significantemente a velocidade de desenvolvimento, evitando a perda de minutos que já estamos acostumados entre parar servidor de aplicação, fazer re-deploy, iniciar aplicação, …

Classloader tricks only take you so far.

Ruby (meu):

require 'open-uri'
open('http://www.google.com.br/search?q=ruby').read =~ %r{class=l href="(.*?)">(.*?)</a.*?j><font.*?>(.*?)<br><}m
puts ($2 + "\n" + $1 + "\n" + $3 + "\n").gsub(/<.*?\>/, '')

Java (do Giuliano, bastante melhorada depois pelo Urubatan):

import java.net.URL;
import java.net.URLConnection;
import java.util.Scanner;

public class HTTPSample {
       public static void main(String[] args) throws Exception {
               URLConnection con = new URL("http://www.google.com/search?q=java").openConnection();
               con.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.12) Gecko/20050915 Firefox/1.0.7");
               Scanner sc = new Scanner(con.getInputStream());
               System.out.println(sc.findWithinHorizon("<a>.*?</a>", 0).replaceAll("<a>(.*?)</a>", "$2=$1").replaceAll("", ""));
       }
}

PHP (do Pilger, com ajuste do Fernando):

<?php
  $html = implode('', file('http://www.google.com.br/search?q=php'));
  preg_match_all("|class=l href=\"(.*?)\">(.*?)</a.*?j><font.*?>(.*?)<br><|", $html, $out, PREG_SET_ORDER);
  echo $out[0][1]." ".$out[0][2]." ".$out[0][3];
?>

Python (do Salviato):

 import urllib
 import re

 class AppURLopener(urllib.FancyURLopener):
   version = "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.0.1) Gecko/20060111 Firefox/1.5.0.1"

 urllib._urlopener = AppURLopener()

 html = urllib.urlopen('http://www.google.com.br/search?q=python').read()
 out = re.search('class=l href="(.*?)">(.*?)</a.*?j><font.*?>(.*?)<br><', html, re.DOTALL)
 print re.sub('<.*?>', '', (out.group(1) + '\n' + out.group(2) + '\n' + out.group(3)))

TCl/TK (do Salviato):

 package require http
 http::config -useragent {Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.0.1) Gecko/20060111 Firefox/1.5.0.1}
 set html [http::data [http::geturl {http://www.google.com.br/search?q=tcl}]]
 set out [regexp -inline {class=l href="(.*?)">(.*?)(.*?)< } $html]
 puts [regsub -all {<.*?>} [concat "[lindex $out 1]\n[lindex $out 2]\n[lindex $out 3]"] "" ]

VB (do Giuliano):

   Dim http As New WinHttp.WinHttpRequest
   Dim re As New RegExp, matcher As Match
   Dim texto As String
   http.Open "GET", "http://www.google.com.br/search?q=java", False
   http.SetRequestHeader "User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.12) Gecko/20050915 Firefox/1.0.7"
   http.Send
   texto = http.ResponseText
   re.Pattern = "class=l href=""(.*?)"">(.*?)</a.*?j><font.*?>(.*?)<br><"
   re.Global = True
   re.IgnoreCase = True
   re.MultiLine = True
   For Each matcher In re.Execute(texto)
       Dim strSaida: strSaida = ""
       strSaida = matcher.SubMatches(0) + vbCrLf + matcher.SubMatches(1) + vbCrLf + matcher.SubMatches(2)
       MsgBox strSaida
       Exit For
    Next

Coldfusion (do Kenji)

<cfhttp url="http://www.google.com.br/search?q=coldfusion+mx">
<cfset tmp = REFindNoCase('class=l href="(.*?)">(.*?)</a.*?j><font.*?>(.*?)<br><', cfhttp.filecontent,1,true)>
<cfoutput>#mid(cfhttp.filecontent,tmp.pos[2],tmp.len[2])# #mid(cfhttp.filecontent,tmp.pos[3],tmp.len[3])# #mid(cfhttp.filecontent,tmp.pos[4],tmp.len[4])#</cfoutput>

Buenas, semana passada no meu post “Ruby, less-code”, o Pilger deu a idéia de colocar os códigos lado-a-lado, até pra facilitar a comparação. Bom, conversando com o Giuliano este final de semana surgiu uma idéia: fazer uma espécie de “coding contest”. Claro, não vai valer nada. Todos os “desafios” vão ficar sob a tag “code contest“

A idéia é essa: pegamos um problema qualquer e cada um resolve em uma linguagem. Ajuda a ver algumas vantagens/desvantagens de cada linguagem, e claro, da pra aprender muito também. A versão inicial de cada solução nós fazemos, se alguém sugerir alguma mudança/melhoria alteramos e publicamos(citando o autor, claro). A idéia é criar um problemas por semana em média.

Ah, se alguém tiver interesse de solucionar em alguma linguagem diferente e mandar, será muito bem vinda também. Seja ela Python (Jonas? Carlos?), Lisp (Shoes? Taq?), C/C++(Fernando?), Groovy (Daniel?), PHP (Pilger?), .Net, etc.

Como criar problemas não é nossa especialidade(e sim resolvê-los), sugestões de problemas também são bem vindas, mas por favor, nada de calcular órbitas e bizarrices do gênero. É só pra se divertir mesmo.

E-mail pra cá, e-mail pra lá… ele mandava algo em Java, eu entendia o problema e respondia com a solução em Ruby. E assim foi por um bom tempo.

Não nos limitamos somente à if/else’s e while’s. Fomos de estrutura de classes à threads, passando por I/O, requisições HTTP, regular expressions, etc.

O resultado foi interessante: em nenhum exemplo o código Java ficou menor. E o código não ficou somente menor, mas a clareza do que estava acontecendo também me agradou muito. O mais próximo que Java chegou foi em um pequeno exemplo em que quase empatou, mas… ficou no quase.

E ontem, estava fazendo umas experiências em casa com Ruby(novidade…) e acabei me lembrando do caso. Pergunta: alguém possui algum código em Java (hum, .net?) que não possa ser escrito de forma mais concisa em Ruby?

Logo que comecei a programar, conheci o Dreamweaver. Achei ótimo clicar e arrastar componentes pra cá e pra lá, colocar formatação, tudo muito prático. Felizmente, as pessoas evoluem. Aos poucos começei a entender melhor o que acontecia por baixo dos panos, e entender também o significado daquela monstruiosidade de tags que eram criadas. Conforme fui evoluindo, mais cresceu meu desafeto com ele, devido ao código porcalhão que ele gera. A facilidade de ver as alterações on-the-fly continuava lá, mas já começava a fazer tudo no braço.

A partir dai, cada vez mais busquei editores que facilitassem minha vida, não visualmente, mas que permitissem gerar um código elegante com maior velocidade e facilidade.

Experimentei de tudo, Scite (recomendação do Jonas), Crimson Editor, UltraEdit, Dreamweaver, entre muitos outros, mas sempre sentia falta de algo, fosse um code completion decente ou um syntax highlighter pra alguma linguagem. E ficar trocando de editor pra cada tipo de arquivo que for editar, além de ser improdutivo (você acaba não sabendo usar nenhum bem), obriga você a ter mais que um editor no computador – e pior, ficar alternando entre eles.

Felizmente, chegou ao meu conhecimento um editor que estava ganhando espaço – e fazendo bastante sucesso: o Eclipse. No começo, não me chamou a atenção, parecia ser mais um editor com uma interface legal e com um code complete aguçado. Pesquisando um pouco mais sobre ele, descobri que sabendo usá-lo corretamente – e por completo, pode fazer chover. Tirando proveito da plataforma super extensível dele, com alguns plugins ele pode ser tornar um ambiente de trabalho muito produtivo.

Antes de partir para os plugins, vou dar algumas dicas referentes ao funcionamento e utilização dele como um todo. Para começar, entre no site do Eclipse, e faça o download dele, selecionando conforme o seu sistema operacional. Feito isto, recomendo que descompacte ele em alguma pasta de fácil acesso (algo como c:\dev\eclipse\). Abra ele e use por um tempo, crie um projeto, alguns arquivos, altere as opções, salve, edite, bagunce mesmo – mas lembre-se, sempre tenha uma cópia do arquivo de instalação dele para um eventual “acidente”.

Atalhos do editor

* alguns funcionam somente no editor Java

• <Ctrl> + <Space> – Abre o code completion. Lembre-se, anote, marque na sua testa, control-espaço é seu amigo;
• <Ctrl> + <Shift> + <r> – Open Resource. Abre uma janela para abrir qualquer arquivo (xml, properties, jsp, etc);
• <Ctrl> + <Shift> + <t> – Open Type. Abre uma janela para pesquisa das classes disponíveis;
• <Ctrl> + </> – (des)Comenta bloco de código;
• <Alt> + (<up> ou <down>) – Move bloco de código;
• <Shift> + <Enter> – Insere linhas em branco abaixo da atual;
• <Ctrl> + <Shift> + <Enter> – Insere linhas em branco acima da atual.
• <Ctrl> + <d> – Remove linha atual;
• <Ctrl> + <1> – Exibe possíveis soluções para um problema que ele encontrou no seu código;
• <Ctrl> + <Shift> + <o> – Ajusta seus imports(no caso do Java ao menos);
• <Ctrl> + <Shift> + <f> – Formata o código conforme configuração de padrão definida;
• <Ctrl> + <m> – Altera entre maximizada/default para uma view, muito útil quando se está trabalhando com arquivo com muito código;
• <Ctrl> + <h> – Busca por referências do elemento(método,atributo…) que o cursor está posicionado sobre, em todo projeto;
• <Ctrl> + <i> – Corrige identação de um pedaço de código;
• <Ctrl> + <3> – Quick Access… quase um Quicksilver para o Eclipse;
• <Ctrl> + <3> – Quick Outline… exibe a lista de métodos/atributos da classe. Se pressionado 2 vezes, exibe também das classes mães;

Eclipse Plugins

Bom, depois de toda essa ladainha, vamos ao que interessa, os plugins. O Eclipse conta com uma estrutura muito boa no quesito extensibilidade – mesmo sua API sendo criticada por alguns. Pode-se adicionar features para praticamente qualquer propósito nele. A instalação de plugins é muito fácil e pode ser feita de duas maneiras:

• Via update site – abra o Eclipse, vá em “Help”, “Software Updates…”, “Find and Instal…” Na tela que abre, selecione a segunda opção e de next. Clique agora em “New Remote Site…”. No campo “Name” coloque o nome do plugin que será instalado, e no campo URL coloque o endereço do update site(quando existir um). Clique agora no íncone de “+” ao lado do nome do plugin e selecione o “pacote” que você deseja instalar. Clique em “Next”. Selecione a versão do plugin, dê “Next”, aceite os termos do plugin e vá em “Finish”. Ele vai baixar automaticamente os arquivos necessários e provavelmente vai pedir para você restartar o Eclipse.
• Via download – entre no site do desenvolvedor do plugin, baixe o arquivo contendo o plugin e descompacte ele. Normalmente, os pluguins vem com uma ou duas pastas dentro: “plugins” e “features”. Coloque os arquivos nas suas devidas pastas e entre novamente no Eclipse.

Procurei deixar os plugins com funcionalidades semelhantes próximos para facilitar a localização. O nome do plugin é também um link para o site do desenvolvedor/projeto, ficando ao seu lado o link para download ou update site, seguido de uma pequena descrição.

Eclipse Web Tools Plataform (WTP) – Download
Provavelmente quem já usa o Eclipse à mais tempo deve conhecer o Lomboz. O WebTools na verdade é uma “continuação” do projeto Lomboz, mas agora como sub-projeto da Eclipse Foundation. Vem com editores para JSP, HTML, Javascript, CSS, SQL, XML, DTD, XSD e WSDL.

Run Jetty Run – Update site
Uma forma decente e simples de usar o Jetty para desenvolvimento, já que o connector atual disponível pro WTP é uma piada de mal gosto.

Aptana – Update site
Excelente plugin para coding e debug Ruby + Rails (antigo RadRails), Python+Jython(antigo PyDev), JavaScript/Ajax (Jaxer), PHP, xHTML/RHTML e CSS, além de Adobe Air e iPhone. Seu site conta com diversos screencasts demonstrando a utilização do plugin.

Hibernate Tools – Update site
Auxilia o desenvolvedor que utiliza Hibernate na sua aplicação, facilitando a edição dos hbm.xmls (com syntax highlighting, code-completion), permite navegação e impressão do entity model, engenharia reversa e geração de código, code completion para HQL/JPA-QL queries diretamente no editor Java, editor para testes para Criteria queries e HQL/JPA-QL queries. A criação do console configuration para você poder utilizar o plugin também é mostrada no site.

Spring IDE – Update site
Interface gráfica para trabalhar com arquivos de configuração do Spring Framework. Conta com diversas features como editor para os arquivos de configuração dos beans, validação dos arquivos de configuração, etc.

Eclipse PDT – Update site
Plugin oficial da Eclipse Foundation para quem desenvolve PHP. Inicialmente criado pela Zend (empresa de dois grandes contribuidores do PHP).

PHPEclipse – Update site
Pra quem desenvolve PHP, este plugin é uma legítima mão na roda. O code assist dele é ótimo, tendo praticamente todas (se não todas) as funções nativas. Possui integração com MySQL e com o Apache. No seu site explica como instalar o debbuger e o pacotão WAMPP. No Wiki do site Plog4u existe um ótimo tutorial para este plugin.

Groovy Eclipse Plugin – Update site
Plugin para suporte à Groovy desenvolvido pelo pessoal da Codehaus.

EPIC – Eclipse Perl Integration – Update site
Plugin bem completo para Perl, vem com o mesmo tester de regular expressions do Ruby Development Tools(o código foi cedido por eles). Pra quem ainda usa Perl é uma boa pedida.

CFEclipse – Update site
Possui syntax
highlighting, code insight, content outline e auxilia a encontrar problemas no código. Substitui perfeitamente qualquer editor proprietário da Macromedia como o HomeSite, Dreamweaver e o próprio ColdFusion. Talvez o pessoal do CFGigolô conheça.

C/C++ Development Tools – Update site
Adiciona funcionalidades para desenvolvimento em C/C++ ao Eclipse.

Subversive – Update site / Connectors update site
Oferece suporte ao Subversion de forma similar ao suporte à CVS que já vem integrado com o Eclipse. Conta com diversas features legais, além de ter uma interface simples de usar.

EclipseME – Update site
Plugin para auxiliar no desenvolvimento de MIDlets J2ME, permitindo que o desenvolvedor se preocupe mais com o desenvolvimento da aplicação do que com requisitos específicos da plataforma J2ME.

QuantumDB – Update site
Quantum é um plugin para acesso à banco de dados, através de um driver JDBC padrão. Sua interface mostra tabelas, views e sequences em formato de árvore (como a maioria) e possui também um SQL editor com syntax highlighting.

Clay Database Modeling – Download
O Clay é um plugin que ajuda no design de um banco de dados. Ele possui algumas features bem interessantes, como: interface super intuitiva, engenharia reversa e editores gráficos.

AnyEdit tools – Update site
Adicionar algumas funções para facilitar o desenvolvimento, como conversão caracteres para entidades HTML, maiúscula/minúscula, espaços/tabulações, remover espaços no final das linhas.

TPTP Testing Tools – Update site
Como o nome sugere, o TPTP é um pacote de ferramentas voltadas para ciclos de testes, que se extende de testes manuais à testes para aplicações web. Possui integração com o JUnit.

PMD – Update site
Acredito que o PMD seja o plugin de verificação/análise de bugs e estilo de código mais usado na atualidade. Possui uma série de verificações legais como busca por blocos vazios de try/catch/finally/switch, variáveis não usadas, entre outras. Dica de amigo: mantenha ele longe do seu analista se você não conhece o código à fundo.

Eclipse-CS – Update site
O plugin integra o já famoso code analyzer Checkstyle, ferramenta para ajudar você a garantir que seu código Java adere à alguns padrões de codificação. O Checkstyle faz isso inspencionando seus códigos fontes e apontando os itens que foram selecionados no conjunto de regras disponíveis. Além disso, você pode usar o Checkstyle diretamente da linha de comando, ou como parte do seu nt build.

Find Bugs – Update site
Ferramenta que ajuda à detectar bugs em potencial para códigos Java.

Outras distribuições do Eclipse

• Aptana Studio
• JBoss Tools
• MyEclipse
• IBM Rational software
• BEA Workshop Studio
• EasyEclipse
• Exadel Studio
• Yoxos
• Omondo UML

Dicas

• Se você instalar dois ou mais plugins que possuam editor’s para o mesmo tipo de arquivo (ex: DBEdit e DBExplorer, para *.sql), você pode facilmente editar o default entrando em “Window” >> “Preferences” >> “Workbench” >> “File Associatons”. Selecione o tipo de arquivo que você deseja alterar o padrão e logo abaixo irá aparecer os editor’s disponíveis. Marque o desejado e clique em “Dafault”.
• Uma coisa que quem está começando não sabe, é que o Eclipse não usa o CLASSPATH do sistema. Então para adicionar libs / classes / projetos, você precisa fazer isso diretamente na IDE. Clique com o botão direito do mouse no nome projeto, entre em Properties -> Java Build Path -> Libraries. Feito isso, entre em “Add class folder” para adicionar um diretório com .class, e “add jars / add external jars” para adicionar jars.
• Quando você instalar um plugin, pode ser que o Eclipse não reconheca automaticamente, então você deve usar o parâmetro -clean (“C:\eclipse\eclipse.exe -clean” por exemplo). Utilizando este parâmetro, você estará forçando o Eclipse a reconstruir o repositório no qual ele armazena todos os plugin.xml’s (ele faz isso como uma forma de tornar o load inicial mais rápido).
• Além do -clean, o Eclipse oferece uma série de outros parâmetros que podem ser utilizados na sua inicialização, que podem inclusive aumentar sua performance.

Links relacionados

• How to Install and setup Eclipse with Sun’s Java – Ubuntu
• Refactoring for everyone
• Getting started with the Eclipse Platform
• Build GUIs with the Eclipse Visual Editor project
• Extending Eclipse with Helpful Views
• EclipseCON Tutorials
• Java Code Templates
• Tune Eclipse’s startup performance, Part 1 & Part 2
• Finding unresolved Plug-in dependencies in Eclipse