-
Recent Posts
Archives
Categories
Meta
Simulado para uma possível certificação do Eclipse PDE/RCP
Fui convidado pela empresa ANCIT CONSULTING
para fazer um simulado para uma possível certificação sobre o Eclipse PDE/RCP, segue abaixo o teste realizado:
Simulate of Cerificate the Eclipse PDE/RCP
A Eclipse Foundation
O Eclipse é uma comunidade de código-fonte aberto cujos projetos se concentram em fornecer uma plataforma de desenvolvimento e frameworks de aplicativo baseados em código-fonte aberto e neutros em relação a fornecedores para a criação de software. é uma corporação sem fins lucrativos formada para avançar no processo de criação, evolução, promoção e suporte da Eclipse Platform e incentivar tanto uma comunidade de código-fonte aberto como um ecossistema de produtos, capacidades e serviços complementares.
Os líderes do setor Borland, IBM, MERANT, QNX Software Systems, Rational Software, Red Hat, SuSE, TogetherSoft e Webgain formaram, em novembro de 2001, o eclipse.org Board of Stewards. No final de 2003, o número de membros desse consórcio inicial havia aumentado para mais de 80.
O Eclipse foi originalmente desenvolvido pela Object Technology International (OTI), que mais tarde foi comprada pela IBM.
A IBM subsequentemente doou a tecnologia Eclipse (segundo informes, valendo US$ 40 milhões) para organizações de código-fonte aberto e recrutou as várias corporações mencionadas anteriormente para, conjuntamente, desenvolverem produtos altamente integrados para essa plataforma (na forma de plug-ins).
A Eclipse Foundation é semelhante à Apache Foundation pelo fato de fornecer ferramentas de código-fonte aberto. Mas uma das diferenças subjacentes é que as ferramentas Eclipse tendem a ser uma natureza mais gráfica que as ferramentas Apache, que tendem a ser mais baseadas em texto, como servidores, APIs e ferramentas (Ant e Tomcat, por exemplo). Penso que isso é uma mudança revigorante. Acho que finalmente os fornecedores de ferramentas Java começam a entender isso.
A batalha das ferramentas de desenvolvimento gráfica só agora começou. Por que demorou tanto tempo está além da minha compreensão, considerando o fato de que ferramentas robustas de desenvolvimento/depuração com interface gráfica para outras linguagens de programação já estão disponíveis há algumas décadas.
Eclipse: Uma caixa de ferramentas consolidada
A plataforma Eclipse, combinada com o grande número de plug-ins disponíveis altamente integrados, serve essencialmente como um ambiente de desenvolvimento de software consolidado. Por exemplo, há plug-ins disponíveis para diagramação de UML, codificação, depuração, gerenciamento de banco de dados, teste de unidade, gerenciamento de servidor de aplicativos, documentação e muito mais. Você poderia pensar no Eclipse como uma caixa de ferramentas, análoga à caixa de ferramentas de um carpinteiro, que contém vários tipos de ferramentas para fazer seu tipo de trabalho.
Como colocar uma descrição na ViewPart
public SampleView extends ViewPart {
public void createPartControl(Composite aParent) {
setContentDescription("Esta e a minha view...");
....
}
}
Segue um gerador aritimético a partir do console do OSGi
Neste exemplo, vamos tentar fazer algo diferente pela construção de um gerador qualquer dentro do OSGi console. A idéia é escrever um simples console de comando com argumentos.
Neste exemplo, você vai aprender a ampliar o OSGi console, com comandos do usuário personalizado, bem como criar uma classe usando o gerador.
Estendendo o OSGi Console
Para começar, crie um novo plug-in do projeto usando o Plug-in Project Wizard. Nomeie o novo projeto como gererator.calculator. Desmarque a opção “Este plug-in fará com que as contribuições para a interface do usuário” opção e defina “Gostaria de criar um aplicativo cliente rico?” para o número (Este plug-in será executado no âmbito OSGi (equinox); assim, não será um RCP).
O novo plug-in deve ser modificado para estender a OSGi console. Isso permitirá que o usuário digite comandos personalizados quando rodando em modo console. Quando um objeto deseja oferecer uma série de comandos para o console, ele deve implementar a interface org.eclipse.osgi.framework.console.CommandProvider, e define os comandos como métodos começando com um caractere _ e tendo um CommandInterpreter como argumento. Durante a execução, o console irá encontrar todos os comandos público. Por exemplo, o seguinte trecho de código abaixo:
public Object _hello( final CommandInterpreter intp ) {
return "hello " + intp.nextArgument();
}
Observação: Ao implementar a interface CommandInterpreter, o método do plug-in deve sobrecarregar public String getHelp() para retornar o texto de ajuda que explica o comando.
O objetivo é adicionar um comando de calculadora para gerar algum resultado. Abra a classe Activator (Activator.java) do plug-in e insere um comando para calcular, como mostrado na Listagem 1-1.
Listagem 1-1 Activator Plug-in com um comando calculator
package generator.calculator.internal;
import java.util.Hashtable;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.osgi.framework.console.CommandInterpreter;
import org.eclipse.osgi.framework.console.CommandProvider;
import org.osgi.framework.BundleContext;
import generator.calculator.generator.CalculatorGenerator;
/**
* The activator class controls the plug-in life cycle
*/
public class Activator extends Plugin implements CommandProvider {
// The plug-in ID
public static final String PLUGIN_ID = "generator.calculator";
// The shared instance
private static Activator plugin;
/**
* The constructor
*/
public Activator() {
}
/*
* (non-Javadoc)
* @see org.eclipse.core.runtime.Plugin#start(org.osgi.framework.BundleContext)
*/
@SuppressWarnings("unchecked")
public void start( final BundleContext context ) throws Exception {
super.start( context );
plugin = this;
final Hashtable properties = new Hashtable();
context.registerService( CommandProvider.class.getName(), this, properties );
System.out.println( "CALCULATOR GENERATOR STARTED" );
}
/*
* (non-Javadoc)
* @see org.eclipse.core.runtime.Plugin#stop(org.osgi.framework.BundleContext)
*/
public void stop( final BundleContext context ) throws Exception {
plugin = null;
super.stop( context );
}
/**
* Returns the shared instance
*
* @return the shared instance
*/
public static Activator getDefault() {
return plugin;
}
@Override
public String getHelp() {
return "---CALCULATOR Console Commands---"
+ "\n\tcalculator <param1> <operation_type> <param2>"
+ "\n\t\tuser params: 1 + 1...";
}
/**
* Calculator command
*
* @param ci CommandInterpreter
* @throws Exception
*/
public void _calculator( final CommandInterpreter ci ) throws Exception {
// Argumentos:
final String param1 = ci.nextArgument();
final String operator = ci.nextArgument();
final String param2 = ci.nextArgument();
if (param1 == null) {
ci.println( "Argumentos invalidos.\n" + getHelp() );
return;
}
try {
CalculatorGenerator generator = new CalculatorGenerator();
generator.run( param1, operator, param2 );
} catch (final Exception e) {
e.printStackTrace();
}
}
}
Listagem 1-1 mostra um plug-in activator que define o comando _calculator, que apresentará um relatório a partir da linha de comando. Essa classe também registra o serviço CommandProvider (dentro do método start()), com as propriedades especificas, com o framework:
context.registerService(CommandProvider.class.getName(), this, properties)
Gerando o calculador
package generator.calculator;
import java.util.HashMap;
public class CalculatorGenerator {
public CalculatorGenerator() {
}
/**
* Run
* @param param1
* @param operation
* @param param2
* @throws Exception
*/
@SuppressWarnings("unchecked")
public void run( String param1, String operation, String param2 ) throws Exception {
Executa as operações aritiméticas...
...
...
}
}
O arquivo do manifest segue abaixo:
Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Calculator Plug-in
Bundle-SymbolicName: generator.calculator
Bundle-Version: 1.0.0
Bundle-Activator: generator.calculator.internal.Activator
Require-Bundle: org.eclipse.core.runtime
Bundle-ActivationPolicy: lazy
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Com este exemplo você poderá criar diversos comandos, ou até algum outro gerador, por exemplo: gerador de relatório, gráfico etc.
