| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| |
| = Usando o CDI para Injetar Pacotes OSGi como Serviços no NetBeans IDE |
| :jbake-type: tutorial |
| :jbake-tags: tutorials |
| :jbake-status: published |
| :icons: font |
| :syntax: true |
| :source-highlighter: pygments |
| :toc: left |
| :toc-title: |
| :description: Usando o CDI para Injetar Pacotes OSGi como Serviços no NetBeans IDE - Apache NetBeans |
| :keywords: Apache NetBeans, Tutorials, Usando o CDI para Injetar Pacotes OSGi como Serviços no NetBeans IDE |
| |
| Este documento demonstra como o suporte integrado para o framework link:http://www.osgi.org/Main/HomePage[+Open Services Gateway Initiative+] (OSGi) no NetBeans IDE simplifica o processo de criação de pacotes OSGi e o uso dos pacotes em seus projetos. Neste tutorial, você criará dois pacotes OSGi simples a partir do arquétipo de pacote Maven OSGi e, em seguida, implantará os pacotes no GlassFish Server Open Source Edition 3.1. |
| |
| Depois de criar os pacotes OSGi básicos, você criará uma aplicação cliente Web e usará o CDI para injetar os pacotes como um serviço. A seguir, você implantará a aplicação Web como um pacote no servidor. O tutorial, em seguida, demonstrará como usar a Console de Admin OSGi para trabalhar com pacotes OSGi. |
| |
| Utilizar um pacote OSGi em uma Aplicação Corporativa pode fornecer maior modularidade e flexibilidade em relação à atualização de pacotes individuais. O suporte predefinido para OSGi que acompanha o GlassFish Server torna a incorporação de pacotes na sua aplicação muito fácil. |
| |
| Este tutorial tem base na publicação do blog link:http://blogs.oracle.com/arungupta/entry/totd_154_dynamic_osgi_services[+ TOTD #154: Dynamic OSGi services in GlassFish 3.1 - Using CDI and @OSGiService +] e outras entradas do blog que podem ser encontradas no link:http://blog.arungupta.me/[+blog de Arun Gupta+]. Certifique-se de visitar o blog e ver muitas outras entradas excelentes relacionadas ao trabalho com o OSGi. |
| |
| Além disso, os recursos a seguir contêm uma variedade de informações sobre o uso do OSGi e CDI em aplicações híbridas. |
| |
| * link:http://weblogs.java.net/blog/2009/06/14/developing-hybrid-osgi-java-ee-applications-glassfish[+ Desenvolvendo aplicações Híbridas (OSGi + Java EE) no GlassFish+] |
| * link:http://blogs.oracle.com/sivakumart/entry/typesafe_injection_of_dynamic_osgi[+ Injeção segura de serviços OSGi dinâmicos em aplicações Java EE híbridas+] |
| * link:http://weblogs.java.net/blog/2009/06/04/osgi-enabled-web-applications-inglassfish[+ Aplicações Web compatíveis com OSGi no GlassFish+] |
| * link:http://www.youtube.com/watch?v=vaOpJJ-Xm70[+ Vídeo do YouTube: injeção segura de serviços OSGI dinâmicos com o GlassFish 3.1 e CDI +] |
| * link:http://glassfish.java.net/public/GF-OSGi-Features.pdf[+ Desenvolvimento de Aplicações OSGi usando o GlassFish Server"+] [PDF] |
| |
| *Exercícios do Tutorial* |
| |
| * <<Exercise_1,Criando o Projeto POM pai>> |
| * <<Exercise_2,Criando os Projetos de Pacotes OSGi>> |
| * <<Exercise_2a,Criando o Pacote da Interface MavenHelloServiceApi>> |
| * <<Exercise_2b,Criando o Pacote de Implementação MavenHelloServiceImpl>> |
| * <<Exercise_2c,Construindo e Implantando os Pacotes OSGi>> |
| * <<Exercise_3,Criando a Aplicação Cliente Web>> |
| * <<Exercise_3a,Configurando as Dependências no Projeto POM>> |
| * <<Exercise_3b,Criando a Aplicação Web MavenHelloWebClient>> |
| * <<Exercise_3c,Construindo a Aplicação Web como um Pacote>> |
| * <<Exercise_3d,Implantando o Pacote de Aplicações Web>> |
| * <<Exercise_4,Instalando e Usando a Console de Admin OSGi>> |
| * <<Exercise_5,Referências e Leitura Adicional>> |
| |
| *Para seguir este tutorial, são necessários os recursos e o software a seguir.* |
| |
| |=== |
| |Software ou Recurso |Versão Necessária |
| |
| |link:http://download.netbeans.org/netbeans/7.1/beta/[+NetBeans IDE+] |Versão Java EE 7.2, 7.3, 7.4, 8.0 |
| |
| |link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+JDK (Java Development Kit)+] |versão 7 ou 8 |
| |
| |GlassFish Server Open Source Edition |3.1.x ou 4.x |
| |=== |
| |
| *Pré-requisitos* |
| |
| Este tutorial pressupõe que você tenha algum conhecimento básico das tecnologias a seguir, ou alguma experiência de programação com elas: |
| |
| * Programação em Java |
| * NetBeans IDE |
| * Framework Maven |
| |
| Antes de começar este tutorial, talvez você queira se familiarizar com a documentação a seguir. |
| |
| * link:http://wiki.netbeans.org/MavenBestPractices[+Melhores Práticas para o Apache Maven no NetBeans IDE+] |
| * link:http://books.sonatype.com/mvnref-book/reference/introduction.html[+Capítulo 1. Introdução ao Apache Maven+] (do link:http://books.sonatype.com/mvnref-book/reference/index.html[+Maven: A Referência Completa +]) |
| * link:http://www.osgi.org/javadoc/r4v42/[+Framework OSGi +] |
| |
| |
| |
| |
| == Criando o Projeto POM Pai |
| |
| Nesta seção você criará o projeto POM pai para os pacotes OSGi que serão criados neste tutorial. Você editará o projeto POM ( ``pom.xml`` ) para adicionar elementos de Gerenciamento de Dependências que serão herdados como dependências por projetos filho. |
| |
| 1. Selecione Novo Projeto (Ctrl-Shift-N; ⌘-Shift-N no Mac) no menu principal. |
| 2. Selecione o Projeto POM na categoria Maven. |
| |
| image::images/cdi-newpomproject.png[title="Arquétipo do Projeto POM Maven no Assistente de Novo Projeto"] |
| |
| |
| [start=3] |
| . Digite *MavenOSGiCDIProject* como nome do Projeto. Clique em Finalizar. |
| |
| Quando você clica em Finalizar, o IDE cria o projeto POM e abre o projeto na janela Projetos. |
| |
| |
| [start=4] |
| . Expanda o nó dos Arquivos do Projeto na janela Projetos e clique duas vezes em ``pom.xml`` para abrir o arquivo no editor. |
| |
| O POM básico do projeto deverá ser similar ao seguinte. |
| |
| |
| [source,xml] |
| ---- |
| |
| <?xml version="1.0" encoding="UTF-8"?> |
| <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> |
| <modelVersion>4.0.0</modelVersion> |
| <groupId>com.mycompany</groupId> |
| <artifactId>MavenOSGiCDIProject</artifactId> |
| <version>1.0-SNAPSHOT</version> |
| <packaging>pom</packaging> |
| <properties> |
| <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> |
| </properties> |
| </project> |
| |
| ---- |
| |
| [start=5] |
| . Modifique o ``pom.xml`` pai para adicionar os elementos a seguir. Salve as alterações. |
| |
| [source,xml] |
| ---- |
| |
| <?xml version="1.0" encoding="UTF-8"?> |
| <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> |
| <modelVersion>4.0.0</modelVersion> |
| <groupId>com.mycompany</groupId> |
| <artifactId>MavenOSGiCDIProject</artifactId> |
| <version>1.0-SNAPSHOT</version> |
| <packaging>pom</packaging> |
| <properties> |
| <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> |
| </properties> |
| |
| *<dependencyManagement> |
| <dependencies> |
| <dependency> |
| <groupId>org.osgi</groupId> |
| <artifactId>org.osgi.core</artifactId> |
| <version>4.2.0</version> |
| <scope>provided</scope> |
| </dependency> |
| </dependencies> |
| </dependencyManagement>* |
| </project> |
| |
| ---- |
| |
| Neste exercício, você especificou explicitamente um artefato e a versão do artefato que serão usados no projeto. Ao usar o Gerenciamento de Dependências e especificar os artefatos no POM pai, é possível tornar os POMs nos projetos filho mais simples e garantir que as versões das dependências estejam consistentes no projeto. |
| |
| Para saber mais sobre o uso do Gerenciamento de Dependências, consulte link:http://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html[+Introdução ao Mecanismo de Dependências+]. |
| |
| |
| == Criando os Projetos de Pacotes OSGi |
| |
| A categoria Maven no assistente Novos Projetos inclui um arquétipo do Pacote OSGi para a criação de projetos de pacotes OSGi. Quando você cria um projeto de pacote OSGi, o POM gerado declara o JAR ``org.osgi.core`` como uma dependência e especifica o ``plug-in-do-pacote-maven`` para a construção do projeto. |
| |
| |
| === Criando o Pacote da Interface MavenHelloServiceApi |
| |
| Neste exercício, você utilizará o assistente Novo Projeto para criar um projeto de pacote OSGi que fornecerá uma interface simples que será implementada por outros pacotes. Depois de criar o pacote e a interface, você modificará o POM para atualizar a dependência no artefato ``org.osgi.core`` que foi especificado no projeto POM pai. |
| |
| 1. Selecione Arquivo > Novo Projeto para abrir o assistente de Novo Projeto. |
| 2. Selecione Pacote OSGi na categoria Maven. Clique em Próximo. |
| |
| image::images/cdi-new-osgiproject.png[title="Arquétipo do Pacote OSGI Maven no assistente de Novo Projeto"] |
| |
| |
| [start=3] |
| . Digite *MavenHelloServiceApi* como Nome do Projeto. |
| |
| [start=4] |
| . Clique em Procurar e selecione o projeto POM *MavenOSGiCDIProject* como o Local. Clique em Finalizar. |
| |
| Quando você clica em Finalizar, o IDE cria o projeto do pacote e abre o projeto na janela Projetos. Se você abrir ``pom.xml`` para o projeto MavenHelloServiceApi no editor, verá que o elemento ``encapsulamento`` especifica o ``pacote`` e que o ``plug-in-do-pacote-maven`` será usado ao construir o pacote. |
| |
| |
| [source,xml] |
| ---- |
| |
| <project> |
| <modelVersion>4.0.0</modelVersion> |
| <parent> |
| <artifactId>MavenOSGiCDIProject</artifactId> |
| <groupId>com.mycompany</groupId> |
| <version>1.0-SNAPSHOT</version> |
| </parent> |
| |
| <groupId>com.mycompany</groupId> |
| <artifactId>MavenHelloServiceApi</artifactId> |
| <version>1.0-SNAPSHOT</version> |
| *<packaging>bundle</packaging>* |
| <name>MavenHelloServiceApi OSGi Bundle</name> |
| |
| <properties> |
| <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> |
| </properties> |
| |
| <dependencies> |
| <dependency> |
| <groupId>org.osgi</groupId> |
| <artifactId>org.osgi.core</artifactId> |
| <version>4.3.0</version> |
| <scope>provided</scope> |
| </dependency> |
| </dependencies> |
| |
| <build> |
| <plugins> |
| <plugin> |
| <groupId>org.apache.felix</groupId> |
| *<artifactId>maven-bundle-plugin</artifactId>* |
| <version>2.3.7</version> |
| <extensions>true</extensions> |
| <configuration> |
| <instructions> |
| <Bundle-Activator>com.mycompany.mavenhelloserviceimpl.Activator</Bundle-Activator> |
| <Export-Package /> |
| </instructions> |
| </configuration> |
| </plugin> |
| |
| ... |
| </plugins> |
| </build> |
| |
| ... |
| <project> |
| ---- |
| |
| Você também poderá ver que, ao criar um projeto de pacote OSGi utilizando o arquétipo do Pacote OSGi Maven, o IDE adicionou o artefato ``org.osgi.core`` como uma dependência por padrão. |
| |
| |
| [start=5] |
| . Clique com o botão direito do mouse no nó do projeto MavenHelloServiceApi na janela Projetos e selecione Propriedades. |
| |
| [start=6] |
| . Selecione a categoria Códigos-fonte na caixa de diálogo Propriedades do Projeto. |
| |
| [start=7] |
| . Defina *Source/Binary Format* como 1.6 e confirme se a *Codificação* é UTF-8. Clique em OK. |
| |
| [start=8] |
| . Clique com o botão direito do mouse no nó Pacotes de Código-fonte e selecione Novo > Interface Java. |
| |
| [start=9] |
| . Digite *Hello* como Nome da Classe. |
| |
| [start=10] |
| . Selecione *com.mycompany.mavenhelloserviceapi* como o Pacote. Clique em Finalizar. |
| |
| [start=11] |
| . Adicione o método ``sayHello`` a seguir à interface (em negrito) e salve as alterações. |
| |
| [source,java] |
| ---- |
| |
| public interface Hello { |
| *String sayHello(String name);* |
| } |
| ---- |
| |
| [start=12] |
| . Clique com o botão direito do mouse no nó do projeto na janela Projetos e selecione Construir. |
| |
| Depois de construir o projeto, se você abrir a janela Arquivos e expandir o nó do projeto, verá que ``MavenHelloServiceApi-1.0-SNAPSHOT.jar`` foi criado na pasta de ``destino`` . |
| |
| image::images/cdi-manifest.png[title="Exibir o conteúdo do JAR compilado na janela Arquivos"] |
| |
| O ``plug-in-do-pacote-maven`` trata da geração do arquivo ``MANIFEST.MF`` ao construir o projeto. Se abrir o arquivo ``MANIFEST.MF`` no JAR compilado, você verá que o plug-in gerou um cabeçalho de manifesto que declara os pacotes exportados. Para OSGi, todos os pacotes que você deseja que sejam expostos e estejam disponíveis para outros pacotes devem ser listados no elemento ``Exportar-Pacote`` no ``MANIFEST.MF`` . |
| |
| |
| [start=13] |
| . Confirme se o ``MANIFEST.MF`` contém o elemento ``Export-Package`` (o elemento mostrado em *negrito* no exemplo abaixo). |
| |
| [source,java] |
| ---- |
| |
| Manifest-Version: 1.0 |
| Bnd-LastModified: 1395049732676 |
| Build-Jdk: 1.7.0_45 |
| Built-By: nb |
| Bundle-Activator: com.mycompany.mavenhelloserviceapi.Activator |
| Bundle-ManifestVersion: 2 |
| Bundle-Name: MavenHelloServiceApi OSGi Bundle |
| Bundle-SymbolicName: com.mycompany.MavenHelloServiceApi |
| Bundle-Version: 1.0.0.SNAPSHOT |
| Created-By: Apache Maven Bundle Plugin |
| *Export-Package: com.mycompany.mavenhelloserviceapi;uses:="org.osgi.frame |
| work";version="1.0.0.SNAPSHOT"* |
| Import-Package: org.osgi.framework;version="[1.6,2)" |
| Tool: Bnd-1.50.0 |
| ---- |
| |
| O contêiner OSGi lerá o cabeçalho do manifesto ``Exportar-Pacote`` para determinar as classes no pacote que podem ser acessadas de fora do pacote. Nesse exemplo, as classes no pacote ``com.mycompany.mavenhelloserviceapi`` estão expostas. |
| |
| NOTE: Se o `` MANIFEST.MF`` não contiver o elemento `` Export-Package`` , você precisará ativar o procedimento do plug-in default para o plug-in na janela Propriedades do Projeto e reconstruir o projeto. Na janela Propriedades do Projeto, selecione a categoria Exportar Pacotes e selecione a opção *Default maven-bundle-plugin behavior*. Você pode usar o painel Exportar Pacotes da janela Propriedades do Projeto para especificar explicitamente os pacotes que deverão ser expostos ou especificar os pacotes diretamente em ``pom.xml.`` . |
| |
| |
| |
| |
| === Criando o Pacote de Implementação MavenHelloServiceImpl |
| |
| Neste exercício, você criará o MavenHelloServiceImpl no projeto POM. |
| |
| 1. Selecione Arquivo > Novo Projeto para abrir o assistente de Novo Projeto. |
| 2. Selecione o Pacote OSGi na categoria Maven. Clique em Próximo. |
| 3. Digite *MavenHelloServiceImpl* como Nome do Projeto. |
| 4. Clique em Procurar e selecione o projeto POM *MavenOSGiCDIProject* como o Local (caso não esteja selecionado). Clique em Finalizar. |
| 5. Clique com o botão direito do mouse no nó do projeto na janela Projetos e escolha Propriedades. |
| 6. Selecione a categoria Códigos-fonte na caixa de diálogo Propriedades do Projeto. |
| 7. Defina *Source/Binary Format* como 1.6 e confirme se a *Codificação* é UTF-8. Clique em OK. |
| 8. Clique com o botão direito do mouse no nó Pacotes de Código-fonte na janela Projetos e selecione Novo > Classe Java. |
| 9. Digite *HelloImpl* para o Nome da Classe. |
| 10. Selecione *com.mycompany.mavenhelloserviceimpl* como o Pacote. Clique em Finalizar. |
| 11. Digite o seguinte (em negrito) e salve as alterações. |
| |
| [source,java] |
| ---- |
| |
| public class HelloImpl *implements Hello { |
| |
| public String sayHello(String name) { |
| return "Hello " + name;* |
| } |
| } |
| ---- |
| |
| Quando você implementar ``Hello`` , o IDE exibirá um erro que deverá ser resolvido adicionando o projeto MavenHelloServiceApi como uma dependência. |
| |
| |
| [start=12] |
| . Clique com o botão direito do mouse no nó Dependências do *MavenHelloServiceImpl* na janela Projetos e selecione Adicionar Dependência. |
| |
| [start=13] |
| . Clique na guia Abrir Projetos na caixa de diálogo Adicionar Biblioteca. |
| |
| [start=14] |
| . Selecione o Pacote OSGi MavenHelloServiceApi. Clique em Add. |
| |
| image::images/cdi-add-dependency.png[title="Clique na guia Abrir Projetos na caixa de diálogo Adicionar Biblioteca."] |
| |
| |
| [start=15] |
| . Clique com o botão direito do mouse na classe ``HelloImpl.java`` que está aberta no editor e selecione Corrigir Importações (Alt-Shift-I; ⌘-Shift-I no Mac) para adicionar uma instrução de importação para ``com.mycompany.mavenhelloserviceapi.Hello`` . Salve as alterações. |
| |
| [start=16] |
| . Expanda o pacote ``com.mycompany.mavenhelloserviceimpl`` e clique duas vezes em ``Activator.java`` para abrir o arquivo no editor. |
| |
| image::images/cdi-activator.png[title="Classe do ativador na janela Projetos"] |
| |
| O IDE criou automaticamente a classe ativadora do pacote ``Activator.java`` em seu projeto. Um ativador de pacote é utilizado para gerenciar o ciclo de vida de um pacote. A classe do ativador de pacote é declarada no ``MANIFEST.MF`` do pacote e é instanciada quando o pacote é iniciado pelo contêiner. |
| |
| Um pacote OSGi não requer uma classe de ativador de pacote, mas é possível utilizar o método ``start()`` na classe do ativador, por exemplo, para inicializar serviços ou outros recursos necessários para o pacote. Neste exercício, você adicionará algumas linhas de código à classe que imprimirá mensagens na janela de Saída. Isso facilitará a identificação de quando um pacote é iniciado e parado. |
| |
| |
| [start=17] |
| . Modifique os métodos ``start()`` e ``stop()`` na classe do ativador do pacote para adicionar as linhas a seguir (em negrito). |
| |
| [source,java] |
| ---- |
| |
| public class Activator implements BundleActivator { |
| |
| public void start(BundleContext context) throws Exception { |
| *System.out.println("HelloActivator::start"); |
| context.registerService(Hello.class.getName(), new HelloImpl(), null); |
| System.out.println("HelloActivator::registration of Hello service successful");* |
| } |
| |
| public void stop(BundleContext context) throws Exception { |
| *context.ungetService(context.getServiceReference(Hello.class.getName())); |
| System.out.println("HelloActivator stopped");* |
| } |
| } |
| ---- |
| |
| Você pode ver que a classe do ativador de pacotes importa ``org.osgi.framework.BundleActivator`` e ``org.osgi.framework.BundleContext`` . Por default, a classe gerada contém dois métodos: ``start()`` e ``stop()`` . O framework do OSGi invoca os métodos ``start()`` e ``stop()`` para iniciar e parar a funcionalidade fornecida pelo pacote. Quando o pacote é iniciado, o componente de serviço fornecido pelo pacote é registrado no registro de serviço do OSGi. Depois que um pacote é registrado, outros pacotes poderão utilizar o registro para pesquisa e, em seguida, utilizar os serviços ativos por meio do contexto do pacote. |
| |
| Ao olhar o POM do projeto, você verá o elemento ``<Bundle-Activator>`` que especifica o ativador do pacote sob o elemento de configuração do ``plug-in-do-pacote-maven`` . |
| |
| |
| [source,xml] |
| ---- |
| |
| <plugin> |
| <groupId>org.apache.felix</groupId> |
| <artifactId>maven-bundle-plugin</artifactId> |
| <version>2.3.7</version> |
| <extensions>true</extensions> |
| <configuration> |
| <instructions> |
| *<Bundle-Activator>com.mycompany.mavenhelloserviceimpl.Activator</Bundle-Activator>* |
| </instructions> |
| </configuration> |
| </plugin> |
| ---- |
| |
| Quando você construir o pacote, o plug-in gerará um Cabeçalho de Manifesto no arquivo de manifesto do pacote no JAR e especificará a classe do Ativador do Pacote. O runtime do OSGi procura pelo cabeçalho ``Bundle-Activator`` no arquivo do manifesto quando um pacote é implantado. |
| |
| |
| [start=18] |
| . Corrija as instruções de importação em ``Activator.java`` para importar ``com.mycompany.mavenhelloserviceapi.Hello`` . Salve as alterações. |
| |
| [start=19] |
| . Expanda o nó Dependências e confirme se o artefato ``org.osgi.core`` é listado como uma dependência. |
| |
| NOTE: Remova todas as versões mais antigas do artefato que são listadas no nó Dependências, clicando com o botão direito do mouse no artefato e escolhendo Remover Dependência. As únicas dependências devem ser o projeto MavenHelloServiceApi e o artefato ``org.osgi.core`` . |
| |
| image::images/cdi-implproject.png[title="Classe do ativador na janela Projetos"] |
| |
| |
| |
| === Construindo e Implantando os Pacotes OSGi |
| |
| Neste exercício, você construirá os pacotes OSGi e implantará os pacotes no GlassFish. |
| |
| 1. Clique com o botão direito do mouse no nó MavenOSGiCDIProject na janela Projetos e selecione Limpar e Construir. |
| |
| Quando você construir o projeto, o IDE criará os arquivos JAR na pasta de ``destino`` de cada um dos projetos e também instalará o JAR de snapshot no repositório local. Na janela Arquivos, você pode expandir a pasta de ``destino`` para cada um dos dois projetos de pacotes e ver os dois arquivos compactados JAR ( ``MavenHelloServiceApi-1.0-SNAPSHOT.jar`` e ``MavenHelloServiceImpl-1.0-SNAPSHOT.jar`` ). |
| |
| |
| [start=2] |
| . Inicie o GlassFish Server, se ainda não o tiver feito. |
| |
| [start=3] |
| . Copie o ``MavenHelloServiceApi-1.0-SNAPSHOT.jar`` para o diretório ``glassfish/domains/domain1/autodeploy/bundles/`` da instalação do GlassFish. |
| |
| No log do GlassFish Server, na janela de Saída, você deverá ver uma saída semelhante à mostrada a seguir. |
| |
| |
| [source,java] |
| ---- |
| |
| INFO: Started bundle: file:/glassfish-4.0/glassfish/domains/domain1/autodeploy/bundles/MavenHelloServiceApi-1.0-SNAPSHOT.jar |
| |
| ---- |
| |
| Clique com o botão direito do mouse no nó do GlassFish Server na janela Serviços e selecione Exibir Log do Servidor de Domínio, se o log do servidor não estiver visível na janela de Saída. |
| |
| |
| [start=4] |
| . Repita as etapas para copiar o ``MavenHelloServiceImpl-1.0-SNAPSHOT.jar`` no diretório ``autodeploy/bundles`` . |
| |
| No log do GlassFish Server, você agora deverá ver uma saída semelhante à mostrada a seguir. |
| |
| |
| [source,java] |
| ---- |
| |
| INFO: HelloActivator::start |
| INFO: HelloActivator::registration of Hello service successful |
| INFO: Started bundle: file:/glassfish-4.0/glassfish/domains/domain1/autodeploy/bundles/MavenHelloServiceImpl-1.0-SNAPSHOT.jar |
| INFO: Started bundle: file:/glassfish-4.0/glassfish/domains/domain1/autodeploy/bundles/MavenHelloServiceImpl-1.0-SNAPSHOT.jar |
| |
| ---- |
| |
| Ou então, é possível instalar os pacotes a partir da Console de Admin OSGi do GlassFish. Para obter mais informações, consulte a seção <<Exercise_4,Instalando e Usando a Console de Admin OSGi>>. |
| |
| |
| == Criando uma Aplicação Cliente Web |
| |
| Esta seção demonstra como criar um cliente Web Java EE que acessa o serviço fornecido pelo pacote OSGi. Você criará um servlet simples em uma aplicação Web e, em seguida, injetará os serviços declarados. Antes de criar o projeto, você adicionará alguns elementos de gerenciamento de dependências ao projeto POM pai. |
| |
| |
| === Configurando dependências no Projeto POM Pai |
| |
| Neste exercício, você especificará elementos de dependência no projeto POM pai. Você também adicionará um repositório para artefatos que serão utilizados no projeto. |
| |
| 1. Expanda o nó Arquivos do Projeto do projeto *MavenOSGiCDIProject* na janela Projetos e clique duas vezes em ``pom.xml`` para abrir o arquivo no editor. |
| 2. Modifique o ``pom.xml`` pai para adicionar os seguintes elementos de Gerenciamento de Dependências (em negrito). Salve as alterações. |
| |
| [source,xml] |
| ---- |
| |
| <?xml version="1.0" encoding="UTF-8"?> |
| <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> |
| <modelVersion>4.0.0</modelVersion> |
| <groupId>com.mycompany</groupId> |
| <artifactId>MavenOSGiCDIProject</artifactId> |
| <version>1.0-SNAPSHOT</version> |
| <packaging>pom</packaging> |
| <properties> |
| <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> |
| </properties> |
| |
| ... |
| |
| <dependencyManagement> |
| <dependencies> |
| <dependency> |
| <groupId>org.osgi</groupId> |
| <artifactId>org.osgi.core</artifactId> |
| <version>4.3.0</version> |
| <scope>provided</scope> |
| </dependency> |
| *<dependency> |
| <groupId>org.osgi</groupId> |
| <artifactId>org.osgi.compendium</artifactId> |
| <version>4.2.0</version> |
| <scope>provided</scope> |
| </dependency> |
| <dependency> |
| <groupId>org.glassfish</groupId> |
| <artifactId>osgi-cdi-api</artifactId> |
| <version>3.1-b41</version> |
| <type>jar</type> |
| <scope>provided</scope> |
| </dependency>* |
| |
| </dependencies> |
| </dependencyManagement> |
| |
| ... |
| </project> |
| |
| ---- |
| |
| [start=3] |
| . Adicione os elementos a seguir para adicionar o repositório do GlassFish ao POM. Salve as alterações. |
| |
| [source,xml] |
| ---- |
| |
| <project> |
| |
| ... |
| |
| </dependencyManagement> |
| |
| *<repositories> |
| <!-- glassfish nexus repo for glassfish dependencies --> |
| <repository> |
| <id>glassfish-repo-archive</id> |
| <name>Nexus repository collection for Glassfish</name> |
| <url>http://maven.glassfish.org/content/groups/glassfish</url> |
| <snapshots> |
| <updatePolicy>never</updatePolicy> |
| </snapshots> |
| </repository> |
| </repositories>* |
| <modules> |
| <module>MavenHelloServiceApi</module> |
| <module>MavenHelloServiceImpl</module> |
| </modules> |
| </project> |
| |
| ---- |
| |
| Depois de adicionar o repositório do GlassFish ao POM, se você exibir a lista de repositórios no nó Repositórios Maven na janela Serviços, verá que o IDE adicionou automaticamente um nó para o repositório do GlassFish. Por default, o IDE exibe um nó para o repositório Maven Local. Quando um projeto aberto especifica um repositório, o IDE automaticamente adiciona um nó ao repositório no nó Repositórios Maven. |
| |
| image::images/cdi-maven-repositories.png[title="Repositório do GlassFish na janela Repositórios Maven"] |
| |
| Neste exercício, você adicionou artefatos extras e versões de artefatos que serão utilizados no projeto. Você também adicionou o repositório do GlassFish que contém os artefatos ``osgi-cdi-api`` . |
| |
| |
| === Criando a Aplicação Web MavenHelloWebClient |
| |
| Primeiro, você criará uma aplicação Web regular e, em seguida, modificará o projeto para torná-lo um pacote OSGi (Pacote de Aplicação Web (WAB)). |
| |
| 1. Escolha Arquivo > Novo Projeto no menu principal. |
| 2. Selecione Aplicação Web na categoria Maven. Clique em Próximo. |
| 3. Digite *MavenHelloWebClient* como nome do Projeto. |
| 4. Clique em Procurar e selecione o projeto POM *MavenOSGiCDIProject* como o Local (caso não esteja selecionado). Clique em Próximo. |
| 5. Selecione o GlassFish Server como servidor e o Java EE 6 ou Java EE 7 como a versão do Java EE. Clique em Finalizar. |
| 6. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Servlet. |
| 7. Digite *HelloServlet* no Nome da Classe. |
| 8. Selecione ``com.mycompany.mavenhellowebclient`` como o Pacote. Clique em Finalizar. |
| 9. Delete os métodos default no servlet que foram gerados pelo IDE ( ``processRequest`` , ``doGet`` , ``doPost`` , ``getServletInfo`` ). |
| |
| NOTE: Você precisará expandir a pasta do editor para deletar os métodos do HttpServlet. |
| |
| |
| [start=10] |
| . Digite o código a seguir (em negrito) para injetar o serviço. |
| |
| [source,java] |
| ---- |
| |
| @WebServlet(name = "HelloServlet", urlPatterns = {"/HelloServlet"}) |
| public class HelloServlet extends HttpServlet { |
| |
| *@Inject |
| @OSGiService(dynamic=true) |
| Hello hello;* |
| } |
| ---- |
| |
| [start=11] |
| . Adicione o método ``doGet`` a seguir. |
| |
| [source,java] |
| ---- |
| |
| @Override |
| protected void doGet(HttpServletRequest request, HttpServletResponse response) |
| throws ServletException, IOException { |
| PrintWriter out = response.getWriter(); |
| out.println(hello.sayHello("Duke")); |
| } |
| ---- |
| |
| [start=12] |
| . Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro. |
| |
| [start=13] |
| . Selecione *beans.xml* na categoria Contextos e Injeção de Dependências. Clique em Próximo. |
| |
| [start=14] |
| . Use o nome de arquivo default ( ``beans`` ). Clique em Finalizar. |
| |
| Quando você clicar em Finalizar, o assistente criará o arquivo ``beans.xml`` na aplicação Web. O CDI será automaticamente ativado se o ``beans.xml`` for parte da aplicação. |
| |
| |
| [start=15] |
| . Modifique o arquivo ``beans.xml`` para alterar o valor padrão de ``bean-discovery-mode`` para ``all`` . |
| |
| [source,java] |
| ---- |
| |
| bean-discovery-mode="*all*" |
| ---- |
| |
| Salve suas alterações e feche o arquivo. |
| |
| Para obter mais informações sobre as diferenças entre os valores ``bean-discovery-mode`` , consulte as seguintes páginas: |
| |
| * link:http://docs.oracle.com/javaee/7/tutorial/doc/cdi-adv001.htm[+25.1 Encapsulando Aplicações CDI+] no Tutorial do Java EE 7 |
| * link:http://stackoverflow.com/questions/18107858/cdi-inject-fails-on-maven-embedded-glassfish-plugin-org-jboss-weld-exceptions[+http://stackoverflow.com/questions/18107858/cdi-inject-fails-on-maven-embedded-glassfish-plugin-org-jboss-weld-exceptions+] |
| |
| [start=16] |
| . Clique com o botão direito do mouse no nó Dependências do MavenHelloWebClient na janela Projetos e selecione Adicionar Dependência. |
| |
| [start=17] |
| . Selecione *Provided* como o Escopo. |
| |
| [start=18] |
| . Clique na guia Abrir Projetos na caixa de diálogo Adicionar Biblioteca e selecione *Pacote OSGi MavenHelloServiceApi*. Clique em Add. |
| |
| [start=19] |
| . Clique novamente com o botão direito do mouse no nó Dependências e selecione Adicionar Dependência. |
| |
| [start=20] |
| . Clique na guia Gerenciamento de Dependências na caixa de diálogo Adicionar Biblioteca e selecione o artefato ``osgi-cdi-api`` que você especificou no projeto POM pai. Clique em Add. |
| |
| image::images/cdi-add-dependency3.png[title="Guia de Gerenciamento de Dependências na caixa de diálogo Adicionar Biblioteca"] |
| |
| |
| [start=21] |
| . Clique com o botão direito do mouse em ``HelloServlet.java`` no editor e selecione Corrigir Importações (Alt-Shift-I; ⌘-Shift-I no Mac) para adicionar ``com.mycompany.mavenhelloserviceapi.Hello`` , ``javax.inject.Inject`` e ``org.glassfish.osgicdi.OSGiService`` . Salve as alterações. |
| |
| NOTE: Pode ser preciso adicionar manualmente uma instrução de importação para o ``com.mycompany.mavenhelloserviceapi.hello`` se o IDE não adicionar automaticamente para você. |
| |
| |
| [start=22] |
| . Clique com o botão direito do mouse em MavenOSGiCDIProject e selecione Limpar e Construir. |
| |
| Ao construir o projeto, na janela de Saída, você deverá ver uma saída semelhante à seguinte. |
| |
| |
| [source,java] |
| ---- |
| |
| Reactor Summary: |
| |
| MavenOSGiCDIProject ............................... SUCCESS [0.798s] |
| MavenHelloServiceApi OSGi Bundle .................. SUCCESS [7.580s] |
| MavenHelloServiceImpl OSGi Bundle ................. SUCCESS [1.142s] |
| MavenHelloWebClient ............................... SUCCESS [8.072s] |
| ------------------------------------------------------------------------ |
| BUILD SUCCESS |
| ---- |
| |
| NOTE: Crie a aplicação web manualmente se ela não for criada automaticamente quando você criar o projeto MavenOSGiCDIProject. |
| |
| Na janela Arquivos, expanda o nó do projeto para a aplicação Web e confirme se o arquivo compactado ``MavenHelloWebClient-1.0-SNAPSHOT.war`` foi criado no diretório de destino. Se você expandir o arquivo compactado WAR do cliente Web e examinar o ``MANIFEST.MF`` , verá que o manifesto contém linhas similares às seguintes. |
| |
| |
| [source,java] |
| ---- |
| |
| Manifest-Version: 1.0 |
| Archiver-Version: Plexus Archiver |
| Created-By: Apache Maven |
| Built-By: nb |
| Build-Jdk: 1.7.0_45 |
| ---- |
| |
| |
| === Construindo a aplicação Web como um Pacote OSGi |
| |
| Para usar o ``@OSGiService`` e recuperar pacotes OSGi registrados, é preciso tornar a aplicação Web um pacote que possa acessar o ``BundleContext`` . Para tornar o WAR um pacote OSGi (Pacote de Aplicação Web), adicione os metadados ``Web-ContextPath`` ao ``MANIFEST.MF`` no WAR. Para tanto, especifique o elemento ``<Web-ContextPath>`` nas instruções do ``maven-bundle-plugin`` e o manifesto gerado pelo plug-in conterá o elemento. Em seguida, você modificará a configuração do ``maven-war-plugin`` para instruir o plug-in a adicionar o manifesto que foi gerado pelo ``plug-in-do-pacote-maven`` ao arquivo compactado WAR. |
| |
| 1. Na janela Projetos, expanda o nó dos Arquivos de Projeto sob o MavenHelloWebCliente clique duas vezes em ``pom.xml`` para abrir o arquivo no editor. |
| 2. Adicione a seguinte entrada para adicionar o ``plug-in-do-pacote-maven`` ao POM. |
| |
| [source,xml] |
| ---- |
| |
| <build> |
| <plugins> |
| *<plugin> |
| <groupId>org.apache.felix</groupId> |
| <artifactId>maven-bundle-plugin</artifactId> |
| <version>2.2.0</version> |
| <extensions>true</extensions> |
| <configuration> |
| <supportedProjectTypes> |
| <supportedProjectType>ejb</supportedProjectType> |
| <supportedProjectType>war</supportedProjectType> |
| <supportedProjectType>bundle</supportedProjectType> |
| <supportedProjectType>jar</supportedProjectType> |
| </supportedProjectTypes> |
| <instructions> |
| <!-- Specify elements to add to MANIFEST.MF --> |
| <Web-ContextPath>/mavenhellowebclient</Web-ContextPath> |
| <!-- By default, nothing is exported --> |
| <Export-Package>!*.impl.*, *</Export-Package> |
| </instructions> |
| </configuration> |
| <executions> |
| <execution> |
| <id>bundle-manifest</id> |
| <phase>process-classes</phase> |
| <goals> |
| <goal>manifest</goal> |
| </goals> |
| </execution> |
| <execution> |
| <id>bundle-install</id> |
| <phase>install</phase> |
| <goals> |
| <goal>install</goal> |
| </goals> |
| </execution> |
| </executions> |
| </plugin>* |
| |
| ---- |
| |
| [start=3] |
| . Modifique os elementos de configuração do ``maven-war-plugin`` para adicionar informações do pacote ao ``MANIFEST.MF`` . Salve as alterações. |
| |
| [source,xml] |
| ---- |
| |
| <plugin> |
| <groupId>org.apache.maven.plugins</groupId> |
| <artifactId>maven-war-plugin</artifactId> |
| <version>2.3</version> |
| <configuration> |
| *<archive> |
| <!-- add bundle plugin generated manifest to the war --> |
| <manifestFile> |
| ${project.build.outputDirectory}/META-INF/MANIFEST.MF |
| </manifestFile> |
| <!-- For some reason, adding Bundle-ClassPath in maven-bundle-plugin |
| confuses that plugin and it generates wrong Import-Package, etc. |
| So, we generate it here.--> |
| <manifestEntries> |
| <Bundle-ClassPath>WEB-INF/classes/</Bundle-ClassPath> |
| </manifestEntries> |
| </archive>* |
| <failOnMissingWebXml>false</failOnMissingWebXml> |
| </configuration> |
| </plugin> |
| ---- |
| |
| [start=4] |
| . Clique com o botão direito do mouse no nó do projeto MavenHelloWebClient na janela Projetos e selecione Limpar e Construir. |
| |
| Ao expandir o arquivo compactado WAR e abrir o ``MANIFEST.MF`` no editor, você verá que o ``MANIFEST.MF`` contém informações adicionais, incluindo a entrada ``Web-ContextPath: /mavenhellowebclient`` especificada na configuração ``maven-bundle-plugin`` e entradas de nome de pacote. |
| |
| |
| [source,java] |
| ---- |
| |
| Manifest-Version: 1.0 |
| Export-Package: com.mycompany.mavenhellowebclient;uses:="com.mycompany |
| .mavenhelloserviceapi,javax.servlet,org.glassfish.osgicdi,javax.injec |
| t,javax.servlet.annotation,javax.servlet.http";version="1.0.0.SNAPSHO |
| T" |
| Bundle-ClassPath: WEB-INF/classes/ |
| Built-By: nb |
| Tool: Bnd-1.50.0 |
| Bundle-Name: MavenHelloWebClient |
| Created-By: Apache Maven Bundle Plugin |
| *Web-ContextPath: /mavenhellowebclient* |
| Build-Jdk: 1.7.0_45 |
| Bundle-Version: 1.0.0.SNAPSHOT |
| Bnd-LastModified: 1395053424008 |
| Bundle-ManifestVersion: 2 |
| Import-Package: com.mycompany.mavenhelloserviceapi;version="[1.0,2)",j |
| avax.inject,javax.servlet,javax.servlet.annotation,javax.servlet.http |
| ,org.glassfish.osgicdi;version="[1.0,2)" |
| Bundle-SymbolicName: com.mycompany.MavenHelloWebClient |
| Archiver-Version: Plexus Archiver |
| ---- |
| |
| Para obter mais informações sobre como construir aplicações Web como pacotes OSGi, consulte as páginas seguintes. |
| |
| * link:http://weblogs.java.net/blog/2009/06/04/osgi-enabled-web-applications-inglassfish[+ http://weblogs.java.net/blog/2009/06/04/osgi-enabled-web-applications-inglassfish+] |
| * link:http://felix.apache.org/site/apache-felix-maven-bundle-plugin-bnd.html[+ http://felix.apache.org/site/apache-felix-maven-bundle-plugin-bnd.html+] |
| |
| |
| === Implantando o Pacote de Aplicação Web |
| |
| Neste exercício, você copiará o pacote da aplicação Web para a pasta ``implantação automática/pacotes`` na instalação do GlassFish. |
| |
| 1. Navegue até o diretório de ``destino`` que contém o ``MavenHelloWebClient-1.0-SNAPSHOT.war`` . |
| 2. Copie o ``MavenHelloWebClient-1.0-SNAPSHOT.war`` na pasta ``implantação automática/pacotes`` da instalação do GlassFish. |
| |
| Quando você copiar o arquivo compactado WAR para o diretório, um resultado semelhante ao mostrado a seguir será exibido no log do GlassFish Server. |
| |
| |
| [source,java] |
| ---- |
| |
| INFO: Started bundle: file:/glassfish-3.1.1/glassfish/domains/domain1/autodeploy/bundles/MavenHelloWebClient-1.0-SNAPSHOT.war |
| ... |
| INFO: ---- Injection requested for framework service type interface com.mycompany.mavenhelloserviceapi.Hello and annotated with dynamic=true, serviceCriteria= |
| INFO: WEB0671: Loading application [com.mycompany.MavenHelloWebClient_1.0.0.SNAPSHOT] at [/mavenhellowebclient] |
| INFO: Registered ServletContext as a service with properties: {osgi.web.symbolicname=com.mycompany.MavenHelloWebClient, osgi.web.version=1.0.0.SNAPSHOT, osgi.web.contextpath=/mavenhellowebclient} |
| |
| ---- |
| |
| É possível exibir o servlet no browser clicando no link a seguir link:http://localhost:8080/mavenhellowebclient/HelloServlet[+http://localhost:8080/mavenhellowebclient/HelloServlet+]. |
| |
| |
| == Instalando e Usando a Console de Admnin do OSGI |
| |
| Você pode usar a Console de Admin do OSGi GlassFish para instalar, iniciar e parar os pacotes do OSGi implantados no servidor. Neste exercício, você ativará a Console de Admin do OSGi GlassFish e, em seguida, exibirá a lista de pacotes OSGi registrados. |
| |
| Realize as etapas a seguir para instalar os add-ons do GlassFish necessários para a ativação da Console do OSGi e para exibir os pacotes na Console de Admin do Domínio do GlassFish. |
| |
| 1. Abra a Console de Admin do Domínio do GlassFish no browser. |
| |
| Clique com o botão direito do mouse no nó do GlassFish server na janela Serviços e selecione Exibir Console de Admin de Domínio. |
| |
| |
| [start=2] |
| . Clique na Ferramenta de Atualização na coluna de navegação esquerda. |
| |
| [start=3] |
| . Selecione ``glassfish-osgi-gui`` na lista de add-ons disponíveis. |
| |
| Clique em Instalar e aceite a licença. |
| |
| image::images/cdi-glassfish-addons.png[title="Ferramenta de Atualização da Console de Admin do GlassFish"] |
| |
| |
| [start=4] |
| . Reinicie o GlassFish Server. |
| |
| *Importante:* se você estiver executando GlassFish Server 3.1.2.2 você precisará modificar o arquivo ``osgi.properties`` localizado no diretório ``_GLASSFISH-INSTALL_/glassfish/config/`` e definir o valor da propriedade ``org.osgi.framework.startlevel.beginning`` como "2" ( ``org.osgi.framework.startlevel.beginning=2`` ). |
| Consulte o seguinte fórum para obter mais detalhes: |
| link:http://www.java.net/forum/topic/glassfish/glassfish/cannot-start-web-console-glassfish-version-3122[+Não é possível iniciar a console Web no Glassfish versão 3.1.2.2+]. |
| |
| |
| [start=5] |
| . Abra a Console de Admin novamente e clique em *servidor (Servidor de Admin)* na coluna de navegação esquerda. |
| |
| [start=6] |
| . Clique na guia da Console do OSGi para exibir uma lista de pacotes OSGi implantados. |
| |
| image::images/cdi-glassfish-console.png[title="Guia de Gerenciamento de Dependências na caixa de diálogo Adicionar Biblioteca"] |
| |
| NOTE: Você poderá ser solicitado a informar o nome de usuário e a senha para exibir a lista de pacotes OSGi. Confirme se a caixa de diálogo de autorização não está oculta se você não vir uma lista de pacotes na guia Console do OSGi. O nome de usuário padrão do servidor GlassFish 4 é ``admin`` se você instalou o servidor quando instalou o IDE. A senha fica vazia por padrão. |
| |
| É possível rolar a lista para baixo para exibir os status dos pacotes OSGi registrados, além de iniciar e parar os pacotes individuais. Se a lista for ordenada por Id (maior para menor), você verá que os três pacotes que foram implantados serão exibidos perto do topo da lista. |
| |
| |
| link:/about/contact_form.html?to=3&subject=Feedback:%20Using%20CDI%20to%20Inject%20OSGi%20Bundles%20as%20Services[+Enviar Feedback neste Tutorial+] |
| |
| |
| |
| == Consulte Também |
| |
| Para obter mais informações sobre o uso do NetBeans IDE e Maven para desenvolver pacotes OSGi, consulte os seguintes recursos: |
| |
| * link:http://wiki.netbeans.org/OSGiAndNetBeans[+OSGi And NetBeans at wiki.netbeans.org+] |
| * link:http://wiki.netbeans.org/MavenBestPractices[+Melhores Práticas para o Apache Maven no NetBeans IDE+] |
| * link:https://blogs.oracle.com/arungupta/entry/totd_125_creating_an_osgi[+TOTD #125: Criando um pacote OSGi utilizando o NetBeans e implantando no GlassFish+] |
| * link:../../trails/java-ee.html[+Trilha de Aprendizado do Java EE e Java Web+] |
| |
| Para enviar comentários e sugestões, obter suporte e se manter informado sobre os mais recentes desenvolvimentos das funcionalidades de desenvolvimento do Java EE do NetBeans IDE, link:../../../community/lists/top.html[+inscreva-se na lista de correspondência de nbj2ee+]. |
| |
