Eclipse ― a alternativa de software livre

Ultimamente, o Eclipse, o ambiente de desenvolvimento integrado extensível de software livre, tem atraído merecidamente muita atenção. Ele sempre teve seus adeptos, algo que algumas pessoas não entendiam quando ele carecia de recursos que eram comuns há muito tempo em outros IDEs, como o JBuilder. O desenvolvimento de software é principalmente (não totalmente) sobre composição de código. Não importa quantos recursos um IDE fornece, se ele é um obstáculo a essa tarefa essencial, mais atrapalhará do que ajudará o programador. Eis o motivo porque muitos programadores por muito tempo preferiam um editor de texto simples a um IDE.

Curiosamente, muitos adeptos recentes do Eclipse migraram de editores de texto e não de outros IDEs. Isso, evidentemente, explica porque eles não se importavam com a ausência de recursos. Para muitos, esse foi o primeiro IDE a não ser um obstáculo e que simplesmente os permitiu progredir com seu trabalho.

Uma pergunta mais interessante é se o Eclipse é tão bom quanto os IDEs que custam dinheiro. A resposta é um enfático "sim". Primeiramente, isso depende do objetivo para o qual você pretende usar. Se você precisa apenas fazer desenvolvimento básico, não há necessidade de procurar mais. Para codificação, depuração, refatoração, teste de unidade, e assim por diante, ele iguala ou supera tudo o mais disponível. Como a edição do JBuilder X Foundation, o Eclipse tem conclusão de código, modelos de código e suporte integrado para refatoração, Ant, CVS e JUnit. Na verdade, você provavelmente descobrirá que o Eclipse em relação ao JBuilder tem suporte melhor para muitos de tais recursos. Por exemplo, o Eclipse tem mais refatorações e melhor suporte para combinação de código local com um servidor CVS.

Além dos fundamentos e dependendo de que recursos você necessita, a história fica um pouco mais complicada. Um dos benefícios do Eclipse ser software livre e extensível é que muitos plug-ins, de software livre e comerciais, estão disponíveis para estendê-lo. Se precisar de um recurso que o Eclipse IDE básico não tem, você provavelmente encontrará um plug-in grátis que execute a tarefa, pelo menos, adequadamente ― isso é verdade, por exemplo, para web e desenvolvimento do J2EE. (Para artigos sobre como obter, instalar e usar plug-ins para Struts e desenvolvimento de aplicativo da web, veja a seção Recursos posteriormente neste artigo.)

Em adição aos plug-ins grátis, é possível localizar para o Eclipse muito plug-ins comerciais com preços razoáveis. Se precisar apenas de alguns recursos avançados, e não achar as ofertas grátis satisfatórias, talvez seja mais econômico comprar plug-ins à do catálogo de um fornecedor terceiro em vez de comprar um pacote IDE corporativo completo. Devido à sua popularidade e natureza de software livre, o Eclipse tem vantagem em relação aos outros IDEs nesse respeito ― estão disponíveis centenas de plug-ins, grátis e comerciais. É possível localizar a maioria deles visitando a página de plug-ins do Eclipse listada em Recursos.

Um recurso que o Eclipse 3.0 carece no momento da composição e que o JBuilder tem a longa data, é uma ferramenta visual para construção de interfaces do usuário. Essa carência está sendo ativamente resolvida. O Eclipse Visual Editor (VE) release 0.5, que suporta AWT/Swing, está disponível para o Eclipse 2.1.x. agora e uma versão para Eclipse 3.0, release 1.0, estará disponível em breve. A VE 1.0 estará disponível como um download separado no website do Eclipse e não suportará apenas AWT/Swing, mas também SWT. Para obter mais informações e uma visualização do VE, consulte o artigo Visual Editor listado em Recursos.

Voltar para parte superior

Getting started with Eclipse

O Eclipse é um pouco diferente de outros IDEs porque introduz um nível de abstração novo, não familiar, para a interface com o usuário: a perspectiva . Finalmente, você descobrirá que esse conceito simplifica a navegação pelo conjunto de recursos elaborado do Eclipse removendo opções que não são relevantes para a tarefa em questão e permitindo que você se concentre no que precisa fazer.

Para explicar, precisamos apresentar um pouco mais da terminologia do Eclipse. O ambiente de desenvolvimento do Eclipse ― ou seja, a janela principal do Eclipse como um todo ― é denominado ambiente de trabalho. Dentro dessa janela principal há várias áreas de janela, denominadas visualizações, que exibem a saída do console, visualizações de estrutura de tópicos do projeto, e assim por diante. Várias visualizações são frequentemente dispostas em um arranjo de bloco de notas e podem ser selecionadas usando guias. Em adição às visualizações, o ambiente de trabalho tem uma área de janela especial, o editor, onde é possível editar tipos diferentes de documentos, como um código de origem.

Até agora, esta descrição do ambiente de trabalho do Eclipse não soa muito diferente do modo como o JBuilder está organizado. À medida que você executa tarefas diferentes, como codificação, depuração ou mesclagem das alterações do código com as tarefas em um repositório de código centralizado, é possível usar um arranjo de janelas escolhido especificamente para essa tarefa. Esse arranjo de janelas específico da tarefa é denominado perspectiva . É similar à função das guias abaixo do editor no JBuilder, exceto que no Eclipse todo o ambiente de trabalho pode ser alterado, incluindo a barra de tarefas principal e menu.

A perspectiva básica, aquela que o Eclipse inicia quando você dispensa a tela de boas-vindas inicial, é denominada perspectiva Resource, como mostrado na Figura 1:

Voltar para parte superior

Uma questão de perspectiva

Como o JBuilder, a perspectiva Resource no Eclipse tem uma visualização orientada em árvore, o Navigator, na parte superior esquerda, (não visível aqui, obviamente, porque nada foi criado) que permite a navegação e o gerenciamento dos recursos. Inicialmente, a perspectiva Resource tem duas outras visualizações ― uma visualização Outline abaixo do Navigator e uma visualização Task abaixo da área do editor principal.

O Eclipse faz uma distinção importante entre visualizações e editores. A perspectiva pode ter muitas visualizações, mas pode ter apenas um editor que é o ponto focal do ambiente de trabalho. Em termos gerais, se você tiver um arquivo aberto no editor, as outras visualizações refletirão aspectos diferentes desse arquivo. Se for um arquivo Java™ e você estiver na perspectiva Java, a visualização Package Explorer mostrará onde ele está localizado fisicamente na hierarquia de arquivos e pacotes, e a visualização Outline mostrará (entre outras coisas) os métodos e atributos da classe. Se você tiver vários arquivos Java, essas visualizações mudarão à medida que você alternar entre os diferentes arquivos no editor.

Embora seja fácil abrir novas perspectivas e alternar entre elas, geralmente isso não é necessário porque, à medida que você trabalha, a perspectiva muda automaticamente quando é apropriado. (O Eclipse solicitará sua permissão primeiro, evidentemente.) Você verá isso em um minuto, quando criarmos um projeto Java e, posteriormente, ao depurarmos um programa Java. Depois que estiver acostumado com as perspectivas, você provavelmente descobrirá que elas são um modo de trabalho suave e natural porque eliminam da UI quaisquer botões, menus ou visualizações que não sejam apropriadas para a tarefa em questão. Isso torna muito mais fácil localizar as ferramentas relevantes.

Voltar para parte superior

Criando um novo projeto no Eclipse

Para iniciar o trabalho no Eclipse, primeiro, é necessário criar um projeto. Ao iniciar o Eclipse pela primeira vez, você será solicitado a informar a localização de um diretório workspace (presumindo que você não o tenha especificado como uma opção da linha de comando) e o Eclipse criará tal diretório para você, se ele não existir. Por padrão, todas as suas informações ― algumas informações específicas do Eclipse, os arquivos de origem e de classe Java, as imagens, e assim por diante ― estão armazenados em subdiretórios ou pastas no diretório workspace. Cada pasta nesse diretório corresponde a um projeto e normalmente contém um aplicativo independente, um aplicativo da web ou um componente de algum tipo.

Embora usar a área de trabalho do projeto seja recomendado, pois mantém as coisas melhor organizadas, o Eclipse 3.0 introduziu a capacidade de criar ou especificar diretórios existentes fora da área de trabalho que será usada como pasta do projeto. Isso pode ser especialmente útil se você estiver migrando de outro IDE que não encoraje uma estrutura de diretório estritamente organizada.

Se quiser acompanhar as instruções e ainda não tiver iniciado o Eclipse, inicie-o agora. Caso ainda não tenha instalado o Eclipse, consulte o artigo "Introdução à Plataforma Eclipse" listado em Recursos. A primeira vez que executar o Eclipse, você obterá uma tela de boas-vindas. Essa leva a tutoriais e a outras informações interessantes às quais talvez queira voltar, mas ignore isso no momento clicando no "X" na guia superior; para chamar novamente essa tela mais tarde selecione Help > Welcome no menu principal.

Como mostrado anteriormente na Figura 1, você estará na perspectiva Resource. Há sempre mais de um modo de se fazer as coisas no Eclipse ― usando atalhos, barras de ferramenta ou seleções de menu ― mas, neste artigo, usaremos menus no geral. Criaremos aqui um projeto usando um menu de contexto, como segue:

• Na perspectiva Resource, clique com o botão direito do mouse na visualização Navigator e selecione New > Project.
• Selecione Java Project no assistente New Project.
• Insira um nome de projeto, por exemplo, "Hello".
• Observe que na seção Location, você tem a opção de criar o projeto em um local externo, mas aceite o padrão, "Create project in workspace".
• Além disso, na seção Project Layout, aceite a seleção padrão, "Use project folder as root for sources and class files". Geralmente, é melhor usar diretórios separados (normalmente src e bin), mas manteremos as coisas simples por agora, assim aceite o padrão.
• Clicar em Next permitirá que você configure bibliotecas e inclua outros projetos no caminho de classe do qual este projeto depende, mas não precisamos fazer isso. Em vez disso, clique em Finish.
• Depois de um momento, o Eclipse pergunta: "This kind of project is associated with the Java Perspective. Do you want to switch to this perspective now?" Marque a caixa denominada "Remember my decision" e clique em Yes.

Agora que temos um projeto, poderemos criar uma classe. Criaremos uma variação do programa padrão "Hello, world".

• Clique com o botão direito do mouse no projeto Hello e selecione New > Class. Isso abrirá o assistente New Class.
• Insira com.example.hello como o nome do pacote.
• Insira HelloObject como o nome da classe.
• Deixe java.lang.Object como a superclasse.
• Assegure que a opção para criar um stub para um método main() esteja marcada.
• Clique em Finish. Veja a Figura 2.

Embora usar a área de trabalho seja recomendado, pois mantém as coisas melhor organizadas, o Eclipse 3.0 introduz a capacidade de criar ou especificar diretórios existentes fora da área de trabalho que será usada como pasta do projeto. Isso pode ser especialmente útil se você estiver migrando de outro IDE que não encoraje uma estrutura de diretório estritamente organizada.

Você observará diversas coisas diferentes depois da criação da classe. Primeiro, um par de itens "TODO" aparece no arquivo para indicar a necessidade de customizar os modelos que geram comentários. Como outras anotações como marcadores, pontos de interrupção e problemas de sintaxe, esses são indicados por um símbolo na margem esquerda do editor. Posteriormente, você deverá modificar o modelo do código para esse comentário de acordo com as orientações, mas deixe como está por enquanto.

Observe também que correspondendo a cada símbolo na coluna esquerda, há uma caixa pequena, da mesma cor, na coluna direita. Ao passo que a margem esquerda marca somente coisas atualmente visíveis no editor, a margem direita mostra coisas marcadas no arquivo. Se você tiver um arquivo longo com um erro no final, haverá uma pequena caixa vermelha na parte inferior da margem direita independentemente da parte do arquivo que está sendo mostrada no editor; clicar nessa caixa levará ao erro.

Em adição aos símbolos de marca de verificação na margem mais à esquerda, há pequenos triângulos em uma coluna à direita de tais símbolos, apenas no JBuilder, para controlar a compactação do código. Clicar no primeiro triângulo ao lado do comentário que precede a definição da classe exclui o comentário, substituindo-o por reticências, como mostrado na Figura 3:

À medida que trabalhar com o código no Eclipse, observará ainda outra coluna na margem esquerda entre as anotações e os controles de compactação do código. Essa contém barras coloridas que permitem a comparação do código atual no editor com as versões anteriores do código. Esse recurso é chamado QuickDiff. Talvez você deseje explorar isso por conta própria posteriormente.

Examinando a verificação de sintaxe e a conclusão do código

Precisaremos incluir algum código de modo que tenhamos algo com que trabalhar. Como veremos, o Eclipse fornece o equivalente do CodeInsight, ClassInsight e outros recursos do JBuilder que ajudam a compor o código de origem.

Incluir uma linha para o método main() criando um Vetor denominado names. Como você não importou o tipo de Vetor, haverá um símbolo vagamente familiar na margem esquerda, uma caixa vermelha com um "X" combinado com uma lâmpada amarela. (Se você apertar os olhos um pouco, poderá até confundi-lo com a chave dourada e o círculo vermelho com um ponto de exclamação que o JBuilder usa. Veja a Figura 4.)

O "X", evidentemente, significa que há um problema, mas a lâmpada significa que o Eclipse tem uma QuickFix: uma ou mais sugestões para resolver o problema. Clique na lâmpada ou no Vetor e pressione Ctrl-1 (o atalho para a QuickFix). Um pop-up aparece listando possíveis correções incluindo: "Import Vector," "Rename in File" e "Create Class Vector". É possível clicar duas vezes na primeira sugestão para que o Eclipse inclua uma instrução de importação para você.

Depois de assegurar que o Vetor seja devidamente importado, inicie a próxima linha novamente digitando os nomes. É possível usar a conclusão do código para localizar o método apropriado para incluir itens no Vetor names.

A conclusão do código no Eclipse funciona quase da mesma forma que o JBuilder, mas, por padrão, é um pouco mais lento. Depois de digitar o ponto após os nomes, você tem de esperar meio segundo até aparecer uma lista de nomes de métodos. (Isso se dá porque o Eclipse tenta ficar fora do seu caminho se você estiver digitando rapidamente. É possível alterar isso selecionando Windows > Preferences > Java > Editor no menu principal e alterando o atraso de autoativação para outro valor em milissegundos.) Se desejar uma sugestão e não quiser esperar, pressione Ctrl-Space para ver uma lista de opções imediatamente. A conclusão do código aqui é especialmente útil caso você tenha esquecido o nome do método de que necessita: era put() ouadd()?

Evidentemente, é add() que você deseja, e depois de selecionar a versão do parâmetro individual na lista, você observará que o Eclipse não apenas completa o nome do método, mas inclui os parêntesis de abertura e fechamento, coloca o cursor regular dentro do parêntesis e desenha uma linha verde (parecendo um cursor) depois do parêntesis de fechamento. Você verá essa linha verde muitas vezes sempre que inserir o código no Eclipse e, embora seja possível ignorá-la sem nenhum efeito aparente, é melhor explicar agora. Se você gravar seus próprios modelos de conclusão de código posteriormente (algo que é muito fácil fazer no Eclipse), provavelmente desejará tirar proveito desse recurso.

Inclua a cadeia de caractere codificada permanentemente "Moe" no Vetor names. Quando digitar o sinal de aspas de abertura, o Eclipse prontamente fornecerá o sinal de aspas de fechamento, moverá o cursor para dentro dos sinais de aspas e fornecerá um novo ponto de inserção depois do sinal de aspas de fechamento. Depois de digitar Moe, pressione Tab para mover além do sinal de aspas de fechamento. O primeiro ponto de inserção, depois do parêntesis de fechamento, reaparecerá agora. Pressione Tab novamente para mover para o final da instrução, e digite um ponto-e-vírgula.

Similarmente, inclua dois nomes no vetor names, Curly e Larry. O código deve se parecer agora com este:

			
      public static void main(String[] args) {
            Vector names = new Vector();
            names.add("Moe");
            names.add("Curly");
            names.add("Larry");
            }
      }

Uma das coisas positivas sobre as conclusões de código no Eclipse é que elas levam em conta seu contexto. Aqui, se você digitar for e pressionar Ctrl-Space, várias opções estarão disponíveis e, entre elas, iterar por uma coleção. Selecione essa opção e o código a ser iterado pelo vetor names será inserido como mostrado na Figura 5:

Observe que a primeira instância de cada identificador que o Eclipse incluiu está encerrada em uma caixa. Se você alterar um desses identificadores, o Eclipse mudará o identificador em todos os lugares em que ele aparecer. Se você renomear iter para i, as outras instâncias também mudarão automaticamente. A única coisa que você deve mudar aqui é o tipo para String, mas talvez você queira mudar também element para name. É possível pressionar Tab e Shift-Tab para mover entre cada um desses itens. É assim que o código se parece depois de fazer essas alterações e da inclusão de uma chamada para um método greet() que não existe ainda:

			
            for (Iterator i = names.iterator(); i.hasNext();) {
                  String name = (String) i.next();
                  greet(name);
            }

Em seguida, use a QuickFix do Eclipse (clicando em greet e pressionando Ctrl-1, por exemplo) para gerar um método stub para greet(), e inclua código para o stub como segue:

			
      private static void greet(String name) {
               System.out.println("Hello, " + name);
     }

A esta altura, o código não deve ter nenhum erro. Clique com o botão direito do mouse no editor e selecione Save no menu de contexto.

Executando e depurando seu programa

Como já foi mencionado, o Eclipse usa um compilador incremental, assim não é necessário compilar explicitamente seus arquivos Java. Os arquivos de classe compilados são salvos quando você salva seus arquivos Java. Para executar seu programa, selecione o arquivo Java no editor ou no Package Explorer e selecione Run > Run As > Java Application no menu principal do Eclipse. (Observe que isso é diferente da opção de menu Run > Run..., que veremos mais tarde.) Isso deve produzir a seguinte saída na visualização Console abaixo do Editor:

			
      Hello, Moe
      Hello, Curly
      Hello, Larry

Executar um programa simples no depurador é similar. Primeiro, defina um ponto de interrupção na chamada para greet() no método main() clicando duas vezes (não um clique único como no JBuilder) na margem esquerda. Se quiser um ponto de interrupção condicional ― um que pare quando uma expressão específica, como i==2 is true, ou um que pare depois de um número específico de ocorrências ― é possível clicar com o botão direito do mouse no ponto de interrupção e selecione as propriedades Breakpoint no menu de contexto.

Para iniciar a depuração, selecione Run > Debug As > Java Application no menu principal. Como o Eclipse tem uma perspectiva Debug que é mais adequada para depurar do que a perspectiva Java, você será consultado se deseja alterar para tal perspectiva. Marque a caixa "Remember my decision" e clique em Yes. Veja a Figura 6.

Você observará que as visualizações na perspectiva Debug têm equivalentes no JBuilder, mas como todo o ambiente de trabalho do Eclipse está dedicado à depuração nessa perspectiva, não será necessário alternar entre diferentes guias parar ver variáveis, a pilha de chamada e o console de saída.

Observe também que a pilha de chamada é mostrada em uma visualização denominada visualização Debug (não confunda com a perspectiva Debug que a contém) e que há botões de ferramenta (Step over, Step into e assim por diante) para controlar a execução nessa barra de ferramentas. O motivo que esses controles estão localizados aqui, junto com a pilha de chamada, é que se estiver depurando mais de um programa (ou a instância de um programa), ou um programa com vários encadeamentos, poderá selecionar o programa ou encadeamento a ser controlado clicando nele na pilha de chamada. Se desejar, poderá brincar com isso ativando esse programa de exemplo novamente, sem terminar a primeira instância.

Algumas vezes, você não deseja (ou não pode) executar um programa usando a seleção de menus simples Run > Run As > Java Application. Se for necessário informar argumentos para o programa ou a VM na qual ele executa, você precisará usar a opção de menu Run > Run.... Isso abrirá um diálogo que você pode usar para configurar essas e outras opções como mostrado na Figura 7:

Voltar para parte superior

Perspectiva Resource revisitada

Uma das coisas boas sobre perspectivas é que elas mantêm sua tela livre de interferência. Você pode ter observado, por exemplo, que arquivos de classe não aparecem no Package Explorer nas perspectivas Java. Presumindo que o Eclipse seja capaz de compilar seus arquivos Java (e ele informará quando não for capaz), não será realmente necessário fazer nada com elas para desenvolver, executar e depurar um programa. Mas quando estiver pronto, você desejará copiar o arquivo de classe para outro diretório ou compactá-lo para enviar a alguém por email.

Um modo de fazer isso é sair do Eclipse, visto que você sabe onde o diretório workspace está ― não há nada especial sobre esse diretório ou o subdiretório Hello onde seus arquivos de projeto são mantidos. Mas também é possível fazer isso de dentro do Eclipse selecionando File > Export no menu principal. Mas, primeiro, será necessário retornar à perspectiva Resource para ver todos os seus arquivos. É possível fazer isso facilmente clicando no botão da perspectiva Resource, no canto superior direito do ambiente de trabalho, como mostrado na Figura 8:

Aqui você verá vários arquivos que foram ocultos na perspectiva Java: seu arquivo de classe, HelloObject.obj, e dois arquivos de metadados que o Eclipse usa para armazenar as informações do seu projeto (.project e .classfile). Para compactar seu arquivo de classe:

• Clique em HelloObject.class para selecioná-la.
• Selecione File > Export no menu principal.
• Selecione o arquivo Zip como destino de exportação e clique em Next.
• O arquivo a ser compactado deve estar selecionado na tela a seguir; no campo denominado "To zip file:", busque ou insira um caminho e nome de arquivo para o arquivo zip que você deseja criar e clique em Finish.

Voltar para parte superior

Refatorar

Como com o JBuilder, um dos recursos mais avançados do Eclipse é a capacidade de refatorar código. Embora o Eclipse tenha mais refatorações que o JBuilder, e o JBuilder tenha uma ou duas refatorações que o Eclipse não possui, as mais importantes eles têm em comum. Para obter mais informações sobre as refatorações disponíveis no Eclipse (e as refatorações no geral), consulte o artigo "Refatorando para todos" listado em Recursos.

Se estiver usando refatoração no JBuilder, descobrirá que é essencialmente o mesmo no Eclipse, exceto pelo fato de que o Eclipse usa um assistente para guiá-lo pelo processo. Usando esse assistente, você terá a oportunidade de usar a caixa de diálogo de comparação avançada do Eclipse para navegar entre as alterações que o Eclipse propõe fazer; é possível vetar ou aceitar cada alteração.

Olharemos rapidamente uma refatoração relativamente simples: Change Method Signature. Usaremos essa para alterar o tipo do parâmetro String no método greet() do programa de exemplo para o Object e incluiremos um parâmetro adicional do tipo String na saudação que ele imprime. Para fazer isso:

• Selecione o método greet() clicando com o botão direito do mouse no nome no editor ou na visualização Outline.
• Selecione Refactor > Change Method Signature... no menu de contexto. (Veja a Figura 9.)
• Na tabela denominada Parameters, clique no tipo String e o altere para Object.
• Altere o nome do parâmetro para object.
• Clique no botão Add à direita; esse incluirá uma nova entrada abaixo do parâmetro existente. Mude o tipo para String, o nome para saudação e o valor padrão para "Welcome, ".
• Queremos que o novo parâmetro de saudação seja o primeiro parâmetro; assegure que ele ainda seja o parâmetro selecionado e clique no botão Up. (Ou selecione o parâmetro original e clique no botão Down.)

Como com todas as refatorações no Eclipse, você tem duas opções. A primeira é o que você poderia chamar a opção "Just Do It". Normalmente, o Eclipse obtém suas refatorações certas e, no caso raro quando isso não acontece, sempre é possível desfazê-las usando a seleção de menus Refactor > Undo. (Embora essa oferta seja boa apenas por um tempo limitado depois da refatoração. Se você alterar qualquer um dos arquivos envolvidos, não será mais capaz de desfazer a refatoração.) Se estiver confortável com isso, poderá simplesmente clicar em OK. Normalmente, essa é a coisa mais fácil a fazer, mas não faça isso agora.

A segunda opção, "I want to micromanage", é interessante de ver, pelo menos uma vez. Por clicar em Preview, o Eclipse mostrará uma caixa de diálogo que permite selecionar mudanças específicas em todos os arquivos afetados no alto e numa comparação lado a lado, antes e depois do arquivo selecionado abaixo desse. (Neste caso, é claro, há apenas um arquivo.) Aqui é possível examinar a refatoração proposta arquivo por arquivo, alteração por alteração, e aprovar ou rejeitar cada alteração individualmente, como mostrado na Figura 10. Deixe todas as alterações marcadas e clique em OK.

É assim que o código se parece depois da refatoração:

			
      public static void main(String[] args) {
            int x = 100;

            Vector names = new Vector();
            names.add("Moe");
            names.add("Curly");
            names.add("Larry");
            for (Iterator i = names.iterator(); i.hasNext();) {
                  String name = (String) i.next();
                  greet("Welcome, ", name);
            }
      }

      /**
       * @param greeting TODO
       * @param object
       */
      private static void greet(String greeting, Object object) {
                  System.out.println("Hello, " + object);
      }

Observe que a refatoração atualizou a chamada do método greet() no método main() e usou para o valor padrão ("Welcome, " para o primeiro parâmetro), além de alterar o método em si. Se houver outros arquivos no projeto e eles forem chamados em greet() também, eles serão alterados do mesmo modo.

Se executar o programa agora, ele produzirá exatamente o mesmo resultado que antes, como qualquer refatoração apropriada deve fazer. O que ganhamos foi a capacidade de imprimir e usar uma saudação diferente cada vez que chamarmos o método greet(), mas essa é uma alteração de código funcional que fizemos por conta própria, alterando a chamada System.out.println(), como segue:

System.out.println(greeting + object);

Posteriormente, talvez desejemos alterar o modo como o objeto é impresso, dependendo do tipo do objeto. Isso funciona bem para cadeias de caractere, mas se for para outra coisa, o objeto será convertido em uma cadeia de caractere usando o método toString() do objeto. Algumas vezes, isso produzirá um resultado indesejado.

Voltar para parte superior

Usando CVS

Embora tanto o JBuilder quanto o Eclipse tenham suporte para CVS e outros sistemas de controle de versão, o Eclipse fornece uma interface muito mais elaborada usando duas perspectivas separadas. A primeira é a perspectiva CVS Repository Exploring para escolha dos repositórios e módulos do CVS a que se conectar, e para explorar os arquivos que eles contêm. A segunda é uma perspectiva Team Synchronizing para mesclagem das alterações no repositório. Embora isso possa dificultar um pouco o uso do CVS inicialmente, essa abordagem encoraja um fluxo de trabalho disciplinado e estruturado.

Outra diferença é que o Eclipse é bastante rigoroso sobre o tipo de repositório CVS que suporta. Primeiro, ele não suporta um repositório local; ou seja, não terá acesso a um repositório CVS diretamente no disco, mas precisa usar uma conexão cliente-servidor ― especificamente usar o protocolo pserver ou ssh. Entre esses, o ssh é recomendado por ser mais seguro já que o pserver transmite a senha como texto não criptografado. Convenientemente, o Eclipse fornece um cliente integrado para ambos os protocolos.

Para começar, você precisará acessar a um repositório CVS e as informações necessárias para se conectar a ele. Abra a perspectiva CVS Repository Exploring selecionando Window > Open Perspective > Other no menu principal e selecionando CVS Repository Exploring. Essa perspectiva tem várias visualizações interessantes, mas a principal é uma na parte superior esquerda, CVS Repositories. Clicar com o botão direito do mouse aqui e selecionar New > Repository Location permitirá que você insira as informações necessárias para se conectar a um servidor CVS (veja a Figura 11). Você observará que para usar ssh, precisará selecionar o tipo de conexão extssh do Eclipse.

Para criar um novo módulo CVS de um projeto Eclipse:

• Alterne para a perspectiva Java ou Resource.
• Clique com o botão direito do mouse no nome do projeto e selecione Team > Share Project... no menu de contexto.
• Uma caixa de diálogo aparecerá, com a opção "Use existing repository location selection" marcada. Abaixo de tal caixa, o repositório que você inseriu antes será selecionado. Pressione Next.
• Na caixa de diálogo a seguir, aceite a opção para usar o nome do projeto como o nome do módulo, e clique em Next.
• A próxima caixa de diálogo permitirá que você reveja o que está prestes a efetuar o registro de entrada; se não houver problemas, clique em Finish.
• Uma caixa de diálogo final o notificará que você ainda não confirmou suas alterações e perguntará se deseja confirmá-las. Clique em Yes.

Agora, você será notificado que há seis recursos que não estão ainda sob controle de versão. É possível simplesmente responder Sim, se desejar, mas se for curioso, descubra que recursos são esses, pressionando Details primeiro. Você descobrirá que esses são os dois arquivos metadados do Eclipse: .project e .classpath, o arquivo de origem Java, HelloObject.java, e as pastas aninhadas em que o arquivo de origem Java está armazenado (correspondendo ao seu pacote): /Hello/com, /Hello/com/example e na Hello/com/example/hello.

• Pressione Yes, se ainda não tiver feito.
• Você será solicitado para um comentário; insira "Initial version".

Depois de ter efetuado o registro de entrada e de saída dos arquivos do CVS e ter trabalhado neles um pouco mais, será necessário assegurar que suas alterações não estejam em conflito com as de outra pessoa antes de registrá-las; na verdade, se houver algum conflito, o CVS não permitirá que o registro de entrada seja efetuado.

É possível resolver e mesclar seu código com o repositório de dois modos. O modo mais simples é atualizar simplesmente seus arquivos locais com alterações do repositório CVS clicando com o botão direito do mouse no projeto e selecionando Team > Update no menu de contexto. Se houver alterações, elas serão automaticamente mescladas nos arquivos usando o formato diff (muitos sinais de maior e menor marcando que linhas estão no código, mas não no repositório, e vice-versa). Tentar arrumar isso pode ser tedioso e propenso a erro.

É melhor usar a perspectiva Team Synchronizing do Eclipse, que apresentará os arquivos alterados lado a lado, para viabilizar a revisão, aceitação ou rejeição das alterações em cada arquivo. Para fazer isso:

• Clique com o botão direito do mouse no nome do projeto e selecione Team > Synchronize with Repository no menu de contexto.
• Você será notificado de que essa tarefa está associada à perspectiva Team Synchronizing, e perguntado se deseja alterar para essa perspectiva. Marque "Remember my decision" e pressione Yes.

Como a maioria das outras perspectivas, a visualização que você deseja examinar primeiro é aquela na parte superior esquerda do ambiente de trabalho, neste caso, a visualização Synchronize. No alto são vários botões de ferramentas, incluindo Incoming Mode, Outgoing Mode, Incoming/Outgoing Mode e Conflicts Mode. Que modo estará selecionado inicialmente dependerá de se há alterações no repositório, no código local ou em ambos (ou se as alterações em ambos estão ou não em conflito). O modo determina quais arquivos são mostrados nesta visualização: arquivos locais alterados, arquivos de repositório alterados ou ambos. Isso pode soar confuso, mas, na prática, você não precisa se preocupar com os detalhes; o importante é que este atua para filtrar informações desnecessárias. Você verá apenas os arquivos que precisa revisar para trazer o código de origem atualizado com o repositório.

Suponha que você inclua algum código em HelloObject (de forma que, por exemplo, ele manipule String de modo diferente que outros objetos) e, nesse meio tempo, alguém também registre a saída do código e faça outra alteração ( para o método main(), por exemplo). Você não precisa necessariamente estar ciente disso, mas antes de registrar a entrada do seu arquivo, poderá clicar com o botão direito do mouse e selecionar Team > Synchronize with Repository.... Isso abrirá a perspectiva Repository Synchronizing (com sua permissão, evidentemente) e mostrará uma comparação lado a lado do arquivo local e do arquivo no Repositório, como mostrado na Figura 12:

Aqui, é possível revisar cada alteração em cada arquivo, e copiá-lo para sua origem clicando no botão de ferramenta Copy Right to Left na visualização Java Source Compare ou editando o arquivo local manualmente, como apropriado. Quando estiver satisfeito com a sua mesclagem, marque o arquivo como mesclado, clicando com o botão direito do mouse no nome do arquivo na visualização Synchronize e selecionando Mark as Merged no menu de contexto.

Assim que tiver resolvido qualquer conflito e mesclado todos os arquivos na visualização Synchronize, retorne à visualização java e verifique se o projeto compila e executa corretamente antes de efetuar o registro de entrada do seu código. Para efetuar o registro de entrada do seu código:

• Clique com o botão direito do mouse no nome do projeto (ou em um nome de arquivo para confirmar um único arquivo) e selecione Team > Commit no menu do projeto.
• Insira um comentário quando consultado. (Observe que se estiver efetuando o registro de entrada no projeto e vários arquivos tiverem sido alterados, esse comentário será aplicado a todos os arquivos. Para inserir comentários para arquivos individuais, precisará efetuar o registro de entrada dos arquivos individualmente.)

Voltar para parte superior

Resumo

Tanto o Eclipse 3.0 quanto a edição JBuilder X Foundation da Borland são IDEs Java com muitos recursos que fornecem verificação de sintaxe, assistência de código e geração de código para codificação, mas suporte para refatoração, Ant, teste de unidade e CVS. E em pouco tempo, estará disponível o Eclipse Visual Editor 1.0 para desenvolvimento de GUIs usando AWT/Swing ou SWT. Mas há algumas diferenças importantes entre os dois.

Uma diferença importante reside no modo como a interface com o usuário do Eclipse é projetada usando o conceito de uma perspectiva ― uma coleção de visualizações, editores e outros elementos UI que são mais adequados para executar uma tarefa específica. Isso torna mais fácil realizar o trabalho porque as ferramentas apropriadas (e somente as ferramentas apropriadas) estão à mão.

Outra diferença importante é que o Eclipse é um projeto de software livre. Por causa disso, o Eclipse atraiu uma grande comunidade de desenvolvedores que estão criando plug-ins, gratuitos e comerciais, para o Eclipse. Se precisar de um recurso, qualquer coisa, desde o suporte de desenvolvimento orientado a aspecto ou um MP3 player integrado, é provável que encontre um plug-in gratuito disponível que estenda o Eclipse.

Recursos

• Saiba mais no website do Eclipse e obtenha uma lista abrangente de plug-ins do Eclipse.
  
  
• A última versão da JBuilder Foundation está no website da Borland.
  
  
• O artigo Getting started with the Eclipse Platform (developerWorks, novembro de 2002) de David fornece um histórico e visão geral do Eclipse, incluindo detalhes sobre como instalar o Eclipse e plug-ins. Também no seu livro, Eclipse In Action: A Guide for Java Developers (Independent Pub Group, 2003), é leitura obrigatória para desenvolvedores Java usando Eclipse.
  
  
• Para obter uma visão geral do Visual Editor e da tecnologia por detrás dele, junto com uma breve demonstração dos recursos do Visual Editor 0.5 para desenvolver aplicativos AWT/Swing e uma visualização do suporte SWT no Visual Editor 1.0, consulte Desenvolver GUIs com o Projeto Visual Editor do Eclipse (developerWorks, maio de 2004).
  
  
• Refactoring for everyone (developerWorks, setembro de 2003) mostra como e porque usar os recursos de refatoração automatizados do Eclipse com exemplos de todos os recursos de refatoração no Eclipse 2.1.x e a maioria dos recursos de refatoração no Eclipse 3.0.
  
  
• Using Eclipse as development environment with Jakarta Tomcat (developerWorks, maio de 2004) mostra como desenvolver aplicativos Tomcat usando o Eclipse e o plug-in Sysdeo Tomcat. Instruções são incluídas para instalar Tomcat e o plug-in.
  
  
• Debugging with the Eclipse Platform (developerWorks, maio de 2003) fornece uma visão geral de depuração no Eclipse.
  
  
• Developing Struts with Easy Struts for Eclipse (developerWorks, abril de 2004), mostra como desenvolver aplicativos Struts no Eclipse usando o plugin Easy Struts. Instruções são incluídas para instalar Struts e o plug-in.
  
  
• David escreveu artigos de instruções similares para ajudar usuários do Netbeans e IntelligJ IDEA a migrar para o Eclipse: Migrating from Netbeans to Eclipse (developerWorks, setembro de 2004) e Migrating from IntelliJ IDEA to Eclipse (developerWorks, setembro de 2004).
  
  
• Visite o Estação de migração do developerWorks para diversos outros caminhos de migração para desenvolvimento baseado em padrões abertos.
  
  
• Em adição a todos os artigos do Eclipse no developerWorks, localize mais recursos para desenvolver com o Eclipse na Zona de software livre do developerWorks e Zona Java do developerWorks.
  
  
• Participe da comunidade do developerWorks participando dos blogs do developerWorks .
  
  
• Busque por livros sobre esses e outros tópicos técnicos.
  
  

Sobre o autor

Classificar este artigo

Comentários

Voltar para parte superior

Índice

• Eclipse ― a alternativa de software livre
• Getting started with Eclipse
• Uma questão de perspectiva
• Criando um novo projeto no Eclipse
• Perspectiva Resource revisitada
• Refatorar
• Usando CVS
• Resumo
• Recursos
• Sobre o autor
• Comentários

Conheça a IBM da sua cidade

A IBM está mais perto do que você imagina!

---

Saiba mais