Plugins para o Eclipse

em 21/06/2003 , por Ricardo Rodrigues Lecheta

Introdução
Um dos fatores pelo grande sucesso do Eclipse é a possibilidade de se construir plugins,
aumentando o seu conjunto padrão de funcionalidades. Atualmente, sempre estamos à
procura de bons plugins, que permitem o Eclipse realizar uma diversidade muito grande
de tarefas, tornando-se um ambiente de desenvolvimento cada vez mais completo. Os
plugins são construídos através do PDE (Plugin Development Environment). É
possível criar um "Plugin Project" e testá-lo dentro do próprio ambiente de execução do
Eclipse. Neste tutorial vamos construir um plugin que possui um Wizard para a criação
de uma página JSP. Faça o download do material, as classes Java estão com
comentários, o que ajudará a entender o exemplo.
Criando um Plugin Project
Crie um novo Plugin Project, File -> New -> Project -> Plug-in Development -> "Plug-
in Project" e informe o nome do projeto como "guj.wizards". Na tela seguinte preencha
o Plug-in Id com o mesmo nome do Projeto, "guj.wizards". Este é o nome pelo qual seu
plugin vai ser reconhecido pelo Eclipse. Em Plug-in runtime library preencha com
"guj_wizards.jar", que é o nome do arquivo JAR que será distribuído com o seu
plugin. Clique em next. No passo seguinte pode-se escolher em criar um novo projeto
ou criar um projeto baseado nos modelos fornecidos pelo Eclipse. Existem vários
exemplos de plugins, como por exemplo à criação de Views, Wizards, Editors,
Perspectives, etc. Você pode utilizar estes exemplos fornecidos pelo Eclipse para
aprender mais sobre a construção de plugins, mas neste tutorial vamos criar um plugin
partindo de um projeto novo, para isso marque a opção "Create a blank plug-in
project". Clique em Finish.
Plugin.xml
Este arquivo é fundamental para o funcionamento do plugin, pois é nele que estão todas
as funcionalidades a serem adicionadas. Quando o Eclipse é carregado em memória ele
lê todas as informações contidas neste arquivo, e a partir disto é possível que novas
funcionalidades sejam acrescentadas ao seu ambiente de desenvolvimento. O
plugin.xml possui um editor gráfico, mas também é possível editar manualmente o fonte
do arquivo XML. Agora abra o arquivo e clique na tab "source". Repare que são
declarados o "id" do plugin e a "library" que o plugin utilizará para executar dentro do
ambiente de desenvolvimento do Eclipse. A library é o nome do arquivo JAR que
corresponde ao plugin. Abaixo como está o plugin.xml:
<?xml version="1.0" encoding="UTF-8"?>
<plugin id="guj.w izards" name="guj.w izards" >
<runtime>
<library name="guj_w izards.jar"/>
</runtime>
</plugin>

Por hora este arquivo está bem simples, mas à medida que vão sendo acrescentadas
novas funcionalidades ao plugin, cada uma delas precisa ser declarada neste arquivo.
Um exemplo do que se pode criar são novas views, editors, perspectives ou wizards.
Configurando o ambiente para construir o Plugin
Para que se possa criar o plugin, é necessário ter algumas bibliotecas no classpath do
projeto. Procure no diretório [ECLIPSE_HOME]/plugins os seguintes JAR?s: jface.jar,
resources.jar, runtime.jar, swt.jar, ui.jar, workbench.jar e adicione-os no
classpath.Estas bibliotecas são necessárias para compilar as classes que você irá
construir. Outra configuração necessária é indicar quais plugins são obrigatórios para o
desenvolvimento de nosso plugin. Para configurar isto clique em Window ->
Preferences -> Plug-in Development -> Target Plataform, e clique em Select All.
Existem dois motivos para realizar esta configuração, um deles é porque existem
plugins que são utilizados pelo nosso plugin, e caso estes não fossem selecionados em
Target Platform seriam mostrados warnings dizendo que estes plugins não foram
encontrados. O segundo motivo pelo qual é necessário realizar esta configuração é para
testar o plugin. Da mesma maneira que rodamos uma classe Java normal, podemos
testar nosso plugin de dentro do próprio Eclipse, basta clicar em Run -> Run-time
Workbench. Mas para isso alguns plugins precisam estar no nosso ambiente. Para
adicionar estes plugins que são utilizados em execução pelo plugin que você está
construindo abra o arquivo plugin.xml e adicione o seguinte trecho no fonte do XML:
<requires>
<import plugin="org.eclipse.ui"/>
<import plugin="org.eclipse.core.resources"/>
<import plugin="org.eclipse.jdt.core"/>
<import plugin="org.eclipse.jdt.ui"/>
</requires>

Criando a classe principal do Plugin

Agora vamos criar a classe responsável pelo plugin. Crie uma classe Java com o nome
"GUJWizardPlugin" dentro do pacote guj.wizards.plugin. Repare que a classe precisa
herdar de AbstractUIPlugin.
package guj.w izards.plugin;

import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.IPluginDescriptor;
import org.eclipse.ui.plugin.AbstractUIPlugin;

public class GUJWizardPlugin extends AbstractUIPlugin {

// esta classe representa o plugin e precisa ser decla
}

Após ter criado esta classe precisa-se declará-la no arquivo plugin.xml, então adicione o
parâmetro class na declaração do plugin e informe o caminho da classe que você acabou
de criar:
<plugin id="guj.w izards" name="guj.w izards" version="1.0.0"
class="guj.w izards.plugin.GUJWizardPlugin">

Entendendo o Wizard que será construído

Bem, agora imagine que o objetivo seja criar um wizad chamado "GUJ Wizards" onde
existem os seguintes wizards disponíveis: criar JSP, HTML, XML e Servlets. Para isso,
basta criar uma classe que herde da classe "org.eclipse.jface.wizard.Wizard" para cada
wizard. Faça o download do material para este tutorial e veja a imagem do plugin que
será criado:
Não se preocupe em entender todas as anotações feitas na imagem, continue lendo o
tutorial e depois observe mais detalhadamente as marcações. Os wizards de HTML,
XML e Servlets que aparecem na imagem são somente ilustração, neste tutorial será
implementado apenas o JSP Wizard.
Criando o JSP Wizard
Para criar o wizard "JSP Wizard" crie uma classe Java com o nome de "WizardJSP"
dentro do pacote guj.wizards.jsp, e utilize o código que acompanha o tutorial (repare
que a classe faz herança de org.eclipse.jface.wizard.Wizard).
package guj.w izards.jsp;

public class WizardJSP extends Wizard implements INew Wizar

{
private WizardJSPPage page;
private ISelection selection;

public void addPages()

{ // adiciona quantas telas terá o w izard
page = new WizardJSPPage(selection);

Observe o método addPages(), nele adicionamos quantos passos terá o wizard, observe
que neste caso apenas uma tela foi adicionada, isto significa que não será necessário
clicar em Next. Quando o botão Finish do wizard for clicado, o método
performFinish() é invocado automaticamente, então basta recuperar os parâmetros
informados no wizard e efetuar a geração de código fonte.
Criando as telas do JSP Wizard (WizardPages)
Para cada passo do wizard, isto é, todas as telas que precisamos preencher antes de
clicar em Finish, é necessário criar classes que correspondem a cada passo. Para fazer
isto basta criar um classe que faça a herança de
"org.eclipse.jface.wizard.WizardPage" e adiciona-la no método addPages() da classe
que corresponde ao Wizard. Para criar o WizardPage crie uma classe Java com o nome
de "WizardJSPPage" dentro do pacote guj.wizards.jsp, e utilize o código que
acompanha o tutorial:
package guj.w izards.jsp;

public class WizardJSPPage extends WizardPage

{
public WizardJSPPage(ISelection selection)
{
super("w izardPage");
setTitle("JSP Wizard");
setDescription("Este Wizard cria um JSP.")
}

O método createControl(Composite parent) é chamado automaticamente, e nele deve-

se fazer a criação dos componentes gráficos como botões e campos de texto. Observe
que neste trecho de código são definidos Listeners que farão a validação de algumas
informações, como por exemplo garantir que a extensão criada seja *.jsp. Veja o
método dialogChanged() definido como um ModifyListener.
Configurando o Plugin.xml
Agora que tudo já está criado basta informar no arquivo plugin.xml que este wizard
existe. Para isso insira o seguinte trecho no arquivo:
<extension point="org.eclipse.ui.new Wizards">
<category
name="GUJ Wizards"
id="guj.w izards">
</category>
<w izard
name="JSP Wizard"
icon="icons/sample.gif"
category="guj.w izards"
class="guj.w izards.jsp.WizardJSP"

O que fizemos foi definir um "extension point", existem extension points para cada
funcionalidade do Eclipse, como por exemplo wizards, views e editors. Para saber mais
sobre extension points consulte o Help que acompanha o Eclipse, no tópico Platform
Plug-in Developer Guide -> Reference -> Extension Points Reference. Em "category"
definimos o nome que será dado ao wizard e o "id" pelo qual será conhecido. Depois
basta criar uma tag "wizard" para cada Wizard que o plugin vai possuir, neste exemplo
será implementado apenas o "JSP Wizard". Abaixo a listagem completa do plugin.xml?
<?xml version="1.0" encoding="UTF-8"?>
<plugin id="guj.w izards" name="guj.w izards" version="1.0.0">

<runtime>
<library name="guj_w izards.jar"/>
</runtime>

<requires>
<import plugin="org.eclipse.ui"/>
<import plugin="org.eclipse.core.resources"/>
Testando o Plugin
Agora o seu plugin está pronto para ser testado. Para testar o plugin clique em Run ->
Run-time Workbench, aceite todos os defaults e clique em Run. Um novo workspace
será aberto, e nele poderá ser verificado se o plugin está funcionando corretamente.
Depois que o workspace for aberto, crie um novo Projeto. Depois crie um arquivo JSP
com o "GUJ Wizards", para isso clique em File -> New -> Other -> GUJ Wizards.
Informe o nome do arquivo e veja os resultados. Se tudo andar corretamente, um
arquivo JSP foi criado e o editor do Eclipse abriu para a visualização do arquivo.
Também é possível marcar um breakpoint em algum lugar do código e rodar o Debug,
isto é útil para depurar o seu plugin.
Distribuindo o Plugin
Agora que você já testou o plugin, já é possível instalá-lo no Eclipse. Para isto crie uma
pasta guj.wizards em diretório [ECLIPSE_HOME]/plugins. Feito isto exporte um JAR
com as classes Java para este diretório, não esqueça que o nome do JAR precisa ser
guj_wizards.jar, pois este é o nome que foi informado em plugin.xml. Não se esqueça
de exportar o arquivo plugin.xml e também a pasta icons onde estão as imagens
utilizadas pelo plugin. Agora feche o Eclipse e abra novamente, desta forma o plugin
será instalado e já pode ser utilizado.
Conclusão
Este foi apenas um HelloWorld, para saber mais sobre a construção de plugins você
pode estudar os exemplos de acompanham o próprio Eclipse. O Help também é bem
completo e pode ser consultado para auxiliar no desenvolvimento. Outra forma de
estudar é verificando o código fonte de outros plugins, sendo que existe vários deles que
são open-source. Para maiores exemplos consulte os artigos no site do Eclipse:
http://www.eclipse.org/articles/index.html