O Eclipse é um framework para integrar diferentes tipos de aplicações. Uma de suas aplicações é a JDT(Java Development Tooling), a qual já vem com o Eclipse.
Essas aplicações são oferecidas em forma de plugins e automaticamente reconhecidas e integradas pela plataforma. Tendo seus próprios recursos para gerenciamento de mecanismo, que são geralmente arquivos no seu Hard Disk. Eles residem no seu workspace, uma pasta especial localizada no seu sistema de arquivos. As aplicações instaladas comunicam-se entre si, com isso, se uma aplicação altera um recurso qualquer, todas as outras aplicações instaladas serão notificadas sobre essa mudança, garantindo uma consistência e integração em todo o seu ambiente de desenvolvimento.
Um usuário sempre trabalha no workbench, a parte "visível" da plataforma(GUI). A perspectiva escolhida determina a aparência atual do workbench. A perspectiva é uma coleção conhecida como "views e editores" que contribuem com ações especiais para o menu e a toolbar.
A maioria das views mostra informações especiais sobre os recursos. Dependendo da view somente partes ou relacionamentos internos dos recursos poderão ser mostrados. Como no caso de arquivos do tipo XML.
Um editor trabalha diretamente sobre um recurso(classes Java como exemplo). O Eclipse segue um ciclo de carrega-altera-salva que somente se um editor salvar suas alterações, a plataforma será capaz de notificar as outras aplicações.
Views especiais podem ser conectadas diretamente a um editor, adicionando recursos complementares ao manuseamento dos recursos. Por exemplo a Outline View da perspectiva Java é conectada diretamente ao Editor Java.
O que torna o Eclipse uma IDE especial, é a extrema flexibilidade na qual podem ser combinadas views e editores. Dessa forma o workbench pode ser arrumado de uma forma livre e que melhor adapte o desenvolvedor. As views e editores podem ser adicionados em uma perspectiva aberta (mesmo se eles foram definidos em um plugin totalmente diferente). Portanto é possível ter a total liberdade para criar o ambiente de desenvolvimento que melhor agrade ao desenvolvedor, de uma forma agradável e customizada.
Para abrir uma nova perspectiva no seu worbench faça:
1. Escolha 'Window -> Open Perspective' no menu principal:
2. Escolha 'Other' para ver todas as perspectivas instaladas:
Para instalar novas aplicações, simplesmente copie os plugins para dentro da pasta $ECLIPSE_HOME/plugins como mostrado
com o Tomcat plugin. Será preciso reiniciar o Eclipse para tornar a nova aplicação "ativa". Dependendo plugin uma nova perspectiva
poderá ser escolhida, sendo encontradas novas opções no menu e toolbar.
Como default a pasta root do workspace é $ECLIPSE_HOME/workspace. Caso seja necessário atuar com em vários projetos, ou mesmo compartilhar uma maquina para armazenamento dos projetos, faz mais sentido separar o workspace. Pode ser escolhido um diretório arbitrário para o wokspace, para ter uma pasta especifica como root basta usar a opção -data na inicialização do Eclipse. Por exemplo "eclipse -data c:\MeuWorkspace".
A navigator view será adicionada na perspectiva Java.
Se um recurso existente no workspce for alterado por uma ferramenta externa, a notificação não chegara ao Eclipse automaticamente. Mas se o recurso alterado externamente estiver aberto em um editor no Eclipse, será recebida uma notificação perguntando se é desejado carregar as alterações ocorridas.
Caso sejam criados arquivos ou pastas para o seu projetos externamente, será preciso notificar ao Eclipse:
Após a inicialização do Eclipse, serão necessárias algumas configurações da ferramenta.
Por padrão os arquivos fonte e compilados serão salvos diretamente na pasta do projeto. É melhor separar o código fonte do código compilado (arquivos .class). Com isso devemos ter uma pasta especial (source) que contem somente o código fonte.
Um projeto pode crescer consideravelmente através da adição de novas pastas de código fonte.
O compilador Java e editor do Eclipse podem ser configurados para trabalhar com diferentes versões de JDK.
Para ver o código fonte das classes padrão do Java, precisa ser "avisado" ao Eclipse para usar o JDK correspondente. Por padrão o Eclipse utiliza o JRE, o qual não possui código fonte (o arquivo src.zip).
Ao usar o JDK, ajudas adicionais serão oferecidas:
Code Assist pode mostrar nomes e retornos dos métodos existentes no JavaDoc e comentários através de um hover help.
Pré-requisito: O JDK precisa estar instalado no Sistema Operacional
Classpath variables são definidas a nível do workbench. Pastas e arquivos .jar ou .zip podem receber nomes, fazendo com que seja fácil inclui-los no buildpath.
Como criar um projeto Java simples, onde o código fonte esta separado na sua pasta de "saída'.
Criação do projeto Java:
Não importa se será criado um novo projeto ou será importado um projeto existente, é necessário criar um projeto Java no Eclipse antes.
No matter if you want to start an all new project or want to import an existing one - you need to create an Eclipse Java project first.
'File -> New -> Project' para obter um dialogo que deixa escolher 'Java project'.
'New Java Project':
Criação da classe Java:
na toolbar.
Para executar o método main, será preciso configurar o launcher:
Como atalho pode ser escolhido 'Run As -> Java Application' e no menu dropdown 'Run'. Isso é totalmente suficiente para executar um programa simples (sem parâmetros etc.)
Pressionando o botão 'Run' a ultima ação será executada novamente, nesse caso a classe 'Test'.
Será necessário criar uma nova configuração:
Para importar um projeto existente, será necessário:
O buildpath avisa ao compilador onde procurar por vários arquivos e recursos para realizar o seu trabalho. Isso significa que devem ser compilados o código fonte e as classes definidas através das implementações. Essas informações são armazenadas no arquivo .classpath do projeto Java. Não é aconselhável editar esse arquivo diretamente, mas sim usar um assistente especial.
Significado das várias tabs:
Source:
Aqui serão especificadas as pastas nas quais os códigos fonte serão armazenados. Somente nessas pastas novas classes
e packages poderão ser criados. Por padrão novas classes serão criadas diretamente nessas pastas dos projetos.
Para separar o código fonte dos arquivos compilados, precisa ser especificado aqui.
Projects:
Aqui projetos existentes podem ser adicionados ao buildpath. O compilador procura por classes definidas
nos projetos especificados.
Libraries:
Referencias para arquivos .jar e .zip dentro do workspace ou em qualquer lugar do seu HardDisk pode ser especificado aqui.
Detalhes:
O Eclipse permite rodar programas em modo debug, ou seja, habilitar ferramentas como breakpoints e variable tracking.
O debugger permite detectar e diagnosticar erros em programas sendo executados localmente ou remotamente. Torna-se fácil controlar a execução dos programas, através da adição de breakpoints, os quais suspendem a inicialização, possibilitando analisar o código por "dentro" e examinar o conteúdo das variáveis.
A utiilzação dessa perspectiva é através de um design cliente/servidor, sendo assim os programas podem rodar remotamente em outros sistemas operacionais na rede, como rodariam localmente na estação de trabalho do desenvolvedor. O servidor para debugger roda na mesmo sistema operacional que o programa a ser analisado, o qual pode estar na maquina do desenvolvedor (local debugging) ou um sistema operacional que esteja acessível através da rede (remote debugging).
BREAKPOINTS
Breakpoints são marcos colocados no programa, que avisam ao debugger onde parar. Quando o workbench esta rodando um programa e encontra um breakpoint, a execução e suspensa. O thread correspondente é suspenso (temporariamente para de rodar) permitindo que seja vista toda a stack para o thread em questão.
A execução é suspensa antes do statement que contém o breakpoint. Os conteúdos das variáveis e a stack podem ser checados nesse momento, além de realizar step over, step into em métodos ou classes, a execução rodará até encontrar o próximos breakpoint ou o fim do programa.
Os brakpoints podem ser desabilitados sem suspender a execução, e habilitados em outro momento.
REMOTE DEBUGGING
Remote debugging permite rodar aplicações em um sistema operacional e realizar o debug em outro sistema operacional. O sistema local roda o debugger, e o sistema remoto roda o debugging engine e o programa.
CONNECTION
O principal requerimento para remote debugging é acessar a maquina remota, na qual os arquivos onde ocorrerá o debug devem residir. Ao realizar o remote debugging em um programa, o debug engine daemon inicia escutando a conexão, após realizada pode ser feito o debug do programa.
Esta view permite o gerenciamento para realizar o debugging de um programa no workbench. Ela mostra uma janela com a stack de cada thread suspenso para cada tarefa que esteja realizando o debugging. Cada thread aparece como um nó da arvore.
| Comandos da Debug View | ||
|---|---|---|
| Botões da Toolbar | Comando | Descrição |
 | Resume | Este comando executa o thread suspenso. |
 | Suspend | Este comando suspende o thread da tarefa, podendo navegar ou modificar o código, inspecionar os dados, etapas e assim por diante. |
 | Terminate | Este comando terminar a tarefa do debug selecionado. |
| Somente no menu | Terminate & Remove | Este comando termina todas as tarefas de debug selecionadas e remove-as da janela. |
| Somente no menu | Terminate All | Este comando termina todas as atividades iniciadas na janela. |
 | Disconnect | Este comando fecha todas as conexões das tarefas de debug |
| selecionadas quando executado remote debugging. | ||
 | Remove All Terminated Launches | Este comando limpa da janela todas as tarefas de debug terminadas. |
 | Step Into | Este comando executa um steps into no statement selecionado. |
 | Step Over | Este comando executa um step over no statement selecionado. A execução continuará até a próxima linha no caso domesmo método, ou voltará para o método de origem, caso o método corrente tenha sido chamado por outro método.O cursor é posicionado no método e seleciona a linha. |
 | Run to Return | Este comando sai do método corrente. Esta opção para a execução após sair do método corrente. |
 | Show/Hide Qualified Names | Esta opção pode ser selecionada para mostrar ou ocultar qualified names. |
| Somente no menu | Relaunch | Este comando reinicia a tarefa de debug selecionada. |
| Somente no menu | Properties | Este comando mostra as propriedades do processo selecionado, também permitindo visualizar as linhas de comando do processo selecionado. |
Além dos plug-ins como o JDT para editar, compilar e debugar aplicações, outros plug-ins estão disponíveis para suportar completamente o processo de desenvolvimento através de modelagem, automação de deployment, teste unitário, teste de performance, controlador de versão e gerencia de configuração.
Dica: Adicionando novas aplicações ao Eclipse
Para instalar novas aplicações, simplesmente copie os plugins para dentro da pasta $ECLIPSE_HOME/plugins. Será preciso
reiniciar o Eclipse para tornar a nova aplicação "ativa". Dependendo do plugin uma nova perspectiva poderá ser escolhida,
sendo encontradas novas opções no menu e toolbar.
Esse plugin auxilia aos programadores Java realizarem build, teste e deploy das aplicações Java nos Servidores de aplicação J2EE.
Ele oferece uma série de funcionalidades, tais como:
Instalação
<Eclipse_Home>
Adicionar ações, wizards e views para o Eclipse.
Esse plugin auxilia aos programadores Java na utilização do framework Struts e seus componentes.
Ele oferece uma série de funcionalidades, tais como:
<Eclipse_Home>
Style
Struts 1.1
Validate struts-config.xml content
XSLT stylesheet
Alterando o layout para geração de arquivos JSP
Adicionar wizards para o Eclipse.
Ele oferece uma série de funcionalidades, tais como:
<Eclipse_Home>
Ele oferece uma série de funcionalidades, tais como:
<Eclipse_Home>
O CVS é um sistema que permite que grupos de pessoas trabalhem simultaneamente em grupos de arquivos como, por exemplo, manuais, apostilas, códigos de programas ou dados dos pacotes RPM. É utilizado um repositório central com as versões mais recentes dos arquivos. Sendo possível, a qualquer momento, criar uma cópia pessoal desses arquivos e, caso no futuro esses arquivos sejam atualizados, o CVS se encarregará de atualizar a sua cópia quando você desejar fazê-lo. Você pode alterar os seus arquivos a vontade. Se novas versões destes arquivos forem colocadas no CVS nesse período de modificação, a atualização tentará o máximo possível combinar as alterações do repositório com as feitas localmente por você.
Caso haja coincidência nas alterações e algum conflito seja criado pelas suas mudanças e as já em efeito no repositório, o CVS lhe avisará e você deverá resolver este problema na sua cópia. Após resolvido o problema você poderá, então, enviar os arquivos para o repositório. Quando você tentar enviar um arquivo para o repositório, o CVS verificará se a versão que você possui é a mais recente. Caso não seja, você receberá uma notificação do CVS, deverá atualizar a sua cópia, resolver quaisquer conflitos que venham a surgir e, só então, enviar os arquivos para o repositório.
Com o CVS cada desenvolvedor trabalha em seu próprio diretório, com suas próprias versões dos arquivos e o sistema se encarrega de juntar as versões espalhadas numa só, contemplando todas as mudanças feitas pelos diversos desenvolvedores.
Alguns conceitos
O Eclipse vem com um plug-in padrão para trabalhar com o CVS, o open source Concurrent Versions System para controle de fonte. O plug-in Team se conecta ao CVS server, permitindo que os membros da equipe de desenvolvimento trabalhem com um conjunto de arquivos fontes sem passar por cima de alterações efetuadas por outros da equipe. A capacidade de dar suporte ao desenvolvimento em equipe, não somente para um desenvolvedor sozinho, é uma ferramenta importantíssima do Eclipse, principalmente quando se trata de integração.
Com esse cliente gráfico para o CVS, o que torna fácil o gerenciamento de projetos no repositório de versões.
Utilizar uma cópia de um projeto já existente no Workbench.
Uso básico do CVS com Eclipse.
O Eclipse contém um cliente gráfico para o CVS, o que torna fácil o gerenciamento de projetos no repositório de versões.
Pré-requisitos: Um servidor CVS instalado e configurado.
Criando um novo repositório
Um novo repositório pode ser criado aqui 'on the fly'.
Caso já exista esse projeto no workspace, será perguntado se deseja sobrescrever os arquivos existentes.
Através do uso do Eclipse com o Junit, torna-se fácil desenvolver códigos de boa qualidade.
O primeiro teste é para uma instancia da classe AmpelModell que deve estar no estado vermelho. O estado dessa instancia é acessado por três métodos getters, getRed(), getYellow() e getGreen() cada um retornando valores do tipo boolean.
Métodos que contenham os testes serão adicionados. JUnit procura automaticamente por métodos que iniciam com 'test':
public class AmpelModellTest extends TestCase {
public void testNewAmpel() {
AmpelModell a = new AmpelModell();
assertTrue(a.getRed());
assertFalse(a.getYellow());
assertFalse(a.getGreen());
}
}
public class AmpelModell {
public boolean getRed() {
return false;
}
public boolean getYellow() {
return false;
}
public boolean getGreen() {
return false;
}
}
A view abaixo mostra o 'Failure Trace'. Pode ser visto a call stack da falha do teste. Um clique duplo localiza o código fonte onde foi ocorrido a falha.
Por favor, dê a sua opinião a respeito do conteúdo apresentado. Correções, sugestões ou qualquer outra informação relevante é de suma importância para nós e será muito bem vinda.
Contato: owner@hotwork.dev.java.net