Implementando um Aplicativo Baseado em Eclipse com Java Web Start

Permitindo uma Fácil Implementação para um Produto Customizado

Saiba como construir um pequeno aplicativo de estrutura baseado na Estrutura do Eclipse e implementá-lo através de Java™ Web Start (JWS) — uma tecnologia que você pode utilizar para implementar aplicativos Java facilmente através de sites padrão da Internet, permitindo fácil upgrade e distribuição.

Nathan A. Good, Senior Information Engineer, Freelance Developer

Nathan A. Good mora na área Twin Cities em Minnesota. Profissionalmente, ele realiza desenvolvimento de software, arquitetura de software e administração de sistemas. Quando ele não está desenvolvendo software, ele gosta de montar PCs e servidores, ler sobre e trabalhar com novas tecnologias e tentar convencer seus amigos de começarem a usar software livre. Ele escreveu e coescreveu muitos livros e artigos, incluindo Professional Red Hat Enterprise Linux 3, Regular Expression Recipes: A Problem-Solution Approach, Regular Expression Recipes for Windows Developers: A Problem-Solution Approach, PHP 5 Recipes: A Problem-Solution Approach e Foundations of PEAR: Rapid PHP Development.



26/Mai/2014

Antes de Iniciar

Sobre Este Tutorial

Quando eu estava começando a construir um aplicativo, determinei que a linguagem de programação Java seria minha linguagem de implementação. Eu queria gravar um aplicativo que pudesse ser executado no Microsoft® Windows®, Linux® ou Mac OS X. O aplicativo teria que utilizar recursos locais, por isso, construí-lo como um aplicativo independente fazia mais sentido do que experimentá-lo em um aplicativo da Web. Entretanto, fique preso na implementação. Eu queria poder implementar facilmente o aplicativo para a instalação inicial e poder enviar atualizações facilmente, sem ter que construir necessariamente uma estrutura de atualização em meu aplicativo. Conheça JWS, uma tecnologia que permite a implementação de aplicativos através da Internet com um único clique.

Se você juntar o JWS com sua capacidade de construir um aplicativo na Plataforma Eclipse, você terá uma combinação poderosa que permite a implementação de algumas ferramentas corporativas sérias de uma maneira muito mais fácil do que construir e enviar programas instaladores.

Este tutorial mostra como construir um aplicativo com base na Plataforma Eclipse e como implementar esse aplicativo com JWS. Isso não deve ser confundido com a construção de um aplicativo Rich Client Platform (RCP) através de Standard Widget Toolkit (SWT) no Eclipse e com o uso do JWS para distribuí-lo (consulte Recursos para acessar o tutorial sobre como fazer isso).

Objetivos

Após ler este tutorial, você deverá estar preparado para desenvolver um produto que estenda a Plataforma Eclipse e para implementar o aplicativo baseado em Eclipse utilizando JWS.

Pré-requisitos

Você deve estar familiarizado com Eclipse e com a linguagem de programação Java. O conhecimento do XML será útil durante a leitura de exemplos de XML.

Requisitos do Sistema

Para executar amostras, você deve ter o Eclipse V3.3 ou posterior instalado e em execução. Você também precisará ter o Java V1.5 ou posterior. Para executar o exemplo de JWS, você precisa ter acesso a um servidor da Web em execução e a capacidade de incluir uma associação do tipo MIME ao servidor da Web, caso isso ainda não tenha sido corretamente configurado. Idealmente, você deve ter um servidor da Web de desenvolvimento local que possa ser utilizado para testes.


Visão Geral da Estrutura do Eclipse

O ambiente de desenvolvimento integrado (IDE) Java do Eclipse é baseado na Plataforma Eclipse. O IDE Java padrão que a maioria das pessoas está acostumada a utilizar é a Plataforma Eclipse padrão com um conjunto de plug-ins básicos que são instalados automaticamente com a distribuição do Eclipse transferível por download. Esses plug-ins compõem aquilo que o usuário experimenta como IDE.

No site do Eclipse, você pode fazer o download apenas do kit de desenvolvimento de software (SDK) da Plataforma Eclipse. Com apenas o SDK da Plataforma Eclipse, você não pode fazer o desenvolvimento Java sem instalar plug-ins adicionais. Se tentar criar um novo projeto utilizando um assistente, você verá que nenhum dos assistentes usuais (como o projeto Java) estará disponível. Devido ao comportamento limitado, o SDK da Plataforma Eclipse não é particularmente útil. Mas como o SDK da Plataforma Eclipse fornece uma estrutura para a construção de aplicativos, ele é muito útil como ponto de partida para a construção de ferramentas mais poderosas.

Quando você constrói recursos sobre a Plataforma Eclipse e possui seu próprio aplicativo, sua implementação em seus usuários é a próxima etapa. O JWS é um mecanismo que você pode utilizar para implementar aplicativos Java. O Eclipse, sendo escrito na linguagem Java, não é uma exceção. O JWS fornece a capacidade de implementar aplicativos de modo relativamente fácil através da Internet quando um usuário clica em um link.

Aplicativos RCP

O Eclipse também fornece a capacidade de construir aplicativos RCP utilizando SWT. Esse processo é diferente da construção de produtos que se tornam aplicativos com base na Plataforma Eclipse. Aplicativos construídos através de SWT podem ser menores e não precisam estender a Plataforma Eclipse. Se você estiver construindo um aplicativo que não estende a Plataforma Eclipse, considere utilizar SWT; você ainda pode distribuir seu aplicativo SWT utilizando JWS.


Visão Geral do Java Web Start

O JWS permite que você implemente aplicativos Java independentes através da Internet com um único clique. Seus usuários clicam em um link para um arquivo XML com uma extensão Java Network Launch Protocol (.jnlp) e o JWS se encarrega do restante. Utilizando o JNLP, o JWS faz o download dos arquivos que precisa, os armazena em cache e ativa o aplicativo.

Como um desenvolvedor, você coloca os arquivos necessários — como Java Archives (JARs) — em um local que possa ser acessado a partir de um servidor da Web. O arquivo JNLP contém informações que dizem ao cliente do JWS nos computadores dos seus usuários onde obter os JARs. Portanto, em vez de implementar seu aplicativo Java independente nos computadores de todos os seus usuários, você só tem que implementar o aplicativo em um servidor da Web. Seus usuários o pegam lá.

Além de implementações, o JWS simplifica muito as atualizações. Sempre que um aplicativo JWS é iniciado, o cliente do JWS nos computadores dos usuários tenta localizar o servidor e se certificar de que o cliente possui os arquivos mais recentes. Se os arquivos locais forem obsoletos, ele fará automaticamente o download dos arquivos atualizados para o cliente. As atualizações são mais ou menos transparentes para o usuário, o que apresenta um ambiente ideal através do qual é possível implementar um aplicativo com base na Plataforma Eclipse.

Segurança

Aplicativos costumam exigir que os usuários tenham permissões elevadas para instalá-los. A necessidade dos usuários de ter permissões de nível superior ao que costumam ter geralmente é uma barreira para fornecer aos usuários a capacidade de instalar aplicativos em seus computadores — principalmente em grandes empresas. Como o JWS armazena em cache os JARs em um diretório fora do sistema, os usuários não precisam ter permissões elevadas para instalar e executar aplicativos JWS localmente. A capacidade de usuários relativamente restritos de tirarem proveito do JWS é outra boa razão a ser considerada para implementação em grandes organizações.

O JWS executa o aplicativo no formato "sandboxed", semelhante a um applet Java. Entradas no arquivo JNLP — que será coberto com mais detalhes mais adiante — fornecem a capacidade de solicitar permissões de acesso ao sistema de arquivos e à rede. Para solicitar todas as permissões, você deve assinar os JARs. O Eclipse cuida disso para você, desde que você tenha um keystore. (Mais informações sobre a configuração do Eclipse para utilizar seu keystore são fornecidas na seção "Empacotando o Aplicativo".)

Executando Off-line

Quando seus usuários tiverem transferido seu aplicativo por download e o tiverem executado uma vez, e quando o JWS tiver os recursos que precisa em seu cache local, seus usuários estarão livres para utilizar o aplicativo sem se conectarem à Internet (desde que seu aplicativo não exija conectividade com a Internet). O JWS simplesmente utiliza os recursos em cache localmente para executar o aplicativo.


Configurando

Instalar JWS

Se tiver uma Plataforma Java, Standard Edition (Java SE) V5 ou posterior, você já terá o JWS instalado. Se tiver o Windows, o JWS está instalado em seu diretório inicial Java (por exemplo, C:\Program Files\Java\jre\bin). No Mac OS X, o JWS reside em Applications/Utilities/Java. Você pode iniciar o console do JWS sem instalar ou executar de fato um aplicativo JWS.

Ao iniciar o console do JWS, você pode visualizar os aplicativos em seu cache do JWS. No console, você pode iniciar quaisquer aplicativos JWS que tenham sido instalados, excluí-los do cache ou instalar atalhos nos aplicativos. Para iniciar o console, digite o seguinte comando, certificando-se de que o Java esteja no caminho:

javaws -viewer

Após ser iniciado, o visualizador fica parecido com a Figura 1. Você pode não ter nenhum aplicativo instalado se nunca tiver utilizado o JWS antes.

Figura 1. O Visualizador do Java Web Start

Se você não tiver um Java Runtime Environment (JRE) instalado, faça o download da versão mais recente e instale-a. Desde que seja Java SE V5 ou posterior, ele vai incluir o JWS.

Configurar Servidor da Web

Na maioria dos casos, o JWS deve ser iniciado automaticamente se você abrir um arquivo JNLP. Se o arquivo JNLP estiver em um servidor da Web que não tem o arquivo JNLP associado corretamente, é possível fazer o download do arquivo e abri-lo localmente. Eu enviei o arquivo JNLP por e-mail antes — ainda tendo os recursos localizados na URL no arquivo — e os destinatários puderam executar o aplicativo com sucesso utilizando o JWS.

Se você estiver configurando um servidor da Web para entregar arquivos JNLP, que é o método de distribuição mais fácil, você vai precisar incluir o seguinte arquivo de associação:

application/x-java-jnlp-file JNLP

Siga a documentação do servidor da Web para configurar a associação MIME corretamente. Se estiver utilizando um ISP, consulte a documentação do ISP para aprender como você pode incluir o tipo JNLP MIME.

Estrutura do Arquivo JNLP

O arquivo JNLP é um arquivo XML que contém instruções sobre como o JWS fará o download e utilizará seu aplicativo. Ele ajuda a entender as diferentes partes do arquivo JNLP, portanto, você pode modificá-lo com segurança.

A Listagem 1 mostra um arquivo JNLP básico. Ele possui apenas os elementos absolutamente necessários para distribuir um aplicativo independente com o JWS.

Listagem 1. Um Arquivo JNLP Básico
<?xml version="1.0" encoding="utf-8"?>
<jnlp spec="1.0+" codebase="http://www.example.com/applications/" href="app.jnlp">
  <information>
    <title>Application Title</title>
    <vendor>Application Vendor</vendor>
    <homepage href="http://www.example.com" />
    <description>This is an application.</description>
  </information>
  <security>
    <all-permissions />
  </security>
  <!-- The name of the main class to execute. -->
  <application-desc main-class="
com.example.MyMainClass">
  </application-desc>
  <resources>
    <jar href="exampleApp.jar" />
  </resources>
</jnlp>

O exemplo na Listagem 1 diria ao JWS para fazer o download do arquivo exampleApp.jar a partir da URL. A URL completa seria http://www.example.com/applications/exampleApp.jar. Quando o JAR for transferido por download, o JWS executará a classe com.example.MyMainClass. Supondo que tudo que a classe precisa executar está incluído no exampleApp.jar, ela executaria conforme os usuários a inicializassem. Esse arquivo seria equivalente à execução do comando:

java -cp exampleApp.jar com.example.MyMainClass

Nesse exemplo, como o elemento <all-permissions> está presente, exampleApp.jar deve ser assinado.

O elemento <jnlp>, que é o elemento-raiz do arquivo, possui os atributos na Tabela 1.

Tabela 1. Atributos do Elemento <jnlp>

AtributoDescrição
specA versão mínima da especificação do JNLP com a qual este arquivo vai trabalhar
codebaseA URL base do seu aplicativo (as outras URLs no arquivo serão relativas a essa base)
hrefA URL do arquivo JNLP em si (arquivos JNLP podem ser utilizados on-line e essa URL diz ao JWS onde obter a versão on-line)
versionA versão do aplicativo e o arquivo JNLP (quando estiver construindo aplicativos JWS, pense neles da mesma forma)

O elemento <information> possui os atributos mostrados na Tabela 2.

Tabela 2. Atributos do Elemento <information>

AtributoDescrição
osO sistema operacional que o aplicativo JWS suporta
archA arquitetura (processador) suportada
platformA plataforma suportada
localeO código do idioma suportado

Outros elementos necessários:

  • O elemento <title> contém o título do aplicativo. Ele é exibido no painel de controle do JWS. Ele também é exibido quando usuários iniciam o aplicativo com JWS.
  • O elemento <vendor> contém o nome do fornecedor de software para o aplicativo.
  • O elemento <resources> contém as informações sobre os recursos que o aplicativo requer. Recursos aqui incluem os JARs que contêm as classes que seu aplicativo utiliza ou propriedades que seu aplicativo pode configurar e utilizar. Recursos típicos podem ser listados em qualquer um dos elementos mostrados na Tabela 3 (consulte Recursos para obter a listagem completa).

Tabela 3. Elementos <resource> Típicos

ElementoDescrição
<jar>Um atributo href que contém o href para um JAR
<nativelib>Um atributo href que contém o href para o JAR da biblioteca nativa
<j2se>A versão e os argumentos fornecidos à máquina virtual (VM)
<property>Especifica as propriedades que podem ser localizadas por System.getProperty

Para obter a sintaxe completa do arquivo JNLP, consulte os links para a documentação da Sun Microsystems em Recursos.


Construindo um Aplicativo Básico Baseado em Eclipse

Neste ponto, você deve ter um entendimento do que o arquivo JNLP faz e o que ele precisa conter para você implementar um aplicativo utilizando o JWS. Você deve ter um servidor da Web a partir do qual possa ativar um arquivo JNLP com a associação correta. Com um entendimento básico de JWS e do arquivo JNLP, você pode começar a construir seu aplicativo baseado em Eclipse.

Instalar o Eclipse

Para começar, você precisa fazer o download do SDK da Plataforma Eclipse (caso ainda não tenha o Eclipse instalado). Se já tiver o Eclipse, você pode utilizar a versão que já instalou. Quando tiver o SDK da Plataforma, você precisará instalar o recurso Eclipse Plug-in Development Environment (consulte a Figura 2 para obter um exemplo do recurso selecionado no instalador). Para saber mais sobre a instalação de plug-ins no Eclipse, consulte Recursos.

Figura 2. Selecionando o Eclipse Plug-in Development Environment

Criar um Novo Produto

Verificando um Exemplo

Para examinar um exemplo do Eclipse, verifique o navegador da Web de exemplo. O código está disponível através de Concurrent Versions System (CVS), portanto, para obtê-lo, você deve ter um cliente CVS em seu computador. É possível verificar o projeto através do seguinte comando: cvs -d :pserver:anonymous@dev.eclipse.org:/cvsroot/eclipse export -r HEAD org.eclipse.ui.examples.rcp.browser. Após ter o projeto localmente, você pode importá-lo na área de trabalho do Eclipse.

Para entender a implementação do JWS em ação, crie um novo produto. Seu produto vai conter um aplicativo que será carregado automaticamente quando o ativador do Eclipse ativar a plataforma Eclipse.

O aplicativo possui uma visualização simples que mostra a você que ele foi carregado corretamente, de forma semelhante ao aplicativo fundamental Hello World. A visualização é aberta em uma nova perspectiva no ambiente de trabalho. Um diagrama de Linguagem de Modelagem Unificada (UML) dessas classes é mostrado na Figura 3.

Figura 3. UML de Classes Básicas para um Produto

Para resumir, mantive as classes o mais simples possível. Elas são suficientes para mostrar que um produto novo customizado está sendo carregado com sua própria visualização customizada. Se construir seu próprio produto, você poderá incluir barras de menus, outras visualizações, telas de ajuda e muito mais. Para incluir esses recursos customizados, consulte a seção Recursos para encontrar mais lugares onde você pode aprender sobre a extensão do Eclipse.

Para construir um exemplo de produto simples, comece construindo um novo projeto de plug-in. Escolha Arquivo > Novo > Projeto. Na janela Selecionar um Assistente, expanda Desenvolvimento de Plug-in e selecione Projeto de Plug-in, conforme mostrado na Figura 4. Clique em Avançar para continuar.

Figura 4. Selecionando o Projeto de Plug-in

Para o Nome do Projeto, digite um nome que seja adequado ao projeto. Gosto de usar o nome pacote base do plug-in como projeto, como com.nathanagood.examples.rcp.simpleApp. Os projetos de plug-in do Eclipse parecem ser nomeados da mesma forma, por isso sigo essa convenção. Após digitar o nome do projeto, deixe os outros valores como o padrão.

Figura 5. Inserindo Informações do Projeto

Na janela Conteúdo do Plug-in (consulte Figura 6), você tem uma chance de ajustar o nome do plug-in, o nome do provedor e a versão. Eu incluo .plugin no final do valor-padrão para o ID do plug-in, mas é uma preferência minha. Não é necessário alterá-los. Se quiser alterar o nome da classe Ativador ou o pacote da classe, faça isso nesta janela. Quando terminar suas mudanças, clique em Avançar.

Figura 6. Inserindo o Conteúdo do Plug-in

A página Modelos (consulte Figura 7) contém uma lista de modelos que servirão de introdução ao plug-in. Como eu queria criar uma visualização de exemplo, depois incluir as extensões do produto e do aplicativo, selecionei Plug-in com uma Visualização para começar. Escolha o modelo que deseja utilizar e clique em Concluir para construir seu projeto.

Figura 7. Escolhendo um Modelo

Conclua o Projeto de Amostra

Neste ponto, você tem um novo projeto de plug-in com a visualização. Para concluir a construção do projeto de exemplo:

  1. Estenda a classe WorkbenchAdvisor (SimpleApplicationAdvisor, neste exemplo).

    Esta classe possui um método que retorna o ID da perspectiva para carregar na inicialização do aplicativo, assim você vê a perspectiva customizada com a visualização customizada imediatamente, sem ver o ambiente de trabalho Bem-vindo.

  2. Crie uma implementação de IPerspectiveFactory (ou seja, SimpleAppPerspectiveFactory).

    O factory cria sua perspectiva inicial modificando o IPageLayout passado para seu método createInitialLayout().

  3. Estenda WorkbenchWindowAdvisor (ou seja, SimpleWindowAdvisor).

    Ao substituir preWindowOpen(), você pode configurar o tamanho inicial e outros atributos do ambiente de trabalho.

  4. Crie uma implementação de IApplication (ou seja, SimpleApplication).

    A classe de implementação cria e executa sua configuração de ambiente de trabalho customizado, carregando sua perspectiva e visualização na inicialização.

Exemplos dessas classes estão disponíveis em download de código fornecido com este tutorial.

Modifique o Arquivo plugin.xml

Após construir as classes, modifique o arquivo plugin.xml para incluir os pontos de extensão que têm referências a todas as classes recém-criadas. A vantagem de gravar todas as classes primeiro, como neste tutorial, é que você pode utilizar o editor gráfico para o arquivo plugin.xml para selecionar os pontos de extensão e classes. Embora você possa editar com facilidade o XML de origem manualmente, o uso da GUI para incluir os pontos de extensão reduz a probabilidade de nomes de classes ou pontos de extensão serem digitados incorretamente. A maioria das resoluções de problemas é resultado de erros de copiar e colar, em que IDs ou nomes de classes são digitados incorretamente.

A Figura 8 mostra os pontos de extensão na guia Extensões do Editor de Manifesto de Plug-in gráfico.

Figura 8. Pontos de Extensão

Um exemplo do arquivo plugin.xml é mostrado na Listagem 2.

Listagem 2. Arquivo plugin.xml de Amostra
<?xml version="1.0" encoding="utf-8"?>
<?eclipse version="3.2"?>
<plugin>
  <extension point="org.eclipse.ui.views">
    <category name="Sample Category"
    id="com.nathanagood.examples.rcp.simpleApp.plugin"></category>
    <view name="Sample View" icon="icons/sample.gif"
    category="com.nathanagood.examples.rcp.simpleApp.plugin"
    class="com.nathanagood.examples.rcp.simpleapp.plugin.views.SampleView"
    id="com.nathanagood.examples.rcp.simpleapp.plugin.views.SampleView">
    </view>
  </extension>
  <extension point="org.eclipse.ui.perspectives">
    <perspective id="com.nathanagood.examples.rcp.simpleApp.plugin.perspective"
    name="Simple App Perspective"
    class="com.nathanagood.examples.rcp.simpleapp.SimpleAppPerspectiveFactory"
    fixed="false" />
  </extension>
  <extension point="org.eclipse.ui.perspectiveExtensions">
    <perspectiveExtension targetID="org.eclipse.jdt.ui.JavaPerspective">

      <view ratio="0.5" relative="org.eclipse.ui.views.TaskList"
      relationship="right"
      id="com.nathanagood.examples.rcp.simpleapp.plugin.views.SampleView">
      </view>
    </perspectiveExtension>
  </extension>
  <extension point="org.eclipse.help.contexts">
    <contexts file="contexts.xml"></contexts>
  </extension>
  <extension point="org.eclipse.core.runtime.products"
  id="product">
    <product name="Simple App"
    application="com.nathanagood.examples.rcp.simpleApp.plugin.app">

      <property name="appName" value="Simple App" />
    </product>
  </extension>
  <extension id="app"
  point="org.eclipse.core.runtime.applications">
    <application>
      <run class="com.nathanagood.examples.rcp.simpleapp.SimpleApplication">
      </run>
    </application>
  </extension>
</plugin>

Inclua o Arquivo de Configuração

Após modificar completamente e salvar o arquivo plugin.xml, é hora de incluir o arquivo de configuração do produto utilizado para informar a Plataforma Eclipse sobre seu produto:

  1. Escolha Arquivo > Novo > Configuração do Produto.

    A janela Configuração do Produto aparece.

    Figura 9. Configuração do Produto
  2. Escolha seu projeto de plug-in como a pasta-pai.
  3. Inclua o nome do arquivo (por exemplo, SimpleApplication.product).
  4. Selecione Utilizar um Produto Existente, em seguida, na lista, selecione o ID do produto.

    O ID do produto é o que você definiu no arquivo plugin.xml no ponto de extensão org.eclipse.core.runtime.products.

Após você ter incluído o arquivo de configuração do produto, é possível utilizar o Editor de Configuração do Produto gráfico para editar os detalhes sobre o produto. Na guia Visão Geral, clique em Sincronizar para se certificar de que a configuração esteja atualizada. Agora você pode clicar em Ativar um Aplicativo do Eclipse (consulte Figura 10) para testar o produto. Se você precisar depurá-lo, clique em Ativar um aplicativo do Eclipse no modo Depuração.

Figura 10. Ativando o Aplicativo do Eclipse

Execute Seu Produto

Antes de continuar, certifique-se de poder executar seu produto com sucesso. A garantia de que ele será executado com sucesso elimina futuros problemas e frustrações. O download de código, quando iniciado, é semelhante à Figura 11.

Figura 11. O Aplicativo de Amostra Simples

Empacotando o Aplicativo

Neste ponto, você deve ter um entendimento básico de JWS e da estrutura do arquivo JNLP. É preciso ter um servidor da Web no qual você possa publicar os arquivos e o arquivo JNLP do seu produto, além de ter um produto funcional que possa ser ativado a partir do IDE do Eclipse. Com tudo isso feito, você estará pronto para construir um recurso wrapper que será utilizado para publicar seu produto.

Crie o Recurso Wrapper

O recurso wrapper é simplesmente um projeto de recurso que contém dois arquivos, sendo que cada um contém referências ao plug-in do produto e a quaisquer plug-ins e recursos necessários para a execução do plug-in do produto. Para incluir o novo projeto de recurso wrapper, escolha Arquivo > Novo > Projeto. Em seguida, na janela Selecionar um Assistente, expanda Desenvolvimento de Plug-in e selecione Projeto de Recurso, conforme mostrado na Figura 12.

Figura 12. Criando um Novo Projeto de Recurso

Na janela Propriedades do Recurso, digite o nome do projeto, o ID do recurso, o nome, a versão e as informações do provedor, conforme mostrado na Figura 13, e clique em Avançar.

Figura 13. Editando as Propriedades do Recurso

Na janela Plug-ins e Fragmentos de Referência, mostrada na Figura 14, selecione Inicializar a partir da configuração de ativação, depois escolha o nome do arquivo de configuração do produto (por exemplo, SimpleApp.product) da lista. Clique em Concluir quando terminar.

Figura 14. Selecionando a Configuração do Produto

Para implementar os plug-ins e recursos através do JWS, você deve assinar os JARs. A assinatura de JARs requer um keystore, que você pode gerar utilizando o keytool Java fornecido com o kit de desenvolvimento de software Java (JDK). Para obter mais informações sobre a criação de um keystore, consulte Recursos.

O novo projeto de recurso terá dois arquivos: build.properties e feature.xml. O arquivo feature.xml possui um editor gráfico como a configuração do produto gráfico e editores de plug-in. Abra o editor gráfico para o arquivo feature.xml.

Na guia Plug-ins, certifique-se de que seu plug-in de produto esteja listado. Além disso, verifique se o plug-in org.eclipse.equinox.launcher está listado. Na guia Recursos, inclua quaisquer recursos adicionais exigidos por seu plug-in ou recurso. Se estiver com pressa para ver seu produto com o JWS, você pode selecionar todos eles; isso não vai danificar nada, a não ser o tamanho do diretório do seu aplicativo. Entretanto, para um produto real, você deve localizar as dependências para deixar o tamanho do download o menor possível.

Exporte o Recurso Wrapper

Quando tiver selecionado os plug-ins e recursos, você poderá exportar o projeto de wrapper do recurso para um diretório. Para exportar o projeto, escolha Arquivo > Exportar. Na janela Selecionar, expanda Desenvolvimento de Plug-in e clique em Recursos Implementáveis, conforme mostrado na Figura 15. Clique em Avançar.

Figura 15. Criando um Recurso Implementável

Agora:

  1. Na janela Recursos Implementáveis, mostrada na Figura 16, selecione seu recurso.
    Figura 16. Selecionando o Recurso para Implementar
  2. Na guia Destino, clique em Diretório e digite o nome do diretório onde você vai publicar os arquivos. Esse diretório deve estar sob uma pasta da Web para que fique acessível com a URL que você forneceu na guia Java Web Start.
  3. Na guia Opções, selecione Empacotar como Arquivos JAR Individuais.
  4. Na guia Assinatura JAR, selecione Assinar os arquivos JAR utilizando um keystore. Em seguida, navegue para o local do keystore e digite o alias e a senha.

    Nota: Se você não tiver um keystore, consulte Recursos para conhecer os links sobre como criá-lo.

  5. Na guia Java Web Start, selecione Criar manifestos JNLP para arquivos JAR.
  6. Atualize a URL do Site para a URL base do diretório do JWS. O acesso dessa URL a partir de um navegador deve acessar o diretório que você inseriu na guia Destino.
    Figura 17. Configurando Propriedades do JWS

Clique em Concluir quando terminar de atualizar as informações sobre a implementação do recurso. O Eclipse exporta as informações no diretório fornecido. Dependendo do número de plug-ins e recursos selecionados e dos recursos do hardware, a exportação do recurso pode levar algum tempo. Quando o Eclipse for concluído, você terá dois diretórios novos dentro do diretório fornecido: features e plugins. O arquivo JNLP do recurso estará no diretório features. Para obter uma listagem de exemplo do conteúdo do diretório features, consulte a Listagem 3.

Listagem 3. Conteúdo do Diretório features
$ ls
com.nathanagood.examples.simpleApp.feature_1.0.0.jar
com.nathanagood.examples.simpleApp.feature_1.0.0.jnlp
org.eclipse.equinox.p2.user.ui.source_1.0.1.r34x_v20080721-7d-7OEMsLAz-vTBJ.jar
org.eclipse.equinox.p2.user.ui.source_1.0.1.r34x_v20080721-7d-7OEMsLAz-vTBJ.jnlp
org.eclipse.equinox.p2.user.ui_1.0.1.r34x_v20080721-7d-7OEMsLAz-vTBJ-ZHQaF155CE.jar
org.eclipse.equinox.p2.user.ui_1.0.1.r34x_v20080721-7d-7OEMsLAz-vTBJ-ZHQaF155CE.jnlp
org.eclipse.help.source_1.0.1.R34x_v20080827-7r7xEIxEI6Zu5nEqN7M3UBpglaat.jar
org.eclipse.help.source_1.0.1.R34x_v20080827-7r7xEIxEI6Zu5nEqN7M3UBpglaat.jnlp
org.eclipse.help_1.0.1.R34x_v20080827-7r7xEIxEI6Zu5nEqN7M3UBpglaat.jar
org.eclipse.help_1.0.1.R34x_v20080827-7r7xEIxEI6Zu5nEqN7M3UBpglaat.jnlp
org.eclipse.platform.source_3.4.1.r341_v20080731-9I96EiDElYevwz.jar
org.eclipse.platform.source_3.4.1.r341_v20080731-9I96EiDElYevwz.jnlp
org.eclipse.platform_3.4.1.r341_v20080731-9I96EiDElYevwz-p1bP5z-NlAaP7vtX6Utotqsu.jar
org.eclipse.platform_3.4.1.r341_v20080731-9I96EiDElYevwz-p1bP5z-NlAaP7vtX6Utotqsu.jnlp
org.eclipse.rcp.source_3.4.100.r341_v20080814-989JESIEdAciFYfkZZsBfSwQ2341.jar
org.eclipse.rcp.source_3.4.100.r341_v20080814-989JESIEdAciFYfkZZsBfSwQ2341.jnlp
org.eclipse.rcp_3.4.100.r341_v20080814-989JESIEdAciFYfkZZsBfSwQ2341.jar
org.eclipse.rcp_3.4.100.r341_v20080814-989JESIEdAciFYfkZZsBfSwQ2341.jnlp

Com o recurso wrapper exportado com sucesso para um diretório acessível a partir de um servidor da Web, é hora de construir o arquivo JNLP principal do aplicativo.


O Arquivo JNLP

Nesta seção, você vai construir e publicar seu arquivo JNLP, testar sua implementação e executar quaisquer resoluções de problemas necessárias.

Construa o Arquivo JNLP

Neste ponto, você deve ter exportado com sucesso o recurso para um diretório e ter verificado se os diretórios features e plugins existem em um local acessível a partir de um servidor da Web. Agora é hora de gravar o arquivo JNLP em seu aplicativo. Um arquivo JNLP de exemplo é fornecido por completo.

Listagem 4. Arquivo JNLP de Exemplo para o Aplicativo Simples
<?xml version="1.0" encoding="utf-8"?>
<jnlp spec="1.0+"
    codebase="http://localhost/~user/jws2" href="simpleapp.jnlp">
  <information>
    <title>SimpleApp Test</title>
    <vendor>Nathan Good</vendor>
    <homepage href="http://www.nathanagood.com" />
    <description>This is my simple JWS Eclipse
     application test.</description>
  </information>
  <!--request all permissions from the application. This does not change-->
  <security>
    <all-permissions />
  </security>
  <!-- The name of the main class to execute. This does not change-->
  <application-desc main-class="org.eclipse.equinox.launcher.WebStartMain">
  </application-desc>
  <resources>
    <jar href="plugins/org.eclipse.equinox.launcher_1.0.101.R34x_v20080819.jar"/>
    <extension name="Simple App Feature"
     href="features/com.nathanagood.examples.simpleApp.feature_1.0.0.jnlp" />
    <property name="eclipse.product"
     value="com.nathanagood.examples.rcp.simpleApp.plugin.product" />
  </resources>
  <resources os="Mac">
    <j2se version="1.5+" java-vm-args="-XstartOnFirstThread" />
  </resources>
  <resources os="Windows">
    <j2se version="1.4+" />
  </resources>
  <resources os="Linux">
    <j2se version="1.4+" />
  </resources>
</jnlp>

Nesse arquivo JNLP, o valor do atributo codebase é configurado como a URL base do local onde você publicou o recurso wrapper. Ele deve corresponder à URL utilizada na guia Java Web Start na janela Recursos Implementáveis na Figura 17. O atributo href é o nome do arquivo JNLP.

Utilizando localhost

Talvez você tenha observado que, em meus exemplos, estou utilizando localhost como URL. Isso porque testei esse aplicativo utilizando um servidor da Web local e não implementei de fato meu arquivo para ninguém. O uso do localhost não funcionará se você pretende implementar este aplicativo (embora ele seja perfeito para testar). Certifique-se de utilizar um nome do host que possa ser resolvido externamente (por exemplo, myhost.example.com) ou um endereço IP.

O elemento <information> inclui o título, a descrição e outras informações sobre o aplicativo sendo distribuído. Os elementos <security> e <application-desc> precisam ser conforme mostrado na Listagem 4.

Modifique o elemento <resources> para incluir a versão correta do plug-in ativador Equinox para o elemento <jar>. Talvez você precise examinar o diretório features para localizar o nome completo correto do JAR do ativador. É provável que, em breve, o nome na Listagem 4 estará obsoleto, conforme novas versões do arquivo se tornam disponíveis.

Atualize o atributo href do elemento <extension> para incluir a URL (relativa à URL no atributo codebase) do arquivo JNLP do recurso wrapper. O arquivo JNLP do recurso wrapper incluirá todos os outros recursos e plug-ins necessários.

Finalmente, atualize o elemento <property> para incluir o ID do produto. Esse ID será o ID do arquivo de configuração do produto do plug-in (ou seja, SimpleApp.product).

Publique o Arquivo JNLP

Por enquanto, você construiu o arquivo JNLP. Você tem os diretórios features e plugins a partir da exportação do recurso implementável. O recurso inclui seu plug-in, bem como todas as dependências. Você está pronto para publicar o arquivo JNLP.

O arquivo JNLP vai para o mesmo diretório que os diretórios features e plugins. Ele deve ser o mesmo diretório que você utilizou ao exportar o recurso implementável. A Listagem 5 mostra uma listagem de diretórios de exemplo.

Listagem 5. Listagem de Diretórios com Arquivo JNLP
drwxr-xr-x   20 user  user   680 Dec 19 09:46 features
drwxr-xr-x  280 user  user  9520 Dec 19 09:46 plugins
-rw-r--r--    1 user  user  1222 Dec 19 10:05 simpleapp.jnlp

Para facilitar o teste do arquivo, crie uma página HTML simples e chame-a de index.html. Ela deve incluir o código mostrado na Listagem 6, em que simpleapp.jnlp é atualizado para o nome do seu arquivo JNLP.

Listagem 6. Exemplo de Arquivo HTML
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<title>My Application</title>
</head>
<body>
<a href="simpleapp.jnlp">My Application</a>
</body>
</html>

Salve o arquivo HTML na pasta que estará acessível a partir da URL do código base no arquivo JNLP principal do aplicativo. Após salvar o arquivo HTML no diretório, a listagem de diretórios deverá ser semelhante à Listagem 7.

Listagem 7. Listagem de Diretórios com Todos os Arquivos
drwxr-xr-x   20 user  user   680 Dec 19 09:46 features
-rw-r--r--    1 user  user   288 Dec 19 08:37 index.html
drwxr-xr-x  280 user  user  9520 Dec 19 09:46 plugins
-rw-r--r--    1 user  user  1222 Dec 19 10:05 simpleapp.jnlp

Testando a Implementação

Neste ponto, você:

  • Entende a estrutura básica do arquivo JNLP.
  • Configurou seu servidor da Web com o tipo MIME apropriado.
  • Tem um produto Eclipse básico construído em um projeto de plug-in.
  • Tem um projeto de recurso wrapper que inclui o plug-in.
  • Exportou o recurso wrapper para um diretório.
  • Criou e salvou um arquivo JNLP para seu aplicativo.

Agora é hora de testar a implementação. Abra um navegador da Web e navegue para a URL que você forneceu para a URL de código base (por exemplo, http://localhost/~user/jws/). O arquivo index.html que você criou na seção "Publicar o Arquivo JNLP" deve aparecer. Clique no link. Desde que tudo esteja configurado corretamente, uma tela de abertura para o JWS deve aparecer (consulte Figura 18). Em seguida, o progresso do download do aplicativo aparece. Dependendo do tamanho final dos seus recursos e plug-ins, bem como da conexão da rede, esse processo pode levar algum tempo.

Figura 18. A Tela de Abertura do JWS

Quando todas as dependências tiverem sido transferidas por download, o aplicativo será aberto. Minha visualização simples será semelhante à Figura 19.

Figura 19. O Aplicativo Simples Iniciado a partir do JWS

Resolução de Problemas

Encontrei alguns problemas enquanto construía meu primeiro exemplo de um produto Eclipse sendo implementado através do JWS:

  • O arquivo JNLP é exibido no navegador como texto. Se isso acontecer, a causa mais provável é a ausência de uma associação do tipo MIME para o tipo JNLP na configuração do seu servidor da Web. Certifique-se de que o tipo MIME correto esteja associado (consulte a seção "Configurar Seu Servidor da Web").
  • Não é possível ativar o aplicativo. Se você obtiver esse erro do JWS, clique em Detalhes para obter mais informações sobre o erro. Se o erro for um java.io.FileNotFoundException, pode haver uma URL incorreta. Recebi esse erro quando renomeei meu arquivo JNLP inicial, mas esqueci de atualizar o valor no atributo href do elemento <jnlp>.
  • Não é possível carregar um recurso. Semelhante ao erro anterior, essa mensagem fica visível após você clicar em Detalhes. Recebi esse erro quando tentei testar o aplicativo em um computador diferente. Em minhas URLs para esse exemplo, utilizei localhost como nome do host. Para resolver esse problema altere a URL para o endereço IP ou nome do host do servidor no qual você está publicando o arquivo JNLP.
  • O JWS parece estar iniciado, mas nada fica visível e o JWS é fechado. A causa mais provável desse problema é um ID do produto incorreto na propriedade eclipse.product no elemento <resources>. Dê um clique duplo no valor do ID do produto e certifique-se de que ele corresponda ao ID no arquivo de configuração do produto (SimpleApp.product).

Resumo

Este tutorial demonstra como construir um produto simples — um aplicativo baseado na Plataforma Eclipse — e implementá-lo para seus usuários através do JWS. Seguindo as etapas aqui e incluindo suas extensões, você pode construir um aplicativo sofisticado que pode ser implementado em várias plataformas a partir de um local central. As atualizações são tão fáceis quanto implementá-las no diretório a partir do qual os recursos do JWS são implementados.

Para construir um produto com sucesso, você precisa entender um pouco sobre como o arquivo JNLP é estruturado. Você precisa construir um plug-in com as implementações de pelo menos algumas classes. É necessário fornecer pontos de extensão no plug-in. E, finalmente, você precisa incluir uma configuração de produto no projeto do plug-in.

Quando seu projeto de plug-in estiver concluído, você vai precisar construir um recurso wrapper que inclua seu plug-in e todos os outros recursos e plug-ins necessários para a execução do plug-in. Quando concluir o recurso wrapper, você poderá utilizar um assistente do Eclipse para implementar os arquivos necessários em uma estrutura de diretório.

Um arquivo JNLP simples contém referências ao arquivo JNLP do recurso wrapper que você criou. Ele também contém todos os parâmetros adicionais que você precisa para que o Eclipse execute seu produto, como o ID do produto de inicialização.


Download

DescriçãoNomeTamanhoMétodo de download
Source codeos-eclipse-jws-code.zip25KBHTTP

Informações sobre métodos de download

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=Linux
ArticleID=387176
ArticleTitle=Implementando um Aplicativo Baseado em Eclipse com Java Web Start
publish-date=05262014