Desenvolvendo Plug-ins do Eclipse

Como criar, depurar e instalar seu plug-in

Neste artigo, o autor David Gallardo mostra como criar os plug-ins do Eclipse usando o assistente de geração de código do Plug-in Development Environment. Você aprenderá como executar e depurar o plug-in no ambiente de trabalho do tempo de execução e instalará o plug-in concluído no Eclipse. Ele também examina problemas relacionados a plug-ins de pacote -- incluindo a manutenção das informações de versão, upgrade da funcionalidade no formato de fragmentos de plug-in e combinação de plug-ins para criar recursos completos.

David Gallardo, Author

David Gallardo é um consultor de software independente e autor especializado em internacionalização de software, aplicativos da Web Java e desenvolvimento de banco de dados. É um engenheiro de software profissional há mais de quinze anos e tem experiência com muitos sistemas operacionais, linguagens de programação e protocolos de rede. Sua experiência recente inclui a liderança do desenvolvimento de banco de dados e internacionalização em uma empresa de e-commerce de relações comerciais entre empresas, a TradeAccess, Inc. Antes disso, ele era um engenheiro sênior do grupo de Desenvolvimento de Produtos Internacionais na Lotus Development Corporation, onde contribuiu para o desenvolvimento de uma biblioteca para várias plataforma, fornecendo suporte a Unicode e a idiomas internacionais para produtos Lotus, incluindo o Domino. David pode ser contatado em david@gallardo.org.



01/Dez/2002

Uma Arquitetura Baseada em Plug-in

A Plataforma Eclipse, uma estrutura de desenvolvimento doada à comunidade de software livre pela IBM® , é notável não por causa da quantidade de dinheiro que dizem que a IBM gastou se desenvolvendo -- $40 milhões -- mas devido ao que ela tem para mostrar pelo gasto: uma arquitetura madura, bem-projetada e extensível. O que é valioso sobre o Eclipse é que fornece uma plataforma de software livre para criar um ambiente de desenvolvimento integrado (IDE) extensível. Essa plataforma permite que qualquer pessoa construa ferramentas que são integradas de forma transparente com o ambiente e outras ferramentas.

A chave para a integração transparente de ferramentas com o Eclipse é o plug-in. Com a exceção de um pequeno kernel de tempo de execução, tudo no Eclipse é um plug-in. Isso significa que um plug-in desenvolvido integra-se ao Eclipse em exatamente da mesma maneira que outros plug-ins; em relação a isso, todos os recursos são criados iguais.

Alguns plug-ins são mais iguais que outros, no entanto. O Workbench e o Workspace são dois plug-ins indispensáveis da Plataforma Eclipse — eles fornecem os pontos de extensão usados pela maioria dos plug-ins, conforme mostrado na Figura 1. Um plug-in requer um ponto de extensão ao qual conectar para que funcione.

Figura 1. O Workbench e o Workspace do Eclipse: Suporte a Plug-in Essencial
O Workbench e o Workspace do Eclipse: Suporte a Plug-in Essencial

O componente Workbench contém pontos de extensão que, por exemplo, permitem que seu plug-in estenda a interface com o usuário do Eclipse com seleções de menu e botões da barra de ferramentas, para solicitar notificação de diferentes tipos de eventos e para criar novas visualizações. O componente Workspace contém pontos de extensão que permitem interagir com recursos, incluindo projetos e arquivos.

O Workbench e o Workspace não são os únicos componentes do Eclipse que podem ser estendidos por outros plug-ins, é claro. Além disso, há um componente Debug que permitirá que seu plug-in ative um programa, interaja com o programa de execução e trate dos erros -- tudo que é necessário para construir um depurador. Apesar de necessário para determinados tipos de aplicativos, o componente Debug não é necessário para a maioria dos aplicativos.

Há também um componente Team que permite que recursos do Eclipse interajam com sistemas de controle de versão (VCS), mas, a menos que você esteja construindo um cliente do Eclipse para um VCS, o componente Team, assim como o componente Debug, não terá sua funcionalidade estendida nem aprimorada.

Por fim, há um componente Help disponível para permitir fornecer documentação on-line e ajuda sensível ao contexto para seu aplicativo. Não há como negar que a documentação da ajuda é uma parte essencial de um aplicativo profissional, mas não é essencial para a funcionalidade de um plug-in.

Os pontos de extensão que cada um dos componentes acima fornece estão documentados na Ajuda da Plataforma Eclipse, na seção de referência do Platform Plug-in Developer guide. Uma olhada rápida, principalmente na seção Workbench da referência da API é inicialmente desanimadora. Em vez de mergulhar nos detalhes dos muitos pontos de extensão disponíveis, vamos simplesmente molhar os pés dando uma olhada em um plug-in simples e seus componentes.


Uma Introdução Leve a Plug-ins

A maneira mais fácil de criar um plug-in é usando o Plug-in Development Environment (PDE). O PDE, juntamente com o Java™ Development Tooling (JDT) IDE, são fornecidos como uma extensão padrão do Eclipse. O PDE fornece assistentes para ajudar a criar plug-ins, incluindo o exemplo "Hello World" que iremos examinar aqui.

No menu Eclipse, selecione Arquivo > Novo > Outro (ou pressione Ctrl+N), em seguida, selecione o assistente Desenvolvimento de Plug-in do lado esquerdo do diálogo Selecionar. Do lado direito do diálogo Selecionar, escolha Projeto Plug-in. Pressione Avançar. Na próxima tela, insira um nome de projeto; eu usei com.example.hello. Pressione Avançar novamente. Na próxima tela, observe que o ID do plug-in corresponde ao nome do projeto. Usar o nome do projeto como o ID do plug-in minimiza as chances de esse plug-in entrar em conflito com o nome de outro plug-in. Clique em Avançar novamente. A próxima tela fornece a opção de criar manualmente o código de plug-in inicial ou executar um assistente de geração de código. Deixe o assistente de geração de código padrão, selecione Hello World e clique em Avançar, conforme mostrado na Figura 2.

Figura 2. Selecionando o Assistente de Geração de Código Hello World
Selecionando o Assistente de Geração de Código Hello World

A próxima tela solicita informações adicionais. Observe as informações nessa tela: ela inclui o nome do plug-in, o número da versão, o nome do provedor e o nome da classe. Há partes de informações importantes sobre nosso plug-in, como veremos posteriormente. Você pode aceitar os padrões fornecidos pelo assistente. Clique em Avançar. Na próxima tela, aceite os padrões para o nome do pacote, o nome da classe e o texto da mensagem. Deixe a caixa de opção "Incluir a ação configurada para a perspectiva do recurso" marcada, em seguida, clique em Concluir.

Se você for notificado de que o assistente precisa ativar outros plug-ins específicos para ser concluído, clique em OK.

Após algum tempo, o assistente será concluído e você terá um novo projeto denominado com.example.hello em sua área de trabalho, conforme mostrado na Figura 3.

Figura 3. A Perspectiva PDE: Bem-vindo ao Plug-in Hello
A Perspectiva PDE: Bem-vindo ao Plug-in Hello

À esquerda do ambiente de trabalho, no Package Explorer, está uma visão geral de algumas das coisas criadas pelo assistente. A maioria dos itens não é muito interessante. Há diversos arquivos .jar incluídos no caminho de classe do projeto (eles incluem as classes do Eclipse necessárias para o plug-in e o tempo de execução Java), uma pasta icons contendo um gráfico para um botão da barra de ferramentas e um arquivo build.properties contendo variáveis usadas por um script de construção automatizado.

As coisas mais interessantes aqui são a pasta src, que contém o código de origem para nosso plug-in e o arquivo plugin.xml — o arquivo de manifesto de plug-in. Vamos das uma olhada no plugin.xml primeiro.


O Arquivo de Manifesto de Plug-in

O arquivo de manifesto de plug-ins, plugin.xml, contém informações descritivas que serão usadas pelo Eclipse para integrar o plug-in à estrutura. Por padrão, o plugin.xml é aberto na área do editor de manifesto quando o plug-in é criado pela primeira vez. Guias na parte inferior do editor permitem selecionar diferentes conjuntos de informações sobre o plug-in. A guia Bem-vindo exibe a mensagem "Bem-vindo ao Plug-in Hello" e discute resumidamente os modelos usados e as dicas sobre como usar o Eclipse para implementar o plug-in. Selecionar a guia Origem permitirá que você veja a origem completa do arquivo plugin.xml.

Vamos dar uma olhada nas diferentes partes do arquivo de manifesto de plug-ins. Primeiro estão informações gerais sobre o plug-in, incluindo seu nome, número de versão, o nome do arquivo de classe que o implementa e o nome do arquivo JAR.

Lista 1. Arquivo de Manifesto de Plug-ins— Informações Gerais
<?xmlversion="1.0" encoding="UTF-8"?>
<plugin
   id="com.example.hello"
   name="Hello Plug-in"
   version="1.0.0"
   provider-name="EXAMPLE"
   class="com.example.hello.HelloPlugin">

   <runtime>
      <library name="hello.jar"/>
   </runtime>

Em seguida, os plug-ins necessários para nosso plug-in são listados.

Lista 2. Arquivo de Manifesto de Plug-ins — Plug-ins Necessários
   <requires>
      <import plugin="org.eclipse.core.resources"/>
      <import plugin="org.eclipse.ui"/>
   </requires>

O primeiro plug-in listado, org.eclipse.core.resources, é o plug-in da área de trabalho, mas não é realmente necessário para nosso plug-in. O segundo plug-in, org.eclipse.ui, é o ambiente de trabalho. Precisamos do plug-in do ambiente de trabalho, pois estaremos estendendo dois de seus pontos de extensão, conforme indicado pelas tags de extensão a seguir.

A primeira tag de extensão tem o atributo do ponto org.eclipse.ui.actionSets. Um conjunto de ações é um grupo de contribuições que um plug-in inclui na interface com o usuário do ambiente de trabalho — ou seja, menus, itens de menu e barras de ferramentas. Um conjunto de ações agrupa contribuições de forma que um usuário possa gerenciá-las mais facilmente. Por exemplo, os itens de menu e da barra de ferramentas de nosso plug-in Hello aparecerão na Perspectiva do Recurso, devido à opção que fizemos quando executamos o assistente de geração de código. O usuário pode alterar isso usando a opção de menu Janela > Customizar Perspectiva para remover "Conjunto de Ações de Amostra" dos itens a serem exibidos na Perspectiva do Recurso.

Figura 4. Customizando a Perspectiva do Recurso
Customizando a Perspectiva do Recurso

O conjunto de ações contém duas tags: uma tag de menu que descreve onde e como nosso item deve aparecer no menu do ambiente de trabalho e uma tag de ação que descreve o que deve fazer — especificamente, a tag de ação identifica a classe que executa a ação. Observe que essa classe é diferente da classe de plug-in listada acima.

Lista 3. Conjunto de Ações
   <extension
         point="org.eclipse.ui.actionSets">
      <actionSet
            label="Sample Action Set"
            visible="true"
            id="com.example.hello.actionSet">
         <menu
               label="Sample &Menu"
               id="sampleMenu">
            <separator
                  name="sampleGroup">
            </separator>
         </menu>
         <action
               label="&Sample Action"
               icon="icons/sample.gif"
               class="com.example.hello.actions.SampleAction"
               tooltip="Hello, Eclipse world"
               menubarPath="sampleMenu/sampleGroup"
               toolbarPath="sampleGroup"
               id="com.example.hello.actions.SampleAction">
         </action>
      </actionSet>
   </extension>

O propósito de muitos dos atributos de menu e ação é bem óbvio — por exemplo, fornecer o texto das dicas de ferramenta e identificar o gráfico para o item da barra de ferramentas. Observe também o menubarPath na tag de ação: esse atributo identifica qual item de menu definido na tag de menu chama a ação definida na tag de ação. Para obter informações detalhadas sobre isso e outros pontos de extensão do ambiente de trabalho, consulte o Platform Plug-in Developer Guide, principalmente o capítulo "Plugging into the workbench" (o guia está disponível a partir do menu da ajuda no Eclipse).

A segunda tag de extensão foi gerada como resultado de nossa eleição em ter nosso plug-in incluído na Perspectiva do Recurso. Essa tag faz com que nosso plug-in seja incluído na Perspectiva do Recurso quando o Eclipse for iniciado pela primeira vez e carregar nosso plug-in.

Lista 4. Tag de Extensão
   <extension
         point="org.eclipse.ui.perspectiveExtensions">
      <perspectiveExtension
            targetID="org.eclipse.ui.resourcePerspective">
         <actionSet
               id="com.example.hello.actionSet">
         </actionSet>
      </perspectiveExtension>
   </extension> </plugin>

Se essa última extensão tiver sido omitida, o usuário precisaria incluir o plug-in na Perspectiva do Recurso (ou outra) usando Janela > Customizar Perspectiva.


O Código de Origem do Plug-in

O assistente de geração de códigos gerou dois arquivos de origem Java, que você pode ver abrindo a pasta src no package explorer do PDE. O primeiro, HelloPlugin.java , é a classe de plug-in e estende a classe abstrata AbstractUIPlugin . HelloPlugin é responsável por gerenciar o ciclo de vida do plug-in e, em um aplicativo mais estendido, seria responsável por manter coisas como as configurações da caixa de diálogo e as preferências do usuário. HelloPlugin não faz muito.

Lista 5. HelloPlugin
packagecom.example.hello.actions;

import org.eclipse.ui.plugin.*;
import org.eclipse.core.runtime.*;
import org.eclipse.core.resources.*;
import java.util.*;

/**
 * The main plugin class to be used in the desktop.
 */
public class HelloPlugin extends AbstractUIPlugin {
      //The shared instance.
      private static HelloPlugin plugin;
      //Resource bundle.
      private ResourceBundle resourceBundle;
      
      /**
       * The constructor.
       */
      public HelloPlugin(IPluginDescriptor descriptor) {
            super(descriptor);
            plugin = this;
            try {
                  resourceBundle= ResourceBundle.getBundle(
                       "com.example.hello.HelloPluginResources");
            } catch (MissingResourceException x) {
                  resourceBundle = null;
            }
      }

      /**
       * Returns the shared instance.
       */
      public static HelloPlugin getDefault() {
            return plugin;
      }

      /**
       * Returns the workspace instance.
       */
      public static IWorkspace getWorkspace() {
            return ResourcesPlugin.getWorkspace();
      }

      /**
       * Returns the string from the plugin's resource bundle,
       * or 'key' if not found.
       */
      public static String getResourceString(String key) {
            ResourceBundle bundle= HelloPlugin.getDefault().getResourceBundle();
            try {
                  return bundle.getString(key);
            } catch (MissingResourceException e) {
                  return key;
            }
      }

      /**
      * Returns the plugin's resource bundle,
      */
      public ResourceBundle getResourceBundle() {
          return resourceBundle;
      }
}

O segundo arquivo de origem, SampleAction.java, contém a classe que executa a ação especificada no conjunto de ações no arquivo de manifesto. SampleAction implementa a interface IWorkbenchWindowActionDelegate , que permite que o Eclipse use um proxy para nosso plug-in de forma que o Eclipse não precise carregar o plug-in até que seja absolutamente necessário (essa otimização funciona para minimizar problemas de memória e desempenho quando os plug-ins são carregados). Os métodos da interface IWorkbenchWindowActionDelegate permitem que nosso plug-in interaja com o proxy.

Lista 6. Métodos da Interface IWorkbenchWindowActionDelegate
package com.example.hello.actions;

import org.eclipse.jface.action.IAction;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;
import org.eclipse.jface.dialogs.MessageDialog;

/**
 * Our sample action implements workbench action delegate.
 * The action proxy will be created by the workbench and
 * shown in the UI. When the user tries to use the action,
 * this delegate will be created and execution will be 
 * delegated to it.
 * @see IWorkbenchWindowActionDelegate
 */
public class SampleAction implements IWorkbenchWindowActionDelegate {
      private IWorkbenchWindow window;
      /**
       * The constructor.
       */
      public SampleAction() {
      }

      /**
       * The action has been activated. The argument of the
       * method represents the 'real' action sitting
       * in the workbench UI.
       * @see IWorkbenchWindowActionDelegate#run
       */
      public void run(IAction action) {
            MessageDialog.openInformation(
                  window.getShell(),
                  "Hello Plug-in",
                  "Hello, Eclipse world");
      }

      /**
       * Selection in the workbench has been changed. We 
       * can change the state of the 'real' action here
       * if we want, but this can only happen after 
       * the delegate has been created.
       * @see IWorkbenchWindowActionDelegate#selectionChanged
       */
      public void selectionChanged(IAction action, ISelection selection) {
      }

      /**
       * We can use this method to dispose of any system
       * resources we previously allocated.
       * @see IWorkbenchWindowActionDelegate#dispose
       */
      public void dispose() {
      }

      /**
       * We will cache window object in order to
       * be able to provide parent shell for the message dialog.
       * @see IWorkbenchWindowActionDelegate#init
       */
      public void init(IWorkbenchWindow window) {
            this.window = window;
      }
}

Executando e Depurando o Plug-in

Ao desenvolver um plug-in para o Eclipse, seria estranho precisar parar o Eclipse e, em seguida, reiniciá-lo com o novo plug-in para testar e depurar. O PDE do Eclipse, ainda bem, fornece um ambiente de desenvolvimento auto-hospedado que permite executar um plug-in sem instalação em uma instância separada do ambiente de trabalho.

Para executar o plug-in Hello, selecione Executar > Executar como > Ambiente de Trabalho do Tempo de Execução para iniciar outra instância do Ambiente de Trabalho com a seleção de menu e a barra de ferramentas de nosso plug-in incluídas, conforme mostrado na Figura 5.

Figura 5. O Plug-in Hello em Execução no Ambiente de Trabalho do Tempo de Execução
O Plug-in Hello em Execução no Ambiente de Trabalho do Tempo de Execução

Podemos ativar o plug-in clicando no botão da barra de ferramentas ou a partir do menu "Menu de Amostra". Qualquer um dos dois métodos ativará uma caixa intitulada "Plug-in Hello" com o conteúdo "Hello, Eclipse world" e um botão OK para dispensá-la.

Podemos depurar um plug-in de maneira semelhante, selecionando Executar > Depurar como > Ambiente de Trabalho do Tempo de Execução. Desta vez, podemos percorrer o código de origem, examinar variáveis, etc. no ambiente de trabalho original enquanto o plug-in é executado na segunda instância do ambiente de trabalho.

Quando nosso plug-in for testado e estiver pronto para o release, precisaremos colocá-lo em um pacote apropriado para instalação no Eclipse.


Colocando o Plug-in em um Pacote

O Eclipse determina quais plug-ins carregar, consultando seu diretório plugins na inicialização. Para instalar um plug-in, precisamos criar um subdiretório no diretório plugins e copiar nossos arquivos de programa e arquivos de manifesto lá. Não é necessário, mas é recomendável, que o nome do diretório indique o ID do plug-in, seguido por um sublinhado e o número da versão. Suponhamos que o Eclipse esteja instalado em C:\eclipse; podemos criar um diretório:

C:\eclipse\plugins\com.example.hello_1.0.0.

Como é padrão com os aplicativos Java, nossos arquivos de programa precisam ser arquivados em um arquivo JAR — nosso arquivo de manifesto de plug-ins, você pode se lembrar, continha esta entrada:

   <runtime>
      <library name="hello.jar"/>
   </runtime>

Para criar o arquivo hello.jar , podemos exportar nossos arquivos de plug-in realçando o nome do projeto e selecionando Arquivo > Exportar no menu Eclipse. Selecione arquivo JAR como o destino, clique em Avançar e navegue até o diretório criado para ele. Em seguida, precisamos copiar o arquivo plugin.xml para esse mesmo diretório. Você pode usar a seleção de menu Arquivo > Exportar também (mas lembre-se de escolher Sistema de Arquivos como o destino).

Isso é tudo que é necessário para instalar o plug-in, mas será necessário parar e reiniciar o Eclipse para que o novo plug-in seja reconhecido. É possível localizar informações sobre os plug-ins instalados, incluindo o número da versão, selecionando "Sobre a Plataforma Eclipse" no menu da ajuda. Um dos botões que aparece na tela será Detalhes do Plug-in; role na lista para baixo para localizar o plug-in Hello e seu número de versão.


Atualizando a Versão do Plug-in

O propósito de incluir o número da versão no nome do diretório é permitir que diversas versões de um plug-in coexistam na mesma máquina (somente um é carregado por vez). Podemos ver como isso funciona criando uma versão atualizada do plug-in Hello; por exemplo, altere o número da versão no arquivo plugin.xml para "1.0.1" e altere o texto de SampleAction.java para "New and improved Hello, Eclipse world". Selecione Projeto > Reconstruir Tudo no menu Eclipse. Em seguida, exporte os arquivos de projeto como um JAR para um novo diretório de plug-in — por exemplo, com.example.hello_1.0.1. Copie o arquivo plugin.xml revisado para o mesmo diretório. Ao parar e reiniciar o Eclipse, somente o plug-in atualizado será carregado.


Fragmentos e Recursos do Plug-in

O Eclipse é composto por plug-ins, mas há dois outros níveis de componentes que são importantes a serem considerados ao desenvolver plug-ins para o Eclipse: fragmentos e recursos de plug-in.

Um fragmento de plug-in, como o nome sugere, forma uma parte do plug-in inteiro — o plug-in de destino . A funcionalidade fornecida pelo fragmento é fundida à do plug-in de destino. Um fragmento pode ser usado para localizar um plug-in para diferentes idiomas, para incluir recursos de forma incremental em um plug-in existente sem a necessidade de um novo release completo ou para fornecer funcionalidade específica da plataforma. Em muitos aspectos, um fragmento é idêntico a um plug-in. A principal diferença é que um fragmento não possui uma classe de plug-in — o ciclo de vida do fragmento é gerenciado por seu plug-in de destino. Além disso, o arquivo de manifesto do fragmento, chamado fragment.xml, lista o ID e o número da versão do plug-in de destino, assim como o ID e o número da versão do fragmento.

Um recurso do plug-in, por outro lado, não inclui nenhuma codificação. Na terminologia da arquitetura Eclipse um recurso é o pacote de um grupo de plug-ins relacionados em um produto integral. Por exemplo, o JDT é um recurso formado por plug-ins como o editor Java, o depurador e o console. Um arquivo de manifesto chamado feature.xml descreve um archive de recurso. Entre outras coisas, o arquivo de manifesto inclui referências aos plug-ins e outros recursos que o recurso engloba, informações sobre como o recurso deve ser atualizado, informações de copyright e informações sobre licença.

No Eclipse, um recurso principal configura a aparência e comportamento da Plataforma Eclipse. Espera-se que o recurso principal determine coisas como a tela inicial e outras características que fornecem ao Eclipse sua identidade. O Eclipse permite somente um recurso principal. Dessa forma — criando um conjunto de plug-ins, empacotando-as em um recurso e tornando esse recurso o recurso principal — o Eclipse pode ter a marca redefinida e ser usado para criar um produto totalmente novo e diferente. Conforme transferido por download da Eclipse.org, o recurso principal padrão é eclipse.org.platform.


Próximas Etapas

Esta introdução para plug-ins cobre, necessariamente, muito pouco do que pode ser feito com um plug-in. O melhor recurso para aprender mais sobre plug-ins é o Plug-in Developer's Guide disponível no menu da ajuda no Eclipse. A documentação inclui um guia de programação, uma referência à API do Eclipse e os pontos de extensão do plug-in, um guia para os exemplos de programação disponíveis em Eclipse.org e uma lista de perguntas mais frequentes. Um outro recurso excelente é o código de origem para o próprio Eclipse. Dependendo de seu interesse, você pode querer encontrar exemplos de como diferentes recursos do ambiente de trabalho, como visualizações e editores são estendidos ou como o SWT (a API gráfica do Eclipse) é usado. Além disso, os Recursos abaixo podem ajudá-lo a aprender mais.

Recursos

Aprender

Obter produtos e tecnologias

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Software livre
ArticleID=382623
ArticleTitle=Desenvolvendo Plug-ins do Eclipse
publish-date=12012002