Usando o CDI para Injetar Pacotes OSGi como Serviços no NetBeans IDE

Este documento demonstra como o suporte integrado para o framework 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 TOTD #154: Dynamic OSGi services in GlassFish 3.1 - Using CDI and @OSGiService e outras entradas do blog que podem ser encontradas no 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.

Exercícios do Tutorial

O conteúdo desta página se aplica ao NetBeans IDE 7.2, 7.3, 7.4 e 8.0

Para seguir este tutorial, são necessários os recursos e o software a seguir.

Software ou Recurso Versão Necessária
NetBeans IDE Versão Java EE 7.2, 7.3, 7.4, 8.0
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.

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.
    tela do assistente Novo Projeto
  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.

  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.

    <?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>
            
  5. Modifique o pom.xml pai para adicionar os elementos a seguir. Salve as alterações.
    <?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 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.
    tela do assistente Novo Projeto
  3. Digite MavenHelloServiceApi como Nome do Projeto.
  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.

    <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.

  5. Clique com o botão direito do mouse no nó do projeto MavenHelloServiceApi na janela Projetos e selecione 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 e selecione Novo > Interface Java.
  9. Digite Hello como Nome da Classe.
  10. Selecione com.mycompany.mavenhelloserviceapi como o Pacote. Clique em Finalizar.
  11. Adicione o método sayHello a seguir à interface (em negrito) e salve as alterações.
    public interface Hello {
        String sayHello(String name);
    }
  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.

    Tela do projeto na janela de 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.

  13. Confirme se o MANIFEST.MF contém o elemento Export-Package (o elemento mostrado em negrito no exemplo abaixo).
    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.

    Observação. 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.
    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.

  12. Clique com o botão direito do mouse no nó Dependências do MavenHelloServiceImpl na janela Projetos e selecione Adicionar Dependência.
  13. Clique na guia Abrir Projetos na caixa de diálogo Adicionar Biblioteca.
  14. Selecione o Pacote OSGi MavenHelloServiceApi. Clique em Add.
    Tela da caixa de diálogo Adicionar Biblioteca
  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.
  16. Expanda o pacote com.mycompany.mavenhelloserviceimpl e clique duas vezes em Activator.java para abrir o arquivo no editor.
    tela da 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.

  17. Modifique os métodos start() e stop() na classe do ativador do pacote para adicionar as linhas a seguir (em negrito).
    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.

    <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.

  18. Corrija as instruções de importação em Activator.java para importar com.mycompany.mavenhelloserviceapi.Hello. Salve as alterações.
  19. Expanda o nó Dependências e confirme se o artefato org.osgi.core é listado como uma dependência.

    Observação. 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.

    tela da 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).

  2. Inicie o GlassFish Server, se ainda não o tiver feito.
  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.

    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.

  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.

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 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.
    <?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>
    
  3. Adicione os elementos a seguir para adicionar o repositório do GlassFish ao POM. Salve as alterações.
    <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.

Tela da 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).

    Observação. Você precisará expandir a pasta do editor para deletar os métodos do HttpServlet.

  10. Digite o código a seguir (em negrito) para injetar o serviço.
    @WebServlet(name = "HelloServlet", urlPatterns = {"/HelloServlet"})
    public class HelloServlet extends HttpServlet {
    
        @Inject
        @OSGiService(dynamic=true)
        Hello hello;
    }
  11. Adicione o método doGet a seguir.
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            PrintWriter out = response.getWriter();
            out.println(hello.sayHello("Duke"));
        }
  12. Clique com o botão direito do mouse no nó do projeto e selecione Novo > Outro.
  13. Selecione beans.xml na categoria Contextos e Injeção de Dependências. Clique em Próximo.
  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.

  15. Modifique o arquivo beans.xml para alterar o valor padrão de bean-discovery-mode para all.
    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:

  16. Clique com o botão direito do mouse no nó Dependências do MavenHelloWebClient na janela Projetos e selecione Adicionar Dependência.
  17. Selecione Provided como o Escopo.
  18. Clique na guia Abrir Projetos na caixa de diálogo Adicionar Biblioteca e selecione Pacote OSGi MavenHelloServiceApi. Clique em Add.
  19. Clique novamente com o botão direito do mouse no nó Dependências e selecione Adicionar Dependência.
  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.
    Tela da caixa de diálogo Adicionar Biblioteca
  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.

    Observação. 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ê.

  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.

Reactor Summary:

MavenOSGiCDIProject ............................... SUCCESS [0.798s]
MavenHelloServiceApi OSGi Bundle .................. SUCCESS [7.580s]
MavenHelloServiceImpl OSGi Bundle ................. SUCCESS [1.142s]
MavenHelloWebClient ............................... SUCCESS [8.072s]
------------------------------------------------------------------------
BUILD SUCCESS

Observação. 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.

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.
    <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>
                
  3. Modifique os elementos de configuração do maven-war-plugin para adicionar informações do pacote ao MANIFEST.MF. Salve as alterações.
     <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>
  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.

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.

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 pastaimplantaçã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.

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 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.

  2. Clique na Ferramenta de Atualização na coluna de navegação esquerda.
  3. Selecione glassfish-osgi-gui na lista de add-ons disponíveis.

    Clique em Instalar e aceite a licença.

    Tela da Ferramenta de Atualização na Console de Admin do GlassFish
  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:
    Não é possível iniciar a console Web no Glassfish versão 3.1.2.2.

  5. Abra a Console de Admin novamente e clique em servidor (Servidor de Admin) na coluna de navegação esquerda.
  6. Clique na guia da Console do OSGi para exibir uma lista de pacotes OSGi implantados.
    Tela da caixa de diálogo Adicionar Biblioteca

    Observação. 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.



Consulte Também

Para obter mais informações sobre o uso do NetBeans IDE e Maven para desenvolver pacotes OSGi, consulte os seguintes recursos:

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, inscreva-se na lista de correspondência de nbj2ee.

get support for the NetBeans

Support


By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2013, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo